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