More reverting of r63675 per the mailing list discussions. This restores
authorGregory P. Smith <greg@mad-scientist.com>
Tue, 10 Jun 2008 17:42:36 +0000 (17:42 +0000)
committerGregory P. Smith <greg@mad-scientist.com>
Tue, 10 Jun 2008 17:42:36 +0000 (17:42 +0000)
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.

Modules/datetimemodule.c
Objects/bytesobject.c
Objects/fileobject.c

index 3adf0e2aaa30b60b45991b43d910492579c0b19c..3443b42baa91237ca0d8497b40ad5f750e1d5beb 100644 (file)
@@ -1207,9 +1207,9 @@ wrap_strftime(PyObject *object, const char *format, size_t format_len,
         * 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;
index d0e4e26edbcece55cc30f3bfe41b6318d35421d2..793cc8879360aa5594d9c2a9c094b2d6e29c50ac 100644 (file)
@@ -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 PyBytesObject *nullstring;
 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 @@ static PyObject *interned;
    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 @@ PyBytes_FromStringAndSize(const char *str, Py_ssize_t size)
        }
 
        /* 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 @@ PyBytes_FromStringAndSize(const char *str, Py_ssize_t size)
        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 @@ PyBytes_FromStringAndSize(const char *str, Py_ssize_t size)
 }
 
 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 @@ PyBytes_FromString(const char *str)
        }
 
        /* 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 @@ PyBytes_FromString(const char *str)
        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 @@ PyBytes_FromString(const char *str)
 }
 
 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 @@ PyBytes_FromFormatV(const char *format, va_list vargs)
        /* 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 @@ PyBytes_FromFormatV(const char *format, va_list vargs)
        }
 
  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 @@ PyBytes_FromFormat(const char *format, ...)
 #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 @@ PyObject *PyBytes_AsDecodedObject(PyObject *str,
     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 @@ PyObject *PyBytes_AsDecodedString(PyObject *str,
            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 @@ PyObject *PyBytes_AsDecodedString(PyObject *str,
     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 @@ PyObject *PyBytes_AsEncodedObject(PyObject *str,
     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 @@ PyObject *PyBytes_AsEncodedString(PyObject *str,
            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 @@ PyObject *PyBytes_AsEncodedString(PyObject *str,
 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 @@ string_dealloc(PyObject *op)
    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 @@ PyObject *PyBytes_DecodeEscape(const char *s,
        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 @@ PyObject *PyBytes_DecodeEscape(const char *s,
                                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 @@ PyObject *PyBytes_DecodeEscape(const char *s,
                }
        }
        if (p-buf < newlen)
-               _PyBytes_Resize(&v, p - buf);
+               _PyString_Resize(&v, p - buf);
        return v;
   failed:
        Py_DECREF(v);
@@ -702,7 +702,7 @@ string_getsize(register PyObject *op)
 {
        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 @@ string_getbuffer(register PyObject *op)
 {
        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 @@ PyBytes_AsStringAndSize(register PyObject *obj,
                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 @@ PyBytes_AsStringAndSize(register PyObject *obj,
                }
        }
 
-       *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 @@ PyBytes_AsStringAndSize(register PyObject *obj,
 #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 @@ string_print(PyBytesObject *op, FILE *fp, int flags)
 }
 
 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 @@ PyBytes_Repr(PyObject *obj, int smartquotes)
                        "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 @@ PyBytes_Repr(PyObject *obj, int smartquotes)
                    !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 @@ PyBytes_Repr(PyObject *obj, int smartquotes)
                        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 @@ PyBytes_Repr(PyObject *obj, int smartquotes)
 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 @@ string_concat(register PyBytesObject *a, register PyObject *bb)
                             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 @@ string_concat(register PyBytesObject *a, register PyObject *bb)
        }
          
        /* 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 @@ string_concat(register PyBytesObject *a, register PyObject *bb)
 }
 
 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 @@ string_repeat(register PyBytesObject *a, register Py_ssize_t n)
                        "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_repeat(register PyBytesObject *a, register Py_ssize_t n)
 /* 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 @@ string_slice(register PyBytesObject *a, register Py_ssize_t i,
                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 @@ string_contains(PyObject *str_obj, PyObject *sub_obj)
 }
 
 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 @@ string_item(PyBytesObject *a, register Py_ssize_t i)
        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 @@ string_item(PyBytesObject *a, register Py_ssize_t i)
 }
 
 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 @@ string_richcompare(PyBytesObject *a, PyBytesObject *b, int op)
        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 @@ string_richcompare(PyBytesObject *a, PyBytesObject *b, int op)
 }
 
 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 @@ string_hash(PyBytesObject *a)
 }
 
 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 @@ string_subscript(PyBytesObject* self, PyObject* item)
                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 @@ string_subscript(PyBytesObject* self, PyObject* item)
                                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 @@ string_subscript(PyBytesObject* self, PyObject* item)
 }
 
 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 @@ string_buffer_getreadbuf(PyBytesObject *self, Py_ssize_t index, const void **ptr
 }
 
 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 @@ string_buffer_getwritebuf(PyBytesObject *self, Py_ssize_t index, const void **pt
 }
 
 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 @@ string_buffer_getsegcount(PyBytesObject *self, Py_ssize_t *lenp)
 }
 
 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 @@ string_buffer_getcharbuf(PyBytesObject *self, Py_ssize_t index, const char **ptr
 }
 
 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 @@ static const char *stripformat[] = {"|O:lstrip", "|O:rstrip", "|O:strip"};
        (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 @@ static const char *stripformat[] = {"|O:lstrip", "|O:rstrip", "|O:strip"};
                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 @@ static const char *stripformat[] = {"|O:lstrip", "|O:rstrip", "|O:strip"};
 #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 @@ split_whitespace(PyBytesObject *self, Py_ssize_t len, Py_ssize_t maxsplit)
                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 @@ split_whitespace(PyBytesObject *self, Py_ssize_t len, Py_ssize_t maxsplit)
 }
 
 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 @@ split_char(PyBytesObject *self, Py_ssize_t len, char ch, Py_ssize_t maxcount)
                        }
                }
        }
-       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 @@ whitespace string is a separator and empty strings are removed\n\
 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 @@ string_split(PyBytesObject *self, PyObject *args)
                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 @@ the separator itself, and the part after it.  If the separator is not\n\
 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 @@ string_partition(PyBytesObject *self, PyObject *sep_obj)
 
        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 @@ the part before it, the separator itself, and the part after it.  If the\n\
 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 @@ string_rpartition(PyBytesObject *self, PyObject *sep_obj)
 
        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 @@ rsplit_whitespace(PyBytesObject *self, Py_ssize_t len, Py_ssize_t maxsplit)
                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 @@ rsplit_whitespace(PyBytesObject *self, Py_ssize_t len, Py_ssize_t maxsplit)
 }
 
 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 @@ rsplit_char(PyBytesObject *self, Py_ssize_t len, char ch, Py_ssize_t maxcount)
                        }
                }
        }
-       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 @@ done. If sep is not specified or is None, any whitespace string\n\
 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 @@ string_rsplit(PyBytesObject *self, PyObject *args)
                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 @@ string_rsplit(PyBytesObject *self, PyObject *args)
        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 @@ Return a string which is the concatenation of the strings in the\n\
 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 @@ string_join(PyBytesObject *self, PyObject *orig)
        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 @@ string_join(PyBytesObject *self, PyObject *orig)
        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 @@ string_join(PyBytesObject *self, PyObject *orig)
                        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 @@ string_join(PyBytesObject *self, PyObject *orig)
        }
 
        /* 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 @@ string_join(PyBytesObject *self, PyObject *orig)
 }
 
 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 @@ string_adjust_indices(Py_ssize_t *start, Py_ssize_t *end, Py_ssize_t len)
 }
 
 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 @@ string_find_internal(PyBytesObject *self, PyObject *args, int dir)
                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 @@ string_find_internal(PyBytesObject *self, PyObject *args, int dir)
 
        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 @@ arguments start and end are interpreted as in slice notation.\n\
 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 @@ PyDoc_STRVAR(index__doc__,
 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 @@ arguments start and end are interpreted as in slice notation.\n\
 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 @@ PyDoc_STRVAR(rindex__doc__,
 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 @@ string_rindex(PyBytesObject *self, PyObject *args)
 
 
 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 @@ do_xstrip(PyBytesObject *self, int striptype, PyObject *sepobj)
                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 @@ do_strip(PyBytesObject *self, int striptype)
                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 @@ do_argstrip(PyBytesObject *self, int striptype, PyObject *args)
                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 given and not None, remove characters in chars instead.\n\
 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 given and not None, remove characters in chars instead.\n\
 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 given and not None, remove characters in chars instead.\n\
 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 @@ Return a copy of the string S converted to lowercase.");
 #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 @@ Return a copy of the string S converted to uppercase.");
 #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 @@ Return a titlecased version of S, i.e. words start with uppercase\n\
 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 @@ Return a copy of the string S with only its first character\n\
 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 @@ string S[start:end].  Optional arguments start and end are interpreted\n\
 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 @@ string_count(PyBytesObject *self, PyObject *args)
                _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 @@ string_count(PyBytesObject *self, PyObject *args)
        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 @@ Return a copy of the string S with uppercase characters\n\
 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 @@ remaining characters have been mapped through the given\n\
 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 @@ string_translate(PyBytesObject *self, PyObject *args)
                              &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 @@ string_translate(PyBytesObject *self, PyObject *args)
        }
 
        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 @@ string_translate(PyBytesObject *self, PyObject *args)
                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 @@ string_translate(PyBytesObject *self, PyObject *args)
                        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 @@ string_translate(PyBytesObject *self, PyObject *args)
                                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_translate(PyBytesObject *self, PyObject *args)
 
 /* 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 @@ countstring(const char *target, Py_ssize_t target_len,
 /* 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 @@ replace_interleave(PyBytesObject *self,
                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 @@ replace_interleave(PyBytesObject *self,
 
 /* 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 @@ replace_delete_single_character(PyBytesObject *self,
        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 @@ replace_delete_single_character(PyBytesObject *self,
 
 /* 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 @@ replace_delete_substring(PyBytesObject *self,
        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 @@ replace_delete_substring(PyBytesObject *self,
 }
 
 /* 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 @@ replace_single_character_in_place(PyBytesObject *self,
        }
 
        /* 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 @@ replace_single_character_in_place(PyBytesObject *self,
 }
 
 /* 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 @@ replace_substring_in_place(PyBytesObject *self,
        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 @@ replace_substring_in_place(PyBytesObject *self,
        }
 
        /* 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 @@ replace_substring_in_place(PyBytesObject *self,
 }
 
 /* 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 @@ replace_single_character(PyBytesObject *self,
        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 @@ replace_single_character(PyBytesObject *self,
                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 @@ replace_single_character(PyBytesObject *self,
 }
 
 /* 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 @@ replace_substring(PyBytesObject *self,
        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 @@ replace_substring(PyBytesObject *self,
                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 @@ replace_substring(PyBytesObject *self,
 }
 
 
-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 @@ replace(PyBytesObject *self,
        /* 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 @@ old replaced by new.  If the optional argument count is\n\
 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 @@ string_replace(PyBytesObject *self, PyObject *args)
        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 @@ string_replace(PyBytesObject *self, PyObject *args)
        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 @@ string_replace(PyBytesObject *self, PyObject *args)
        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 @@ string_replace(PyBytesObject *self, PyObject *args)
  * -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 @@ _string_tailmatch(PyBytesObject *self, PyObject *substr, Py_ssize_t start,
 #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 @@ With optional end, stop comparing S at that position.\n\
 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 @@ With optional end, stop comparing S at that position.\n\
 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 @@ a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and\n\
 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 @@ string_encode(PyBytesObject *self, PyObject *args)
 
     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 @@ as well as any other name registerd with codecs.register_error that is\n\
 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 @@ string_decode(PyBytesObject *self, PyObject *args)
 
     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 @@ Return a copy of S where all tab characters are expanded using spaces.\n\
 If tabsize is not given, a tab size of 8 characters is assumed.");
 
 static PyObject*
-string_expandtabs(PyBytesObject *self, PyObject *args)
+string_expandtabs(PyStringObject *self, PyObject *args)
 {
     const char *e, *p, *qe;
     char *q;
@@ -3392,8 +3392,8 @@ string_expandtabs(PyBytesObject *self, PyObject *args)
     /* 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 @@ string_expandtabs(PyBytesObject *self, PyObject *args)
        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 @@ string_expandtabs(PyBytesObject *self, PyObject *args)
 }
 
 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 @@ pad(PyBytesObject *self, Py_ssize_t left, Py_ssize_t right, char fill)
     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 @@ PyDoc_STRVAR(ljust__doc__,
 "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 @@ string_ljust(PyBytesObject *self, PyObject *args)
     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 @@ PyDoc_STRVAR(rjust__doc__,
 "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 @@ string_rjust(PyBytesObject *self, PyObject *args)
     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 @@ PyDoc_STRVAR(center__doc__,
 "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 @@ string_center(PyBytesObject *self, PyObject *args)
     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 @@ PyDoc_STRVAR(zfill__doc__,
 "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 @@ string_zfill(PyBytesObject *self, PyObject *args)
     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 @@ Return True if all characters in S are whitespace\n\
 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 @@ Return True if all characters in S are alphabetic\n\
 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 @@ Return True if all characters in S are alphanumeric\n\
 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 @@ Return True if all characters in S are digits\n\
 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 @@ Return True if all cased characters in S are lowercase and there is\n\
 at least one cased character in S, False otherwise.");
 
 static PyObject*
-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 @@ Return True if all cased characters in S are uppercase and there is\n\
 at least one cased character in S, False otherwise.");
 
 static PyObject*
-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 @@ characters and lowercase characters only cased ones. Return False\n\
 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 @@ Line breaks are not included in the resulting list unless keepends\n\
 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 @@ string_splitlines(PyBytesObject *self, PyObject *args)
     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 @@ PyDoc_STRVAR(sizeof__doc__,
 "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 @@ string_sizeof(PyBytesObject *v)
 #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 @@ string__format__(PyObject* self, PyObject* args)
     /* 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 @@ string__format__(PyObject* self, PyObject* args)
     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 @@ string_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
        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 @@ str_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
        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 @@ basestring_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 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 @@ PyDoc_STRVAR(string_doc,
 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 @@ PyTypeObject PyBytes_Type = {
 };
 
 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 @@ PyBytes_ConcatAndDel(register PyObject **pv, register PyObject *w)
 */
 
 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 @@ _PyBytes_Resize(PyObject **pv, Py_ssize_t newsize)
        _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 @@ formatfloat(char *buf, size_t buflen, int flags,
        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 @@ formatfloat(char *buf, size_t buflen, int flags,
  * 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 @@ _PyBytes_FormatLong(PyObject *val, int flags, int prec, int type,
        if (!result)
                return NULL;
 
-       buf = PyBytes_AsString(result);
+       buf = PyString_AsString(result);
        if (!buf) {
                Py_DECREF(result);
                return NULL;
@@ -4416,9 +4416,9 @@ _PyBytes_FormatLong(PyObject *val, int flags, int prec, int type,
                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 @@ _PyBytes_FormatLong(PyObject *val, int flags, int prec, int type,
 
        /* 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 @@ _PyBytes_FormatLong(PyObject *val, int flags, int prec, int type,
                *b1 = '\0';
                Py_DECREF(result);
                result = r1;
-               buf = PyBytes_AS_STRING(result);
+               buf = PyString_AS_STRING(result);
                len = numnondigits + prec;
        }
 
@@ -4575,7 +4575,7 @@ Py_LOCAL_INLINE(int)
 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 @@ formatchar(char *buf, size_t buflen, PyObject *v)
 #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 @@ PyBytes_Format(PyObject *format, PyObject *args)
        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 @@ PyBytes_Format(PyObject *format, PyObject *args)
                        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 @@ PyBytes_Format(PyObject *format, PyObject *args)
                                                   "incomplete format key");
                                        goto error;
                                }
-                               key = PyBytes_FromStringAndSize(keystart,
+                               key = PyString_FromStringAndSize(keystart,
                                                                 keylen);
                                if (key == NULL)
                                        goto error;
@@ -4835,14 +4835,14 @@ PyBytes_Format(PyObject *format, PyObject *args)
                                        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 @@ PyBytes_Format(PyObject *format, PyObject *args)
                                                        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 @@ PyBytes_Format(PyObject *format, PyObject *args)
                                  "at index %zd",
                                  c, c,
                                  (Py_ssize_t)(fmt - 1 -
-                                              PyBytes_AsString(format)));
+                                              PyString_AsString(format)));
                                goto error;
                        }
                        if (sign) {
@@ -4966,11 +4966,11 @@ PyBytes_Format(PyObject *format, PyObject *args)
                                        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 @@ PyBytes_Format(PyObject *format, PyObject *args)
        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 @@ PyBytes_Format(PyObject *format, PyObject *args)
        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 @@ PyBytes_Format(PyObject *format, PyObject *args)
 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 @@ PyString_InternInPlace(PyObject **p)
        /* 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 @@ PyString_InternImmortal(PyObject **p)
 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 @@ PyString_Fini(void)
 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 @@ void _Py_ReleaseInternedStrings(void)
        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 */
index 8cc829bacd02d987739fc4fd9d8f2cea21189f9f..7c49afff0699eeff10ade07391a7495f2a5f98dd 100644 (file)
@@ -453,7 +453,7 @@ PyFile_SetEncodingAndErrors(PyObject *f, const char *enc, char* errors)
        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 @@ PyFile_WriteObject(PyObject *v, PyObject *f, int flags)
 #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;