[Python-checkins] r64086 - in python/trunk: Modules/datetimemodule.c Objects/bytesobject.c Objects/fileobject.c
gregory.p.smith
python-checkins at python.org
Tue Jun 10 19:42:37 CEST 2008
Author: gregory.p.smith
Date: Tue Jun 10 19:42:36 2008
New Revision: 64086
Log:
More reverting of r63675 per the mailing list discussions. This restores
occurances of PyBytes_ in the code to their original PyString_ names. The
bytesobject.c file will be renamed back to stringobject.c in a future checkin.
Modified:
python/trunk/Modules/datetimemodule.c
python/trunk/Objects/bytesobject.c
python/trunk/Objects/fileobject.c
Modified: python/trunk/Modules/datetimemodule.c
==============================================================================
--- python/trunk/Modules/datetimemodule.c (original)
+++ python/trunk/Modules/datetimemodule.c Tue Jun 10 19:42:36 2008
@@ -1207,9 +1207,9 @@
* is expensive, don't unless they're actually used.
*/
totalnew = format_len + 1; /* realistic if no %z/%Z/%f */
- newfmt = PyBytes_FromStringAndSize(NULL, totalnew);
+ newfmt = PyString_FromStringAndSize(NULL, totalnew);
if (newfmt == NULL) goto Done;
- pnew = PyBytes_AsString(newfmt);
+ pnew = PyString_AsString(newfmt);
usednew = 0;
pin = format;
Modified: python/trunk/Objects/bytesobject.c
==============================================================================
--- python/trunk/Objects/bytesobject.c (original)
+++ python/trunk/Objects/bytesobject.c Tue Jun 10 19:42:36 2008
@@ -1,4 +1,4 @@
-/* String object implementation */
+/* String (str/bytes) object implementation */
#define PY_SSIZE_T_CLEAN
@@ -9,8 +9,8 @@
int null_strings, one_strings;
#endif
-static PyBytesObject *characters[UCHAR_MAX + 1];
-static PyBytesObject *nullstring;
+static PyStringObject *characters[UCHAR_MAX + 1];
+static PyStringObject *nullstring;
/* This dictionary holds all interned strings. Note that references to
strings in this dictionary are *not* counted in the string's ob_refcnt.
@@ -23,19 +23,19 @@
static PyObject *interned;
/*
- For both PyBytes_FromString() and PyBytes_FromStringAndSize(), the
+ For both PyString_FromString() and PyString_FromStringAndSize(), the
parameter `size' denotes number of characters to allocate, not counting any
null terminating character.
- For PyBytes_FromString(), the parameter `str' points to a null-terminated
+ For PyString_FromString(), the parameter `str' points to a null-terminated
string containing exactly `size' bytes.
- For PyBytes_FromStringAndSize(), the parameter the parameter `str' is
+ For PyString_FromStringAndSize(), the parameter the parameter `str' is
either NULL or else points to a string containing at least `size' bytes.
- For PyBytes_FromStringAndSize(), the string in the `str' parameter does
+ For PyString_FromStringAndSize(), the string in the `str' parameter does
not have to be null-terminated. (Therefore it is safe to construct a
- substring by calling `PyBytes_FromStringAndSize(origstring, substrlen)'.)
- If `str' is NULL then PyBytes_FromStringAndSize() will allocate `size+1'
+ substring by calling `PyString_FromStringAndSize(origstring, substrlen)'.)
+ If `str' is NULL then PyString_FromStringAndSize() will allocate `size+1'
bytes (setting the last byte to the null terminating character) and you can
fill in the data yourself. If `str' is non-NULL then the resulting
PyString object must be treated as immutable and you must not fill in nor
@@ -45,16 +45,16 @@
items" in a variable-size object, will contain the number of bytes
allocated for string data, not counting the null terminating character. It
is therefore equal to the equal to the `size' parameter (for
- PyBytes_FromStringAndSize()) or the length of the string in the `str'
- parameter (for PyBytes_FromString()).
+ PyString_FromStringAndSize()) or the length of the string in the `str'
+ parameter (for PyString_FromString()).
*/
PyObject *
-PyBytes_FromStringAndSize(const char *str, Py_ssize_t size)
+PyString_FromStringAndSize(const char *str, Py_ssize_t size)
{
- register PyBytesObject *op;
+ register PyStringObject *op;
if (size < 0) {
PyErr_SetString(PyExc_SystemError,
- "Negative size passed to PyBytes_FromStringAndSize");
+ "Negative size passed to PyString_FromStringAndSize");
return NULL;
}
if (size == 0 && (op = nullstring) != NULL) {
@@ -75,10 +75,10 @@
}
/* Inline PyObject_NewVar */
- op = (PyBytesObject *)PyObject_MALLOC(sizeof(PyBytesObject) + size);
+ op = (PyStringObject *)PyObject_MALLOC(sizeof(PyStringObject) + size);
if (op == NULL)
return PyErr_NoMemory();
- PyObject_INIT_VAR(op, &PyBytes_Type, size);
+ PyObject_INIT_VAR(op, &PyString_Type, size);
op->ob_shash = -1;
op->ob_sstate = SSTATE_NOT_INTERNED;
if (str != NULL)
@@ -88,13 +88,13 @@
if (size == 0) {
PyObject *t = (PyObject *)op;
PyString_InternInPlace(&t);
- op = (PyBytesObject *)t;
+ op = (PyStringObject *)t;
nullstring = op;
Py_INCREF(op);
} else if (size == 1 && str != NULL) {
PyObject *t = (PyObject *)op;
PyString_InternInPlace(&t);
- op = (PyBytesObject *)t;
+ op = (PyStringObject *)t;
characters[*str & UCHAR_MAX] = op;
Py_INCREF(op);
}
@@ -102,10 +102,10 @@
}
PyObject *
-PyBytes_FromString(const char *str)
+PyString_FromString(const char *str)
{
register size_t size;
- register PyBytesObject *op;
+ register PyStringObject *op;
assert(str != NULL);
size = strlen(str);
@@ -130,10 +130,10 @@
}
/* Inline PyObject_NewVar */
- op = (PyBytesObject *)PyObject_MALLOC(sizeof(PyBytesObject) + size);
+ op = (PyStringObject *)PyObject_MALLOC(sizeof(PyStringObject) + size);
if (op == NULL)
return PyErr_NoMemory();
- PyObject_INIT_VAR(op, &PyBytes_Type, size);
+ PyObject_INIT_VAR(op, &PyString_Type, size);
op->ob_shash = -1;
op->ob_sstate = SSTATE_NOT_INTERNED;
Py_MEMCPY(op->ob_sval, str, size+1);
@@ -141,13 +141,13 @@
if (size == 0) {
PyObject *t = (PyObject *)op;
PyString_InternInPlace(&t);
- op = (PyBytesObject *)t;
+ op = (PyStringObject *)t;
nullstring = op;
Py_INCREF(op);
} else if (size == 1) {
PyObject *t = (PyObject *)op;
PyString_InternInPlace(&t);
- op = (PyBytesObject *)t;
+ op = (PyStringObject *)t;
characters[*str & UCHAR_MAX] = op;
Py_INCREF(op);
}
@@ -155,7 +155,7 @@
}
PyObject *
-PyBytes_FromFormatV(const char *format, va_list vargs)
+PyString_FromFormatV(const char *format, va_list vargs)
{
va_list count;
Py_ssize_t n = 0;
@@ -230,11 +230,11 @@
/* step 2: fill the buffer */
/* Since we've analyzed how much space we need for the worst case,
use sprintf directly instead of the slower PyOS_snprintf. */
- string = PyBytes_FromStringAndSize(NULL, n);
+ string = PyString_FromStringAndSize(NULL, n);
if (!string)
return NULL;
- s = PyBytes_AsString(string);
+ s = PyString_AsString(string);
for (f = format; *f; f++) {
if (*f == '%') {
@@ -334,12 +334,12 @@
}
end:
- _PyBytes_Resize(&string, s - PyBytes_AS_STRING(string));
+ _PyString_Resize(&string, s - PyString_AS_STRING(string));
return string;
}
PyObject *
-PyBytes_FromFormat(const char *format, ...)
+PyString_FromFormat(const char *format, ...)
{
PyObject* ret;
va_list vargs;
@@ -349,34 +349,34 @@
#else
va_start(vargs);
#endif
- ret = PyBytes_FromFormatV(format, vargs);
+ ret = PyString_FromFormatV(format, vargs);
va_end(vargs);
return ret;
}
-PyObject *PyBytes_Decode(const char *s,
+PyObject *PyString_Decode(const char *s,
Py_ssize_t size,
const char *encoding,
const char *errors)
{
PyObject *v, *str;
- str = PyBytes_FromStringAndSize(s, size);
+ str = PyString_FromStringAndSize(s, size);
if (str == NULL)
return NULL;
- v = PyBytes_AsDecodedString(str, encoding, errors);
+ v = PyString_AsDecodedString(str, encoding, errors);
Py_DECREF(str);
return v;
}
-PyObject *PyBytes_AsDecodedObject(PyObject *str,
+PyObject *PyString_AsDecodedObject(PyObject *str,
const char *encoding,
const char *errors)
{
PyObject *v;
- if (!PyBytes_Check(str)) {
+ if (!PyString_Check(str)) {
PyErr_BadArgument();
goto onError;
}
@@ -401,13 +401,13 @@
return NULL;
}
-PyObject *PyBytes_AsDecodedString(PyObject *str,
+PyObject *PyString_AsDecodedString(PyObject *str,
const char *encoding,
const char *errors)
{
PyObject *v;
- v = PyBytes_AsDecodedObject(str, encoding, errors);
+ v = PyString_AsDecodedObject(str, encoding, errors);
if (v == NULL)
goto onError;
@@ -421,7 +421,7 @@
goto onError;
}
#endif
- if (!PyBytes_Check(v)) {
+ if (!PyString_Check(v)) {
PyErr_Format(PyExc_TypeError,
"decoder did not return a string object (type=%.400s)",
Py_TYPE(v)->tp_name);
@@ -435,28 +435,28 @@
return NULL;
}
-PyObject *PyBytes_Encode(const char *s,
+PyObject *PyString_Encode(const char *s,
Py_ssize_t size,
const char *encoding,
const char *errors)
{
PyObject *v, *str;
- str = PyBytes_FromStringAndSize(s, size);
+ str = PyString_FromStringAndSize(s, size);
if (str == NULL)
return NULL;
- v = PyBytes_AsEncodedString(str, encoding, errors);
+ v = PyString_AsEncodedString(str, encoding, errors);
Py_DECREF(str);
return v;
}
-PyObject *PyBytes_AsEncodedObject(PyObject *str,
+PyObject *PyString_AsEncodedObject(PyObject *str,
const char *encoding,
const char *errors)
{
PyObject *v;
- if (!PyBytes_Check(str)) {
+ if (!PyString_Check(str)) {
PyErr_BadArgument();
goto onError;
}
@@ -481,13 +481,13 @@
return NULL;
}
-PyObject *PyBytes_AsEncodedString(PyObject *str,
+PyObject *PyString_AsEncodedString(PyObject *str,
const char *encoding,
const char *errors)
{
PyObject *v;
- v = PyBytes_AsEncodedObject(str, encoding, errors);
+ v = PyString_AsEncodedObject(str, encoding, errors);
if (v == NULL)
goto onError;
@@ -501,7 +501,7 @@
goto onError;
}
#endif
- if (!PyBytes_Check(v)) {
+ if (!PyString_Check(v)) {
PyErr_Format(PyExc_TypeError,
"encoder did not return a string object (type=%.400s)",
Py_TYPE(v)->tp_name);
@@ -518,7 +518,7 @@
static void
string_dealloc(PyObject *op)
{
- switch (PyBytes_CHECK_INTERNED(op)) {
+ switch (PyString_CHECK_INTERNED(op)) {
case SSTATE_NOT_INTERNED:
break;
@@ -544,7 +544,7 @@
the string is UTF-8 encoded and should be re-encoded in the
specified encoding. */
-PyObject *PyBytes_DecodeEscape(const char *s,
+PyObject *PyString_DecodeEscape(const char *s,
Py_ssize_t len,
const char *errors,
Py_ssize_t unicode,
@@ -555,10 +555,10 @@
const char *end;
PyObject *v;
Py_ssize_t newlen = recode_encoding ? 4*len:len;
- v = PyBytes_FromStringAndSize((char *)NULL, newlen);
+ v = PyString_FromStringAndSize((char *)NULL, newlen);
if (v == NULL)
return NULL;
- p = buf = PyBytes_AsString(v);
+ p = buf = PyString_AsString(v);
end = s + len;
while (s < end) {
if (*s != '\\') {
@@ -582,9 +582,9 @@
if (!w) goto failed;
/* Append bytes to output buffer. */
- assert(PyBytes_Check(w));
- r = PyBytes_AS_STRING(w);
- rn = PyBytes_GET_SIZE(w);
+ assert(PyString_Check(w));
+ r = PyString_AS_STRING(w);
+ rn = PyString_GET_SIZE(w);
Py_MEMCPY(p, r, rn);
p += rn;
Py_DECREF(w);
@@ -687,7 +687,7 @@
}
}
if (p-buf < newlen)
- _PyBytes_Resize(&v, p - buf);
+ _PyString_Resize(&v, p - buf);
return v;
failed:
Py_DECREF(v);
@@ -702,7 +702,7 @@
{
char *s;
Py_ssize_t len;
- if (PyBytes_AsStringAndSize(op, &s, &len))
+ if (PyString_AsStringAndSize(op, &s, &len))
return -1;
return len;
}
@@ -712,29 +712,29 @@
{
char *s;
Py_ssize_t len;
- if (PyBytes_AsStringAndSize(op, &s, &len))
+ if (PyString_AsStringAndSize(op, &s, &len))
return NULL;
return s;
}
Py_ssize_t
-PyBytes_Size(register PyObject *op)
+PyString_Size(register PyObject *op)
{
- if (!PyBytes_Check(op))
+ if (!PyString_Check(op))
return string_getsize(op);
return Py_SIZE(op);
}
/*const*/ char *
-PyBytes_AsString(register PyObject *op)
+PyString_AsString(register PyObject *op)
{
- if (!PyBytes_Check(op))
+ if (!PyString_Check(op))
return string_getbuffer(op);
- return ((PyBytesObject *)op) -> ob_sval;
+ return ((PyStringObject *)op) -> ob_sval;
}
int
-PyBytes_AsStringAndSize(register PyObject *obj,
+PyString_AsStringAndSize(register PyObject *obj,
register char **s,
register Py_ssize_t *len)
{
@@ -743,7 +743,7 @@
return -1;
}
- if (!PyBytes_Check(obj)) {
+ if (!PyString_Check(obj)) {
#ifdef Py_USING_UNICODE
if (PyUnicode_Check(obj)) {
obj = _PyUnicode_AsDefaultEncodedString(obj, NULL);
@@ -760,10 +760,10 @@
}
}
- *s = PyBytes_AS_STRING(obj);
+ *s = PyString_AS_STRING(obj);
if (len != NULL)
- *len = PyBytes_GET_SIZE(obj);
- else if (strlen(*s) != (size_t)PyBytes_GET_SIZE(obj)) {
+ *len = PyString_GET_SIZE(obj);
+ else if (strlen(*s) != (size_t)PyString_GET_SIZE(obj)) {
PyErr_SetString(PyExc_TypeError,
"expected string without null bytes");
return -1;
@@ -781,23 +781,23 @@
#include "stringlib/find.h"
#include "stringlib/partition.h"
-#define _Py_InsertThousandsGrouping _PyBytes_InsertThousandsGrouping
+#define _Py_InsertThousandsGrouping _PyString_InsertThousandsGrouping
#include "stringlib/localeutil.h"
static int
-string_print(PyBytesObject *op, FILE *fp, int flags)
+string_print(PyStringObject *op, FILE *fp, int flags)
{
Py_ssize_t i, str_len;
char c;
int quote;
/* XXX Ought to check for interrupts when writing long strings */
- if (! PyBytes_CheckExact(op)) {
+ if (! PyString_CheckExact(op)) {
int ret;
/* A str subclass may have its own __str__ method. */
- op = (PyBytesObject *) PyObject_Str((PyObject *)op);
+ op = (PyStringObject *) PyObject_Str((PyObject *)op);
if (op == NULL)
return -1;
ret = string_print(op, fp, flags);
@@ -860,9 +860,9 @@
}
PyObject *
-PyBytes_Repr(PyObject *obj, int smartquotes)
+PyString_Repr(PyObject *obj, int smartquotes)
{
- register PyBytesObject* op = (PyBytesObject*) obj;
+ register PyStringObject* op = (PyStringObject*) obj;
size_t newsize = 2 + 4 * Py_SIZE(op);
PyObject *v;
if (newsize > PY_SSIZE_T_MAX || newsize / 4 != Py_SIZE(op)) {
@@ -870,7 +870,7 @@
"string is too large to make repr");
return NULL;
}
- v = PyBytes_FromStringAndSize((char *)NULL, newsize);
+ v = PyString_FromStringAndSize((char *)NULL, newsize);
if (v == NULL) {
return NULL;
}
@@ -887,12 +887,12 @@
!memchr(op->ob_sval, '"', Py_SIZE(op)))
quote = '"';
- p = PyBytes_AS_STRING(v);
+ p = PyString_AS_STRING(v);
*p++ = quote;
for (i = 0; i < Py_SIZE(op); i++) {
/* There's at least enough room for a hex escape
and a closing quote. */
- assert(newsize - (p - PyBytes_AS_STRING(v)) >= 5);
+ assert(newsize - (p - PyString_AS_STRING(v)) >= 5);
c = op->ob_sval[i];
if (c == quote || c == '\\')
*p++ = '\\', *p++ = c;
@@ -912,11 +912,11 @@
else
*p++ = c;
}
- assert(newsize - (p - PyBytes_AS_STRING(v)) >= 1);
+ assert(newsize - (p - PyString_AS_STRING(v)) >= 1);
*p++ = quote;
*p = '\0';
- _PyBytes_Resize(
- &v, (p - PyBytes_AS_STRING(v)));
+ _PyString_Resize(
+ &v, (p - PyString_AS_STRING(v)));
return v;
}
}
@@ -924,36 +924,36 @@
static PyObject *
string_repr(PyObject *op)
{
- return PyBytes_Repr(op, 1);
+ return PyString_Repr(op, 1);
}
static PyObject *
string_str(PyObject *s)
{
- assert(PyBytes_Check(s));
- if (PyBytes_CheckExact(s)) {
+ assert(PyString_Check(s));
+ if (PyString_CheckExact(s)) {
Py_INCREF(s);
return s;
}
else {
/* Subtype -- return genuine string with the same value. */
- PyBytesObject *t = (PyBytesObject *) s;
- return PyBytes_FromStringAndSize(t->ob_sval, Py_SIZE(t));
+ PyStringObject *t = (PyStringObject *) s;
+ return PyString_FromStringAndSize(t->ob_sval, Py_SIZE(t));
}
}
static Py_ssize_t
-string_length(PyBytesObject *a)
+string_length(PyStringObject *a)
{
return Py_SIZE(a);
}
static PyObject *
-string_concat(register PyBytesObject *a, register PyObject *bb)
+string_concat(register PyStringObject *a, register PyObject *bb)
{
register Py_ssize_t size;
- register PyBytesObject *op;
- if (!PyBytes_Check(bb)) {
+ register PyStringObject *op;
+ if (!PyString_Check(bb)) {
#ifdef Py_USING_UNICODE
if (PyUnicode_Check(bb))
return PyUnicode_Concat((PyObject *)a, bb);
@@ -965,10 +965,10 @@
Py_TYPE(bb)->tp_name);
return NULL;
}
-#define b ((PyBytesObject *)bb)
+#define b ((PyStringObject *)bb)
/* Optimize cases with empty left or right operand */
if ((Py_SIZE(a) == 0 || Py_SIZE(b) == 0) &&
- PyBytes_CheckExact(a) && PyBytes_CheckExact(b)) {
+ PyString_CheckExact(a) && PyString_CheckExact(b)) {
if (Py_SIZE(a) == 0) {
Py_INCREF(bb);
return bb;
@@ -984,10 +984,10 @@
}
/* Inline PyObject_NewVar */
- op = (PyBytesObject *)PyObject_MALLOC(sizeof(PyBytesObject) + size);
+ op = (PyStringObject *)PyObject_MALLOC(sizeof(PyStringObject) + size);
if (op == NULL)
return PyErr_NoMemory();
- PyObject_INIT_VAR(op, &PyBytes_Type, size);
+ PyObject_INIT_VAR(op, &PyString_Type, size);
op->ob_shash = -1;
op->ob_sstate = SSTATE_NOT_INTERNED;
Py_MEMCPY(op->ob_sval, a->ob_sval, Py_SIZE(a));
@@ -998,12 +998,12 @@
}
static PyObject *
-string_repeat(register PyBytesObject *a, register Py_ssize_t n)
+string_repeat(register PyStringObject *a, register Py_ssize_t n)
{
register Py_ssize_t i;
register Py_ssize_t j;
register Py_ssize_t size;
- register PyBytesObject *op;
+ register PyStringObject *op;
size_t nbytes;
if (n < 0)
n = 0;
@@ -1016,21 +1016,21 @@
"repeated string is too long");
return NULL;
}
- if (size == Py_SIZE(a) && PyBytes_CheckExact(a)) {
+ if (size == Py_SIZE(a) && PyString_CheckExact(a)) {
Py_INCREF(a);
return (PyObject *)a;
}
nbytes = (size_t)size;
- if (nbytes + sizeof(PyBytesObject) <= nbytes) {
+ if (nbytes + sizeof(PyStringObject) <= nbytes) {
PyErr_SetString(PyExc_OverflowError,
"repeated string is too long");
return NULL;
}
- op = (PyBytesObject *)
- PyObject_MALLOC(sizeof(PyBytesObject) + nbytes);
+ op = (PyStringObject *)
+ PyObject_MALLOC(sizeof(PyStringObject) + nbytes);
if (op == NULL)
return PyErr_NoMemory();
- PyObject_INIT_VAR(op, &PyBytes_Type, size);
+ PyObject_INIT_VAR(op, &PyString_Type, size);
op->ob_shash = -1;
op->ob_sstate = SSTATE_NOT_INTERNED;
op->ob_sval[size] = '\0';
@@ -1054,7 +1054,7 @@
/* String slice a[i:j] consists of characters a[i] ... a[j-1] */
static PyObject *
-string_slice(register PyBytesObject *a, register Py_ssize_t i,
+string_slice(register PyStringObject *a, register Py_ssize_t i,
register Py_ssize_t j)
/* j -- may be negative! */
{
@@ -1064,25 +1064,25 @@
j = 0; /* Avoid signed/unsigned bug in next line */
if (j > Py_SIZE(a))
j = Py_SIZE(a);
- if (i == 0 && j == Py_SIZE(a) && PyBytes_CheckExact(a)) {
+ if (i == 0 && j == Py_SIZE(a) && PyString_CheckExact(a)) {
/* It's the same as a */
Py_INCREF(a);
return (PyObject *)a;
}
if (j < i)
j = i;
- return PyBytes_FromStringAndSize(a->ob_sval + i, j-i);
+ return PyString_FromStringAndSize(a->ob_sval + i, j-i);
}
static int
string_contains(PyObject *str_obj, PyObject *sub_obj)
{
- if (!PyBytes_CheckExact(sub_obj)) {
+ if (!PyString_CheckExact(sub_obj)) {
#ifdef Py_USING_UNICODE
if (PyUnicode_Check(sub_obj))
return PyUnicode_Contains(str_obj, sub_obj);
#endif
- if (!PyBytes_Check(sub_obj)) {
+ if (!PyString_Check(sub_obj)) {
PyErr_Format(PyExc_TypeError,
"'in <string>' requires string as left operand, "
"not %.200s", Py_TYPE(sub_obj)->tp_name);
@@ -1094,7 +1094,7 @@
}
static PyObject *
-string_item(PyBytesObject *a, register Py_ssize_t i)
+string_item(PyStringObject *a, register Py_ssize_t i)
{
char pchar;
PyObject *v;
@@ -1105,7 +1105,7 @@
pchar = a->ob_sval[i];
v = (PyObject *)characters[pchar & UCHAR_MAX];
if (v == NULL)
- v = PyBytes_FromStringAndSize(&pchar, 1);
+ v = PyString_FromStringAndSize(&pchar, 1);
else {
#ifdef COUNT_ALLOCS
one_strings++;
@@ -1116,7 +1116,7 @@
}
static PyObject*
-string_richcompare(PyBytesObject *a, PyBytesObject *b, int op)
+string_richcompare(PyStringObject *a, PyStringObject *b, int op)
{
int c;
Py_ssize_t len_a, len_b;
@@ -1124,7 +1124,7 @@
PyObject *result;
/* Make sure both arguments are strings. */
- if (!(PyBytes_Check(a) && PyBytes_Check(b))) {
+ if (!(PyString_Check(a) && PyString_Check(b))) {
result = Py_NotImplemented;
goto out;
}
@@ -1178,17 +1178,17 @@
}
int
-_PyBytes_Eq(PyObject *o1, PyObject *o2)
+_PyString_Eq(PyObject *o1, PyObject *o2)
{
- PyBytesObject *a = (PyBytesObject*) o1;
- PyBytesObject *b = (PyBytesObject*) o2;
+ PyStringObject *a = (PyStringObject*) o1;
+ PyStringObject *b = (PyStringObject*) o2;
return Py_SIZE(a) == Py_SIZE(b)
&& *a->ob_sval == *b->ob_sval
&& memcmp(a->ob_sval, b->ob_sval, Py_SIZE(a)) == 0;
}
static long
-string_hash(PyBytesObject *a)
+string_hash(PyStringObject *a)
{
register Py_ssize_t len;
register unsigned char *p;
@@ -1209,14 +1209,14 @@
}
static PyObject*
-string_subscript(PyBytesObject* self, PyObject* item)
+string_subscript(PyStringObject* self, PyObject* item)
{
if (PyIndex_Check(item)) {
Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
if (i == -1 && PyErr_Occurred())
return NULL;
if (i < 0)
- i += PyBytes_GET_SIZE(self);
+ i += PyString_GET_SIZE(self);
return string_item(self, i);
}
else if (PySlice_Check(item)) {
@@ -1226,27 +1226,27 @@
PyObject* result;
if (PySlice_GetIndicesEx((PySliceObject*)item,
- PyBytes_GET_SIZE(self),
+ PyString_GET_SIZE(self),
&start, &stop, &step, &slicelength) < 0) {
return NULL;
}
if (slicelength <= 0) {
- return PyBytes_FromStringAndSize("", 0);
+ return PyString_FromStringAndSize("", 0);
}
else if (start == 0 && step == 1 &&
- slicelength == PyBytes_GET_SIZE(self) &&
- PyBytes_CheckExact(self)) {
+ slicelength == PyString_GET_SIZE(self) &&
+ PyString_CheckExact(self)) {
Py_INCREF(self);
return (PyObject *)self;
}
else if (step == 1) {
- return PyBytes_FromStringAndSize(
- PyBytes_AS_STRING(self) + start,
+ return PyString_FromStringAndSize(
+ PyString_AS_STRING(self) + start,
slicelength);
}
else {
- source_buf = PyBytes_AsString((PyObject*)self);
+ source_buf = PyString_AsString((PyObject*)self);
result_buf = (char *)PyMem_Malloc(slicelength);
if (result_buf == NULL)
return PyErr_NoMemory();
@@ -1256,7 +1256,7 @@
result_buf[i] = source_buf[cur];
}
- result = PyBytes_FromStringAndSize(result_buf,
+ result = PyString_FromStringAndSize(result_buf,
slicelength);
PyMem_Free(result_buf);
return result;
@@ -1271,7 +1271,7 @@
}
static Py_ssize_t
-string_buffer_getreadbuf(PyBytesObject *self, Py_ssize_t index, const void **ptr)
+string_buffer_getreadbuf(PyStringObject *self, Py_ssize_t index, const void **ptr)
{
if ( index != 0 ) {
PyErr_SetString(PyExc_SystemError,
@@ -1283,7 +1283,7 @@
}
static Py_ssize_t
-string_buffer_getwritebuf(PyBytesObject *self, Py_ssize_t index, const void **ptr)
+string_buffer_getwritebuf(PyStringObject *self, Py_ssize_t index, const void **ptr)
{
PyErr_SetString(PyExc_TypeError,
"Cannot use string as modifiable buffer");
@@ -1291,7 +1291,7 @@
}
static Py_ssize_t
-string_buffer_getsegcount(PyBytesObject *self, Py_ssize_t *lenp)
+string_buffer_getsegcount(PyStringObject *self, Py_ssize_t *lenp)
{
if ( lenp )
*lenp = Py_SIZE(self);
@@ -1299,7 +1299,7 @@
}
static Py_ssize_t
-string_buffer_getcharbuf(PyBytesObject *self, Py_ssize_t index, const char **ptr)
+string_buffer_getcharbuf(PyStringObject *self, Py_ssize_t index, const char **ptr)
{
if ( index != 0 ) {
PyErr_SetString(PyExc_SystemError,
@@ -1311,7 +1311,7 @@
}
static int
-string_buffer_getbuffer(PyBytesObject *self, Py_buffer *view, int flags)
+string_buffer_getbuffer(PyStringObject *self, Py_buffer *view, int flags)
{
return PyBuffer_FillInfo(view, (void *)self->ob_sval, Py_SIZE(self),
0, flags);
@@ -1376,7 +1376,7 @@
(maxsplit >= MAX_PREALLOC ? MAX_PREALLOC : maxsplit+1)
#define SPLIT_APPEND(data, left, right) \
- str = PyBytes_FromStringAndSize((data) + (left), \
+ str = PyString_FromStringAndSize((data) + (left), \
(right) - (left)); \
if (str == NULL) \
goto onError; \
@@ -1388,7 +1388,7 @@
Py_DECREF(str);
#define SPLIT_ADD(data, left, right) { \
- str = PyBytes_FromStringAndSize((data) + (left), \
+ str = PyString_FromStringAndSize((data) + (left), \
(right) - (left)); \
if (str == NULL) \
goto onError; \
@@ -1413,9 +1413,9 @@
#define RSKIP_NONSPACE(s, i) { while (i>=0 && !isspace(Py_CHARMASK(s[i]))) i--; }
Py_LOCAL_INLINE(PyObject *)
-split_whitespace(PyBytesObject *self, Py_ssize_t len, Py_ssize_t maxsplit)
+split_whitespace(PyStringObject *self, Py_ssize_t len, Py_ssize_t maxsplit)
{
- const char *s = PyBytes_AS_STRING(self);
+ const char *s = PyString_AS_STRING(self);
Py_ssize_t i, j, count=0;
PyObject *str;
PyObject *list = PyList_New(PREALLOC_SIZE(maxsplit));
@@ -1430,7 +1430,7 @@
if (i==len) break;
j = i; i++;
SKIP_NONSPACE(s, i, len);
- if (j == 0 && i == len && PyBytes_CheckExact(self)) {
+ if (j == 0 && i == len && PyString_CheckExact(self)) {
/* No whitespace in self, so just use it as list[0] */
Py_INCREF(self);
PyList_SET_ITEM(list, 0, (PyObject *)self);
@@ -1455,9 +1455,9 @@
}
Py_LOCAL_INLINE(PyObject *)
-split_char(PyBytesObject *self, Py_ssize_t len, char ch, Py_ssize_t maxcount)
+split_char(PyStringObject *self, Py_ssize_t len, char ch, Py_ssize_t maxcount)
{
- const char *s = PyBytes_AS_STRING(self);
+ const char *s = PyString_AS_STRING(self);
register Py_ssize_t i, j, count=0;
PyObject *str;
PyObject *list = PyList_New(PREALLOC_SIZE(maxcount));
@@ -1476,7 +1476,7 @@
}
}
}
- if (i == 0 && count == 0 && PyBytes_CheckExact(self)) {
+ if (i == 0 && count == 0 && PyString_CheckExact(self)) {
/* ch not in self, so just use self as list[0] */
Py_INCREF(self);
PyList_SET_ITEM(list, 0, (PyObject *)self);
@@ -1503,11 +1503,11 @@
from the result.");
static PyObject *
-string_split(PyBytesObject *self, PyObject *args)
+string_split(PyStringObject *self, PyObject *args)
{
- Py_ssize_t len = PyBytes_GET_SIZE(self), n, i, j;
+ Py_ssize_t len = PyString_GET_SIZE(self), n, i, j;
Py_ssize_t maxsplit = -1, count=0;
- const char *s = PyBytes_AS_STRING(self), *sub;
+ const char *s = PyString_AS_STRING(self), *sub;
PyObject *list, *str, *subobj = Py_None;
#ifdef USE_FAST
Py_ssize_t pos;
@@ -1519,9 +1519,9 @@
maxsplit = PY_SSIZE_T_MAX;
if (subobj == Py_None)
return split_whitespace(self, len, maxsplit);
- if (PyBytes_Check(subobj)) {
- sub = PyBytes_AS_STRING(subobj);
- n = PyBytes_GET_SIZE(subobj);
+ if (PyString_Check(subobj)) {
+ sub = PyString_AS_STRING(subobj);
+ n = PyString_GET_SIZE(subobj);
}
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(subobj))
@@ -1580,14 +1580,14 @@
found, returns S and two empty strings.");
static PyObject *
-string_partition(PyBytesObject *self, PyObject *sep_obj)
+string_partition(PyStringObject *self, PyObject *sep_obj)
{
const char *sep;
Py_ssize_t sep_len;
- if (PyBytes_Check(sep_obj)) {
- sep = PyBytes_AS_STRING(sep_obj);
- sep_len = PyBytes_GET_SIZE(sep_obj);
+ if (PyString_Check(sep_obj)) {
+ sep = PyString_AS_STRING(sep_obj);
+ sep_len = PyString_GET_SIZE(sep_obj);
}
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(sep_obj))
@@ -1598,7 +1598,7 @@
return stringlib_partition(
(PyObject*) self,
- PyBytes_AS_STRING(self), PyBytes_GET_SIZE(self),
+ PyString_AS_STRING(self), PyString_GET_SIZE(self),
sep_obj, sep, sep_len
);
}
@@ -1611,14 +1611,14 @@
separator is not found, returns two empty strings and S.");
static PyObject *
-string_rpartition(PyBytesObject *self, PyObject *sep_obj)
+string_rpartition(PyStringObject *self, PyObject *sep_obj)
{
const char *sep;
Py_ssize_t sep_len;
- if (PyBytes_Check(sep_obj)) {
- sep = PyBytes_AS_STRING(sep_obj);
- sep_len = PyBytes_GET_SIZE(sep_obj);
+ if (PyString_Check(sep_obj)) {
+ sep = PyString_AS_STRING(sep_obj);
+ sep_len = PyString_GET_SIZE(sep_obj);
}
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(sep_obj))
@@ -1629,15 +1629,15 @@
return stringlib_rpartition(
(PyObject*) self,
- PyBytes_AS_STRING(self), PyBytes_GET_SIZE(self),
+ PyString_AS_STRING(self), PyString_GET_SIZE(self),
sep_obj, sep, sep_len
);
}
Py_LOCAL_INLINE(PyObject *)
-rsplit_whitespace(PyBytesObject *self, Py_ssize_t len, Py_ssize_t maxsplit)
+rsplit_whitespace(PyStringObject *self, Py_ssize_t len, Py_ssize_t maxsplit)
{
- const char *s = PyBytes_AS_STRING(self);
+ const char *s = PyString_AS_STRING(self);
Py_ssize_t i, j, count=0;
PyObject *str;
PyObject *list = PyList_New(PREALLOC_SIZE(maxsplit));
@@ -1652,7 +1652,7 @@
if (i<0) break;
j = i; i--;
RSKIP_NONSPACE(s, i);
- if (j == len-1 && i < 0 && PyBytes_CheckExact(self)) {
+ if (j == len-1 && i < 0 && PyString_CheckExact(self)) {
/* No whitespace in self, so just use it as list[0] */
Py_INCREF(self);
PyList_SET_ITEM(list, 0, (PyObject *)self);
@@ -1679,9 +1679,9 @@
}
Py_LOCAL_INLINE(PyObject *)
-rsplit_char(PyBytesObject *self, Py_ssize_t len, char ch, Py_ssize_t maxcount)
+rsplit_char(PyStringObject *self, Py_ssize_t len, char ch, Py_ssize_t maxcount)
{
- const char *s = PyBytes_AS_STRING(self);
+ const char *s = PyString_AS_STRING(self);
register Py_ssize_t i, j, count=0;
PyObject *str;
PyObject *list = PyList_New(PREALLOC_SIZE(maxcount));
@@ -1699,7 +1699,7 @@
}
}
}
- if (i < 0 && count == 0 && PyBytes_CheckExact(self)) {
+ if (i < 0 && count == 0 && PyString_CheckExact(self)) {
/* ch not in self, so just use self as list[0] */
Py_INCREF(self);
PyList_SET_ITEM(list, 0, (PyObject *)self);
@@ -1728,9 +1728,9 @@
is a separator.");
static PyObject *
-string_rsplit(PyBytesObject *self, PyObject *args)
+string_rsplit(PyStringObject *self, PyObject *args)
{
- Py_ssize_t len = PyBytes_GET_SIZE(self), n, i, j;
+ Py_ssize_t len = PyString_GET_SIZE(self), n, i, j;
Py_ssize_t maxsplit = -1, count=0;
const char *s, *sub;
PyObject *list, *str, *subobj = Py_None;
@@ -1741,9 +1741,9 @@
maxsplit = PY_SSIZE_T_MAX;
if (subobj == Py_None)
return rsplit_whitespace(self, len, maxsplit);
- if (PyBytes_Check(subobj)) {
- sub = PyBytes_AS_STRING(subobj);
- n = PyBytes_GET_SIZE(subobj);
+ if (PyString_Check(subobj)) {
+ sub = PyString_AS_STRING(subobj);
+ n = PyString_GET_SIZE(subobj);
}
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(subobj))
@@ -1766,7 +1766,7 @@
j = len;
i = j - n;
- s = PyBytes_AS_STRING(self);
+ s = PyString_AS_STRING(self);
while ( (i >= 0) && (maxsplit-- > 0) ) {
for (; i>=0; i--) {
if (Py_STRING_MATCH(s, i, sub, n)) {
@@ -1796,10 +1796,10 @@
sequence. The separator between elements is S.");
static PyObject *
-string_join(PyBytesObject *self, PyObject *orig)
+string_join(PyStringObject *self, PyObject *orig)
{
- char *sep = PyBytes_AS_STRING(self);
- const Py_ssize_t seplen = PyBytes_GET_SIZE(self);
+ char *sep = PyString_AS_STRING(self);
+ const Py_ssize_t seplen = PyString_GET_SIZE(self);
PyObject *res = NULL;
char *p;
Py_ssize_t seqlen = 0;
@@ -1815,11 +1815,11 @@
seqlen = PySequence_Size(seq);
if (seqlen == 0) {
Py_DECREF(seq);
- return PyBytes_FromString("");
+ return PyString_FromString("");
}
if (seqlen == 1) {
item = PySequence_Fast_GET_ITEM(seq, 0);
- if (PyBytes_CheckExact(item) || PyUnicode_CheckExact(item)) {
+ if (PyString_CheckExact(item) || PyUnicode_CheckExact(item)) {
Py_INCREF(item);
Py_DECREF(seq);
return item;
@@ -1835,7 +1835,7 @@
for (i = 0; i < seqlen; i++) {
const size_t old_sz = sz;
item = PySequence_Fast_GET_ITEM(seq, i);
- if (!PyBytes_Check(item)){
+ if (!PyString_Check(item)){
#ifdef Py_USING_UNICODE
if (PyUnicode_Check(item)) {
/* Defer to Unicode join.
@@ -1856,7 +1856,7 @@
Py_DECREF(seq);
return NULL;
}
- sz += PyBytes_GET_SIZE(item);
+ sz += PyString_GET_SIZE(item);
if (i != 0)
sz += seplen;
if (sz < old_sz || sz > PY_SSIZE_T_MAX) {
@@ -1868,19 +1868,19 @@
}
/* Allocate result space. */
- res = PyBytes_FromStringAndSize((char*)NULL, sz);
+ res = PyString_FromStringAndSize((char*)NULL, sz);
if (res == NULL) {
Py_DECREF(seq);
return NULL;
}
/* Catenate everything. */
- p = PyBytes_AS_STRING(res);
+ p = PyString_AS_STRING(res);
for (i = 0; i < seqlen; ++i) {
size_t n;
item = PySequence_Fast_GET_ITEM(seq, i);
- n = PyBytes_GET_SIZE(item);
- Py_MEMCPY(p, PyBytes_AS_STRING(item), n);
+ n = PyString_GET_SIZE(item);
+ Py_MEMCPY(p, PyString_AS_STRING(item), n);
p += n;
if (i < seqlen - 1) {
Py_MEMCPY(p, sep, seplen);
@@ -1893,11 +1893,11 @@
}
PyObject *
-_PyBytes_Join(PyObject *sep, PyObject *x)
+_PyString_Join(PyObject *sep, PyObject *x)
{
- assert(sep != NULL && PyBytes_Check(sep));
+ assert(sep != NULL && PyString_Check(sep));
assert(x != NULL);
- return string_join((PyBytesObject *)sep, x);
+ return string_join((PyStringObject *)sep, x);
}
Py_LOCAL_INLINE(void)
@@ -1916,7 +1916,7 @@
}
Py_LOCAL_INLINE(Py_ssize_t)
-string_find_internal(PyBytesObject *self, PyObject *args, int dir)
+string_find_internal(PyStringObject *self, PyObject *args, int dir)
{
PyObject *subobj;
const char *sub;
@@ -1937,9 +1937,9 @@
if (!_PyEval_SliceIndex(obj_end, &end))
return -2;
- if (PyBytes_Check(subobj)) {
- sub = PyBytes_AS_STRING(subobj);
- sub_len = PyBytes_GET_SIZE(subobj);
+ if (PyString_Check(subobj)) {
+ sub = PyString_AS_STRING(subobj);
+ sub_len = PyString_GET_SIZE(subobj);
}
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(subobj))
@@ -1953,11 +1953,11 @@
if (dir > 0)
return stringlib_find_slice(
- PyBytes_AS_STRING(self), PyBytes_GET_SIZE(self),
+ PyString_AS_STRING(self), PyString_GET_SIZE(self),
sub, sub_len, start, end);
else
return stringlib_rfind_slice(
- PyBytes_AS_STRING(self), PyBytes_GET_SIZE(self),
+ PyString_AS_STRING(self), PyString_GET_SIZE(self),
sub, sub_len, start, end);
}
@@ -1972,7 +1972,7 @@
Return -1 on failure.");
static PyObject *
-string_find(PyBytesObject *self, PyObject *args)
+string_find(PyStringObject *self, PyObject *args)
{
Py_ssize_t result = string_find_internal(self, args, +1);
if (result == -2)
@@ -1987,7 +1987,7 @@
Like S.find() but raise ValueError when the substring is not found.");
static PyObject *
-string_index(PyBytesObject *self, PyObject *args)
+string_index(PyStringObject *self, PyObject *args)
{
Py_ssize_t result = string_find_internal(self, args, +1);
if (result == -2)
@@ -2011,7 +2011,7 @@
Return -1 on failure.");
static PyObject *
-string_rfind(PyBytesObject *self, PyObject *args)
+string_rfind(PyStringObject *self, PyObject *args)
{
Py_ssize_t result = string_find_internal(self, args, -1);
if (result == -2)
@@ -2026,7 +2026,7 @@
Like S.rfind() but raise ValueError when the substring is not found.");
static PyObject *
-string_rindex(PyBytesObject *self, PyObject *args)
+string_rindex(PyStringObject *self, PyObject *args)
{
Py_ssize_t result = string_find_internal(self, args, -1);
if (result == -2)
@@ -2041,12 +2041,12 @@
Py_LOCAL_INLINE(PyObject *)
-do_xstrip(PyBytesObject *self, int striptype, PyObject *sepobj)
+do_xstrip(PyStringObject *self, int striptype, PyObject *sepobj)
{
- char *s = PyBytes_AS_STRING(self);
- Py_ssize_t len = PyBytes_GET_SIZE(self);
- char *sep = PyBytes_AS_STRING(sepobj);
- Py_ssize_t seplen = PyBytes_GET_SIZE(sepobj);
+ char *s = PyString_AS_STRING(self);
+ Py_ssize_t len = PyString_GET_SIZE(self);
+ char *sep = PyString_AS_STRING(sepobj);
+ Py_ssize_t seplen = PyString_GET_SIZE(sepobj);
Py_ssize_t i, j;
i = 0;
@@ -2064,20 +2064,20 @@
j++;
}
- if (i == 0 && j == len && PyBytes_CheckExact(self)) {
+ if (i == 0 && j == len && PyString_CheckExact(self)) {
Py_INCREF(self);
return (PyObject*)self;
}
else
- return PyBytes_FromStringAndSize(s+i, j-i);
+ return PyString_FromStringAndSize(s+i, j-i);
}
Py_LOCAL_INLINE(PyObject *)
-do_strip(PyBytesObject *self, int striptype)
+do_strip(PyStringObject *self, int striptype)
{
- char *s = PyBytes_AS_STRING(self);
- Py_ssize_t len = PyBytes_GET_SIZE(self), i, j;
+ char *s = PyString_AS_STRING(self);
+ Py_ssize_t len = PyString_GET_SIZE(self), i, j;
i = 0;
if (striptype != RIGHTSTRIP) {
@@ -2094,17 +2094,17 @@
j++;
}
- if (i == 0 && j == len && PyBytes_CheckExact(self)) {
+ if (i == 0 && j == len && PyString_CheckExact(self)) {
Py_INCREF(self);
return (PyObject*)self;
}
else
- return PyBytes_FromStringAndSize(s+i, j-i);
+ return PyString_FromStringAndSize(s+i, j-i);
}
Py_LOCAL_INLINE(PyObject *)
-do_argstrip(PyBytesObject *self, int striptype, PyObject *args)
+do_argstrip(PyStringObject *self, int striptype, PyObject *args)
{
PyObject *sep = NULL;
@@ -2112,7 +2112,7 @@
return NULL;
if (sep != NULL && sep != Py_None) {
- if (PyBytes_Check(sep))
+ if (PyString_Check(sep))
return do_xstrip(self, striptype, sep);
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(sep)) {
@@ -2149,7 +2149,7 @@
If chars is unicode, S will be converted to unicode before stripping");
static PyObject *
-string_strip(PyBytesObject *self, PyObject *args)
+string_strip(PyStringObject *self, PyObject *args)
{
if (PyTuple_GET_SIZE(args) == 0)
return do_strip(self, BOTHSTRIP); /* Common case */
@@ -2166,7 +2166,7 @@
If chars is unicode, S will be converted to unicode before stripping");
static PyObject *
-string_lstrip(PyBytesObject *self, PyObject *args)
+string_lstrip(PyStringObject *self, PyObject *args)
{
if (PyTuple_GET_SIZE(args) == 0)
return do_strip(self, LEFTSTRIP); /* Common case */
@@ -2183,7 +2183,7 @@
If chars is unicode, S will be converted to unicode before stripping");
static PyObject *
-string_rstrip(PyBytesObject *self, PyObject *args)
+string_rstrip(PyStringObject *self, PyObject *args)
{
if (PyTuple_GET_SIZE(args) == 0)
return do_strip(self, RIGHTSTRIP); /* Common case */
@@ -2203,19 +2203,19 @@
#endif
static PyObject *
-string_lower(PyBytesObject *self)
+string_lower(PyStringObject *self)
{
char *s;
- Py_ssize_t i, n = PyBytes_GET_SIZE(self);
+ Py_ssize_t i, n = PyString_GET_SIZE(self);
PyObject *newobj;
- newobj = PyBytes_FromStringAndSize(NULL, n);
+ newobj = PyString_FromStringAndSize(NULL, n);
if (!newobj)
return NULL;
- s = PyBytes_AS_STRING(newobj);
+ s = PyString_AS_STRING(newobj);
- Py_MEMCPY(s, PyBytes_AS_STRING(self), n);
+ Py_MEMCPY(s, PyString_AS_STRING(self), n);
for (i = 0; i < n; i++) {
int c = Py_CHARMASK(s[i]);
@@ -2236,19 +2236,19 @@
#endif
static PyObject *
-string_upper(PyBytesObject *self)
+string_upper(PyStringObject *self)
{
char *s;
- Py_ssize_t i, n = PyBytes_GET_SIZE(self);
+ Py_ssize_t i, n = PyString_GET_SIZE(self);
PyObject *newobj;
- newobj = PyBytes_FromStringAndSize(NULL, n);
+ newobj = PyString_FromStringAndSize(NULL, n);
if (!newobj)
return NULL;
- s = PyBytes_AS_STRING(newobj);
+ s = PyString_AS_STRING(newobj);
- Py_MEMCPY(s, PyBytes_AS_STRING(self), n);
+ Py_MEMCPY(s, PyString_AS_STRING(self), n);
for (i = 0; i < n; i++) {
int c = Py_CHARMASK(s[i]);
@@ -2266,17 +2266,17 @@
characters, all remaining cased characters have lowercase.");
static PyObject*
-string_title(PyBytesObject *self)
+string_title(PyStringObject *self)
{
- char *s = PyBytes_AS_STRING(self), *s_new;
- Py_ssize_t i, n = PyBytes_GET_SIZE(self);
+ char *s = PyString_AS_STRING(self), *s_new;
+ Py_ssize_t i, n = PyString_GET_SIZE(self);
int previous_is_cased = 0;
PyObject *newobj;
- newobj = PyBytes_FromStringAndSize(NULL, n);
+ newobj = PyString_FromStringAndSize(NULL, n);
if (newobj == NULL)
return NULL;
- s_new = PyBytes_AsString(newobj);
+ s_new = PyString_AsString(newobj);
for (i = 0; i < n; i++) {
int c = Py_CHARMASK(*s++);
if (islower(c)) {
@@ -2301,16 +2301,16 @@
capitalized.");
static PyObject *
-string_capitalize(PyBytesObject *self)
+string_capitalize(PyStringObject *self)
{
- char *s = PyBytes_AS_STRING(self), *s_new;
- Py_ssize_t i, n = PyBytes_GET_SIZE(self);
+ char *s = PyString_AS_STRING(self), *s_new;
+ Py_ssize_t i, n = PyString_GET_SIZE(self);
PyObject *newobj;
- newobj = PyBytes_FromStringAndSize(NULL, n);
+ newobj = PyString_FromStringAndSize(NULL, n);
if (newobj == NULL)
return NULL;
- s_new = PyBytes_AsString(newobj);
+ s_new = PyString_AsString(newobj);
if (0 < n) {
int c = Py_CHARMASK(*s++);
if (islower(c))
@@ -2339,10 +2339,10 @@
as in slice notation.");
static PyObject *
-string_count(PyBytesObject *self, PyObject *args)
+string_count(PyStringObject *self, PyObject *args)
{
PyObject *sub_obj;
- const char *str = PyBytes_AS_STRING(self), *sub;
+ const char *str = PyString_AS_STRING(self), *sub;
Py_ssize_t sub_len;
Py_ssize_t start = 0, end = PY_SSIZE_T_MAX;
@@ -2350,9 +2350,9 @@
_PyEval_SliceIndex, &start, _PyEval_SliceIndex, &end))
return NULL;
- if (PyBytes_Check(sub_obj)) {
- sub = PyBytes_AS_STRING(sub_obj);
- sub_len = PyBytes_GET_SIZE(sub_obj);
+ if (PyString_Check(sub_obj)) {
+ sub = PyString_AS_STRING(sub_obj);
+ sub_len = PyString_GET_SIZE(sub_obj);
}
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(sub_obj)) {
@@ -2367,7 +2367,7 @@
else if (PyObject_AsCharBuffer(sub_obj, &sub, &sub_len))
return NULL;
- string_adjust_indices(&start, &end, PyBytes_GET_SIZE(self));
+ string_adjust_indices(&start, &end, PyString_GET_SIZE(self));
return PyInt_FromSsize_t(
stringlib_count(str + start, end - start, sub, sub_len)
@@ -2381,16 +2381,16 @@
converted to lowercase and vice versa.");
static PyObject *
-string_swapcase(PyBytesObject *self)
+string_swapcase(PyStringObject *self)
{
- char *s = PyBytes_AS_STRING(self), *s_new;
- Py_ssize_t i, n = PyBytes_GET_SIZE(self);
+ char *s = PyString_AS_STRING(self), *s_new;
+ Py_ssize_t i, n = PyString_GET_SIZE(self);
PyObject *newobj;
- newobj = PyBytes_FromStringAndSize(NULL, n);
+ newobj = PyString_FromStringAndSize(NULL, n);
if (newobj == NULL)
return NULL;
- s_new = PyBytes_AsString(newobj);
+ s_new = PyString_AsString(newobj);
for (i = 0; i < n; i++) {
int c = Py_CHARMASK(*s++);
if (islower(c)) {
@@ -2416,7 +2416,7 @@
translation table, which must be a string of length 256.");
static PyObject *
-string_translate(PyBytesObject *self, PyObject *args)
+string_translate(PyStringObject *self, PyObject *args)
{
register char *input, *output;
const char *table;
@@ -2432,9 +2432,9 @@
&tableobj, &delobj))
return NULL;
- if (PyBytes_Check(tableobj)) {
- table = PyBytes_AS_STRING(tableobj);
- tablen = PyBytes_GET_SIZE(tableobj);
+ if (PyString_Check(tableobj)) {
+ table = PyString_AS_STRING(tableobj);
+ tablen = PyString_GET_SIZE(tableobj);
}
else if (tableobj == Py_None) {
table = NULL;
@@ -2463,9 +2463,9 @@
}
if (delobj != NULL) {
- if (PyBytes_Check(delobj)) {
- del_table = PyBytes_AS_STRING(delobj);
- dellen = PyBytes_GET_SIZE(delobj);
+ if (PyString_Check(delobj)) {
+ del_table = PyString_AS_STRING(delobj);
+ dellen = PyString_GET_SIZE(delobj);
}
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(delobj)) {
@@ -2482,12 +2482,12 @@
dellen = 0;
}
- inlen = PyBytes_GET_SIZE(input_obj);
- result = PyBytes_FromStringAndSize((char *)NULL, inlen);
+ inlen = PyString_GET_SIZE(input_obj);
+ result = PyString_FromStringAndSize((char *)NULL, inlen);
if (result == NULL)
return NULL;
- output_start = output = PyBytes_AsString(result);
- input = PyBytes_AS_STRING(input_obj);
+ output_start = output = PyString_AsString(result);
+ input = PyString_AS_STRING(input_obj);
if (dellen == 0 && table != NULL) {
/* If no deletions are required, use faster code */
@@ -2496,7 +2496,7 @@
if (Py_CHARMASK((*output++ = table[c])) != c)
changed = 1;
}
- if (changed || !PyBytes_CheckExact(input_obj))
+ if (changed || !PyString_CheckExact(input_obj))
return result;
Py_DECREF(result);
Py_INCREF(input_obj);
@@ -2521,14 +2521,14 @@
continue;
changed = 1;
}
- if (!changed && PyBytes_CheckExact(input_obj)) {
+ if (!changed && PyString_CheckExact(input_obj)) {
Py_DECREF(result);
Py_INCREF(input_obj);
return input_obj;
}
/* Fix the size of the resulting string */
if (inlen > 0)
- _PyBytes_Resize(&result, output - output_start);
+ _PyString_Resize(&result, output - output_start);
return result;
}
@@ -2543,16 +2543,16 @@
/* String ops must return a string. */
/* If the object is subclass of string, create a copy */
-Py_LOCAL(PyBytesObject *)
-return_self(PyBytesObject *self)
+Py_LOCAL(PyStringObject *)
+return_self(PyStringObject *self)
{
- if (PyBytes_CheckExact(self)) {
+ if (PyString_CheckExact(self)) {
Py_INCREF(self);
return self;
}
- return (PyBytesObject *)PyBytes_FromStringAndSize(
- PyBytes_AS_STRING(self),
- PyBytes_GET_SIZE(self));
+ return (PyStringObject *)PyString_FromStringAndSize(
+ PyString_AS_STRING(self),
+ PyString_GET_SIZE(self));
}
Py_LOCAL_INLINE(Py_ssize_t)
@@ -2662,17 +2662,17 @@
/* Algorithms for different cases of string replacement */
/* len(self)>=1, from="", len(to)>=1, maxcount>=1 */
-Py_LOCAL(PyBytesObject *)
-replace_interleave(PyBytesObject *self,
+Py_LOCAL(PyStringObject *)
+replace_interleave(PyStringObject *self,
const char *to_s, Py_ssize_t to_len,
Py_ssize_t maxcount)
{
char *self_s, *result_s;
Py_ssize_t self_len, result_len;
Py_ssize_t count, i, product;
- PyBytesObject *result;
+ PyStringObject *result;
- self_len = PyBytes_GET_SIZE(self);
+ self_len = PyString_GET_SIZE(self);
/* 1 at the end plus 1 after every character */
count = self_len+1;
@@ -2694,12 +2694,12 @@
return NULL;
}
- if (! (result = (PyBytesObject *)
- PyBytes_FromStringAndSize(NULL, result_len)) )
+ if (! (result = (PyStringObject *)
+ PyString_FromStringAndSize(NULL, result_len)) )
return NULL;
- self_s = PyBytes_AS_STRING(self);
- result_s = PyBytes_AS_STRING(result);
+ self_s = PyString_AS_STRING(self);
+ result_s = PyString_AS_STRING(result);
/* TODO: special case single character, which doesn't need memcpy */
@@ -2722,18 +2722,18 @@
/* Special case for deleting a single character */
/* len(self)>=1, len(from)==1, to="", maxcount>=1 */
-Py_LOCAL(PyBytesObject *)
-replace_delete_single_character(PyBytesObject *self,
+Py_LOCAL(PyStringObject *)
+replace_delete_single_character(PyStringObject *self,
char from_c, Py_ssize_t maxcount)
{
char *self_s, *result_s;
char *start, *next, *end;
Py_ssize_t self_len, result_len;
Py_ssize_t count;
- PyBytesObject *result;
+ PyStringObject *result;
- self_len = PyBytes_GET_SIZE(self);
- self_s = PyBytes_AS_STRING(self);
+ self_len = PyString_GET_SIZE(self);
+ self_s = PyString_AS_STRING(self);
count = countchar(self_s, self_len, from_c, maxcount);
if (count == 0) {
@@ -2743,10 +2743,10 @@
result_len = self_len - count; /* from_len == 1 */
assert(result_len>=0);
- if ( (result = (PyBytesObject *)
- PyBytes_FromStringAndSize(NULL, result_len)) == NULL)
+ if ( (result = (PyStringObject *)
+ PyString_FromStringAndSize(NULL, result_len)) == NULL)
return NULL;
- result_s = PyBytes_AS_STRING(result);
+ result_s = PyString_AS_STRING(result);
start = self_s;
end = self_s + self_len;
@@ -2765,18 +2765,18 @@
/* len(self)>=1, len(from)>=2, to="", maxcount>=1 */
-Py_LOCAL(PyBytesObject *)
-replace_delete_substring(PyBytesObject *self,
+Py_LOCAL(PyStringObject *)
+replace_delete_substring(PyStringObject *self,
const char *from_s, Py_ssize_t from_len,
Py_ssize_t maxcount) {
char *self_s, *result_s;
char *start, *next, *end;
Py_ssize_t self_len, result_len;
Py_ssize_t count, offset;
- PyBytesObject *result;
+ PyStringObject *result;
- self_len = PyBytes_GET_SIZE(self);
- self_s = PyBytes_AS_STRING(self);
+ self_len = PyString_GET_SIZE(self);
+ self_s = PyString_AS_STRING(self);
count = countstring(self_s, self_len,
from_s, from_len,
@@ -2791,11 +2791,11 @@
result_len = self_len - (count * from_len);
assert (result_len>=0);
- if ( (result = (PyBytesObject *)
- PyBytes_FromStringAndSize(NULL, result_len)) == NULL )
+ if ( (result = (PyStringObject *)
+ PyString_FromStringAndSize(NULL, result_len)) == NULL )
return NULL;
- result_s = PyBytes_AS_STRING(result);
+ result_s = PyString_AS_STRING(result);
start = self_s;
end = self_s + self_len;
@@ -2817,18 +2817,18 @@
}
/* len(self)>=1, len(from)==len(to)==1, maxcount>=1 */
-Py_LOCAL(PyBytesObject *)
-replace_single_character_in_place(PyBytesObject *self,
+Py_LOCAL(PyStringObject *)
+replace_single_character_in_place(PyStringObject *self,
char from_c, char to_c,
Py_ssize_t maxcount)
{
char *self_s, *result_s, *start, *end, *next;
Py_ssize_t self_len;
- PyBytesObject *result;
+ PyStringObject *result;
/* The result string will be the same size */
- self_s = PyBytes_AS_STRING(self);
- self_len = PyBytes_GET_SIZE(self);
+ self_s = PyString_AS_STRING(self);
+ self_len = PyString_GET_SIZE(self);
next = findchar(self_s, self_len, from_c);
@@ -2838,10 +2838,10 @@
}
/* Need to make a new string */
- result = (PyBytesObject *) PyBytes_FromStringAndSize(NULL, self_len);
+ result = (PyStringObject *) PyString_FromStringAndSize(NULL, self_len);
if (result == NULL)
return NULL;
- result_s = PyBytes_AS_STRING(result);
+ result_s = PyString_AS_STRING(result);
Py_MEMCPY(result_s, self_s, self_len);
/* change everything in-place, starting with this one */
@@ -2862,8 +2862,8 @@
}
/* len(self)>=1, len(from)==len(to)>=2, maxcount>=1 */
-Py_LOCAL(PyBytesObject *)
-replace_substring_in_place(PyBytesObject *self,
+Py_LOCAL(PyStringObject *)
+replace_substring_in_place(PyStringObject *self,
const char *from_s, Py_ssize_t from_len,
const char *to_s, Py_ssize_t to_len,
Py_ssize_t maxcount)
@@ -2871,12 +2871,12 @@
char *result_s, *start, *end;
char *self_s;
Py_ssize_t self_len, offset;
- PyBytesObject *result;
+ PyStringObject *result;
/* The result string will be the same size */
- self_s = PyBytes_AS_STRING(self);
- self_len = PyBytes_GET_SIZE(self);
+ self_s = PyString_AS_STRING(self);
+ self_len = PyString_GET_SIZE(self);
offset = findstring(self_s, self_len,
from_s, from_len,
@@ -2887,10 +2887,10 @@
}
/* Need to make a new string */
- result = (PyBytesObject *) PyBytes_FromStringAndSize(NULL, self_len);
+ result = (PyStringObject *) PyString_FromStringAndSize(NULL, self_len);
if (result == NULL)
return NULL;
- result_s = PyBytes_AS_STRING(result);
+ result_s = PyString_AS_STRING(result);
Py_MEMCPY(result_s, self_s, self_len);
/* change everything in-place, starting with this one */
@@ -2913,8 +2913,8 @@
}
/* len(self)>=1, len(from)==1, len(to)>=2, maxcount>=1 */
-Py_LOCAL(PyBytesObject *)
-replace_single_character(PyBytesObject *self,
+Py_LOCAL(PyStringObject *)
+replace_single_character(PyStringObject *self,
char from_c,
const char *to_s, Py_ssize_t to_len,
Py_ssize_t maxcount)
@@ -2923,10 +2923,10 @@
char *start, *next, *end;
Py_ssize_t self_len, result_len;
Py_ssize_t count, product;
- PyBytesObject *result;
+ PyStringObject *result;
- self_s = PyBytes_AS_STRING(self);
- self_len = PyBytes_GET_SIZE(self);
+ self_s = PyString_AS_STRING(self);
+ self_len = PyString_GET_SIZE(self);
count = countchar(self_s, self_len, from_c, maxcount);
if (count == 0) {
@@ -2947,10 +2947,10 @@
return NULL;
}
- if ( (result = (PyBytesObject *)
- PyBytes_FromStringAndSize(NULL, result_len)) == NULL)
+ if ( (result = (PyStringObject *)
+ PyString_FromStringAndSize(NULL, result_len)) == NULL)
return NULL;
- result_s = PyBytes_AS_STRING(result);
+ result_s = PyString_AS_STRING(result);
start = self_s;
end = self_s + self_len;
@@ -2980,8 +2980,8 @@
}
/* len(self)>=1, len(from)>=2, len(to)>=2, maxcount>=1 */
-Py_LOCAL(PyBytesObject *)
-replace_substring(PyBytesObject *self,
+Py_LOCAL(PyStringObject *)
+replace_substring(PyStringObject *self,
const char *from_s, Py_ssize_t from_len,
const char *to_s, Py_ssize_t to_len,
Py_ssize_t maxcount) {
@@ -2989,10 +2989,10 @@
char *start, *next, *end;
Py_ssize_t self_len, result_len;
Py_ssize_t count, offset, product;
- PyBytesObject *result;
+ PyStringObject *result;
- self_s = PyBytes_AS_STRING(self);
- self_len = PyBytes_GET_SIZE(self);
+ self_s = PyString_AS_STRING(self);
+ self_len = PyString_GET_SIZE(self);
count = countstring(self_s, self_len,
from_s, from_len,
@@ -3015,10 +3015,10 @@
return NULL;
}
- if ( (result = (PyBytesObject *)
- PyBytes_FromStringAndSize(NULL, result_len)) == NULL)
+ if ( (result = (PyStringObject *)
+ PyString_FromStringAndSize(NULL, result_len)) == NULL)
return NULL;
- result_s = PyBytes_AS_STRING(result);
+ result_s = PyString_AS_STRING(result);
start = self_s;
end = self_s + self_len;
@@ -3050,15 +3050,15 @@
}
-Py_LOCAL(PyBytesObject *)
-replace(PyBytesObject *self,
+Py_LOCAL(PyStringObject *)
+replace(PyStringObject *self,
const char *from_s, Py_ssize_t from_len,
const char *to_s, Py_ssize_t to_len,
Py_ssize_t maxcount)
{
if (maxcount < 0) {
maxcount = PY_SSIZE_T_MAX;
- } else if (maxcount == 0 || PyBytes_GET_SIZE(self) == 0) {
+ } else if (maxcount == 0 || PyString_GET_SIZE(self) == 0) {
/* nothing to do; return the original string */
return return_self(self);
}
@@ -3081,7 +3081,7 @@
/* Except for "".replace("", "A") == "A" there is no way beyond this */
/* point for an empty self string to generate a non-empty string */
/* Special case so the remaining code always gets a non-empty string */
- if (PyBytes_GET_SIZE(self) == 0) {
+ if (PyString_GET_SIZE(self) == 0) {
return return_self(self);
}
@@ -3128,7 +3128,7 @@
given, only the first count occurrences are replaced.");
static PyObject *
-string_replace(PyBytesObject *self, PyObject *args)
+string_replace(PyStringObject *self, PyObject *args)
{
Py_ssize_t count = -1;
PyObject *from, *to;
@@ -3138,9 +3138,9 @@
if (!PyArg_ParseTuple(args, "OO|n:replace", &from, &to, &count))
return NULL;
- if (PyBytes_Check(from)) {
- from_s = PyBytes_AS_STRING(from);
- from_len = PyBytes_GET_SIZE(from);
+ if (PyString_Check(from)) {
+ from_s = PyString_AS_STRING(from);
+ from_len = PyString_GET_SIZE(from);
}
#ifdef Py_USING_UNICODE
if (PyUnicode_Check(from))
@@ -3150,9 +3150,9 @@
else if (PyObject_AsCharBuffer(from, &from_s, &from_len))
return NULL;
- if (PyBytes_Check(to)) {
- to_s = PyBytes_AS_STRING(to);
- to_len = PyBytes_GET_SIZE(to);
+ if (PyString_Check(to)) {
+ to_s = PyString_AS_STRING(to);
+ to_len = PyString_GET_SIZE(to);
}
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(to))
@@ -3162,7 +3162,7 @@
else if (PyObject_AsCharBuffer(to, &to_s, &to_len))
return NULL;
- return (PyObject *)replace((PyBytesObject *) self,
+ return (PyObject *)replace((PyStringObject *) self,
from_s, from_len,
to_s, to_len, count);
}
@@ -3174,17 +3174,17 @@
* -1 on error, 0 if not found and 1 if found.
*/
Py_LOCAL(int)
-_string_tailmatch(PyBytesObject *self, PyObject *substr, Py_ssize_t start,
+_string_tailmatch(PyStringObject *self, PyObject *substr, Py_ssize_t start,
Py_ssize_t end, int direction)
{
- Py_ssize_t len = PyBytes_GET_SIZE(self);
+ Py_ssize_t len = PyString_GET_SIZE(self);
Py_ssize_t slen;
const char* sub;
const char* str;
- if (PyBytes_Check(substr)) {
- sub = PyBytes_AS_STRING(substr);
- slen = PyBytes_GET_SIZE(substr);
+ if (PyString_Check(substr)) {
+ sub = PyString_AS_STRING(substr);
+ slen = PyString_GET_SIZE(substr);
}
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(substr))
@@ -3193,7 +3193,7 @@
#endif
else if (PyObject_AsCharBuffer(substr, &sub, &slen))
return -1;
- str = PyBytes_AS_STRING(self);
+ str = PyString_AS_STRING(self);
string_adjust_indices(&start, &end, len);
@@ -3224,7 +3224,7 @@
prefix can also be a tuple of strings to try.");
static PyObject *
-string_startswith(PyBytesObject *self, PyObject *args)
+string_startswith(PyStringObject *self, PyObject *args)
{
Py_ssize_t start = 0;
Py_ssize_t end = PY_SSIZE_T_MAX;
@@ -3265,7 +3265,7 @@
suffix can also be a tuple of strings to try.");
static PyObject *
-string_endswith(PyBytesObject *self, PyObject *args)
+string_endswith(PyStringObject *self, PyObject *args)
{
Py_ssize_t start = 0;
Py_ssize_t end = PY_SSIZE_T_MAX;
@@ -3308,7 +3308,7 @@
codecs.register_error that is able to handle UnicodeEncodeErrors.");
static PyObject *
-string_encode(PyBytesObject *self, PyObject *args)
+string_encode(PyStringObject *self, PyObject *args)
{
char *encoding = NULL;
char *errors = NULL;
@@ -3316,10 +3316,10 @@
if (!PyArg_ParseTuple(args, "|ss:encode", &encoding, &errors))
return NULL;
- v = PyBytes_AsEncodedObject((PyObject *)self, encoding, errors);
+ v = PyString_AsEncodedObject((PyObject *)self, encoding, errors);
if (v == NULL)
goto onError;
- if (!PyBytes_Check(v) && !PyUnicode_Check(v)) {
+ if (!PyString_Check(v) && !PyUnicode_Check(v)) {
PyErr_Format(PyExc_TypeError,
"encoder did not return a string/unicode object "
"(type=%.400s)",
@@ -3345,7 +3345,7 @@
able to handle UnicodeDecodeErrors.");
static PyObject *
-string_decode(PyBytesObject *self, PyObject *args)
+string_decode(PyStringObject *self, PyObject *args)
{
char *encoding = NULL;
char *errors = NULL;
@@ -3353,10 +3353,10 @@
if (!PyArg_ParseTuple(args, "|ss:decode", &encoding, &errors))
return NULL;
- v = PyBytes_AsDecodedObject((PyObject *)self, encoding, errors);
+ v = PyString_AsDecodedObject((PyObject *)self, encoding, errors);
if (v == NULL)
goto onError;
- if (!PyBytes_Check(v) && !PyUnicode_Check(v)) {
+ if (!PyString_Check(v) && !PyUnicode_Check(v)) {
PyErr_Format(PyExc_TypeError,
"decoder did not return a string/unicode object "
"(type=%.400s)",
@@ -3378,7 +3378,7 @@
If tabsize is not given, a tab size of 8 characters is assumed.");
static PyObject*
-string_expandtabs(PyBytesObject *self, PyObject *args)
+string_expandtabs(PyStringObject *self, PyObject *args)
{
const char *e, *p, *qe;
char *q;
@@ -3392,8 +3392,8 @@
/* First pass: determine size of output string */
i = 0; /* chars up to and including most recent \n or \r */
j = 0; /* chars since most recent \n or \r (use in tab calculations) */
- e = PyBytes_AS_STRING(self) + PyBytes_GET_SIZE(self); /* end of input */
- for (p = PyBytes_AS_STRING(self); p < e; p++)
+ e = PyString_AS_STRING(self) + PyString_GET_SIZE(self); /* end of input */
+ for (p = PyString_AS_STRING(self); p < e; p++)
if (*p == '\t') {
if (tabsize > 0) {
incr = tabsize - (j % tabsize);
@@ -3418,15 +3418,15 @@
goto overflow1;
/* Second pass: create output string and fill it */
- u = PyBytes_FromStringAndSize(NULL, i + j);
+ u = PyString_FromStringAndSize(NULL, i + j);
if (!u)
return NULL;
j = 0; /* same as in first pass */
- q = PyBytes_AS_STRING(u); /* next output char */
- qe = PyBytes_AS_STRING(u) + PyBytes_GET_SIZE(u); /* end of output */
+ q = PyString_AS_STRING(u); /* next output char */
+ qe = PyString_AS_STRING(u) + PyString_GET_SIZE(u); /* end of output */
- for (p = PyBytes_AS_STRING(self); p < e; p++)
+ for (p = PyString_AS_STRING(self); p < e; p++)
if (*p == '\t') {
if (tabsize > 0) {
i = tabsize - (j % tabsize);
@@ -3457,7 +3457,7 @@
}
Py_LOCAL_INLINE(PyObject *)
-pad(PyBytesObject *self, Py_ssize_t left, Py_ssize_t right, char fill)
+pad(PyStringObject *self, Py_ssize_t left, Py_ssize_t right, char fill)
{
PyObject *u;
@@ -3466,21 +3466,21 @@
if (right < 0)
right = 0;
- if (left == 0 && right == 0 && PyBytes_CheckExact(self)) {
+ if (left == 0 && right == 0 && PyString_CheckExact(self)) {
Py_INCREF(self);
return (PyObject *)self;
}
- u = PyBytes_FromStringAndSize(NULL,
- left + PyBytes_GET_SIZE(self) + right);
+ u = PyString_FromStringAndSize(NULL,
+ left + PyString_GET_SIZE(self) + right);
if (u) {
if (left)
- memset(PyBytes_AS_STRING(u), fill, left);
- Py_MEMCPY(PyBytes_AS_STRING(u) + left,
- PyBytes_AS_STRING(self),
- PyBytes_GET_SIZE(self));
+ memset(PyString_AS_STRING(u), fill, left);
+ Py_MEMCPY(PyString_AS_STRING(u) + left,
+ PyString_AS_STRING(self),
+ PyString_GET_SIZE(self));
if (right)
- memset(PyBytes_AS_STRING(u) + left + PyBytes_GET_SIZE(self),
+ memset(PyString_AS_STRING(u) + left + PyString_GET_SIZE(self),
fill, right);
}
@@ -3494,7 +3494,7 @@
"done using the specified fill character (default is a space).");
static PyObject *
-string_ljust(PyBytesObject *self, PyObject *args)
+string_ljust(PyStringObject *self, PyObject *args)
{
Py_ssize_t width;
char fillchar = ' ';
@@ -3502,12 +3502,12 @@
if (!PyArg_ParseTuple(args, "n|c:ljust", &width, &fillchar))
return NULL;
- if (PyBytes_GET_SIZE(self) >= width && PyBytes_CheckExact(self)) {
+ if (PyString_GET_SIZE(self) >= width && PyString_CheckExact(self)) {
Py_INCREF(self);
return (PyObject*) self;
}
- return pad(self, 0, width - PyBytes_GET_SIZE(self), fillchar);
+ return pad(self, 0, width - PyString_GET_SIZE(self), fillchar);
}
@@ -3518,7 +3518,7 @@
"done using the specified fill character (default is a space)");
static PyObject *
-string_rjust(PyBytesObject *self, PyObject *args)
+string_rjust(PyStringObject *self, PyObject *args)
{
Py_ssize_t width;
char fillchar = ' ';
@@ -3526,12 +3526,12 @@
if (!PyArg_ParseTuple(args, "n|c:rjust", &width, &fillchar))
return NULL;
- if (PyBytes_GET_SIZE(self) >= width && PyBytes_CheckExact(self)) {
+ if (PyString_GET_SIZE(self) >= width && PyString_CheckExact(self)) {
Py_INCREF(self);
return (PyObject*) self;
}
- return pad(self, width - PyBytes_GET_SIZE(self), 0, fillchar);
+ return pad(self, width - PyString_GET_SIZE(self), 0, fillchar);
}
@@ -3542,7 +3542,7 @@
"done using the specified fill character (default is a space)");
static PyObject *
-string_center(PyBytesObject *self, PyObject *args)
+string_center(PyStringObject *self, PyObject *args)
{
Py_ssize_t marg, left;
Py_ssize_t width;
@@ -3551,12 +3551,12 @@
if (!PyArg_ParseTuple(args, "n|c:center", &width, &fillchar))
return NULL;
- if (PyBytes_GET_SIZE(self) >= width && PyBytes_CheckExact(self)) {
+ if (PyString_GET_SIZE(self) >= width && PyString_CheckExact(self)) {
Py_INCREF(self);
return (PyObject*) self;
}
- marg = width - PyBytes_GET_SIZE(self);
+ marg = width - PyString_GET_SIZE(self);
left = marg / 2 + (marg & width & 1);
return pad(self, left, marg - left, fillchar);
@@ -3569,7 +3569,7 @@
"of the specified width. The string S is never truncated.");
static PyObject *
-string_zfill(PyBytesObject *self, PyObject *args)
+string_zfill(PyStringObject *self, PyObject *args)
{
Py_ssize_t fill;
PyObject *s;
@@ -3579,26 +3579,26 @@
if (!PyArg_ParseTuple(args, "n:zfill", &width))
return NULL;
- if (PyBytes_GET_SIZE(self) >= width) {
- if (PyBytes_CheckExact(self)) {
+ if (PyString_GET_SIZE(self) >= width) {
+ if (PyString_CheckExact(self)) {
Py_INCREF(self);
return (PyObject*) self;
}
else
- return PyBytes_FromStringAndSize(
- PyBytes_AS_STRING(self),
- PyBytes_GET_SIZE(self)
+ return PyString_FromStringAndSize(
+ PyString_AS_STRING(self),
+ PyString_GET_SIZE(self)
);
}
- fill = width - PyBytes_GET_SIZE(self);
+ fill = width - PyString_GET_SIZE(self);
s = pad(self, fill, 0, '0');
if (s == NULL)
return NULL;
- p = PyBytes_AS_STRING(s);
+ p = PyString_AS_STRING(s);
if (p[fill] == '+' || p[fill] == '-') {
/* move sign to beginning of string */
p[0] = p[fill];
@@ -3615,22 +3615,22 @@
and there is at least one character in S, False otherwise.");
static PyObject*
-string_isspace(PyBytesObject *self)
+string_isspace(PyStringObject *self)
{
register const unsigned char *p
- = (unsigned char *) PyBytes_AS_STRING(self);
+ = (unsigned char *) PyString_AS_STRING(self);
register const unsigned char *e;
/* Shortcut for single character strings */
- if (PyBytes_GET_SIZE(self) == 1 &&
+ if (PyString_GET_SIZE(self) == 1 &&
isspace(*p))
return PyBool_FromLong(1);
/* Special case for empty strings */
- if (PyBytes_GET_SIZE(self) == 0)
+ if (PyString_GET_SIZE(self) == 0)
return PyBool_FromLong(0);
- e = p + PyBytes_GET_SIZE(self);
+ e = p + PyString_GET_SIZE(self);
for (; p < e; p++) {
if (!isspace(*p))
return PyBool_FromLong(0);
@@ -3646,22 +3646,22 @@
and there is at least one character in S, False otherwise.");
static PyObject*
-string_isalpha(PyBytesObject *self)
+string_isalpha(PyStringObject *self)
{
register const unsigned char *p
- = (unsigned char *) PyBytes_AS_STRING(self);
+ = (unsigned char *) PyString_AS_STRING(self);
register const unsigned char *e;
/* Shortcut for single character strings */
- if (PyBytes_GET_SIZE(self) == 1 &&
+ if (PyString_GET_SIZE(self) == 1 &&
isalpha(*p))
return PyBool_FromLong(1);
/* Special case for empty strings */
- if (PyBytes_GET_SIZE(self) == 0)
+ if (PyString_GET_SIZE(self) == 0)
return PyBool_FromLong(0);
- e = p + PyBytes_GET_SIZE(self);
+ e = p + PyString_GET_SIZE(self);
for (; p < e; p++) {
if (!isalpha(*p))
return PyBool_FromLong(0);
@@ -3677,22 +3677,22 @@
and there is at least one character in S, False otherwise.");
static PyObject*
-string_isalnum(PyBytesObject *self)
+string_isalnum(PyStringObject *self)
{
register const unsigned char *p
- = (unsigned char *) PyBytes_AS_STRING(self);
+ = (unsigned char *) PyString_AS_STRING(self);
register const unsigned char *e;
/* Shortcut for single character strings */
- if (PyBytes_GET_SIZE(self) == 1 &&
+ if (PyString_GET_SIZE(self) == 1 &&
isalnum(*p))
return PyBool_FromLong(1);
/* Special case for empty strings */
- if (PyBytes_GET_SIZE(self) == 0)
+ if (PyString_GET_SIZE(self) == 0)
return PyBool_FromLong(0);
- e = p + PyBytes_GET_SIZE(self);
+ e = p + PyString_GET_SIZE(self);
for (; p < e; p++) {
if (!isalnum(*p))
return PyBool_FromLong(0);
@@ -3708,22 +3708,22 @@
and there is at least one character in S, False otherwise.");
static PyObject*
-string_isdigit(PyBytesObject *self)
+string_isdigit(PyStringObject *self)
{
register const unsigned char *p
- = (unsigned char *) PyBytes_AS_STRING(self);
+ = (unsigned char *) PyString_AS_STRING(self);
register const unsigned char *e;
/* Shortcut for single character strings */
- if (PyBytes_GET_SIZE(self) == 1 &&
+ if (PyString_GET_SIZE(self) == 1 &&
isdigit(*p))
return PyBool_FromLong(1);
/* Special case for empty strings */
- if (PyBytes_GET_SIZE(self) == 0)
+ if (PyString_GET_SIZE(self) == 0)
return PyBool_FromLong(0);
- e = p + PyBytes_GET_SIZE(self);
+ e = p + PyString_GET_SIZE(self);
for (; p < e; p++) {
if (!isdigit(*p))
return PyBool_FromLong(0);
@@ -3739,22 +3739,22 @@
at least one cased character in S, False otherwise.");
static PyObject*
-string_islower(PyBytesObject *self)
+string_islower(PyStringObject *self)
{
register const unsigned char *p
- = (unsigned char *) PyBytes_AS_STRING(self);
+ = (unsigned char *) PyString_AS_STRING(self);
register const unsigned char *e;
int cased;
/* Shortcut for single character strings */
- if (PyBytes_GET_SIZE(self) == 1)
+ if (PyString_GET_SIZE(self) == 1)
return PyBool_FromLong(islower(*p) != 0);
/* Special case for empty strings */
- if (PyBytes_GET_SIZE(self) == 0)
+ if (PyString_GET_SIZE(self) == 0)
return PyBool_FromLong(0);
- e = p + PyBytes_GET_SIZE(self);
+ e = p + PyString_GET_SIZE(self);
cased = 0;
for (; p < e; p++) {
if (isupper(*p))
@@ -3773,22 +3773,22 @@
at least one cased character in S, False otherwise.");
static PyObject*
-string_isupper(PyBytesObject *self)
+string_isupper(PyStringObject *self)
{
register const unsigned char *p
- = (unsigned char *) PyBytes_AS_STRING(self);
+ = (unsigned char *) PyString_AS_STRING(self);
register const unsigned char *e;
int cased;
/* Shortcut for single character strings */
- if (PyBytes_GET_SIZE(self) == 1)
+ if (PyString_GET_SIZE(self) == 1)
return PyBool_FromLong(isupper(*p) != 0);
/* Special case for empty strings */
- if (PyBytes_GET_SIZE(self) == 0)
+ if (PyString_GET_SIZE(self) == 0)
return PyBool_FromLong(0);
- e = p + PyBytes_GET_SIZE(self);
+ e = p + PyString_GET_SIZE(self);
cased = 0;
for (; p < e; p++) {
if (islower(*p))
@@ -3809,22 +3809,22 @@
otherwise.");
static PyObject*
-string_istitle(PyBytesObject *self, PyObject *uncased)
+string_istitle(PyStringObject *self, PyObject *uncased)
{
register const unsigned char *p
- = (unsigned char *) PyBytes_AS_STRING(self);
+ = (unsigned char *) PyString_AS_STRING(self);
register const unsigned char *e;
int cased, previous_is_cased;
/* Shortcut for single character strings */
- if (PyBytes_GET_SIZE(self) == 1)
+ if (PyString_GET_SIZE(self) == 1)
return PyBool_FromLong(isupper(*p) != 0);
/* Special case for empty strings */
- if (PyBytes_GET_SIZE(self) == 0)
+ if (PyString_GET_SIZE(self) == 0)
return PyBool_FromLong(0);
- e = p + PyBytes_GET_SIZE(self);
+ e = p + PyString_GET_SIZE(self);
cased = 0;
previous_is_cased = 0;
for (; p < e; p++) {
@@ -3857,7 +3857,7 @@
is given and true.");
static PyObject*
-string_splitlines(PyBytesObject *self, PyObject *args)
+string_splitlines(PyStringObject *self, PyObject *args)
{
register Py_ssize_t i;
register Py_ssize_t j;
@@ -3870,8 +3870,8 @@
if (!PyArg_ParseTuple(args, "|i:splitlines", &keepends))
return NULL;
- data = PyBytes_AS_STRING(self);
- len = PyBytes_GET_SIZE(self);
+ data = PyString_AS_STRING(self);
+ len = PyString_GET_SIZE(self);
/* This does not use the preallocated list because splitlines is
usually run with hundreds of newlines. The overhead of
@@ -3921,10 +3921,10 @@
"S.__sizeof__() -> size of S in memory, in bytes");
static PyObject *
-string_sizeof(PyBytesObject *v)
+string_sizeof(PyStringObject *v)
{
Py_ssize_t res;
- res = sizeof(PyBytesObject) + v->ob_size * v->ob_type->tp_itemsize;
+ res = sizeof(PyStringObject) + v->ob_size * v->ob_type->tp_itemsize;
return PyInt_FromSsize_t(res);
}
@@ -3934,7 +3934,7 @@
#undef PREALLOC_SIZE
static PyObject *
-string_getnewargs(PyBytesObject *v)
+string_getnewargs(PyStringObject *v)
{
return Py_BuildValue("(s#)", v->ob_sval, Py_SIZE(v));
}
@@ -3958,7 +3958,7 @@
/* This is to allow things like u''.format('') */
if (!PyArg_ParseTuple(args, "O:__format__", &format_spec))
goto done;
- if (!(PyBytes_Check(format_spec) || PyUnicode_Check(format_spec))) {
+ if (!(PyString_Check(format_spec) || PyUnicode_Check(format_spec))) {
PyErr_Format(PyExc_TypeError, "__format__ arg must be str "
"or unicode, not %s", Py_TYPE(format_spec)->tp_name);
goto done;
@@ -3969,8 +3969,8 @@
format_spec = tmp;
result = _PyBytes_FormatAdvanced(self,
- PyBytes_AS_STRING(format_spec),
- PyBytes_GET_SIZE(format_spec));
+ PyString_AS_STRING(format_spec),
+ PyString_GET_SIZE(format_spec));
done:
Py_XDECREF(tmp);
return result;
@@ -4050,12 +4050,12 @@
PyObject *x = NULL;
static char *kwlist[] = {"object", 0};
- if (type != &PyBytes_Type)
+ if (type != &PyString_Type)
return str_subtype_new(type, args, kwds);
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O:str", kwlist, &x))
return NULL;
if (x == NULL)
- return PyBytes_FromString("");
+ return PyString_FromString("");
return PyObject_Str(x);
}
@@ -4065,18 +4065,18 @@
PyObject *tmp, *pnew;
Py_ssize_t n;
- assert(PyType_IsSubtype(type, &PyBytes_Type));
- tmp = string_new(&PyBytes_Type, args, kwds);
+ assert(PyType_IsSubtype(type, &PyString_Type));
+ tmp = string_new(&PyString_Type, args, kwds);
if (tmp == NULL)
return NULL;
- assert(PyBytes_CheckExact(tmp));
- n = PyBytes_GET_SIZE(tmp);
+ assert(PyString_CheckExact(tmp));
+ n = PyString_GET_SIZE(tmp);
pnew = type->tp_alloc(type, n);
if (pnew != NULL) {
- Py_MEMCPY(PyBytes_AS_STRING(pnew), PyBytes_AS_STRING(tmp), n+1);
- ((PyBytesObject *)pnew)->ob_shash =
- ((PyBytesObject *)tmp)->ob_shash;
- ((PyBytesObject *)pnew)->ob_sstate = SSTATE_NOT_INTERNED;
+ Py_MEMCPY(PyString_AS_STRING(pnew), PyString_AS_STRING(tmp), n+1);
+ ((PyStringObject *)pnew)->ob_shash =
+ ((PyStringObject *)tmp)->ob_shash;
+ ((PyStringObject *)pnew)->ob_sstate = SSTATE_NOT_INTERNED;
}
Py_DECREF(tmp);
return pnew;
@@ -4093,11 +4093,11 @@
static PyObject *
string_mod(PyObject *v, PyObject *w)
{
- if (!PyBytes_Check(v)) {
+ if (!PyString_Check(v)) {
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
- return PyBytes_Format(v, w);
+ return PyString_Format(v, w);
}
PyDoc_STRVAR(basestring_doc,
@@ -4160,10 +4160,10 @@
Return a nice string representation of the object.\n\
If the argument is a string, the return value is the same object.");
-PyTypeObject PyBytes_Type = {
+PyTypeObject PyString_Type = {
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"str",
- sizeof(PyBytesObject),
+ sizeof(PyStringObject),
sizeof(char),
string_dealloc, /* tp_dealloc */
(printfunc)string_print, /* tp_print */
@@ -4205,25 +4205,25 @@
};
void
-PyBytes_Concat(register PyObject **pv, register PyObject *w)
+PyString_Concat(register PyObject **pv, register PyObject *w)
{
register PyObject *v;
if (*pv == NULL)
return;
- if (w == NULL || !PyBytes_Check(*pv)) {
+ if (w == NULL || !PyString_Check(*pv)) {
Py_DECREF(*pv);
*pv = NULL;
return;
}
- v = string_concat((PyBytesObject *) *pv, w);
+ v = string_concat((PyStringObject *) *pv, w);
Py_DECREF(*pv);
*pv = v;
}
void
-PyBytes_ConcatAndDel(register PyObject **pv, register PyObject *w)
+PyString_ConcatAndDel(register PyObject **pv, register PyObject *w)
{
- PyBytes_Concat(pv, w);
+ PyString_Concat(pv, w);
Py_XDECREF(w);
}
@@ -4243,13 +4243,13 @@
*/
int
-_PyBytes_Resize(PyObject **pv, Py_ssize_t newsize)
+_PyString_Resize(PyObject **pv, Py_ssize_t newsize)
{
register PyObject *v;
- register PyBytesObject *sv;
+ register PyStringObject *sv;
v = *pv;
- if (!PyBytes_Check(v) || Py_REFCNT(v) != 1 || newsize < 0 ||
- PyBytes_CHECK_INTERNED(v)) {
+ if (!PyString_Check(v) || Py_REFCNT(v) != 1 || newsize < 0 ||
+ PyString_CHECK_INTERNED(v)) {
*pv = 0;
Py_DECREF(v);
PyErr_BadInternalCall();
@@ -4259,14 +4259,14 @@
_Py_DEC_REFTOTAL;
_Py_ForgetReference(v);
*pv = (PyObject *)
- PyObject_REALLOC((char *)v, sizeof(PyBytesObject) + newsize);
+ PyObject_REALLOC((char *)v, sizeof(PyStringObject) + newsize);
if (*pv == NULL) {
PyObject_Del(v);
PyErr_NoMemory();
return -1;
}
_Py_NewReference(*pv);
- sv = (PyBytesObject *) *pv;
+ sv = (PyStringObject *) *pv;
Py_SIZE(sv) = newsize;
sv->ob_sval[newsize] = '\0';
sv->ob_shash = -1; /* invalidate cached hash value */
@@ -4352,7 +4352,7 @@
return (int)strlen(buf);
}
-/* _PyBytes_FormatLong emulates the format codes d, u, o, x and X, and
+/* _PyString_FormatLong emulates the format codes d, u, o, x and X, and
* the F_ALT flag, for Python's long (unbounded) ints. It's not used for
* Python's regular ints.
* Return value: a new PyString*, or NULL if error.
@@ -4374,7 +4374,7 @@
* produce a '-' sign, but can for Python's unbounded ints.
*/
PyObject*
-_PyBytes_FormatLong(PyObject *val, int flags, int prec, int type,
+_PyString_FormatLong(PyObject *val, int flags, int prec, int type,
char **pbuf, int *plen)
{
PyObject *result = NULL;
@@ -4405,7 +4405,7 @@
if (!result)
return NULL;
- buf = PyBytes_AsString(result);
+ buf = PyString_AsString(result);
if (!buf) {
Py_DECREF(result);
return NULL;
@@ -4416,9 +4416,9 @@
PyErr_BadInternalCall();
return NULL;
}
- llen = PyBytes_Size(result);
+ llen = PyString_Size(result);
if (llen > INT_MAX) {
- PyErr_SetString(PyExc_ValueError, "string too large in _PyBytes_FormatLong");
+ PyErr_SetString(PyExc_ValueError, "string too large in _PyString_FormatLong");
return NULL;
}
len = (int)llen;
@@ -4464,14 +4464,14 @@
/* Fill with leading zeroes to meet minimum width. */
if (prec > numdigits) {
- PyObject *r1 = PyBytes_FromStringAndSize(NULL,
+ PyObject *r1 = PyString_FromStringAndSize(NULL,
numnondigits + prec);
char *b1;
if (!r1) {
Py_DECREF(result);
return NULL;
}
- b1 = PyBytes_AS_STRING(r1);
+ b1 = PyString_AS_STRING(r1);
for (i = 0; i < numnondigits; ++i)
*b1++ = *buf++;
for (i = 0; i < prec - numdigits; i++)
@@ -4481,7 +4481,7 @@
*b1 = '\0';
Py_DECREF(result);
result = r1;
- buf = PyBytes_AS_STRING(result);
+ buf = PyString_AS_STRING(result);
len = numnondigits + prec;
}
@@ -4575,7 +4575,7 @@
formatchar(char *buf, size_t buflen, PyObject *v)
{
/* presume that the buffer is at least 2 characters long */
- if (PyBytes_Check(v)) {
+ if (PyString_Check(v)) {
if (!PyArg_Parse(v, "c;%c requires int or char", &buf[0]))
return -1;
}
@@ -4598,7 +4598,7 @@
#define FORMATBUFLEN (size_t)120
PyObject *
-PyBytes_Format(PyObject *format, PyObject *args)
+PyString_Format(PyObject *format, PyObject *args)
{
char *fmt, *res;
Py_ssize_t arglen, argidx;
@@ -4609,18 +4609,18 @@
PyObject *v, *w;
#endif
PyObject *dict = NULL;
- if (format == NULL || !PyBytes_Check(format) || args == NULL) {
+ if (format == NULL || !PyString_Check(format) || args == NULL) {
PyErr_BadInternalCall();
return NULL;
}
orig_args = args;
- fmt = PyBytes_AS_STRING(format);
- fmtcnt = PyBytes_GET_SIZE(format);
+ fmt = PyString_AS_STRING(format);
+ fmtcnt = PyString_GET_SIZE(format);
reslen = rescnt = fmtcnt + 100;
- result = PyBytes_FromStringAndSize((char *)NULL, reslen);
+ result = PyString_FromStringAndSize((char *)NULL, reslen);
if (result == NULL)
return NULL;
- res = PyBytes_AsString(result);
+ res = PyString_AsString(result);
if (PyTuple_Check(args)) {
arglen = PyTuple_GET_SIZE(args);
argidx = 0;
@@ -4637,9 +4637,9 @@
if (--rescnt < 0) {
rescnt = fmtcnt + 100;
reslen += rescnt;
- if (_PyBytes_Resize(&result, reslen) < 0)
+ if (_PyString_Resize(&result, reslen) < 0)
return NULL;
- res = PyBytes_AS_STRING(result)
+ res = PyString_AS_STRING(result)
+ reslen - rescnt;
--rescnt;
}
@@ -4694,7 +4694,7 @@
"incomplete format key");
goto error;
}
- key = PyBytes_FromStringAndSize(keystart,
+ key = PyString_FromStringAndSize(keystart,
keylen);
if (key == NULL)
goto error;
@@ -4835,14 +4835,14 @@
temp = PyObject_Repr(v);
if (temp == NULL)
goto error;
- if (!PyBytes_Check(temp)) {
+ if (!PyString_Check(temp)) {
PyErr_SetString(PyExc_TypeError,
"%s argument has non-string str()");
Py_DECREF(temp);
goto error;
}
- pbuf = PyBytes_AS_STRING(temp);
- len = PyBytes_GET_SIZE(temp);
+ pbuf = PyString_AS_STRING(temp);
+ len = PyString_GET_SIZE(temp);
if (prec >= 0 && len > prec)
len = prec;
break;
@@ -4882,7 +4882,7 @@
int ilen;
isnumok = 1;
- temp = _PyBytes_FormatLong(iobj, flags,
+ temp = _PyString_FormatLong(iobj, flags,
prec, c, &pbuf, &ilen);
Py_DECREF(iobj);
len = ilen;
@@ -4940,7 +4940,7 @@
"at index %zd",
c, c,
(Py_ssize_t)(fmt - 1 -
- PyBytes_AsString(format)));
+ PyString_AsString(format)));
goto error;
}
if (sign) {
@@ -4966,11 +4966,11 @@
Py_XDECREF(temp);
return PyErr_NoMemory();
}
- if (_PyBytes_Resize(&result, reslen) < 0) {
+ if (_PyString_Resize(&result, reslen) < 0) {
Py_XDECREF(temp);
return NULL;
}
- res = PyBytes_AS_STRING(result)
+ res = PyString_AS_STRING(result)
+ reslen - rescnt;
}
if (sign) {
@@ -5034,7 +5034,7 @@
if (args_owned) {
Py_DECREF(args);
}
- _PyBytes_Resize(&result, reslen - rescnt);
+ _PyString_Resize(&result, reslen - rescnt);
return result;
#ifdef Py_USING_UNICODE
@@ -5063,11 +5063,11 @@
args_owned = 1;
/* Take what we have of the result and let the Unicode formatting
function format the rest of the input. */
- rescnt = res - PyBytes_AS_STRING(result);
- if (_PyBytes_Resize(&result, rescnt))
+ rescnt = res - PyString_AS_STRING(result);
+ if (_PyString_Resize(&result, rescnt))
goto error;
- fmtcnt = PyBytes_GET_SIZE(format) - \
- (fmt - PyBytes_AS_STRING(format));
+ fmtcnt = PyString_GET_SIZE(format) - \
+ (fmt - PyString_AS_STRING(format));
format = PyUnicode_Decode(fmt, fmtcnt, NULL, NULL);
if (format == NULL)
goto error;
@@ -5095,15 +5095,15 @@
void
PyString_InternInPlace(PyObject **p)
{
- register PyBytesObject *s = (PyBytesObject *)(*p);
+ register PyStringObject *s = (PyStringObject *)(*p);
PyObject *t;
- if (s == NULL || !PyBytes_Check(s))
+ if (s == NULL || !PyString_Check(s))
Py_FatalError("PyString_InternInPlace: strings only please!");
/* If it's a string subclass, we don't really know what putting
it in the interned dict might do. */
- if (!PyBytes_CheckExact(s))
+ if (!PyString_CheckExact(s))
return;
- if (PyBytes_CHECK_INTERNED(s))
+ if (PyString_CHECK_INTERNED(s))
return;
if (interned == NULL) {
interned = PyDict_New();
@@ -5127,15 +5127,15 @@
/* The two references in interned are not counted by refcnt.
The string deallocator will take care of this */
Py_REFCNT(s) -= 2;
- PyBytes_CHECK_INTERNED(s) = SSTATE_INTERNED_MORTAL;
+ PyString_CHECK_INTERNED(s) = SSTATE_INTERNED_MORTAL;
}
void
PyString_InternImmortal(PyObject **p)
{
PyString_InternInPlace(p);
- if (PyBytes_CHECK_INTERNED(*p) != SSTATE_INTERNED_IMMORTAL) {
- PyBytes_CHECK_INTERNED(*p) = SSTATE_INTERNED_IMMORTAL;
+ if (PyString_CHECK_INTERNED(*p) != SSTATE_INTERNED_IMMORTAL) {
+ PyString_CHECK_INTERNED(*p) = SSTATE_INTERNED_IMMORTAL;
Py_INCREF(*p);
}
}
@@ -5144,7 +5144,7 @@
PyObject *
PyString_InternFromString(const char *cp)
{
- PyObject *s = PyBytes_FromString(cp);
+ PyObject *s = PyString_FromString(cp);
if (s == NULL)
return NULL;
PyString_InternInPlace(&s);
@@ -5166,7 +5166,7 @@
void _Py_ReleaseInternedStrings(void)
{
PyObject *keys;
- PyBytesObject *s;
+ PyStringObject *s;
Py_ssize_t i, n;
Py_ssize_t immortal_size = 0, mortal_size = 0;
@@ -5187,7 +5187,7 @@
fprintf(stderr, "releasing %" PY_FORMAT_SIZE_T "d interned strings\n",
n);
for (i = 0; i < n; i++) {
- s = (PyBytesObject *) PyList_GET_ITEM(keys, i);
+ s = (PyStringObject *) PyList_GET_ITEM(keys, i);
switch (s->ob_sstate) {
case SSTATE_NOT_INTERNED:
/* XXX Shouldn't happen */
Modified: python/trunk/Objects/fileobject.c
==============================================================================
--- python/trunk/Objects/fileobject.c (original)
+++ python/trunk/Objects/fileobject.c Tue Jun 10 19:42:36 2008
@@ -453,7 +453,7 @@
PyObject *str, *oerrors;
assert(PyFile_Check(f));
- str = PyBytes_FromString(enc);
+ str = PyString_FromString(enc);
if (!str)
return 0;
if (errors) {
@@ -2321,9 +2321,9 @@
#ifdef Py_USING_UNICODE
if ((flags & Py_PRINT_RAW) &&
PyUnicode_Check(v) && enc != Py_None) {
- char *cenc = PyBytes_AS_STRING(enc);
+ char *cenc = PyString_AS_STRING(enc);
char *errors = fobj->f_errors == Py_None ?
- "strict" : PyBytes_AS_STRING(fobj->f_errors);
+ "strict" : PyString_AS_STRING(fobj->f_errors);
value = PyUnicode_AsEncodedString(v, cenc, errors);
if (value == NULL)
return -1;
More information about the Python-checkins
mailing list