diff --git a/Objects/abstract.c b/Objects/abstract.c
index aa30129e..1d5c4d5 100644
--- a/Objects/abstract.c
+++ b/Objects/abstract.c
@@ -105,7 +105,7 @@
 
 	/* cache a hashed version of the attribute string */
 	if (hintstrobj == NULL) {
-		hintstrobj = PyBytes_InternFromString("__length_hint__");
+		hintstrobj = PyString_InternFromString("__length_hint__");
 		if (hintstrobj == NULL)
 			goto defaultcase;
 	}
@@ -227,7 +227,7 @@
 		null_error();
 		return -1;
 	}
-	okey = PyBytes_FromString(key);
+	okey = PyString_FromString(key);
 	if (okey == NULL)
 		return -1;
 	ret = PyObject_DelItem(o, okey);
@@ -723,21 +723,21 @@
 	/* Initialize cached value */
 	if (str__format__ == NULL) {
 		/* Initialize static variable needed by _PyType_Lookup */
-		str__format__ = PyBytes_InternFromString("__format__");
+		str__format__ = PyString_InternFromString("__format__");
 		if (str__format__ == NULL)
 			goto done;
 	}
 
 	/* If no format_spec is provided, use an empty string */
 	if (format_spec == NULL) {
-		empty = PyBytes_FromStringAndSize(NULL, 0);
+		empty = PyString_FromStringAndSize(NULL, 0);
 		format_spec = empty;
 	}
 
 	/* Check the format_spec type, and make sure it's str or unicode */
 	if (PyUnicode_Check(format_spec))
 		spec_is_unicode = 1;
-	else if (PyBytes_Check(format_spec))
+	else if (PyString_Check(format_spec))
 		spec_is_unicode = 0;
 	else {
 		PyErr_Format(PyExc_TypeError,
@@ -817,7 +817,7 @@
 	/* Check the result type, and make sure it's str or unicode */
 	if (PyUnicode_Check(result))
 		result_is_unicode = 1;
-	else if (PyBytes_Check(result))
+	else if (PyString_Check(result))
 		result_is_unicode = 0;
 	else {
 		PyErr_Format(PyExc_TypeError,
@@ -1535,7 +1535,7 @@
 	const char *type_name;
 	static PyObject *int_name = NULL;
 	if (int_name == NULL) {
-		int_name = PyBytes_InternFromString("__int__");
+		int_name = PyString_InternFromString("__int__");
 		if (int_name == NULL)
 			return NULL;
 	}
@@ -1561,7 +1561,7 @@
 
 non_integral_error:
 	if (PyInstance_Check(integral)) {
-		type_name = PyBytes_AS_STRING(((PyInstanceObject *)integral)
+		type_name = PyString_AS_STRING(((PyInstanceObject *)integral)
 					       ->in_class->cl_name);
 	}
 	else {
@@ -1583,7 +1583,7 @@
 	Py_ssize_t buffer_len;
 
 	if (trunc_name == NULL) {
-		trunc_name = PyBytes_InternFromString("__trunc__");
+		trunc_name = PyString_InternFromString("__trunc__");
 		if (trunc_name == NULL)
 			return NULL;
 	}
@@ -1623,9 +1623,9 @@
 	}
 	PyErr_Clear();  /* It's not an error if  o.__trunc__ doesn't exist. */
 
-	if (PyBytes_Check(o))
-		return int_from_string(PyBytes_AS_STRING(o),
-				       PyBytes_GET_SIZE(o));
+	if (PyString_Check(o))
+		return int_from_string(PyString_AS_STRING(o),
+				       PyString_GET_SIZE(o));
 #ifdef Py_USING_UNICODE
 	if (PyUnicode_Check(o))
 		return PyInt_FromUnicode(PyUnicode_AS_UNICODE(o),
@@ -1668,7 +1668,7 @@
 	Py_ssize_t buffer_len;
 
 	if (trunc_name == NULL) {
-		trunc_name = PyBytes_InternFromString("__trunc__");
+		trunc_name = PyString_InternFromString("__trunc__");
 		if (trunc_name == NULL)
 			return NULL;
 	}
@@ -1710,13 +1710,13 @@
 	}
 	PyErr_Clear();  /* It's not an error if  o.__trunc__ doesn't exist. */
 
-	if (PyBytes_Check(o))
+	if (PyString_Check(o))
 		/* need to do extra error checking that PyLong_FromString()
 		 * doesn't do.  In particular long('9.5') must raise an
 		 * exception, not truncate the float.
 		 */
-		return long_from_string(PyBytes_AS_STRING(o),
-					PyBytes_GET_SIZE(o));
+		return long_from_string(PyString_AS_STRING(o),
+					PyString_GET_SIZE(o));
 #ifdef Py_USING_UNICODE
 	if (PyUnicode_Check(o))
 		/* The above check is done in PyLong_FromUnicode(). */
@@ -2407,7 +2407,7 @@
 	if (key == NULL)
 		return null_error();
 
-	okey = PyBytes_FromString(key);
+	okey = PyString_FromString(key);
 	if (okey == NULL)
 		return NULL;
 	r = PyObject_GetItem(o, okey);
@@ -2426,7 +2426,7 @@
 		return -1;
 	}
 
-	okey = PyBytes_FromString(key);
+	okey = PyString_FromString(key);
 	if (okey == NULL)
 		return -1;
 	r = PyObject_SetItem(o, okey, value);
@@ -2754,7 +2754,7 @@
 	PyObject *bases;
 
 	if (__bases__ == NULL) {
-		__bases__ = PyBytes_InternFromString("__bases__");
+		__bases__ = PyString_InternFromString("__bases__");
 		if (__bases__ == NULL)
 			return NULL;
 	}
@@ -2832,7 +2832,7 @@
 	int retval = 0;
 
 	if (__class__ == NULL) {
-		__class__ = PyBytes_InternFromString("__class__");
+		__class__ = PyString_InternFromString("__class__");
 		if (__class__ == NULL)
 			return -1;
 	}
@@ -2908,7 +2908,7 @@
 		return 1;
 
 	if (name == NULL) {
-		name = PyBytes_InternFromString("__instancecheck__");
+		name = PyString_InternFromString("__instancecheck__");
 		if (name == NULL)
 			return -1;
 	}
@@ -2992,7 +2992,7 @@
 	PyErr_Fetch(&t, &v, &tb);
 	
 	if (name == NULL) {
-		name = PyBytes_InternFromString("__subclasscheck__");
+		name = PyString_InternFromString("__subclasscheck__");
 		if (name == NULL)
 			return -1;
 	}
diff --git a/Objects/boolobject.c b/Objects/boolobject.c
index 93affd1..fd73d28 100644
--- a/Objects/boolobject.c
+++ b/Objects/boolobject.c
@@ -25,10 +25,10 @@
 
 	if (self->ob_ival)
 		s = true_str ? true_str :
-			(true_str = PyBytes_InternFromString("True"));
+			(true_str = PyString_InternFromString("True"));
 	else
 		s = false_str ? false_str :
-			(false_str = PyBytes_InternFromString("False"));
+			(false_str = PyString_InternFromString("False"));
 	Py_XINCREF(s);
 	return s;
 }
diff --git a/Objects/bufferobject.c b/Objects/bufferobject.c
index ee8dd3d..37d9bcb 100644
--- a/Objects/bufferobject.c
+++ b/Objects/bufferobject.c
@@ -287,13 +287,13 @@
 	const char *status = self->b_readonly ? "read-only" : "read-write";
 
 	if ( self->b_base == NULL )
-		return PyBytes_FromFormat("<%s buffer ptr %p, size %zd at %p>",
+		return PyString_FromFormat("<%s buffer ptr %p, size %zd at %p>",
 					   status,
 					   self->b_ptr,
 					   self->b_size,
 					   self);
 	else
-		return PyBytes_FromFormat(
+		return PyString_FromFormat(
 			"<%s buffer for %p, size %zd, offset %zd at %p>",
 			status,
 			self->b_base,
@@ -318,7 +318,7 @@
 	 * underlying memory is immutable.  b_readonly is a necessary but not
 	 * sufficient condition for a buffer to be hashable.  Perhaps it would
 	 * be better to only allow hashing if the underlying object is known to
-	 * be immutable (e.g. PyBytes_Check() is true).  Another idea would
+	 * be immutable (e.g. PyString_Check() is true).  Another idea would
 	 * be to call tp_hash on the underlying object and see if it raises
 	 * an error. */
 	if ( !self->b_readonly )
@@ -349,7 +349,7 @@
 	Py_ssize_t size;
 	if (!get_buf(self, &ptr, &size, ANY_BUFFER))
 		return NULL;
-	return PyBytes_FromStringAndSize((const char *)ptr, size);
+	return PyString_FromStringAndSize((const char *)ptr, size);
 }
 
 /* Sequence methods */
@@ -401,10 +401,10 @@
 	if ( (count = (*pb->bf_getreadbuffer)(other, 0, &ptr2)) < 0 )
 		return NULL;
 
- 	ob = PyBytes_FromStringAndSize(NULL, size + count);
+ 	ob = PyString_FromStringAndSize(NULL, size + count);
 	if ( ob == NULL )
 		return NULL;
- 	p = PyBytes_AS_STRING(ob);
+ 	p = PyString_AS_STRING(ob);
  	memcpy(p, ptr1, size);
  	memcpy(p + size, ptr2, count);
 
@@ -426,11 +426,11 @@
 		count = 0;
 	if (!get_buf(self, &ptr, &size, ANY_BUFFER))
 		return NULL;
-	ob = PyBytes_FromStringAndSize(NULL, size * count);
+	ob = PyString_FromStringAndSize(NULL, size * count);
 	if ( ob == NULL )
 		return NULL;
 
-	p = PyBytes_AS_STRING(ob);
+	p = PyString_AS_STRING(ob);
 	while ( count-- )
 	{
 	    memcpy(p, ptr, size);
@@ -454,7 +454,7 @@
 		PyErr_SetString(PyExc_IndexError, "buffer index out of range");
 		return NULL;
 	}
-	return PyBytes_FromStringAndSize((char *)ptr + idx, 1);
+	return PyString_FromStringAndSize((char *)ptr + idx, 1);
 }
 
 static PyObject *
@@ -472,7 +472,7 @@
 		right = size;
 	if ( right < left )
 		right = left;
-	return PyBytes_FromStringAndSize((char *)ptr + left,
+	return PyString_FromStringAndSize((char *)ptr + left,
 					  right - left);
 }
 
@@ -501,9 +501,9 @@
 		}
 
 		if (slicelength <= 0)
-			return PyBytes_FromStringAndSize("", 0);
+			return PyString_FromStringAndSize("", 0);
 		else if (step == 1)
-			return PyBytes_FromStringAndSize((char *)p + start,
+			return PyString_FromStringAndSize((char *)p + start,
 							  stop - start);
 		else {
 			PyObject *result;
@@ -518,7 +518,7 @@
 				result_buf[i] = source_buf[cur];
 			}
 
-			result = PyBytes_FromStringAndSize(result_buf,
+			result = PyString_FromStringAndSize(result_buf,
 							    slicelength);
 			PyMem_Free(result_buf);
 			return result;
diff --git a/Objects/bytes_methods.c b/Objects/bytes_methods.c
index 2d55601..de87905 100644
--- a/Objects/bytes_methods.c
+++ b/Objects/bytes_methods.c
@@ -462,11 +462,11 @@
 	Py_ssize_t i;
 
         /*
-	newobj = PyBytes_FromStringAndSize(NULL, len);
+	newobj = PyString_FromStringAndSize(NULL, len);
 	if (!newobj)
 		return NULL;
 
-	s = PyBytes_AS_STRING(newobj);
+	s = PyString_AS_STRING(newobj);
         */
 
 	Py_MEMCPY(result, cptr, len);
@@ -490,11 +490,11 @@
 	Py_ssize_t i;
 
         /*
-	newobj = PyBytes_FromStringAndSize(NULL, len);
+	newobj = PyString_FromStringAndSize(NULL, len);
 	if (!newobj)
 		return NULL;
 
-	s = PyBytes_AS_STRING(newobj);
+	s = PyString_AS_STRING(newobj);
         */
 
 	Py_MEMCPY(result, cptr, len);
@@ -520,10 +520,10 @@
 	int previous_is_cased = 0;
 
         /*
-	newobj = PyBytes_FromStringAndSize(NULL, len);
+	newobj = PyString_FromStringAndSize(NULL, len);
 	if (newobj == NULL)
 		return NULL;
-	s_new = PyBytes_AsString(newobj);
+	s_new = PyString_AsString(newobj);
         */
 	for (i = 0; i < len; i++) {
 		int c = Py_CHARMASK(*s++);
@@ -553,10 +553,10 @@
 	Py_ssize_t i;
 
         /*
-	newobj = PyBytes_FromStringAndSize(NULL, len);
+	newobj = PyString_FromStringAndSize(NULL, len);
 	if (newobj == NULL)
 		return NULL;
-	s_new = PyBytes_AsString(newobj);
+	s_new = PyString_AsString(newobj);
         */
 	if (0 < len) {
 		int c = Py_CHARMASK(*s++);
@@ -589,10 +589,10 @@
 	Py_ssize_t i;
 
         /*
-	newobj = PyBytes_FromStringAndSize(NULL, len);
+	newobj = PyString_FromStringAndSize(NULL, len);
 	if (newobj == NULL)
 		return NULL;
-	s_new = PyBytes_AsString(newobj);
+	s_new = PyString_AsString(newobj);
         */
 	for (i = 0; i < len; i++) {
 		int c = Py_CHARMASK(*s++);
diff --git a/Objects/bytesobject.c b/Objects/bytesobject.c
index 61ee42ab..d0e4e26 100644
--- a/Objects/bytesobject.c
+++ b/Objects/bytesobject.c
@@ -87,13 +87,13 @@
 	/* share short strings */
 	if (size == 0) {
 		PyObject *t = (PyObject *)op;
-		PyBytes_InternInPlace(&t);
+		PyString_InternInPlace(&t);
 		op = (PyBytesObject *)t;
 		nullstring = op;
 		Py_INCREF(op);
 	} else if (size == 1 && str != NULL) {
 		PyObject *t = (PyObject *)op;
-		PyBytes_InternInPlace(&t);
+		PyString_InternInPlace(&t);
 		op = (PyBytesObject *)t;
 		characters[*str & UCHAR_MAX] = op;
 		Py_INCREF(op);
@@ -140,13 +140,13 @@
 	/* share short strings */
 	if (size == 0) {
 		PyObject *t = (PyObject *)op;
-		PyBytes_InternInPlace(&t);
+		PyString_InternInPlace(&t);
 		op = (PyBytesObject *)t;
 		nullstring = op;
 		Py_INCREF(op);
 	} else if (size == 1) {
 		PyObject *t = (PyObject *)op;
-		PyBytes_InternInPlace(&t);
+		PyString_InternInPlace(&t);
 		op = (PyBytesObject *)t;
 		characters[*str & UCHAR_MAX] = op;
 		Py_INCREF(op);
@@ -5093,12 +5093,12 @@
 }
 
 void
-PyBytes_InternInPlace(PyObject **p)
+PyString_InternInPlace(PyObject **p)
 {
 	register PyBytesObject *s = (PyBytesObject *)(*p);
 	PyObject *t;
 	if (s == NULL || !PyBytes_Check(s))
-		Py_FatalError("PyBytes_InternInPlace: strings only please!");
+		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))
@@ -5131,9 +5131,9 @@
 }
 
 void
-PyBytes_InternImmortal(PyObject **p)
+PyString_InternImmortal(PyObject **p)
 {
-	PyBytes_InternInPlace(p);
+	PyString_InternInPlace(p);
 	if (PyBytes_CHECK_INTERNED(*p) != SSTATE_INTERNED_IMMORTAL) {
 		PyBytes_CHECK_INTERNED(*p) = SSTATE_INTERNED_IMMORTAL;
 		Py_INCREF(*p);
@@ -5142,17 +5142,17 @@
 
 
 PyObject *
-PyBytes_InternFromString(const char *cp)
+PyString_InternFromString(const char *cp)
 {
 	PyObject *s = PyBytes_FromString(cp);
 	if (s == NULL)
 		return NULL;
-	PyBytes_InternInPlace(&s);
+	PyString_InternInPlace(&s);
 	return s;
 }
 
 void
-PyBytes_Fini(void)
+PyString_Fini(void)
 {
 	int i;
 	for (i = 0; i < UCHAR_MAX + 1; i++) {
diff --git a/Objects/cellobject.c b/Objects/cellobject.c
index 16bb150..4e0bcf8 100644
--- a/Objects/cellobject.c
+++ b/Objects/cellobject.c
@@ -73,9 +73,9 @@
 cell_repr(PyCellObject *op)
 {
 	if (op->ob_ref == NULL)
-		return PyBytes_FromFormat("<cell at %p: empty>", op);
+		return PyString_FromFormat("<cell at %p: empty>", op);
 
-	return PyBytes_FromFormat("<cell at %p: %.80s object at %p>",
+	return PyString_FromFormat("<cell at %p: %.80s object at %p>",
 				   op, op->ob_ref->ob_type->tp_name,
 				   op->ob_ref);
 }
diff --git a/Objects/classobject.c b/Objects/classobject.c
index 372a40e..caf6b3e 100644
--- a/Objects/classobject.c
+++ b/Objects/classobject.c
@@ -32,21 +32,21 @@
 	PyClassObject *op, *dummy;
 	static PyObject *docstr, *modstr, *namestr;
 	if (docstr == NULL) {
-		docstr= PyBytes_InternFromString("__doc__");
+		docstr= PyString_InternFromString("__doc__");
 		if (docstr == NULL)
 			return NULL;
 	}
 	if (modstr == NULL) {
-		modstr= PyBytes_InternFromString("__module__");
+		modstr= PyString_InternFromString("__module__");
 		if (modstr == NULL)
 			return NULL;
 	}
 	if (namestr == NULL) {
-		namestr= PyBytes_InternFromString("__name__");
+		namestr= PyString_InternFromString("__name__");
 		if (namestr == NULL)
 			return NULL;
 	}
-	if (name == NULL || !PyBytes_Check(name)) {
+	if (name == NULL || !PyString_Check(name)) {
 		PyErr_SetString(PyExc_TypeError,
 				"PyClass_New: name must be a string");
 		return NULL;
@@ -101,13 +101,13 @@
 	}
 
 	if (getattrstr == NULL) {
-		getattrstr = PyBytes_InternFromString("__getattr__");
+		getattrstr = PyString_InternFromString("__getattr__");
 		if (getattrstr == NULL)
 			goto alloc_error;
-		setattrstr = PyBytes_InternFromString("__setattr__");
+		setattrstr = PyString_InternFromString("__setattr__");
 		if (setattrstr == NULL)
 			goto alloc_error;
-		delattrstr = PyBytes_InternFromString("__delattr__");
+		delattrstr = PyString_InternFromString("__delattr__");
 		if (delattrstr == NULL)
 			goto alloc_error;
 	}
@@ -222,7 +222,7 @@
 class_getattr(register PyClassObject *op, PyObject *name)
 {
 	register PyObject *v;
-	register char *sname = PyBytes_AsString(name);
+	register char *sname = PyString_AsString(name);
 	PyClassObject *klass;
 	descrgetfunc f;
 
@@ -253,7 +253,7 @@
 	if (v == NULL) {
 		PyErr_Format(PyExc_AttributeError,
 			     "class %.50s has no attribute '%.400s'",
-			     PyBytes_AS_STRING(op->cl_name), sname);
+			     PyString_AS_STRING(op->cl_name), sname);
 		return NULL;
 	}
 	f = TP_DESCR_GET(v->ob_type);
@@ -316,9 +316,9 @@
 static char *
 set_name(PyClassObject *c, PyObject *v)
 {
-	if (v == NULL || !PyBytes_Check(v))
+	if (v == NULL || !PyString_Check(v))
 		return "__name__ must be a string object";
-	if (strlen(PyBytes_AS_STRING(v)) != (size_t)PyBytes_GET_SIZE(v))
+	if (strlen(PyString_AS_STRING(v)) != (size_t)PyString_GET_SIZE(v))
 		return "__name__ must not contain null bytes";
 	set_slot(&c->cl_name, v);
 	return "";
@@ -333,9 +333,9 @@
 			   "classes are read-only in restricted mode");
 		return -1;
 	}
-	sname = PyBytes_AsString(name);
+	sname = PyString_AsString(name);
 	if (sname[0] == '_' && sname[1] == '_') {
-		Py_ssize_t n = PyBytes_Size(name);
+		Py_ssize_t n = PyString_Size(name);
 		if (sname[n-1] == '_' && sname[n-2] == '_') {
 			char *err = NULL;
 			if (strcmp(sname, "__dict__") == 0)
@@ -365,7 +365,7 @@
 		if (rv < 0)
 			PyErr_Format(PyExc_AttributeError,
 				     "class %.50s has no attribute '%.400s'",
-				     PyBytes_AS_STRING(op->cl_name), sname);
+				     PyString_AS_STRING(op->cl_name), sname);
 		return rv;
 	}
 	else
@@ -377,15 +377,15 @@
 {
 	PyObject *mod = PyDict_GetItemString(op->cl_dict, "__module__");
 	char *name;
-	if (op->cl_name == NULL || !PyBytes_Check(op->cl_name))
+	if (op->cl_name == NULL || !PyString_Check(op->cl_name))
 		name = "?";
 	else
-		name = PyBytes_AsString(op->cl_name);
-	if (mod == NULL || !PyBytes_Check(mod))
-		return PyBytes_FromFormat("<class ?.%s at %p>", name, op);
+		name = PyString_AsString(op->cl_name);
+	if (mod == NULL || !PyString_Check(mod))
+		return PyString_FromFormat("<class ?.%s at %p>", name, op);
 	else
-		return PyBytes_FromFormat("<class %s.%s at %p>",
-					   PyBytes_AsString(mod),
+		return PyString_FromFormat("<class %s.%s at %p>",
+					   PyString_AsString(mod),
 					   name, op);
 }
 
@@ -397,21 +397,21 @@
 	PyObject *res;
 	Py_ssize_t m, n;
 
-	if (name == NULL || !PyBytes_Check(name))
+	if (name == NULL || !PyString_Check(name))
 		return class_repr(op);
-	if (mod == NULL || !PyBytes_Check(mod)) {
+	if (mod == NULL || !PyString_Check(mod)) {
 		Py_INCREF(name);
 		return name;
 	}
-	m = PyBytes_GET_SIZE(mod);
-	n = PyBytes_GET_SIZE(name);
-	res = PyBytes_FromStringAndSize((char *)NULL, m+1+n);
+	m = PyString_GET_SIZE(mod);
+	n = PyString_GET_SIZE(name);
+	res = PyString_FromStringAndSize((char *)NULL, m+1+n);
 	if (res != NULL) {
-		char *s = PyBytes_AS_STRING(res);
-		memcpy(s, PyBytes_AS_STRING(mod), m);
+		char *s = PyString_AS_STRING(res);
+		memcpy(s, PyString_AS_STRING(mod), m);
 		s += m;
 		*s++ = '.';
-		memcpy(s, PyBytes_AS_STRING(name), n);
+		memcpy(s, PyString_AS_STRING(name), n);
 	}
 	return res;
 }
@@ -541,7 +541,7 @@
 	static PyObject *initstr;
 
 	if (initstr == NULL) {
-		initstr = PyBytes_InternFromString("__init__");
+		initstr = PyString_InternFromString("__init__");
 		if (initstr == NULL)
 			return NULL;
 	}
@@ -634,7 +634,7 @@
 	PyErr_Fetch(&error_type, &error_value, &error_traceback);
 	/* Execute __del__ method, if any. */
 	if (delstr == NULL) {
-		delstr = PyBytes_InternFromString("__del__");
+		delstr = PyString_InternFromString("__del__");
 		if (delstr == NULL)
 			PyErr_WriteUnraisable((PyObject*)inst);
 	}
@@ -696,7 +696,7 @@
 instance_getattr1(register PyInstanceObject *inst, PyObject *name)
 {
 	register PyObject *v;
-	register char *sname = PyBytes_AsString(name);
+	register char *sname = PyString_AsString(name);
 	if (sname[0] == '_' && sname[1] == '_') {
 		if (strcmp(sname, "__dict__") == 0) {
 			if (PyEval_GetRestricted()) {
@@ -716,7 +716,7 @@
 	if (v == NULL && !PyErr_Occurred()) {
 		PyErr_Format(PyExc_AttributeError,
 			     "%.50s instance has no attribute '%.400s'",
-			     PyBytes_AS_STRING(inst->in_class->cl_name), sname);
+			     PyString_AS_STRING(inst->in_class->cl_name), sname);
 	}
 	return v;
 }
@@ -779,7 +779,7 @@
 	assert(PyInstance_Check(pinst));
 	inst = (PyInstanceObject *)pinst;
 
-	assert(PyBytes_Check(name));
+	assert(PyString_Check(name));
 
  	v = PyDict_GetItem(inst->in_dict, name);
 	if (v == NULL)
@@ -795,8 +795,8 @@
 		if (rv < 0)
 			PyErr_Format(PyExc_AttributeError,
 				     "%.50s instance has no attribute '%.400s'",
-				     PyBytes_AS_STRING(inst->in_class->cl_name),
-				     PyBytes_AS_STRING(name));
+				     PyString_AS_STRING(inst->in_class->cl_name),
+				     PyString_AS_STRING(name));
 		return rv;
 	}
 	else
@@ -807,9 +807,9 @@
 instance_setattr(PyInstanceObject *inst, PyObject *name, PyObject *v)
 {
 	PyObject *func, *args, *res, *tmp;
-	char *sname = PyBytes_AsString(name);
+	char *sname = PyString_AsString(name);
 	if (sname[0] == '_' && sname[1] == '_') {
-		Py_ssize_t n = PyBytes_Size(name);
+		Py_ssize_t n = PyString_Size(name);
 		if (sname[n-1] == '_' && sname[n-2] == '_') {
 			if (strcmp(sname, "__dict__") == 0) {
 				if (PyEval_GetRestricted()) {
@@ -875,7 +875,7 @@
 	static PyObject *reprstr;
 
 	if (reprstr == NULL) {
-		reprstr = PyBytes_InternFromString("__repr__");
+		reprstr = PyString_InternFromString("__repr__");
 		if (reprstr == NULL)
 			return NULL;
 	}
@@ -889,16 +889,16 @@
 		classname = inst->in_class->cl_name;
 		mod = PyDict_GetItemString(inst->in_class->cl_dict,
 					   "__module__");
-		if (classname != NULL && PyBytes_Check(classname))
-			cname = PyBytes_AsString(classname);
+		if (classname != NULL && PyString_Check(classname))
+			cname = PyString_AsString(classname);
 		else
 			cname = "?";
-		if (mod == NULL || !PyBytes_Check(mod))
-			return PyBytes_FromFormat("<?.%s instance at %p>",
+		if (mod == NULL || !PyString_Check(mod))
+			return PyString_FromFormat("<?.%s instance at %p>",
 						   cname, inst);
 		else
-			return PyBytes_FromFormat("<%s.%s instance at %p>",
-						   PyBytes_AsString(mod),
+			return PyString_FromFormat("<%s.%s instance at %p>",
+						   PyString_AsString(mod),
 						   cname, inst);
 	}
 	res = PyEval_CallObject(func, (PyObject *)NULL);
@@ -914,7 +914,7 @@
 	static PyObject *strstr;
 
 	if (strstr == NULL) {
-		strstr = PyBytes_InternFromString("__str__");
+		strstr = PyString_InternFromString("__str__");
 		if (strstr == NULL)
 			return NULL;
 	}
@@ -939,7 +939,7 @@
 	static PyObject *hashstr, *eqstr, *cmpstr;
 
 	if (hashstr == NULL) {
-		hashstr = PyBytes_InternFromString("__hash__");
+		hashstr = PyString_InternFromString("__hash__");
 		if (hashstr == NULL)
 			return -1;
 	}
@@ -952,7 +952,7 @@
 		   address.  If an __eq__ or __cmp__ method exists, there must
 		   be a __hash__. */
 		if (eqstr == NULL) {
-			eqstr = PyBytes_InternFromString("__eq__");
+			eqstr = PyString_InternFromString("__eq__");
 			if (eqstr == NULL)
 				return -1;
 		}
@@ -962,7 +962,7 @@
 				return -1;
 			PyErr_Clear();
 			if (cmpstr == NULL) {
-				cmpstr = PyBytes_InternFromString("__cmp__");
+				cmpstr = PyString_InternFromString("__cmp__");
 				if (cmpstr == NULL)
 					return -1;
 			}
@@ -1014,7 +1014,7 @@
 	Py_ssize_t outcome;
 
 	if (lenstr == NULL) {
-		lenstr = PyBytes_InternFromString("__len__");
+		lenstr = PyString_InternFromString("__len__");
 		if (lenstr == NULL)
 			return -1;
 	}
@@ -1063,7 +1063,7 @@
 	PyObject *res;
 
 	if (getitemstr == NULL) {
-		getitemstr = PyBytes_InternFromString("__getitem__");
+		getitemstr = PyString_InternFromString("__getitem__");
 		if (getitemstr == NULL)
 			return NULL;
 	}
@@ -1090,7 +1090,7 @@
 
 	if (value == NULL) {
 		if (delitemstr == NULL) {
-			delitemstr = PyBytes_InternFromString("__delitem__");
+			delitemstr = PyString_InternFromString("__delitem__");
 			if (delitemstr == NULL)
 				return -1;
 		}
@@ -1098,7 +1098,7 @@
 	}
 	else {
 		if (setitemstr == NULL) {
-			setitemstr = PyBytes_InternFromString("__setitem__");
+			setitemstr = PyString_InternFromString("__setitem__");
 			if (setitemstr == NULL)
 				return -1;
 		}
@@ -1135,7 +1135,7 @@
 	PyObject *func, *res;
 
 	if (getitemstr == NULL) {
-		getitemstr = PyBytes_InternFromString("__getitem__");
+		getitemstr = PyString_InternFromString("__getitem__");
 		if (getitemstr == NULL)
 			return NULL;
 	}
@@ -1154,7 +1154,7 @@
 	static PyObject *getslicestr;
 
 	if (getslicestr == NULL) {
-		getslicestr = PyBytes_InternFromString("__getslice__");
+		getslicestr = PyString_InternFromString("__getslice__");
 		if (getslicestr == NULL)
 			return NULL;
 	}
@@ -1166,7 +1166,7 @@
 		PyErr_Clear();
 
 		if (getitemstr == NULL) {
-			getitemstr = PyBytes_InternFromString("__getitem__");
+			getitemstr = PyString_InternFromString("__getitem__");
 			if (getitemstr == NULL)
 				return NULL;
 		}
@@ -1194,7 +1194,7 @@
 
 	if (item == NULL) {
 		if (delitemstr == NULL) {
-			delitemstr = PyBytes_InternFromString("__delitem__");
+			delitemstr = PyString_InternFromString("__delitem__");
 			if (delitemstr == NULL)
 				return -1;
 		}
@@ -1202,7 +1202,7 @@
 	}
 	else {
 		if (setitemstr == NULL) {
-			setitemstr = PyBytes_InternFromString("__setitem__");
+			setitemstr = PyString_InternFromString("__setitem__");
 			if (setitemstr == NULL)
 				return -1;
 		}
@@ -1236,7 +1236,7 @@
 	if (value == NULL) {
 		if (delslicestr == NULL) {
 			delslicestr =
-				PyBytes_InternFromString("__delslice__");
+				PyString_InternFromString("__delslice__");
 			if (delslicestr == NULL)
 				return -1;
 		}
@@ -1247,7 +1247,7 @@
 			PyErr_Clear();
 			if (delitemstr == NULL) {
 				delitemstr =
-				    PyBytes_InternFromString("__delitem__");
+				    PyString_InternFromString("__delitem__");
 				if (delitemstr == NULL)
 					return -1;
 			}
@@ -1263,7 +1263,7 @@
 	else {
 		if (setslicestr == NULL) {
 			setslicestr =
-				PyBytes_InternFromString("__setslice__");
+				PyString_InternFromString("__setslice__");
 			if (setslicestr == NULL)
 				return -1;
 		}
@@ -1274,7 +1274,7 @@
 			PyErr_Clear();
 			if (setitemstr == NULL) {
 				setitemstr =
-				    PyBytes_InternFromString("__setitem__");
+				    PyString_InternFromString("__setitem__");
 				if (setitemstr == NULL)
 					return -1;
 			}
@@ -1311,7 +1311,7 @@
 	 */
 
 	if(__contains__ == NULL) {
-		__contains__ = PyBytes_InternFromString("__contains__");
+		__contains__ = PyString_InternFromString("__contains__");
 		if(__contains__ == NULL)
 			return -1;
 	}
@@ -1417,7 +1417,7 @@
 	}
 
 	if (coerce_obj == NULL) {
-		coerce_obj = PyBytes_InternFromString("__coerce__");
+		coerce_obj = PyString_InternFromString("__coerce__");
 		if (coerce_obj == NULL)
 			return NULL;
 	}
@@ -1504,7 +1504,7 @@
 	PyObject *coerced;
 
 	if (coerce_obj == NULL) {
-		coerce_obj = PyBytes_InternFromString("__coerce__");
+		coerce_obj = PyString_InternFromString("__coerce__");
 		if (coerce_obj == NULL)
 			return -1;
 	}
@@ -1552,7 +1552,7 @@
 #define UNARY(funcname, methodname) \
 static PyObject *funcname(PyInstanceObject *self) { \
 	static PyObject *o; \
-	if (o == NULL) { o = PyBytes_InternFromString(methodname); \
+	if (o == NULL) { o = PyString_InternFromString(methodname); \
 			 if (o == NULL) return NULL; } \
 	return generic_unary_op(self, o); \
 }
@@ -1561,7 +1561,7 @@
 #define UNARY_FB(funcname, methodname, funcname_fb) \
 static PyObject *funcname(PyInstanceObject *self) { \
 	static PyObject *o; \
-	if (o == NULL) { o = PyBytes_InternFromString(methodname); \
+	if (o == NULL) { o = PyString_InternFromString(methodname); \
 			 if (o == NULL) return NULL; } \
 	if (PyObject_HasAttr((PyObject*)self, o)) \
 		return generic_unary_op(self, o); \
@@ -1630,7 +1630,7 @@
 	assert(PyInstance_Check(v));
 
 	if (cmp_obj == NULL) {
-		cmp_obj = PyBytes_InternFromString("__cmp__");
+		cmp_obj = PyString_InternFromString("__cmp__");
 		if (cmp_obj == NULL)
 			return -2;
 	}
@@ -1738,7 +1738,7 @@
 	static PyObject *nonzerostr;
 
 	if (nonzerostr == NULL) {
-		nonzerostr = PyBytes_InternFromString("__nonzero__");
+		nonzerostr = PyString_InternFromString("__nonzero__");
 		if (nonzerostr == NULL)
 			return -1;
 	}
@@ -1747,7 +1747,7 @@
 			return -1;
 		PyErr_Clear();
 		if (lenstr == NULL) {
-			lenstr = PyBytes_InternFromString("__len__");
+			lenstr = PyString_InternFromString("__len__");
 			if (lenstr == NULL)
 				return -1;
 		}
@@ -1787,7 +1787,7 @@
 	static PyObject *indexstr = NULL;
 
 	if (indexstr == NULL) {
-		indexstr = PyBytes_InternFromString("__index__");
+		indexstr = PyString_InternFromString("__index__");
 		if (indexstr == NULL)
 			return NULL;
 	}	
@@ -1814,7 +1814,7 @@
 	PyObject *truncated;
 	static PyObject *int_name;
 	if (int_name == NULL) {
-		int_name = PyBytes_InternFromString("__int__");
+		int_name = PyString_InternFromString("__int__");
 		if (int_name == NULL)
 			return NULL;
 	}
@@ -1929,7 +1929,7 @@
 	if (name_op == NULL)
 		return -1;
 	for (i = 0; i < NAME_OPS; ++i) {
-		name_op[i] = PyBytes_InternFromString(_name_op[i]);
+		name_op[i] = PyString_InternFromString(_name_op[i]);
 		if (name_op[i] == NULL)
 			return -1;
 	}
@@ -2012,12 +2012,12 @@
 	PyObject *func;
 
 	if (iterstr == NULL) {
-		iterstr = PyBytes_InternFromString("__iter__");
+		iterstr = PyString_InternFromString("__iter__");
 		if (iterstr == NULL)
 			return NULL;
 	}
 	if (getitemstr == NULL) {
-		getitemstr = PyBytes_InternFromString("__getitem__");
+		getitemstr = PyString_InternFromString("__getitem__");
 		if (getitemstr == NULL)
 			return NULL;
 	}
@@ -2055,7 +2055,7 @@
 	PyObject *func;
 
 	if (nextstr == NULL) {
-		nextstr = PyBytes_InternFromString("next");
+		nextstr = PyString_InternFromString("next");
 		if (nextstr == NULL)
 			return NULL;
 	}
@@ -2087,7 +2087,7 @@
 		PyErr_Clear();
 		PyErr_Format(PyExc_AttributeError,
 			     "%.200s instance has no __call__ method",
-			     PyBytes_AsString(inst->in_class->cl_name));
+			     PyString_AsString(inst->in_class->cl_name));
 		return NULL;
 	}
 	/* We must check and increment the recursion depth here. Scenario:
@@ -2261,7 +2261,7 @@
 {
 	static PyObject *docstr;
 	if (docstr == NULL) {
-		docstr= PyBytes_InternFromString("__doc__");
+		docstr= PyString_InternFromString("__doc__");
 		if (docstr == NULL)
 			return NULL;
 	}
@@ -2384,12 +2384,12 @@
 			return NULL;
 		PyErr_Clear();
 	}
-	else if (!PyBytes_Check(funcname)) {
+	else if (!PyString_Check(funcname)) {
 		Py_DECREF(funcname);
 		funcname = NULL;
 	}
 	else
-		sfuncname = PyBytes_AS_STRING(funcname);
+		sfuncname = PyString_AS_STRING(funcname);
 	if (klass == NULL)
 		klassname = NULL;
 	else {
@@ -2399,28 +2399,28 @@
 				return NULL;
 			PyErr_Clear();
 		}
-		else if (!PyBytes_Check(klassname)) {
+		else if (!PyString_Check(klassname)) {
 			Py_DECREF(klassname);
 			klassname = NULL;
 		}
 		else
-			sklassname = PyBytes_AS_STRING(klassname);
+			sklassname = PyString_AS_STRING(klassname);
 	}
 	if (self == NULL)
-		result = PyBytes_FromFormat("<unbound method %s.%s>",
+		result = PyString_FromFormat("<unbound method %s.%s>",
 					     sklassname, sfuncname);
 	else {
 		/* XXX Shouldn't use repr() here! */
 		PyObject *selfrepr = PyObject_Repr(self);
 		if (selfrepr == NULL)
 			goto fail;
-		if (!PyBytes_Check(selfrepr)) {
+		if (!PyString_Check(selfrepr)) {
 			Py_DECREF(selfrepr);
 			goto fail;
 		}
-		result = PyBytes_FromFormat("<bound method %s.%s of %s>",
+		result = PyString_FromFormat("<bound method %s.%s of %s>",
 					     sklassname, sfuncname,
-					     PyBytes_AS_STRING(selfrepr));
+					     PyString_AS_STRING(selfrepr));
 		Py_DECREF(selfrepr);
 	}
   fail:
@@ -2472,8 +2472,8 @@
 		PyErr_Clear();
 		return;
 	}
-	if (PyBytes_Check(name)) {
-		strncpy(buf, PyBytes_AS_STRING(name), bufsize);
+	if (PyString_Check(name)) {
+		strncpy(buf, PyString_AS_STRING(name), bufsize);
 		buf[bufsize-1] = '\0';
 	}
 	Py_DECREF(name);
diff --git a/Objects/codeobject.c b/Objects/codeobject.c
index 9892d9c..e94b4cc 100644
--- a/Objects/codeobject.c
+++ b/Objects/codeobject.c
@@ -32,10 +32,10 @@
 
 	for (i = PyTuple_GET_SIZE(tuple); --i >= 0; ) {
 		PyObject *v = PyTuple_GET_ITEM(tuple, i);
-		if (v == NULL || !PyBytes_CheckExact(v)) {
+		if (v == NULL || !PyString_CheckExact(v)) {
 			Py_FatalError("non-string found in code slot");
 		}
-		PyBytes_InternInPlace(&PyTuple_GET_ITEM(tuple, i));
+		PyString_InternInPlace(&PyTuple_GET_ITEM(tuple, i));
 	}
 }
 
@@ -57,9 +57,9 @@
 	    varnames == NULL || !PyTuple_Check(varnames) ||
 	    freevars == NULL || !PyTuple_Check(freevars) ||
 	    cellvars == NULL || !PyTuple_Check(cellvars) ||
-	    name == NULL || !PyBytes_Check(name) ||
-	    filename == NULL || !PyBytes_Check(filename) ||
-	    lnotab == NULL || !PyBytes_Check(lnotab) ||
+	    name == NULL || !PyString_Check(name) ||
+	    filename == NULL || !PyString_Check(filename) ||
+	    lnotab == NULL || !PyString_Check(lnotab) ||
 	    !PyObject_CheckReadBuffer(code)) {
 		PyErr_BadInternalCall();
 		return NULL;
@@ -71,11 +71,11 @@
 	/* Intern selected string constants */
 	for (i = PyTuple_Size(consts); --i >= 0; ) {
 		PyObject *v = PyTuple_GetItem(consts, i);
-		if (!PyBytes_Check(v))
+		if (!PyString_Check(v))
 			continue;
-		if (!all_name_chars((unsigned char *)PyBytes_AS_STRING(v)))
+		if (!all_name_chars((unsigned char *)PyString_AS_STRING(v)))
 			continue;
-		PyBytes_InternInPlace(&PyTuple_GET_ITEM(consts, i));
+		PyString_InternInPlace(&PyTuple_GET_ITEM(consts, i));
 	}
 	co = PyObject_NEW(PyCodeObject, &PyCode_Type);
 	if (co != NULL) {
@@ -145,10 +145,10 @@
 
 	for (i = 0; i < len; i++) {
 		item = PyTuple_GET_ITEM(tup, i);
-		if (PyBytes_CheckExact(item)) {
+		if (PyString_CheckExact(item)) {
 			Py_INCREF(item);
 		}
-		else if (!PyBytes_Check(item)) {
+		else if (!PyString_Check(item)) {
 			PyErr_Format(
 				PyExc_TypeError,
 				"name tuples must contain only "
@@ -158,9 +158,9 @@
 			return NULL;
 		}
 		else {
-			item = PyBytes_FromStringAndSize(
-				PyBytes_AS_STRING(item),
-				PyBytes_GET_SIZE(item));
+			item = PyString_FromStringAndSize(
+				PyString_AS_STRING(item),
+				PyString_GET_SIZE(item));
 			if (item == NULL) {
 				Py_DECREF(newtuple);
 				return NULL;
@@ -281,14 +281,14 @@
 
 	if (co->co_firstlineno != 0)
 		lineno = co->co_firstlineno;
-	if (co->co_filename && PyBytes_Check(co->co_filename))
-		filename = PyBytes_AS_STRING(co->co_filename);
-	if (co->co_name && PyBytes_Check(co->co_name))
-		name = PyBytes_AS_STRING(co->co_name);
+	if (co->co_filename && PyString_Check(co->co_filename))
+		filename = PyString_AS_STRING(co->co_filename);
+	if (co->co_name && PyString_Check(co->co_name))
+		name = PyString_AS_STRING(co->co_name);
 	PyOS_snprintf(buf, sizeof(buf),
 		      "<code object %.100s at %p, file \"%.300s\", line %d>",
 		      name, co, filename, lineno);
-	return PyBytes_FromString(buf);
+	return PyString_FromString(buf);
 }
 
 static int
@@ -508,8 +508,8 @@
 int
 PyCode_Addr2Line(PyCodeObject *co, int addrq)
 {
-	int size = PyBytes_Size(co->co_lnotab) / 2;
-	unsigned char *p = (unsigned char*)PyBytes_AsString(co->co_lnotab);
+	int size = PyString_Size(co->co_lnotab) / 2;
+	unsigned char *p = (unsigned char*)PyString_AsString(co->co_lnotab);
 	int line = co->co_firstlineno;
 	int addr = 0;
 	while (--size >= 0) {
@@ -604,8 +604,8 @@
         int size, addr, line;
         unsigned char* p;
 
-        p = (unsigned char*)PyBytes_AS_STRING(co->co_lnotab);
-        size = PyBytes_GET_SIZE(co->co_lnotab) / 2;
+        p = (unsigned char*)PyString_AS_STRING(co->co_lnotab);
+        size = PyString_GET_SIZE(co->co_lnotab) / 2;
 
         addr = 0;
         line = co->co_firstlineno;
diff --git a/Objects/complexobject.c b/Objects/complexobject.c
index 6110b99..9943d0d 100644
--- a/Objects/complexobject.c
+++ b/Objects/complexobject.c
@@ -303,7 +303,7 @@
 	cv.imag = 0.;
 
 	if (complex_str == NULL) {
-		if (!(complex_str = PyBytes_InternFromString("__complex__")))
+		if (!(complex_str = PyString_InternFromString("__complex__")))
 			return cv;
 	}
 	
@@ -421,7 +421,7 @@
 {
 	char buf[100];
 	complex_to_buf(buf, sizeof(buf), v, PREC_REPR);
-	return PyBytes_FromString(buf);
+	return PyString_FromString(buf);
 }
 
 static PyObject *
@@ -429,7 +429,7 @@
 {
 	char buf[100];
 	complex_to_buf(buf, sizeof(buf), v, PREC_STR);
-	return PyBytes_FromString(buf);
+	return PyString_FromString(buf);
 }
 
 static long
@@ -877,9 +877,9 @@
 #endif
 	Py_ssize_t len;
 
-	if (PyBytes_Check(v)) {
-		s = PyBytes_AS_STRING(v);
-		len = PyBytes_GET_SIZE(v);
+	if (PyString_Check(v)) {
+		s = PyString_AS_STRING(v);
+		len = PyString_GET_SIZE(v);
 	}
 #ifdef Py_USING_UNICODE
 	else if (PyUnicode_Check(v)) {
@@ -1065,7 +1065,7 @@
 		Py_INCREF(r);
 		return r;
 	}
-	if (PyBytes_Check(r) || PyUnicode_Check(r)) {
+	if (PyString_Check(r) || PyUnicode_Check(r)) {
 		if (i != NULL) {
 			PyErr_SetString(PyExc_TypeError,
 					"complex() can't take second arg"
@@ -1074,7 +1074,7 @@
 		}
 		return complex_subtype_from_string(type, r);
 	}
-	if (i != NULL && (PyBytes_Check(i) || PyUnicode_Check(i))) {
+	if (i != NULL && (PyString_Check(i) || PyUnicode_Check(i))) {
 		PyErr_SetString(PyExc_TypeError,
 				"complex() second arg can't be a string");
 		return NULL;
@@ -1082,7 +1082,7 @@
 
 	/* XXX Hack to support classes with __complex__ method */
 	if (complexstr == NULL) {
-		complexstr = PyBytes_InternFromString("__complex__");
+		complexstr = PyString_InternFromString("__complex__");
 		if (complexstr == NULL)
 			return NULL;
 	}
diff --git a/Objects/descrobject.c b/Objects/descrobject.c
index 7cf5e62..fcc174e 100644
--- a/Objects/descrobject.c
+++ b/Objects/descrobject.c
@@ -15,8 +15,8 @@
 static char *
 descr_name(PyDescrObject *descr)
 {
-	if (descr->d_name != NULL && PyBytes_Check(descr->d_name))
-		return PyBytes_AS_STRING(descr->d_name);
+	if (descr->d_name != NULL && PyString_Check(descr->d_name))
+		return PyString_AS_STRING(descr->d_name);
 	else
 		return "?";
 }
@@ -24,7 +24,7 @@
 static PyObject *
 descr_repr(PyDescrObject *descr, char *format)
 {
-	return PyBytes_FromFormat(format, descr_name(descr),
+	return PyString_FromFormat(format, descr_name(descr),
 				   descr->d_type->tp_name);
 }
 
@@ -314,7 +314,7 @@
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
-	return PyBytes_FromString(descr->d_method->ml_doc);
+	return PyString_FromString(descr->d_method->ml_doc);
 }
 
 static PyMemberDef descr_members[] = {
@@ -335,7 +335,7 @@
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
-	return PyBytes_FromString(descr->d_member->doc);
+	return PyString_FromString(descr->d_member->doc);
 }
 
 static PyGetSetDef member_getset[] = {
@@ -350,7 +350,7 @@
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
-	return PyBytes_FromString(descr->d_getset->doc);
+	return PyString_FromString(descr->d_getset->doc);
 }
 
 static PyGetSetDef getset_getset[] = {
@@ -365,7 +365,7 @@
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
-	return PyBytes_FromString(descr->d_base->doc);
+	return PyString_FromString(descr->d_base->doc);
 }
 
 static PyGetSetDef wrapperdescr_getset[] = {
@@ -576,7 +576,7 @@
 	if (descr != NULL) {
 		Py_XINCREF(type);
 		descr->d_type = type;
-		descr->d_name = PyBytes_InternFromString(name);
+		descr->d_name = PyString_InternFromString(name);
 		if (descr->d_name == NULL) {
 			Py_DECREF(descr);
 			descr = NULL;
@@ -922,7 +922,7 @@
 static PyObject *
 wrapper_repr(wrapperobject *wp)
 {
-	return PyBytes_FromFormat("<method-wrapper '%s' of %s object at %p>",
+	return PyString_FromFormat("<method-wrapper '%s' of %s object at %p>",
 				   wp->descr->d_base->name,
 				   wp->self->ob_type->tp_name,
 				   wp->self);
@@ -947,7 +947,7 @@
 {
 	char *s = wp->descr->d_base->name;
 
-	return PyBytes_FromString(s);
+	return PyString_FromString(s);
 }
 
 static PyObject *
@@ -960,7 +960,7 @@
 		return Py_None;
 	}
 	else {
-		return PyBytes_FromString(s);
+		return PyString_FromString(s);
 	}
 }
 
diff --git a/Objects/dictobject.c b/Objects/dictobject.c
index 6b15131..9b14e63 100644
--- a/Objects/dictobject.c
+++ b/Objects/dictobject.c
@@ -224,7 +224,7 @@
 {
 	register PyDictObject *mp;
 	if (dummy == NULL) { /* Auto-initialize dummy */
-		dummy = PyBytes_FromString("<dummy key>");
+		dummy = PyString_FromString("<dummy key>");
 		if (dummy == NULL)
 			return NULL;
 #ifdef SHOW_CONVERSION_COUNTS
@@ -373,7 +373,7 @@
  * this assumption allows testing for errors during PyObject_RichCompareBool()
  * to be dropped; string-string comparisons never raise exceptions.  This also
  * means we don't need to go through PyObject_RichCompareBool(); we can always
- * use _PyBytes_Eq() directly.
+ * use _PyString_Eq() directly.
  *
  * This is valuable because dicts with only string keys are very common.
  */
@@ -391,7 +391,7 @@
 	   including subclasses of str; e.g., one reason to subclass
 	   strings is to override __eq__, and for speed we don't cater to
 	   that here. */
-	if (!PyBytes_CheckExact(key)) {
+	if (!PyString_CheckExact(key)) {
 #ifdef SHOW_CONVERSION_COUNTS
 		++converted;
 #endif
@@ -405,7 +405,7 @@
 	if (ep->me_key == dummy)
 		freeslot = ep;
 	else {
-		if (ep->me_hash == hash && _PyBytes_Eq(ep->me_key, key))
+		if (ep->me_hash == hash && _PyString_Eq(ep->me_key, key))
 			return ep;
 		freeslot = NULL;
 	}
@@ -420,7 +420,7 @@
 		if (ep->me_key == key
 		    || (ep->me_hash == hash
 		        && ep->me_key != dummy
-			&& _PyBytes_Eq(ep->me_key, key)))
+			&& _PyString_Eq(ep->me_key, key)))
 			return ep;
 		if (ep->me_key == dummy && freeslot == NULL)
 			freeslot = ep;
@@ -626,8 +626,8 @@
 	PyThreadState *tstate;
 	if (!PyDict_Check(op))
 		return NULL;
-	if (!PyBytes_CheckExact(key) ||
-	    (hash = ((PyBytesObject *) key)->ob_shash) == -1)
+	if (!PyString_CheckExact(key) ||
+	    (hash = ((PyStringObject *) key)->ob_shash) == -1)
 	{
 		hash = PyObject_Hash(key);
 		if (hash == -1) {
@@ -680,8 +680,8 @@
 	assert(key);
 	assert(value);
 	mp = (PyDictObject *)op;
-	if (PyBytes_CheckExact(key)) {
-		hash = ((PyBytesObject *)key)->ob_shash;
+	if (PyString_CheckExact(key)) {
+		hash = ((PyStringObject *)key)->ob_shash;
 		if (hash == -1)
 			hash = PyObject_Hash(key);
 	}
@@ -728,8 +728,8 @@
 		return -1;
 	}
 	assert(key);
-	if (!PyBytes_CheckExact(key) ||
-	    (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
+	if (!PyString_CheckExact(key) ||
+	    (hash = ((PyStringObject *) key)->ob_shash) == -1) {
 		hash = PyObject_Hash(key);
 		if (hash == -1)
 			return -1;
@@ -982,11 +982,11 @@
 
 	i = Py_ReprEnter((PyObject *)mp);
 	if (i != 0) {
-		return i > 0 ? PyBytes_FromString("{...}") : NULL;
+		return i > 0 ? PyString_FromString("{...}") : NULL;
 	}
 
 	if (mp->ma_used == 0) {
-		result = PyBytes_FromString("{}");
+		result = PyString_FromString("{}");
 		goto Done;
 	}
 
@@ -994,7 +994,7 @@
 	if (pieces == NULL)
 		goto Done;
 
-	colon = PyBytes_FromString(": ");
+	colon = PyString_FromString(": ");
 	if (colon == NULL)
 		goto Done;
 
@@ -1006,8 +1006,8 @@
 		/* Prevent repr from deleting value during key format. */
 		Py_INCREF(value);
 		s = PyObject_Repr(key);
-		PyBytes_Concat(&s, colon);
-		PyBytes_ConcatAndDel(&s, PyObject_Repr(value));
+		PyString_Concat(&s, colon);
+		PyString_ConcatAndDel(&s, PyObject_Repr(value));
 		Py_DECREF(value);
 		if (s == NULL)
 			goto Done;
@@ -1019,29 +1019,29 @@
 
 	/* Add "{}" decorations to the first and last items. */
 	assert(PyList_GET_SIZE(pieces) > 0);
-	s = PyBytes_FromString("{");
+	s = PyString_FromString("{");
 	if (s == NULL)
 		goto Done;
 	temp = PyList_GET_ITEM(pieces, 0);
-	PyBytes_ConcatAndDel(&s, temp);
+	PyString_ConcatAndDel(&s, temp);
 	PyList_SET_ITEM(pieces, 0, s);
 	if (s == NULL)
 		goto Done;
 
-	s = PyBytes_FromString("}");
+	s = PyString_FromString("}");
 	if (s == NULL)
 		goto Done;
 	temp = PyList_GET_ITEM(pieces, PyList_GET_SIZE(pieces) - 1);
-	PyBytes_ConcatAndDel(&temp, s);
+	PyString_ConcatAndDel(&temp, s);
 	PyList_SET_ITEM(pieces, PyList_GET_SIZE(pieces) - 1, temp);
 	if (temp == NULL)
 		goto Done;
 
 	/* Paste them all together with ", " between. */
-	s = PyBytes_FromString(", ");
+	s = PyString_FromString(", ");
 	if (s == NULL)
 		goto Done;
-	result = _PyBytes_Join(s, pieces);
+	result = _PyString_Join(s, pieces);
 	Py_DECREF(s);
 
 Done:
@@ -1064,8 +1064,8 @@
 	long hash;
 	PyDictEntry *ep;
 	assert(mp->ma_table != NULL);
-	if (!PyBytes_CheckExact(key) ||
-	    (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
+	if (!PyString_CheckExact(key) ||
+	    (hash = ((PyStringObject *) key)->ob_shash) == -1) {
 		hash = PyObject_Hash(key);
 		if (hash == -1)
 			return NULL;
@@ -1081,7 +1081,7 @@
 			static PyObject *missing_str = NULL;
 			if (missing_str == NULL)
 				missing_str =
-				  PyBytes_InternFromString("__missing__");
+				  PyString_InternFromString("__missing__");
 			missing = _PyType_Lookup(Py_TYPE(mp), missing_str);
 			if (missing != NULL)
 				return PyObject_CallFunctionObjArgs(missing,
@@ -1794,8 +1794,8 @@
 	long hash;
 	PyDictEntry *ep;
 
-	if (!PyBytes_CheckExact(key) ||
-	    (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
+	if (!PyString_CheckExact(key) ||
+	    (hash = ((PyStringObject *) key)->ob_shash) == -1) {
 		hash = PyObject_Hash(key);
 		if (hash == -1)
 			return NULL;
@@ -1827,8 +1827,8 @@
 	if (!PyArg_UnpackTuple(args, "get", 1, 2, &key, &failobj))
 		return NULL;
 
-	if (!PyBytes_CheckExact(key) ||
-	    (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
+	if (!PyString_CheckExact(key) ||
+	    (hash = ((PyStringObject *) key)->ob_shash) == -1) {
 		hash = PyObject_Hash(key);
 		if (hash == -1)
 			return NULL;
@@ -1856,8 +1856,8 @@
 	if (!PyArg_UnpackTuple(args, "setdefault", 1, 2, &key, &failobj))
 		return NULL;
 
-	if (!PyBytes_CheckExact(key) ||
-	    (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
+	if (!PyString_CheckExact(key) ||
+	    (hash = ((PyStringObject *) key)->ob_shash) == -1) {
 		hash = PyObject_Hash(key);
 		if (hash == -1)
 			return NULL;
@@ -1902,8 +1902,8 @@
 				"pop(): dictionary is empty");
 		return NULL;
 	}
-	if (!PyBytes_CheckExact(key) ||
-	    (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
+	if (!PyString_CheckExact(key) ||
+	    (hash = ((PyStringObject *) key)->ob_shash) == -1) {
 		hash = PyObject_Hash(key);
 		if (hash == -1)
 			return NULL;
@@ -2148,8 +2148,8 @@
 	PyDictObject *mp = (PyDictObject *)op;
 	PyDictEntry *ep;
 
-	if (!PyBytes_CheckExact(key) ||
-	    (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
+	if (!PyString_CheckExact(key) ||
+	    (hash = ((PyStringObject *) key)->ob_shash) == -1) {
 		hash = PyObject_Hash(key);
 		if (hash == -1)
 			return -1;
@@ -2275,7 +2275,7 @@
 PyDict_GetItemString(PyObject *v, const char *key)
 {
 	PyObject *kv, *rv;
-	kv = PyBytes_FromString(key);
+	kv = PyString_FromString(key);
 	if (kv == NULL)
 		return NULL;
 	rv = PyDict_GetItem(v, kv);
@@ -2288,10 +2288,10 @@
 {
 	PyObject *kv;
 	int err;
-	kv = PyBytes_FromString(key);
+	kv = PyString_FromString(key);
 	if (kv == NULL)
 		return -1;
-	PyBytes_InternInPlace(&kv); /* XXX Should we really? */
+	PyString_InternInPlace(&kv); /* XXX Should we really? */
 	err = PyDict_SetItem(v, kv, item);
 	Py_DECREF(kv);
 	return err;
@@ -2302,7 +2302,7 @@
 {
 	PyObject *kv;
 	int err;
-	kv = PyBytes_FromString(key);
+	kv = PyString_FromString(key);
 	if (kv == NULL)
 		return -1;
 	err = PyDict_DelItem(v, kv);
diff --git a/Objects/exceptions.c b/Objects/exceptions.c
index 085ef36..48b47b0 100644
--- a/Objects/exceptions.c
+++ b/Objects/exceptions.c
@@ -44,7 +44,7 @@
         return NULL;
     }
 
-    self->message = PyBytes_FromString("");
+    self->message = PyString_FromString("");
     if (!self->message) {
         Py_DECREF(self);
         return NULL;
@@ -104,7 +104,7 @@
 
     switch (PyTuple_GET_SIZE(self->args)) {
     case 0:
-        out = PyBytes_FromString("");
+        out = PyString_FromString("");
         break;
     case 1:
         out = PyObject_Str(PyTuple_GET_ITEM(self->args, 0));
@@ -133,13 +133,13 @@
     dot = strrchr(name, '.');
     if (dot != NULL) name = dot+1;
 
-    repr = PyBytes_FromString(name);
+    repr = PyString_FromString(name);
     if (!repr) {
         Py_DECREF(repr_suffix);
         return NULL;
     }
 
-    PyBytes_ConcatAndDel(&repr, repr_suffix);
+    PyString_ConcatAndDel(&repr, repr_suffix);
     return repr;
 }
 
@@ -610,7 +610,7 @@
         PyObject *repr;
         PyObject *tuple;
 
-        fmt = PyBytes_FromString("[Errno %s] %s: %s");
+        fmt = PyString_FromString("[Errno %s] %s: %s");
         if (!fmt)
             return NULL;
 
@@ -645,7 +645,7 @@
 
         PyTuple_SET_ITEM(tuple, 2, repr);
 
-        rtnval = PyBytes_Format(fmt, tuple);
+        rtnval = PyString_Format(fmt, tuple);
 
         Py_DECREF(fmt);
         Py_DECREF(tuple);
@@ -654,7 +654,7 @@
         PyObject *fmt;
         PyObject *tuple;
 
-        fmt = PyBytes_FromString("[Errno %s] %s");
+        fmt = PyString_FromString("[Errno %s] %s");
         if (!fmt)
             return NULL;
 
@@ -681,7 +681,7 @@
             PyTuple_SET_ITEM(tuple, 1, Py_None);
         }
 
-        rtnval = PyBytes_Format(fmt, tuple);
+        rtnval = PyString_Format(fmt, tuple);
 
         Py_DECREF(fmt);
         Py_DECREF(tuple);
@@ -841,7 +841,7 @@
         PyObject *repr;
         PyObject *tuple;
 
-        fmt = PyBytes_FromString("[Error %s] %s: %s");
+        fmt = PyString_FromString("[Error %s] %s: %s");
         if (!fmt)
             return NULL;
 
@@ -876,7 +876,7 @@
 
         PyTuple_SET_ITEM(tuple, 2, repr);
 
-        rtnval = PyBytes_Format(fmt, tuple);
+        rtnval = PyString_Format(fmt, tuple);
 
         Py_DECREF(fmt);
         Py_DECREF(tuple);
@@ -885,7 +885,7 @@
         PyObject *fmt;
         PyObject *tuple;
 
-        fmt = PyBytes_FromString("[Error %s] %s");
+        fmt = PyString_FromString("[Error %s] %s");
         if (!fmt)
             return NULL;
 
@@ -912,7 +912,7 @@
             PyTuple_SET_ITEM(tuple, 1, Py_None);
         }
 
-        rtnval = PyBytes_Format(fmt, tuple);
+        rtnval = PyString_Format(fmt, tuple);
 
         Py_DECREF(fmt);
         Py_DECREF(tuple);
@@ -1109,21 +1109,21 @@
         str = PyObject_Str(Py_None);
     if (!str) return NULL;
     /* Don't fiddle with non-string return (shouldn't happen anyway) */
-    if (!PyBytes_Check(str)) return str;
+    if (!PyString_Check(str)) return str;
 
     /* XXX -- do all the additional formatting with filename and
        lineno here */
 
     have_filename = (self->filename != NULL) &&
-        PyBytes_Check(self->filename);
+        PyString_Check(self->filename);
     have_lineno = (self->lineno != NULL) && PyInt_Check(self->lineno);
 
     if (!have_filename && !have_lineno)
         return str;
 
-    bufsize = PyBytes_GET_SIZE(str) + 64;
+    bufsize = PyString_GET_SIZE(str) + 64;
     if (have_filename)
-        bufsize += PyBytes_GET_SIZE(self->filename);
+        bufsize += PyString_GET_SIZE(self->filename);
 
     buffer = PyMem_MALLOC(bufsize);
     if (buffer == NULL)
@@ -1131,19 +1131,19 @@
 
     if (have_filename && have_lineno)
         PyOS_snprintf(buffer, bufsize, "%s (%s, line %ld)",
-            PyBytes_AS_STRING(str),
-            my_basename(PyBytes_AS_STRING(self->filename)),
+            PyString_AS_STRING(str),
+            my_basename(PyString_AS_STRING(self->filename)),
             PyInt_AsLong(self->lineno));
     else if (have_filename)
         PyOS_snprintf(buffer, bufsize, "%s (%s)",
-            PyBytes_AS_STRING(str),
-            my_basename(PyBytes_AS_STRING(self->filename)));
+            PyString_AS_STRING(str),
+            my_basename(PyString_AS_STRING(self->filename)));
     else /* only have_lineno */
         PyOS_snprintf(buffer, bufsize, "%s (line %ld)",
-            PyBytes_AS_STRING(str),
+            PyString_AS_STRING(str),
             PyInt_AsLong(self->lineno));
 
-    result = PyBytes_FromString(buffer);
+    result = PyString_FromString(buffer);
     PyMem_FREE(buffer);
 
     if (result == NULL)
@@ -1250,7 +1250,7 @@
         return NULL;
     }
 
-    if (!PyBytes_Check(attr)) {
+    if (!PyString_Check(attr)) {
         PyErr_Format(PyExc_TypeError, "%.200s attribute must be str", name);
         return NULL;
     }
@@ -1262,7 +1262,7 @@
 static int
 set_string(PyObject **attr, const char *value)
 {
-    PyObject *obj = PyBytes_FromString(value);
+    PyObject *obj = PyString_FromString(value);
     if (!obj)
         return -1;
     Py_CLEAR(*attr);
@@ -1345,7 +1345,7 @@
                                "object");
     if (!obj)
         return -1;
-    size = PyBytes_GET_SIZE(obj);
+    size = PyString_GET_SIZE(obj);
     *start = ((PyUnicodeErrorObject *)exc)->start;
     if (*start<0)
         *start = 0;
@@ -1415,7 +1415,7 @@
     if (!obj)
         return -1;
     *end = ((PyUnicodeErrorObject *)exc)->end;
-    size = PyBytes_GET_SIZE(obj);
+    size = PyString_GET_SIZE(obj);
     if (*end<1)
         *end = 1;
     if (*end>size)
@@ -1506,11 +1506,11 @@
     Py_CLEAR(self->reason);
 
     if (!PyArg_ParseTuple(args, "O!O!nnO!",
-        &PyBytes_Type, &self->encoding,
+        &PyString_Type, &self->encoding,
         objecttype, &self->object,
         &self->start,
         &self->end,
-        &PyBytes_Type, &self->reason)) {
+        &PyString_Type, &self->reason)) {
         self->encoding = self->object = self->reason = NULL;
         return -1;
     }
@@ -1590,20 +1590,20 @@
             PyOS_snprintf(badchar_str, sizeof(badchar_str), "u%04x", badchar);
         else
             PyOS_snprintf(badchar_str, sizeof(badchar_str), "U%08x", badchar);
-        return PyBytes_FromFormat(
+        return PyString_FromFormat(
             "'%.400s' codec can't encode character u'\\%s' in position %zd: %.400s",
-            PyBytes_AS_STRING(uself->encoding),
+            PyString_AS_STRING(uself->encoding),
             badchar_str,
             uself->start,
-            PyBytes_AS_STRING(uself->reason)
+            PyString_AS_STRING(uself->reason)
         );
     }
-    return PyBytes_FromFormat(
+    return PyString_FromFormat(
         "'%.400s' codec can't encode characters in position %zd-%zd: %.400s",
-        PyBytes_AS_STRING(uself->encoding),
+        PyString_AS_STRING(uself->encoding),
         uself->start,
         uself->end-1,
-        PyBytes_AS_STRING(uself->reason)
+        PyString_AS_STRING(uself->reason)
     );
 }
 
@@ -1642,7 +1642,7 @@
     if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)
         return -1;
     return UnicodeError_init((PyUnicodeErrorObject *)self, args,
-                             kwds, &PyBytes_Type);
+                             kwds, &PyString_Type);
 }
 
 static PyObject *
@@ -1654,21 +1654,21 @@
         /* FromFormat does not support %02x, so format that separately */
         char byte[4];
         PyOS_snprintf(byte, sizeof(byte), "%02x",
-                      ((int)PyBytes_AS_STRING(uself->object)[uself->start])&0xff);
-        return PyBytes_FromFormat(
+                      ((int)PyString_AS_STRING(uself->object)[uself->start])&0xff);
+        return PyString_FromFormat(
             "'%.400s' codec can't decode byte 0x%s in position %zd: %.400s",
-            PyBytes_AS_STRING(uself->encoding),
+            PyString_AS_STRING(uself->encoding),
             byte,
             uself->start,
-            PyBytes_AS_STRING(uself->reason)
+            PyString_AS_STRING(uself->reason)
         );
     }
-    return PyBytes_FromFormat(
+    return PyString_FromFormat(
         "'%.400s' codec can't decode bytes in position %zd-%zd: %.400s",
-        PyBytes_AS_STRING(uself->encoding),
+        PyString_AS_STRING(uself->encoding),
         uself->start,
         uself->end-1,
-        PyBytes_AS_STRING(uself->reason)
+        PyString_AS_STRING(uself->reason)
     );
 }
 
@@ -1718,7 +1718,7 @@
         &PyUnicode_Type, &self->object,
         &self->start,
         &self->end,
-        &PyBytes_Type, &self->reason)) {
+        &PyString_Type, &self->reason)) {
         self->object = self->reason = NULL;
         return -1;
     }
@@ -1744,18 +1744,18 @@
             PyOS_snprintf(badchar_str, sizeof(badchar_str), "u%04x", badchar);
         else
             PyOS_snprintf(badchar_str, sizeof(badchar_str), "U%08x", badchar);
-        return PyBytes_FromFormat(
+        return PyString_FromFormat(
             "can't translate character u'\\%s' in position %zd: %.400s",
             badchar_str,
             uself->start,
-            PyBytes_AS_STRING(uself->reason)
+            PyString_AS_STRING(uself->reason)
         );
     }
-    return PyBytes_FromFormat(
+    return PyString_FromFormat(
         "can't translate characters in position %zd-%zd: %.400s",
         uself->start,
         uself->end-1,
-        PyBytes_AS_STRING(uself->reason)
+        PyString_AS_STRING(uself->reason)
     );
 }
 
@@ -2111,7 +2111,7 @@
 	    (PyBaseExceptionObject *)PyExc_RecursionErrorInst;
 	PyObject *args_tuple;
 	PyObject *exc_message;
-	exc_message = PyBytes_FromString("maximum recursion depth exceeded");
+	exc_message = PyString_FromString("maximum recursion depth exceeded");
 	if (!exc_message)
 	    Py_FatalError("cannot allocate argument for RuntimeError "
 			    "pre-allocation");
diff --git a/Objects/fileobject.c b/Objects/fileobject.c
index 4ea97f5..8cc829b 100644
--- a/Objects/fileobject.c
+++ b/Objects/fileobject.c
@@ -26,7 +26,7 @@
 #include <io.h>
 #endif
 
-#define BUF(v) PyBytes_AS_STRING((PyBytesObject *)v)
+#define BUF(v) PyString_AS_STRING((PyStringObject *)v)
 
 #ifndef DONT_HAVE_ERRNO_H
 #include <errno.h>
@@ -160,7 +160,7 @@
         Py_INCREF(name);
         f->f_name = name;
 
-	f->f_mode = PyBytes_FromString(mode);
+	f->f_mode = PyString_FromString(mode);
 
 	f->f_close = close;
 	f->f_softspace = 0;
@@ -370,7 +370,7 @@
 	PyFileObject *f = (PyFileObject *)PyFile_Type.tp_new(&PyFile_Type,
 							     NULL, NULL);
 	if (f != NULL) {
-		PyObject *o_name = PyBytes_FromString(name);
+		PyObject *o_name = PyString_FromString(name);
 		if (o_name == NULL)
 			return NULL;
 		if (fill_file_fields(f, fp, o_name, mode, close) == NULL) {
@@ -525,20 +525,20 @@
 #ifdef Py_USING_UNICODE
 		PyObject *ret = NULL;
 		PyObject *name = PyUnicode_AsUnicodeEscapeString(f->f_name);
-		const char *name_str = name ? PyBytes_AsString(name) : "?";
-		ret = PyBytes_FromFormat("<%s file u'%s', mode '%s' at %p>",
+		const char *name_str = name ? PyString_AsString(name) : "?";
+		ret = PyString_FromFormat("<%s file u'%s', mode '%s' at %p>",
 				   f->f_fp == NULL ? "closed" : "open",
 				   name_str,
-				   PyBytes_AsString(f->f_mode),
+				   PyString_AsString(f->f_mode),
 				   f);
 		Py_XDECREF(name);
 		return ret;
 #endif
 	} else {
-		return PyBytes_FromFormat("<%s file '%s', mode '%s' at %p>",
+		return PyString_FromFormat("<%s file '%s', mode '%s' at %p>",
 				   f->f_fp == NULL ? "closed" : "open",
-				   PyBytes_AsString(f->f_name),
-				   PyBytes_AsString(f->f_mode),
+				   PyString_AsString(f->f_name),
+				   PyString_AsString(f->f_mode),
 				   f);
 	}
 }
@@ -958,7 +958,7 @@
 	"requested number of bytes is more than a Python string can hold");
 		return NULL;
 	}
-	v = PyBytes_FromStringAndSize((char *)NULL, buffersize);
+	v = PyString_FromStringAndSize((char *)NULL, buffersize);
 	if (v == NULL)
 		return NULL;
 	bytesread = 0;
@@ -989,7 +989,7 @@
 		}
 		if (bytesrequested < 0) {
 			buffersize = new_buffersize(f, buffersize);
-			if (_PyBytes_Resize(&v, buffersize) < 0)
+			if (_PyString_Resize(&v, buffersize) < 0)
 				return NULL;
 		} else {
 			/* Got what was requested. */
@@ -997,7 +997,7 @@
 		}
 	}
 	if (bytesread != buffersize)
-		_PyBytes_Resize(&v, bytesread);
+		_PyString_Resize(&v, bytesread);
 	return v;
 }
 
@@ -1115,7 +1115,7 @@
 	size_t increment;	/* amount to increment the buffer */
 	size_t prev_v_size;
 
-	/* Optimize for normal case:  avoid _PyBytes_Resize if at all
+	/* Optimize for normal case:  avoid _PyString_Resize if at all
 	 * possible via first reading into stack buffer "buf".
 	 */
 	total_v_size = INITBUFSIZE;	/* start small and pray */
@@ -1133,7 +1133,7 @@
 			clearerr(fp);
 			if (PyErr_CheckSignals())
 				return NULL;
-			v = PyBytes_FromStringAndSize(buf, pvfree - buf);
+			v = PyString_FromStringAndSize(buf, pvfree - buf);
 			return v;
 		}
 		/* fgets read *something* */
@@ -1162,7 +1162,7 @@
 				assert(p > pvfree && *(p-1) == '\0');
 				--p;	/* don't include \0 from fgets */
 			}
-			v = PyBytes_FromStringAndSize(buf, p - buf);
+			v = PyString_FromStringAndSize(buf, p - buf);
 			return v;
 		}
 		/* yuck:  fgets overwrote all the newlines, i.e. the entire
@@ -1183,7 +1183,7 @@
 	 * into its buffer.
 	 */
 	total_v_size = MAXBUFSIZE << 1;
-	v = PyBytes_FromStringAndSize((char*)NULL, (int)total_v_size);
+	v = PyString_FromStringAndSize((char*)NULL, (int)total_v_size);
 	if (v == NULL)
 		return v;
 	/* copy over everything except the last null byte */
@@ -1238,13 +1238,13 @@
 			Py_DECREF(v);
 			return NULL;
 		}
-		if (_PyBytes_Resize(&v, (int)total_v_size) < 0)
+		if (_PyString_Resize(&v, (int)total_v_size) < 0)
 			return NULL;
 		/* overwrite the trailing null byte */
 		pvfree = BUF(v) + (prev_v_size - 1);
 	}
 	if (BUF(v) + total_v_size != p)
-		_PyBytes_Resize(&v, p - BUF(v));
+		_PyString_Resize(&v, p - BUF(v));
 	return v;
 #undef INITBUFSIZE
 #undef MAXBUFSIZE
@@ -1276,7 +1276,7 @@
 		return getline_via_fgets(f, fp);
 #endif
 	total_v_size = n > 0 ? n : 100;
-	v = PyBytes_FromStringAndSize((char *)NULL, total_v_size);
+	v = PyString_FromStringAndSize((char *)NULL, total_v_size);
 	if (v == NULL)
 		return NULL;
 	buf = BUF(v);
@@ -1349,7 +1349,7 @@
 			Py_DECREF(v);
 			return NULL;
 		}
-		if (_PyBytes_Resize(&v, total_v_size) < 0)
+		if (_PyString_Resize(&v, total_v_size) < 0)
 			return NULL;
 		buf = BUF(v) + used_v_size;
 		end = BUF(v) + total_v_size;
@@ -1357,7 +1357,7 @@
 
 	used_v_size = buf - BUF(v);
 	if (used_v_size != total_v_size)
-		_PyBytes_Resize(&v, used_v_size);
+		_PyString_Resize(&v, used_v_size);
 	return v;
 }
 
@@ -1402,7 +1402,7 @@
 		result = PyEval_CallObject(reader, args);
 		Py_DECREF(reader);
 		Py_DECREF(args);
-		if (result != NULL && !PyBytes_Check(result) &&
+		if (result != NULL && !PyString_Check(result) &&
 		    !PyUnicode_Check(result)) {
 			Py_DECREF(result);
 			result = NULL;
@@ -1411,9 +1411,9 @@
 		}
 	}
 
-	if (n < 0 && result != NULL && PyBytes_Check(result)) {
-		char *s = PyBytes_AS_STRING(result);
-		Py_ssize_t len = PyBytes_GET_SIZE(result);
+	if (n < 0 && result != NULL && PyString_Check(result)) {
+		char *s = PyString_AS_STRING(result);
+		Py_ssize_t len = PyString_GET_SIZE(result);
 		if (len == 0) {
 			Py_DECREF(result);
 			result = NULL;
@@ -1422,10 +1422,10 @@
 		}
 		else if (s[len-1] == '\n') {
 			if (result->ob_refcnt == 1)
-				_PyBytes_Resize(&result, len-1);
+				_PyString_Resize(&result, len-1);
 			else {
 				PyObject *v;
-				v = PyBytes_FromStringAndSize(s, len-1);
+				v = PyString_FromStringAndSize(s, len-1);
 				Py_DECREF(result);
 				result = v;
 			}
@@ -1473,7 +1473,7 @@
 	if (!PyArg_ParseTuple(args, "|i:readline", &n))
 		return NULL;
 	if (n == 0)
-		return PyBytes_FromString("");
+		return PyString_FromString("");
 	if (n < 0)
 		n = 0;
 	return get_line(f, n);
@@ -1539,18 +1539,18 @@
 			}
 			if (big_buffer == NULL) {
 				/* Create the big buffer */
-				big_buffer = PyBytes_FromStringAndSize(
+				big_buffer = PyString_FromStringAndSize(
 					NULL, buffersize);
 				if (big_buffer == NULL)
 					goto error;
-				buffer = PyBytes_AS_STRING(big_buffer);
+				buffer = PyString_AS_STRING(big_buffer);
 				memcpy(buffer, small_buffer, nfilled);
 			}
 			else {
 				/* Grow the big buffer */
-				if ( _PyBytes_Resize(&big_buffer, buffersize) < 0 )
+				if ( _PyString_Resize(&big_buffer, buffersize) < 0 )
 					goto error;
-				buffer = PyBytes_AS_STRING(big_buffer);
+				buffer = PyString_AS_STRING(big_buffer);
 			}
 			continue;
 		}
@@ -1559,7 +1559,7 @@
 		do {
 			/* Process complete lines */
 			p++;
-			line = PyBytes_FromStringAndSize(q, p-q);
+			line = PyString_FromStringAndSize(q, p-q);
 			if (line == NULL)
 				goto error;
 			err = PyList_Append(list, line);
@@ -1578,7 +1578,7 @@
 	}
 	if (nfilled != 0) {
 		/* Partial last line */
-		line = PyBytes_FromStringAndSize(buffer, nfilled);
+		line = PyString_FromStringAndSize(buffer, nfilled);
 		if (line == NULL)
 			goto error;
 		if (sizehint > 0) {
@@ -1588,7 +1588,7 @@
 				Py_DECREF(line);
 				goto error;
 			}
-			PyBytes_Concat(&line, rest);
+			PyString_Concat(&line, rest);
 			Py_DECREF(rest);
 			if (line == NULL)
 				goto error;
@@ -1695,7 +1695,7 @@
 		   could potentially execute Python code. */
 		for (i = 0; i < j; i++) {
 			PyObject *v = PyList_GET_ITEM(list, i);
-			if (!PyBytes_Check(v)) {
+			if (!PyString_Check(v)) {
 			    	const char *buffer;
 				if (((f->f_binary &&
 				      PyObject_AsReadBuffer(v,
@@ -1708,7 +1708,7 @@
 			"writelines() argument must be a sequence of strings");
 					goto error;
 				}
-				line = PyBytes_FromStringAndSize(buffer,
+				line = PyString_FromStringAndSize(buffer,
 								  len);
 				if (line == NULL)
 					goto error;
@@ -1724,8 +1724,8 @@
 		errno = 0;
 		for (i = 0; i < j; i++) {
 		    	line = PyList_GET_ITEM(list, i);
-			len = PyBytes_GET_SIZE(line);
-			nwritten = fwrite(PyBytes_AS_STRING(line),
+			len = PyString_GET_SIZE(line);
+			nwritten = fwrite(PyString_AS_STRING(line),
 					  1, len, f->f_fp);
 			if (nwritten != len) {
 				FILE_ABORT_ALLOW_THREADS(f)
@@ -1921,13 +1921,13 @@
 		Py_INCREF(Py_None);
 		return Py_None;
 	case NEWLINE_CR:
-		return PyBytes_FromString("\r");
+		return PyString_FromString("\r");
 	case NEWLINE_LF:
-		return PyBytes_FromString("\n");
+		return PyString_FromString("\n");
 	case NEWLINE_CR|NEWLINE_LF:
 		return Py_BuildValue("(ss)", "\r", "\n");
 	case NEWLINE_CRLF:
-		return PyBytes_FromString("\r\n");
+		return PyString_FromString("\r\n");
 	case NEWLINE_CR|NEWLINE_CRLF:
 		return Py_BuildValue("(ss)", "\r", "\r\n");
 	case NEWLINE_LF|NEWLINE_CRLF:
@@ -2029,10 +2029,10 @@
    horrified by the recursive call: maximum recursion depth is limited by
    logarithmic buffer growth to about 50 even when reading a 1gb line. */
 
-static PyBytesObject *
+static PyStringObject *
 readahead_get_line_skip(PyFileObject *f, int skip, int bufsize)
 {
-	PyBytesObject* s;
+	PyStringObject* s;
 	char *bufptr;
 	char *buf;
 	Py_ssize_t len;
@@ -2043,17 +2043,17 @@
 
 	len = f->f_bufend - f->f_bufptr;
 	if (len == 0)
-		return (PyBytesObject *)
-			PyBytes_FromStringAndSize(NULL, skip);
+		return (PyStringObject *)
+			PyString_FromStringAndSize(NULL, skip);
 	bufptr = (char *)memchr(f->f_bufptr, '\n', len);
 	if (bufptr != NULL) {
 		bufptr++;			/* Count the '\n' */
 		len = bufptr - f->f_bufptr;
-		s = (PyBytesObject *)
-			PyBytes_FromStringAndSize(NULL, skip+len);
+		s = (PyStringObject *)
+			PyString_FromStringAndSize(NULL, skip+len);
 		if (s == NULL)
 			return NULL;
-		memcpy(PyBytes_AS_STRING(s)+skip, f->f_bufptr, len);
+		memcpy(PyString_AS_STRING(s)+skip, f->f_bufptr, len);
 		f->f_bufptr = bufptr;
 		if (bufptr == f->f_bufend)
 			drop_readahead(f);
@@ -2068,7 +2068,7 @@
 		        PyMem_Free(buf);
 			return NULL;
 		}
-		memcpy(PyBytes_AS_STRING(s)+skip, bufptr, len);
+		memcpy(PyString_AS_STRING(s)+skip, bufptr, len);
 		PyMem_Free(buf);
 	}
 	return s;
@@ -2080,13 +2080,13 @@
 static PyObject *
 file_iternext(PyFileObject *f)
 {
-	PyBytesObject* l;
+	PyStringObject* l;
 
 	if (f->f_fp == NULL)
 		return err_closed();
 
 	l = readahead_get_line_skip(f, 0, READAHEAD_BUFSIZE);
-	if (l == NULL || PyBytes_GET_SIZE(l) == 0) {
+	if (l == NULL || PyString_GET_SIZE(l) == 0) {
 		Py_XDECREF(l);
 		return NULL;
 	}
@@ -2103,7 +2103,7 @@
 	assert(type != NULL && type->tp_alloc != NULL);
 
 	if (not_yet_string == NULL) {
-		not_yet_string = PyBytes_InternFromString("<uninitialized file>");
+		not_yet_string = PyString_InternFromString("<uninitialized file>");
 		if (not_yet_string == NULL)
 			return NULL;
 	}
@@ -2394,7 +2394,7 @@
 		return 0;
 	}
 	else if (!PyErr_Occurred()) {
-		PyObject *v = PyBytes_FromString(s);
+		PyObject *v = PyString_FromString(s);
 		int err;
 		if (v == NULL)
 			return -1;
diff --git a/Objects/floatobject.c b/Objects/floatobject.c
index baf55aa..32e7cc8 100644
--- a/Objects/floatobject.c
+++ b/Objects/floatobject.c
@@ -182,9 +182,9 @@
 
 	if (pend)
 		*pend = NULL;
-	if (PyBytes_Check(v)) {
-		s = PyBytes_AS_STRING(v);
-		len = PyBytes_GET_SIZE(v);
+	if (PyString_Check(v)) {
+		s = PyString_AS_STRING(v);
+		len = PyString_GET_SIZE(v);
 	}
 #ifdef Py_USING_UNICODE
 	else if (PyUnicode_Check(v)) {
@@ -485,7 +485,7 @@
 	char buf[100];
 	format_float(buf, sizeof(buf), v, PREC_REPR);
 
-	return PyBytes_FromString(buf);
+	return PyString_FromString(buf);
 }
 
 static PyObject *
@@ -493,7 +493,7 @@
 {
 	char buf[100];
 	format_float(buf, sizeof(buf), v, PREC_STR);
-	return PyBytes_FromString(buf);
+	return PyString_FromString(buf);
 }
 
 /* Comparison is pretty much a nightmare.  When comparing float to float,
@@ -1218,7 +1218,7 @@
 		return float_subtype_new(type, args, kwds); /* Wimp out */
 	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O:float", kwlist, &x))
 		return NULL;
-	if (PyBytes_Check(x))
+	if (PyString_Check(x))
 		return PyFloat_FromString(x, NULL);
 	return PyNumber_Float(x);
 }
@@ -1269,13 +1269,13 @@
 	char* s;
 	float_format_type r;
 
-	if (!PyBytes_Check(arg)) {
+	if (!PyString_Check(arg)) {
 		PyErr_Format(PyExc_TypeError,
 	     "__getformat__() argument must be string, not %.500s",
 			     Py_TYPE(arg)->tp_name);
 		return NULL;
 	}
-	s = PyBytes_AS_STRING(arg);
+	s = PyString_AS_STRING(arg);
 	if (strcmp(s, "double") == 0) {
 		r = double_format;
 	}
@@ -1291,11 +1291,11 @@
 	
 	switch (r) {
 	case unknown_format:
-		return PyBytes_FromString("unknown");
+		return PyString_FromString("unknown");
 	case ieee_little_endian_format:
-		return PyBytes_FromString("IEEE, little-endian");
+		return PyString_FromString("IEEE, little-endian");
 	case ieee_big_endian_format:
-		return PyBytes_FromString("IEEE, big-endian");
+		return PyString_FromString("IEEE, big-endian");
 	default:
 		Py_FatalError("insane float_format or double_format");
 		return NULL;
diff --git a/Objects/frameobject.c b/Objects/frameobject.c
index 36c1fc2..025431e 100644
--- a/Objects/frameobject.c
+++ b/Objects/frameobject.c
@@ -114,7 +114,7 @@
 
 	/* Find the bytecode offset for the start of the given line, or the
 	 * first code-owning line after it. */
-	PyBytes_AsStringAndSize(f->f_code->co_lnotab, &lnotab, &lnotab_len);
+	PyString_AsStringAndSize(f->f_code->co_lnotab, &lnotab, &lnotab_len);
 	addr = 0;
 	line = f->f_code->co_firstlineno;
 	new_lasti = -1;
@@ -137,7 +137,7 @@
 	}
 
 	/* We're now ready to look at the bytecode. */
-	PyBytes_AsStringAndSize(f->f_code->co_code, (char **)&code, &code_len);
+	PyString_AsStringAndSize(f->f_code->co_code, (char **)&code, &code_len);
 	min_addr = MIN(new_lasti, f->f_lasti);
 	max_addr = MAX(new_lasti, f->f_lasti);
 
@@ -548,7 +548,7 @@
 
 int _PyFrame_Init()
 {
-	builtin_object = PyBytes_InternFromString("__builtins__");
+	builtin_object = PyString_InternFromString("__builtins__");
 	return (builtin_object != NULL);
 }
 
@@ -728,7 +728,7 @@
 	for (j = nmap; --j >= 0; ) {
 		PyObject *key = PyTuple_GET_ITEM(map, j);
 		PyObject *value = values[j];
-		assert(PyBytes_Check(key));
+		assert(PyString_Check(key));
 		if (deref) {
 			assert(PyCell_Check(value));
 			value = PyCell_GET(value);
@@ -776,7 +776,7 @@
 	for (j = nmap; --j >= 0; ) {
 		PyObject *key = PyTuple_GET_ITEM(map, j);
 		PyObject *value = PyObject_GetItem(dict, key);
-		assert(PyBytes_Check(key));
+		assert(PyString_Check(key));
 		/* We only care about NULLs if clear is true. */
 		if (value == NULL) {
 			PyErr_Clear();
diff --git a/Objects/funcobject.c b/Objects/funcobject.c
index 216b6da..a2e87b7 100644
--- a/Objects/funcobject.c
+++ b/Objects/funcobject.c
@@ -28,7 +28,7 @@
 		consts = ((PyCodeObject *)code)->co_consts;
 		if (PyTuple_Size(consts) >= 1) {
 			doc = PyTuple_GetItem(consts, 0);
-			if (!PyBytes_Check(doc) && !PyUnicode_Check(doc))
+			if (!PyString_Check(doc) && !PyUnicode_Check(doc))
 				doc = Py_None;
 		}
 		else
@@ -42,7 +42,7 @@
 		   Otherwise, use None.
 		*/
 		if (!__name__) {
-			__name__ = PyBytes_InternFromString("__name__");
+			__name__ = PyString_InternFromString("__name__");
 			if (!__name__) {
 				Py_DECREF(op);
 				return NULL;
@@ -254,7 +254,7 @@
 		PyErr_Format(PyExc_ValueError,
 			     "%s() requires a code object with %zd free vars,"
 			     " not %zd",
-			     PyBytes_AsString(op->func_name),
+			     PyString_AsString(op->func_name),
 			     nclosure, nfree);
 		return -1;
 	}
@@ -281,7 +281,7 @@
 		return -1;
 	/* Not legal to del f.func_name or to set it to anything
 	 * other than a string object. */
-	if (value == NULL || !PyBytes_Check(value)) {
+	if (value == NULL || !PyString_Check(value)) {
 		PyErr_SetString(PyExc_TypeError,
 				"__name__ must be set to a string object");
 		return -1;
@@ -380,7 +380,7 @@
 			      &PyDict_Type, &globals,
 			      &name, &defaults, &closure))
 		return NULL;
-	if (name != Py_None && !PyBytes_Check(name)) {
+	if (name != Py_None && !PyString_Check(name)) {
 		PyErr_SetString(PyExc_TypeError,
 				"arg 3 (name) must be None or string");
 		return NULL;
@@ -409,7 +409,7 @@
 	if (nfree != nclosure)
 		return PyErr_Format(PyExc_ValueError,
 				    "%s requires closure of length %zd, not %zd",
-				    PyBytes_AS_STRING(code->co_name),
+				    PyString_AS_STRING(code->co_name),
 				    nfree, nclosure);
 	if (nclosure) {
 		Py_ssize_t i;
@@ -465,8 +465,8 @@
 static PyObject*
 func_repr(PyFunctionObject *op)
 {
-	return PyBytes_FromFormat("<function %s at %p>",
-				   PyBytes_AsString(op->func_name),
+	return PyString_FromFormat("<function %s at %p>",
+				   PyString_AsString(op->func_name),
 				   op);
 }
 
diff --git a/Objects/genobject.c b/Objects/genobject.c
index b1c51a8..d2ef508 100644
--- a/Objects/genobject.c
+++ b/Objects/genobject.c
@@ -285,10 +285,10 @@
 gen_repr(PyGenObject *gen)
 {
 	char *code_name;
-	code_name = PyBytes_AsString(((PyCodeObject *)gen->gi_code)->co_name);
+	code_name = PyString_AsString(((PyCodeObject *)gen->gi_code)->co_name);
 	if (code_name == NULL)
 		return NULL;
-	return PyBytes_FromFormat("<generator object %.200s at %p>",
+	return PyString_FromFormat("<generator object %.200s at %p>",
 				   code_name, gen);
 }
 
diff --git a/Objects/intobject.c b/Objects/intobject.c
index 3b68640..f98aee0 100644
--- a/Objects/intobject.c
+++ b/Objects/intobject.c
@@ -367,7 +367,7 @@
 	if (*end != '\0') {
   bad:
 		slen = strlen(s) < 200 ? strlen(s) : 200;
-		sobj = PyBytes_FromStringAndSize(s, slen);
+		sobj = PyString_FromStringAndSize(s, slen);
 		if (sobj == NULL)
 			return NULL;
 		srepr = PyObject_Repr(sobj);
@@ -376,7 +376,7 @@
 			return NULL;
 		PyErr_Format(PyExc_ValueError,
 			     "invalid literal for int() with base %d: %s",
-			     base, PyBytes_AS_STRING(srepr));
+			     base, PyString_AS_STRING(srepr));
 		Py_DECREF(srepr);
 		return NULL;
 	}
@@ -964,11 +964,11 @@
 		return PyInt_FromLong(0L);
 	if (base == -909)
 		return PyNumber_Int(x);
-	if (PyBytes_Check(x)) {
+	if (PyString_Check(x)) {
 		/* Since PyInt_FromString doesn't have a length parameter,
 		 * check here for possible NULs in the string. */
-		char *string = PyBytes_AS_STRING(x);
-		if (strlen(string) != PyBytes_Size(x)) {
+		char *string = PyString_AS_STRING(x);
+		if (strlen(string) != PyString_Size(x)) {
 			/* create a repr() of the input string,
 			 * just like PyInt_FromString does */
 			PyObject *srepr;
@@ -977,7 +977,7 @@
 				return NULL;
 			PyErr_Format(PyExc_ValueError,
 			     "invalid literal for int() with base %d: %s",
-			     base, PyBytes_AS_STRING(srepr));
+			     base, PyString_AS_STRING(srepr));
 			Py_DECREF(srepr);
 			return NULL;
 		}
@@ -1105,7 +1105,7 @@
 	if (negative)
 		*--p = '-';
 
-	return PyBytes_FromStringAndSize(p, &buf[sizeof(buf)] - p);
+	return PyString_FromStringAndSize(p, &buf[sizeof(buf)] - p);
 }
 
 static PyObject *
diff --git a/Objects/listobject.c b/Objects/listobject.c
index 796e8cb..e72f81f 100644
--- a/Objects/listobject.c
+++ b/Objects/listobject.c
@@ -174,7 +174,7 @@
 	}
 	if (i < 0 || i >= Py_SIZE(op)) {
 		if (indexerr == NULL)
-			indexerr = PyBytes_FromString(
+			indexerr = PyString_FromString(
 				"list index out of range");
 		PyErr_SetObject(PyExc_IndexError, indexerr);
 		return NULL;
@@ -349,11 +349,11 @@
 
 	i = Py_ReprEnter((PyObject*)v);
 	if (i != 0) {
-		return i > 0 ? PyBytes_FromString("[...]") : NULL;
+		return i > 0 ? PyString_FromString("[...]") : NULL;
 	}
 
 	if (Py_SIZE(v) == 0) {
-		result = PyBytes_FromString("[]");
+		result = PyString_FromString("[]");
 		goto Done;
 	}
 
@@ -379,29 +379,29 @@
 
 	/* Add "[]" decorations to the first and last items. */
 	assert(PyList_GET_SIZE(pieces) > 0);
-	s = PyBytes_FromString("[");
+	s = PyString_FromString("[");
 	if (s == NULL)
 		goto Done;
 	temp = PyList_GET_ITEM(pieces, 0);
-	PyBytes_ConcatAndDel(&s, temp);
+	PyString_ConcatAndDel(&s, temp);
 	PyList_SET_ITEM(pieces, 0, s);
 	if (s == NULL)
 		goto Done;
 
-	s = PyBytes_FromString("]");
+	s = PyString_FromString("]");
 	if (s == NULL)
 		goto Done;
 	temp = PyList_GET_ITEM(pieces, PyList_GET_SIZE(pieces) - 1);
-	PyBytes_ConcatAndDel(&temp, s);
+	PyString_ConcatAndDel(&temp, s);
 	PyList_SET_ITEM(pieces, PyList_GET_SIZE(pieces) - 1, temp);
 	if (temp == NULL)
 		goto Done;
 
 	/* Paste them all together with ", " between. */
-	s = PyBytes_FromString(", ");
+	s = PyString_FromString(", ");
 	if (s == NULL)
 		goto Done;
-	result = _PyBytes_Join(s, pieces);
+	result = _PyString_Join(s, pieces);
 	Py_DECREF(s);
 
 Done:
@@ -433,7 +433,7 @@
 {
 	if (i < 0 || i >= Py_SIZE(a)) {
 		if (indexerr == NULL)
-			indexerr = PyBytes_FromString(
+			indexerr = PyString_FromString(
 				"list index out of range");
 		PyErr_SetObject(PyExc_IndexError, indexerr);
 		return NULL;
diff --git a/Objects/longobject.c b/Objects/longobject.c
index c9d138b..c65d0c0 100644
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -1199,7 +1199,7 @@
 _PyLong_Format(PyObject *aa, int base, int addL, int newstyle)
 {
 	register PyLongObject *a = (PyLongObject *)aa;
-	PyBytesObject *str;
+	PyStringObject *str;
 	Py_ssize_t i, j, sz;
 	Py_ssize_t size_a;
 	char *p;
@@ -1228,10 +1228,10 @@
 				"long is too large to format");
 		return NULL;
 	}
-	str = (PyBytesObject *) PyBytes_FromStringAndSize((char *)0, sz);
+	str = (PyStringObject *) PyString_FromStringAndSize((char *)0, sz);
 	if (str == NULL)
 		return NULL;
-	p = PyBytes_AS_STRING(str) + sz;
+	p = PyString_AS_STRING(str) + sz;
 	*p = '\0';
         if (addL)
                 *--p = 'L';
@@ -1257,7 +1257,7 @@
 			do {
 				char cdigit = (char)(accum & (base - 1));
 				cdigit += (cdigit < 10) ? '0' : 'a'-10;
-				assert(p > PyBytes_AS_STRING(str));
+				assert(p > PyString_AS_STRING(str));
 				*--p = cdigit;
 				accumbits -= basebits;
 				accum >>= basebits;
@@ -1309,7 +1309,7 @@
 			do {
 				digit nextrem = (digit)(rem / base);
 				char c = (char)(rem - nextrem * base);
-				assert(p > PyBytes_AS_STRING(str));
+				assert(p > PyString_AS_STRING(str));
 				c += (c < 10) ? '0' : 'a'-10;
 				*--p = c;
 				rem = nextrem;
@@ -1347,14 +1347,14 @@
 	}
 	if (sign)
 		*--p = sign;
-	if (p != PyBytes_AS_STRING(str)) {
-		char *q = PyBytes_AS_STRING(str);
+	if (p != PyString_AS_STRING(str)) {
+		char *q = PyString_AS_STRING(str);
 		assert(p > q);
 		do {
 		} while ((*q++ = *p++) != '\0');
 		q--;
-		_PyBytes_Resize((PyObject **)&str,
-				 (Py_ssize_t) (q - PyBytes_AS_STRING(str)));
+		_PyString_Resize((PyObject **)&str,
+				 (Py_ssize_t) (q - PyString_AS_STRING(str)));
 	}
 	return (PyObject *)str;
 }
@@ -1718,7 +1718,7 @@
  onError:
 	Py_XDECREF(z);
 	slen = strlen(orig_str) < 200 ? strlen(orig_str) : 200;
-	strobj = PyBytes_FromStringAndSize(orig_str, slen);
+	strobj = PyString_FromStringAndSize(orig_str, slen);
 	if (strobj == NULL)
 		return NULL;
 	strrepr = PyObject_Repr(strobj);
@@ -1727,7 +1727,7 @@
 		return NULL;
 	PyErr_Format(PyExc_ValueError,
 		     "invalid literal for long() with base %d: %s",
-		     base, PyBytes_AS_STRING(strrepr));
+		     base, PyString_AS_STRING(strrepr));
 	Py_DECREF(strrepr);
 	return NULL;
 }
@@ -3331,11 +3331,11 @@
 		return PyLong_FromLong(0L);
 	if (base == -909)
 		return PyNumber_Long(x);
-	else if (PyBytes_Check(x)) {
+	else if (PyString_Check(x)) {
 		/* Since PyLong_FromString doesn't have a length parameter,
 		 * check here for possible NULs in the string. */
-		char *string = PyBytes_AS_STRING(x);
-		if (strlen(string) != PyBytes_Size(x)) {
+		char *string = PyString_AS_STRING(x);
+		if (strlen(string) != PyString_Size(x)) {
 			/* create a repr() of the input string,
 			 * just like PyLong_FromString does. */
 			PyObject *srepr;
@@ -3344,11 +3344,11 @@
 				return NULL;
 			PyErr_Format(PyExc_ValueError,
 			     "invalid literal for long() with base %d: %s",
-			     base, PyBytes_AS_STRING(srepr));
+			     base, PyString_AS_STRING(srepr));
 			Py_DECREF(srepr);
 			return NULL;
 		}
-		return PyLong_FromString(PyBytes_AS_STRING(x), NULL, base);
+		return PyLong_FromString(PyString_AS_STRING(x), NULL, base);
 	}
 #ifdef Py_USING_UNICODE
 	else if (PyUnicode_Check(x))
diff --git a/Objects/methodobject.c b/Objects/methodobject.c
index 57ab5c5..737a3f7 100644
--- a/Objects/methodobject.c
+++ b/Objects/methodobject.c
@@ -149,7 +149,7 @@
 	const char *doc = m->m_ml->ml_doc;
 
 	if (doc != NULL)
-		return PyBytes_FromString(doc);
+		return PyString_FromString(doc);
 	Py_INCREF(Py_None);
 	return Py_None;
 }
@@ -157,7 +157,7 @@
 static PyObject *
 meth_get__name__(PyCFunctionObject *m, void *closure)
 {
-	return PyBytes_FromString(m->m_ml->ml_name);
+	return PyString_FromString(m->m_ml->ml_name);
 }
 
 static int
@@ -202,9 +202,9 @@
 meth_repr(PyCFunctionObject *m)
 {
 	if (m->m_self == NULL)
-		return PyBytes_FromFormat("<built-in function %s>",
+		return PyString_FromFormat("<built-in function %s>",
 					   m->m_ml->ml_name);
-	return PyBytes_FromFormat("<built-in method %s of %s object at %p>",
+	return PyString_FromFormat("<built-in method %s of %s object at %p>",
 				   m->m_ml->ml_name,
 				   m->m_self->ob_type->tp_name,
 				   m->m_self);
@@ -333,7 +333,7 @@
 	i = 0;
 	for (c = chain; c != NULL; c = c->link) {
 		for (ml = c->methods; ml->ml_name != NULL; ml++) {
-			PyList_SetItem(v, i, PyBytes_FromString(ml->ml_name));
+			PyList_SetItem(v, i, PyString_FromString(ml->ml_name));
 			i++;
 		}
 	}
@@ -360,7 +360,7 @@
 		if (strcmp(name, "__doc__") == 0) {
 			const char *doc = self->ob_type->tp_doc;
 			if (doc != NULL)
-				return PyBytes_FromString(doc);
+				return PyString_FromString(doc);
 		}
 	}
 	while (chain != NULL) {
diff --git a/Objects/moduleobject.c b/Objects/moduleobject.c
index fa3daa9..d1aa771 100644
--- a/Objects/moduleobject.c
+++ b/Objects/moduleobject.c
@@ -22,7 +22,7 @@
 	m = PyObject_GC_New(PyModuleObject, &PyModule_Type);
 	if (m == NULL)
 		return NULL;
-	nameobj = PyBytes_FromString(name);
+	nameobj = PyString_FromString(name);
 	m->md_dict = PyDict_New();
 	if (m->md_dict == NULL || nameobj == NULL)
 		goto fail;
@@ -68,12 +68,12 @@
 	d = ((PyModuleObject *)m)->md_dict;
 	if (d == NULL ||
 	    (nameobj = PyDict_GetItemString(d, "__name__")) == NULL ||
-	    !PyBytes_Check(nameobj))
+	    !PyString_Check(nameobj))
 	{
 		PyErr_SetString(PyExc_SystemError, "nameless module");
 		return NULL;
 	}
-	return PyBytes_AsString(nameobj);
+	return PyString_AsString(nameobj);
 }
 
 char *
@@ -88,12 +88,12 @@
 	d = ((PyModuleObject *)m)->md_dict;
 	if (d == NULL ||
 	    (fileobj = PyDict_GetItemString(d, "__file__")) == NULL ||
-	    !PyBytes_Check(fileobj))
+	    !PyString_Check(fileobj))
 	{
 		PyErr_SetString(PyExc_SystemError, "module filename missing");
 		return NULL;
 	}
-	return PyBytes_AsString(fileobj);
+	return PyString_AsString(fileobj);
 }
 
 void
@@ -117,8 +117,8 @@
 	/* First, clear only names starting with a single underscore */
 	pos = 0;
 	while (PyDict_Next(d, &pos, &key, &value)) {
-		if (value != Py_None && PyBytes_Check(key)) {
-			char *s = PyBytes_AsString(key);
+		if (value != Py_None && PyString_Check(key)) {
+			char *s = PyString_AsString(key);
 			if (s[0] == '_' && s[1] != '_') {
 				if (Py_VerboseFlag > 1)
 				    PySys_WriteStderr("#   clear[1] %s\n", s);
@@ -130,8 +130,8 @@
 	/* Next, clear all names except for __builtins__ */
 	pos = 0;
 	while (PyDict_Next(d, &pos, &key, &value)) {
-		if (value != Py_None && PyBytes_Check(key)) {
-			char *s = PyBytes_AsString(key);
+		if (value != Py_None && PyString_Check(key)) {
+			char *s = PyString_AsString(key);
 			if (s[0] != '_' || strcmp(s, "__builtins__") != 0) {
 				if (Py_VerboseFlag > 1)
 				    PySys_WriteStderr("#   clear[2] %s\n", s);
@@ -195,9 +195,9 @@
 	filename = PyModule_GetFilename((PyObject *)m);
 	if (filename == NULL) {
 		PyErr_Clear();
-		return PyBytes_FromFormat("<module '%s' (built-in)>", name);
+		return PyString_FromFormat("<module '%s' (built-in)>", name);
 	}
-	return PyBytes_FromFormat("<module '%s' from '%s'>", name, filename);
+	return PyString_FromFormat("<module '%s' from '%s'>", name, filename);
 }
 
 /* We only need a traverse function, no clear function: If the module
diff --git a/Objects/object.c b/Objects/object.c
index 8f9d731..ccb5ab7 100644
--- a/Objects/object.c
+++ b/Objects/object.c
@@ -357,9 +357,9 @@
 	}
 #endif
 	if (v == NULL)
-		return PyBytes_FromString("<NULL>");
+		return PyString_FromString("<NULL>");
 	else if (Py_TYPE(v)->tp_repr == NULL)
-		return PyBytes_FromFormat("<%s object at %p>",
+		return PyString_FromFormat("<%s object at %p>",
 					   Py_TYPE(v)->tp_name, v);
 	else {
 		PyObject *res;
@@ -377,7 +377,7 @@
 				return NULL;
 		}
 #endif
-		if (!PyBytes_Check(res)) {
+		if (!PyString_Check(res)) {
 			PyErr_Format(PyExc_TypeError,
 				     "__repr__ returned non-string (type %.200s)",
 				     Py_TYPE(res)->tp_name);
@@ -394,8 +394,8 @@
 	PyObject *res;
 	int type_ok;
 	if (v == NULL)
-		return PyBytes_FromString("<NULL>");
-	if (PyBytes_CheckExact(v)) {
+		return PyString_FromString("<NULL>");
+	if (PyString_CheckExact(v)) {
 		Py_INCREF(v);
 		return v;
 	}
@@ -416,7 +416,7 @@
 	Py_LeaveRecursiveCall();
 	if (res == NULL)
 		return NULL;
-	type_ok = PyBytes_Check(res);
+	type_ok = PyString_Check(res);
 #ifdef Py_USING_UNICODE
 	type_ok = type_ok || PyUnicode_Check(res);
 #endif
@@ -447,7 +447,7 @@
 		    	return NULL;
 	}
 #endif
-	assert(PyBytes_Check(res));
+	assert(PyString_Check(res));
 	return res;
 }
 
@@ -461,7 +461,7 @@
 	static PyObject *unicodestr;
 
 	if (v == NULL) {
-		res = PyBytes_FromString("<NULL>");
+		res = PyString_FromString("<NULL>");
 		if (res == NULL)
 			return NULL;
 		str = PyUnicode_FromEncodedObject(res, NULL, "strict");
@@ -475,7 +475,7 @@
 	   check this before trying the __unicode__
 	   method. */
 	if (unicodestr == NULL) {
-		unicodestr= PyBytes_InternFromString("__unicode__");
+		unicodestr= PyString_InternFromString("__unicode__");
 		if (unicodestr == NULL)
 			return NULL;
 	}
@@ -492,7 +492,7 @@
 			return PyUnicode_FromUnicode(PyUnicode_AS_UNICODE(v),
 			                             PyUnicode_GET_SIZE(v));
 		}
-		if (PyBytes_CheckExact(v)) {
+		if (PyString_CheckExact(v)) {
 			Py_INCREF(v);
 			res = v;
 		}
@@ -1084,7 +1084,7 @@
 
 	if (Py_TYPE(v)->tp_getattr != NULL)
 		return (*Py_TYPE(v)->tp_getattr)(v, (char*)name);
-	w = PyBytes_InternFromString(name);
+	w = PyString_InternFromString(name);
 	if (w == NULL)
 		return NULL;
 	res = PyObject_GetAttr(v, w);
@@ -1112,7 +1112,7 @@
 
 	if (Py_TYPE(v)->tp_setattr != NULL)
 		return (*Py_TYPE(v)->tp_setattr)(v, (char*)name, w);
-	s = PyBytes_InternFromString(name);
+	s = PyString_InternFromString(name);
 	if (s == NULL)
 		return -1;
 	res = PyObject_SetAttr(v, s, w);
@@ -1125,7 +1125,7 @@
 {
 	PyTypeObject *tp = Py_TYPE(v);
 
-	if (!PyBytes_Check(name)) {
+	if (!PyString_Check(name)) {
 #ifdef Py_USING_UNICODE
 		/* The Unicode to string conversion is done here because the
 		   existing tp_getattro slots expect a string object as name
@@ -1147,10 +1147,10 @@
 	if (tp->tp_getattro != NULL)
 		return (*tp->tp_getattro)(v, name);
 	if (tp->tp_getattr != NULL)
-		return (*tp->tp_getattr)(v, PyBytes_AS_STRING(name));
+		return (*tp->tp_getattr)(v, PyString_AS_STRING(name));
 	PyErr_Format(PyExc_AttributeError,
 		     "'%.50s' object has no attribute '%.400s'",
-		     tp->tp_name, PyBytes_AS_STRING(name));
+		     tp->tp_name, PyString_AS_STRING(name));
 	return NULL;
 }
 
@@ -1172,7 +1172,7 @@
 	PyTypeObject *tp = Py_TYPE(v);
 	int err;
 
-	if (!PyBytes_Check(name)){
+	if (!PyString_Check(name)){
 #ifdef Py_USING_UNICODE
 		/* The Unicode to string conversion is done here because the
 		   existing tp_setattro slots expect a string object as name
@@ -1194,14 +1194,14 @@
 	else
 		Py_INCREF(name);
 
-	PyBytes_InternInPlace(&name);
+	PyString_InternInPlace(&name);
 	if (tp->tp_setattro != NULL) {
 		err = (*tp->tp_setattro)(v, name, value);
 		Py_DECREF(name);
 		return err;
 	}
 	if (tp->tp_setattr != NULL) {
-		err = (*tp->tp_setattr)(v, PyBytes_AS_STRING(name), value);
+		err = (*tp->tp_setattr)(v, PyString_AS_STRING(name), value);
 		Py_DECREF(name);
 		return err;
 	}
@@ -1212,14 +1212,14 @@
 			     "(%s .%.100s)",
 			     tp->tp_name,
 			     value==NULL ? "del" : "assign to",
-			     PyBytes_AS_STRING(name));
+			     PyString_AS_STRING(name));
 	else
 		PyErr_Format(PyExc_TypeError,
 			     "'%.100s' object has only read-only attributes "
 			     "(%s .%.100s)",
 			     tp->tp_name,
 			     value==NULL ? "del" : "assign to",
-			     PyBytes_AS_STRING(name));
+			     PyString_AS_STRING(name));
 	return -1;
 }
 
@@ -1271,7 +1271,7 @@
 	Py_ssize_t dictoffset;
 	PyObject **dictptr;
 
-	if (!PyBytes_Check(name)){
+	if (!PyString_Check(name)){
 #ifdef Py_USING_UNICODE
 		/* The Unicode to string conversion is done here because the
 		   existing tp_setattro slots expect a string object as name
@@ -1386,7 +1386,7 @@
 
 	PyErr_Format(PyExc_AttributeError,
 		     "'%.50s' object has no attribute '%.400s'",
-		     tp->tp_name, PyBytes_AS_STRING(name));
+		     tp->tp_name, PyString_AS_STRING(name));
   done:
 	Py_DECREF(name);
 	return res;
@@ -1401,7 +1401,7 @@
 	PyObject **dictptr;
 	int res = -1;
 
-	if (!PyBytes_Check(name)){
+	if (!PyString_Check(name)){
 #ifdef Py_USING_UNICODE
 		/* The Unicode to string conversion is done here because the
 		   existing tp_setattro slots expect a string object as name
@@ -1469,13 +1469,13 @@
 	if (descr == NULL) {
 		PyErr_Format(PyExc_AttributeError,
 			     "'%.100s' object has no attribute '%.200s'",
-			     tp->tp_name, PyBytes_AS_STRING(name));
+			     tp->tp_name, PyString_AS_STRING(name));
 		goto done;
 	}
 
 	PyErr_Format(PyExc_AttributeError,
 		     "'%.50s' object attribute '%.400s' is read-only",
-		     tp->tp_name, PyBytes_AS_STRING(name));
+		     tp->tp_name, PyString_AS_STRING(name));
   done:
 	Py_DECREF(name);
 	return res;
@@ -1682,7 +1682,7 @@
 		int i;
 		for (i = 0; i < PyList_GET_SIZE(list); ++i) {
 			PyObject *item = PyList_GET_ITEM(list, i);
-			if (PyBytes_Check(item)) {
+			if (PyString_Check(item)) {
 				result = PyDict_SetItem(dict, item, Py_None);
 				if (result < 0)
 					break;
@@ -1904,7 +1904,7 @@
 static PyObject *
 none_repr(PyObject *op)
 {
-	return PyBytes_FromString("None");
+	return PyString_FromString("None");
 }
 
 /* ARGUSED */
@@ -1946,7 +1946,7 @@
 static PyObject *
 NotImplemented_repr(PyObject *op)
 {
-	return PyBytes_FromString("NotImplemented");
+	return PyString_FromString("NotImplemented");
 }
 
 static PyTypeObject PyNotImplemented_Type = {
@@ -1983,7 +1983,7 @@
 	if (PyType_Ready(&PyBool_Type) < 0)
 		Py_FatalError("Can't initialize 'bool'");
 
-	if (PyType_Ready(&PyBytes_Type) < 0)
+	if (PyType_Ready(&PyString_Type) < 0)
 		Py_FatalError("Can't initialize 'str'");
 
 	if (PyType_Ready(&PyByteArray_Type) < 0)
diff --git a/Objects/rangeobject.c b/Objects/rangeobject.c
index b3ed673..da4356b 100644
--- a/Objects/rangeobject.c
+++ b/Objects/rangeobject.c
@@ -113,16 +113,16 @@
 	PyObject *rtn;
 
 	if (r->start == 0 && r->step == 1)
-		rtn = PyBytes_FromFormat("xrange(%ld)",
+		rtn = PyString_FromFormat("xrange(%ld)",
 					  r->start + r->len * r->step);
 
 	else if (r->step == 1)
-		rtn = PyBytes_FromFormat("xrange(%ld, %ld)",
+		rtn = PyString_FromFormat("xrange(%ld, %ld)",
 					  r->start,
 					  r->start + r->len * r->step);
 
 	else
-		rtn = PyBytes_FromFormat("xrange(%ld, %ld, %ld)",
+		rtn = PyString_FromFormat("xrange(%ld, %ld, %ld)",
 					  r->start,
 					  r->start + r->len * r->step,
 					  r->step);
diff --git a/Objects/setobject.c b/Objects/setobject.c
index 5e8e05d..371d8c1 100644
--- a/Objects/setobject.c
+++ b/Objects/setobject.c
@@ -151,7 +151,7 @@
 
 /*
  * Hacked up version of set_lookkey which can assume keys are always strings;
- * This means we can always use _PyBytes_Eq directly and not have to check to
+ * This means we can always use _PyString_Eq directly and not have to check to
  * see if the comparison altered the table.
  */
 static setentry *
@@ -168,7 +168,7 @@
 	   including subclasses of str; e.g., one reason to subclass
 	   strings is to override __eq__, and for speed we don't cater to
 	   that here. */
-	if (!PyBytes_CheckExact(key)) {
+	if (!PyString_CheckExact(key)) {
 		so->lookup = set_lookkey;
 		return set_lookkey(so, key, hash);
 	}
@@ -179,7 +179,7 @@
 	if (entry->key == dummy)
 		freeslot = entry;
 	else {
-		if (entry->hash == hash && _PyBytes_Eq(entry->key, key))
+		if (entry->hash == hash && _PyString_Eq(entry->key, key))
 			return entry;
 		freeslot = NULL;
 	}
@@ -194,7 +194,7 @@
 		if (entry->key == key
 		    || (entry->hash == hash
 			&& entry->key != dummy
-			&& _PyBytes_Eq(entry->key, key)))
+			&& _PyString_Eq(entry->key, key)))
 			return entry;
 		if (entry->key == dummy && freeslot == NULL)
 			freeslot = entry;
@@ -381,8 +381,8 @@
 	register long hash;
 	register Py_ssize_t n_used;
 
-	if (!PyBytes_CheckExact(key) ||
-	    (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
+	if (!PyString_CheckExact(key) ||
+	    (hash = ((PyStringObject *) key)->ob_shash) == -1) {
 		hash = PyObject_Hash(key);
 		if (hash == -1)
 			return -1;
@@ -428,8 +428,8 @@
 	PyObject *old_key;
 
 	assert (PyAnySet_Check(so));
-	if (!PyBytes_CheckExact(key) ||
-	    (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
+	if (!PyString_CheckExact(key) ||
+	    (hash = ((PyStringObject *) key)->ob_shash) == -1) {
 		hash = PyObject_Hash(key);
 		if (hash == -1)
 			return -1;
@@ -618,7 +618,7 @@
 	if (status != 0) {
 		if (status < 0)
 			return NULL;
-		return PyBytes_FromFormat("%s(...)", so->ob_type->tp_name);
+		return PyString_FromFormat("%s(...)", so->ob_type->tp_name);
 	}
 
 	keys = PySequence_List((PyObject *)so);
@@ -629,8 +629,8 @@
 	if (listrepr == NULL)
 		goto done;
 
-	result = PyBytes_FromFormat("%s(%s)", so->ob_type->tp_name,
-		PyBytes_AS_STRING(listrepr));
+	result = PyString_FromFormat("%s(%s)", so->ob_type->tp_name,
+		PyString_AS_STRING(listrepr));
 	Py_DECREF(listrepr);
 done:
 	Py_ReprLeave((PyObject*)so);
@@ -685,8 +685,8 @@
 	long hash;
 	setentry *entry;
 
-	if (!PyBytes_CheckExact(key) ||
-	    (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
+	if (!PyString_CheckExact(key) ||
+	    (hash = ((PyStringObject *) key)->ob_shash) == -1) {
 		hash = PyObject_Hash(key);
 		if (hash == -1)
 			return -1;
@@ -983,7 +983,7 @@
 	register PySetObject *so = NULL;
 
 	if (dummy == NULL) { /* Auto-initialize dummy */
-		dummy = PyBytes_FromString("<dummy key>");
+		dummy = PyString_FromString("<dummy key>");
 		if (dummy == NULL)
 			return NULL;
 	}
@@ -2322,7 +2322,7 @@
 	/* Exercise direct iteration */
 	i = 0, count = 0;
 	while (_PySet_Next((PyObject *)dup, &i, &x)) {
-		s = PyBytes_AsString(x);
+		s = PyString_AsString(x);
 		assert(s && (s[0] == 'a' || s[0] == 'b' || s[0] == 'c'));
 		count++;
 	}
diff --git a/Objects/sliceobject.c b/Objects/sliceobject.c
index 75048e3..075418e 100644
--- a/Objects/sliceobject.c
+++ b/Objects/sliceobject.c
@@ -19,7 +19,7 @@
 static PyObject *
 ellipsis_repr(PyObject *op)
 {
-	return PyBytes_FromString("Ellipsis");
+	return PyString_FromString("Ellipsis");
 }
 
 static PyTypeObject PyEllipsis_Type = {
@@ -228,14 +228,14 @@
 {
 	PyObject *s, *comma;
 
-	s = PyBytes_FromString("slice(");
-	comma = PyBytes_FromString(", ");
-	PyBytes_ConcatAndDel(&s, PyObject_Repr(r->start));
-	PyBytes_Concat(&s, comma);
-	PyBytes_ConcatAndDel(&s, PyObject_Repr(r->stop));
-	PyBytes_Concat(&s, comma);
-	PyBytes_ConcatAndDel(&s, PyObject_Repr(r->step));
-	PyBytes_ConcatAndDel(&s, PyBytes_FromString(")"));
+	s = PyString_FromString("slice(");
+	comma = PyString_FromString(", ");
+	PyString_ConcatAndDel(&s, PyObject_Repr(r->start));
+	PyString_Concat(&s, comma);
+	PyString_ConcatAndDel(&s, PyObject_Repr(r->stop));
+	PyString_Concat(&s, comma);
+	PyString_ConcatAndDel(&s, PyObject_Repr(r->step));
+	PyString_ConcatAndDel(&s, PyString_FromString(")"));
 	Py_DECREF(comma);
 	return s;
 }
diff --git a/Objects/stringlib/string_format.h b/Objects/stringlib/string_format.h
index 2e9c7ef..be8e8080 100644
--- a/Objects/stringlib/string_format.h
+++ b/Objects/stringlib/string_format.h
@@ -496,7 +496,7 @@
 #if PY_VERSION_HEX >= 0x03000000
     assert(PyUnicode_Check(result));
 #else
-    assert(PyBytes_Check(result) || PyUnicode_Check(result));
+    assert(PyString_Check(result) || PyUnicode_Check(result));
 
     /* Convert result to our type.  We could be str, and result could
        be unicode */
diff --git a/Objects/stringlib/stringdefs.h b/Objects/stringlib/stringdefs.h
index bdc3a29..daaa2e2 100644
--- a/Objects/stringlib/stringdefs.h
+++ b/Objects/stringlib/stringdefs.h
@@ -6,7 +6,7 @@
    compiled as unicode. */
 #define STRINGLIB_IS_UNICODE     0
 
-#define STRINGLIB_OBJECT         PyBytesObject
+#define STRINGLIB_OBJECT         PyStringObject
 #define STRINGLIB_CHAR           char
 #define STRINGLIB_TYPE_NAME      "string"
 #define STRINGLIB_PARSE_CODE     "S"
@@ -16,13 +16,13 @@
 #define STRINGLIB_TOUPPER        toupper
 #define STRINGLIB_TOLOWER        tolower
 #define STRINGLIB_FILL           memset
-#define STRINGLIB_STR            PyBytes_AS_STRING
-#define STRINGLIB_LEN            PyBytes_GET_SIZE
-#define STRINGLIB_NEW            PyBytes_FromStringAndSize
-#define STRINGLIB_RESIZE         _PyBytes_Resize
-#define STRINGLIB_CHECK          PyBytes_Check
+#define STRINGLIB_STR            PyString_AS_STRING
+#define STRINGLIB_LEN            PyString_GET_SIZE
+#define STRINGLIB_NEW            PyString_FromStringAndSize
+#define STRINGLIB_RESIZE         _PyString_Resize
+#define STRINGLIB_CHECK          PyString_Check
 #define STRINGLIB_CMP            memcmp
 #define STRINGLIB_TOSTR          PyObject_Str
-#define STRINGLIB_GROUPING       _PyBytes_InsertThousandsGrouping
+#define STRINGLIB_GROUPING       _PyString_InsertThousandsGrouping
 
 #endif /* !STRINGLIB_STRINGDEFS_H */
diff --git a/Objects/structseq.c b/Objects/structseq.c
index c348254..b6126ba 100644
--- a/Objects/structseq.c
+++ b/Objects/structseq.c
@@ -270,7 +270,7 @@
 			Py_DECREF(tup);
 			return NULL;
 		}
-		crepr = PyBytes_AsString(repr);
+		crepr = PyString_AsString(repr);
 		if (crepr == NULL) {
 			Py_DECREF(tup);
 			Py_DECREF(repr);
@@ -306,7 +306,7 @@
 	*pbuf++ = ')';
 	*pbuf = '\0';
 
-	return PyBytes_FromString(buf);
+	return PyString_FromString(buf);
 }
 
 static PyObject *
diff --git a/Objects/tupleobject.c b/Objects/tupleobject.c
index 0524aae..e9cb3ef 100644
--- a/Objects/tupleobject.c
+++ b/Objects/tupleobject.c
@@ -218,7 +218,7 @@
 
 	n = Py_SIZE(v);
 	if (n == 0)
-		return PyBytes_FromString("()");
+		return PyString_FromString("()");
 
 	/* While not mutable, it is still possible to end up with a cycle in a
 	   tuple through an object that stores itself within a tuple (and thus
@@ -226,7 +226,7 @@
 	   possible within a type. */
 	i = Py_ReprEnter((PyObject *)v);
 	if (i != 0) {
-		return i > 0 ? PyBytes_FromString("(...)") : NULL;
+		return i > 0 ? PyString_FromString("(...)") : NULL;
 	}
 
 	pieces = PyTuple_New(n);
@@ -246,29 +246,29 @@
 
 	/* Add "()" decorations to the first and last items. */
 	assert(n > 0);
-	s = PyBytes_FromString("(");
+	s = PyString_FromString("(");
 	if (s == NULL)
 		goto Done;
 	temp = PyTuple_GET_ITEM(pieces, 0);
-	PyBytes_ConcatAndDel(&s, temp);
+	PyString_ConcatAndDel(&s, temp);
 	PyTuple_SET_ITEM(pieces, 0, s);
 	if (s == NULL)
 		goto Done;
 
-	s = PyBytes_FromString(n == 1 ? ",)" : ")");
+	s = PyString_FromString(n == 1 ? ",)" : ")");
 	if (s == NULL)
 		goto Done;
 	temp = PyTuple_GET_ITEM(pieces, n-1);
-	PyBytes_ConcatAndDel(&temp, s);
+	PyString_ConcatAndDel(&temp, s);
 	PyTuple_SET_ITEM(pieces, n-1, temp);
 	if (temp == NULL)
 		goto Done;
 
 	/* Paste them all together with ", " between. */
-	s = PyBytes_FromString(", ");
+	s = PyString_FromString(", ");
 	if (s == NULL)
 		goto Done;
-	result = _PyBytes_Join(s, pieces);
+	result = _PyString_Join(s, pieces);
 	Py_DECREF(s);	
 
 Done:
diff --git a/Objects/typeobject.c b/Objects/typeobject.c
index e88ca05..e0ae55b 100644
--- a/Objects/typeobject.c
+++ b/Objects/typeobject.c
@@ -19,10 +19,10 @@
 		 >> (8*sizeof(unsigned int) - MCACHE_SIZE_EXP))
 #define MCACHE_HASH_METHOD(type, name)                                  \
 		MCACHE_HASH((type)->tp_version_tag,                     \
-		            ((PyBytesObject *)(name))->ob_shash)
+		            ((PyStringObject *)(name))->ob_shash)
 #define MCACHE_CACHEABLE_NAME(name)                                     \
-		PyBytes_CheckExact(name) &&                            \
-		PyBytes_GET_SIZE(name) <= MCACHE_MAX_ATTR_SIZE
+		PyString_CheckExact(name) &&                            \
+		PyString_GET_SIZE(name) <= MCACHE_MAX_ATTR_SIZE
 
 struct method_cache_entry {
 	unsigned int version;
@@ -217,7 +217,7 @@
 			s = type->tp_name;
 		else
 			s++;
-		return PyBytes_FromString(s);
+		return PyString_FromString(s);
 	}
 }
 
@@ -236,14 +236,14 @@
 			     "can't delete %s.__name__", type->tp_name);
 		return -1;
 	}
-	if (!PyBytes_Check(value)) {
+	if (!PyString_Check(value)) {
 		PyErr_Format(PyExc_TypeError,
 			     "can only assign string to %s.__name__, not '%s'",
 			     type->tp_name, Py_TYPE(value)->tp_name);
 		return -1;
 	}
-	if (strlen(PyBytes_AS_STRING(value))
-	    != (size_t)PyBytes_GET_SIZE(value)) {
+	if (strlen(PyString_AS_STRING(value))
+	    != (size_t)PyString_GET_SIZE(value)) {
 		PyErr_Format(PyExc_ValueError,
 			     "__name__ must not contain null bytes");
 		return -1;
@@ -256,7 +256,7 @@
 	Py_DECREF(et->ht_name);
 	et->ht_name = value;
 
-	type->tp_name = PyBytes_AS_STRING(value);
+	type->tp_name = PyString_AS_STRING(value);
 
 	return 0;
 }
@@ -279,9 +279,9 @@
 	else {
 		s = strrchr(type->tp_name, '.');
 		if (s != NULL)
-			return PyBytes_FromStringAndSize(
+			return PyString_FromStringAndSize(
 			    type->tp_name, (Py_ssize_t)(s - type->tp_name));
-		return PyBytes_FromString("__builtin__");
+		return PyString_FromString("__builtin__");
 	}
 }
 
@@ -555,7 +555,7 @@
 {
 	PyObject *result;
 	if (!(type->tp_flags & Py_TPFLAGS_HEAPTYPE) && type->tp_doc != NULL)
-		return PyBytes_FromString(type->tp_doc);
+		return PyString_FromString(type->tp_doc);
 	result = PyDict_GetItemString(type->tp_dict, "__doc__");
 	if (result == NULL) {
 		result = Py_None;
@@ -644,7 +644,7 @@
 	mod = type_module(type, NULL);
 	if (mod == NULL)
 		PyErr_Clear();
-	else if (!PyBytes_Check(mod)) {
+	else if (!PyString_Check(mod)) {
 		Py_DECREF(mod);
 		mod = NULL;
 	}
@@ -657,14 +657,14 @@
 	else
 		kind = "type";
 
-	if (mod != NULL && strcmp(PyBytes_AS_STRING(mod), "__builtin__")) {
-		rtn = PyBytes_FromFormat("<%s '%s.%s'>",
+	if (mod != NULL && strcmp(PyString_AS_STRING(mod), "__builtin__")) {
+		rtn = PyString_FromFormat("<%s '%s.%s'>",
 					  kind,
-					  PyBytes_AS_STRING(mod),
-					  PyBytes_AS_STRING(name));
+					  PyString_AS_STRING(mod),
+					  PyString_AS_STRING(name));
 	}
 	else
-		rtn = PyBytes_FromFormat("<%s '%s'>", kind, type->tp_name);
+		rtn = PyString_FromFormat("<%s '%s'>", kind, type->tp_name);
 
 	Py_XDECREF(mod);
 	Py_DECREF(name);
@@ -1136,7 +1136,7 @@
 	PyObject *res;
 
 	if (*attrobj == NULL) {
-		*attrobj = PyBytes_InternFromString(attrstr);
+		*attrobj = PyString_InternFromString(attrstr);
 		if (*attrobj == NULL)
 			return NULL;
 	}
@@ -1328,7 +1328,7 @@
 	}
 	if (name == NULL)
 		return NULL;
-	if (!PyBytes_Check(name)) {
+	if (!PyString_Check(name)) {
 		Py_DECREF(name);
 		return NULL;
 	}
@@ -1350,7 +1350,7 @@
 				o = class_name(o);
 				PyErr_Format(PyExc_TypeError,
 					     "duplicate base class %s",
-					     o ? PyBytes_AS_STRING(o) : "?");
+					     o ? PyString_AS_STRING(o) : "?");
 				Py_XDECREF(o);
 				return -1;
 			}
@@ -1396,7 +1396,7 @@
 	while (PyDict_Next(set, &i, &k, &v) && (size_t)off < sizeof(buf)) {
 		PyObject *name = class_name(k);
 		off += PyOS_snprintf(buf + off, sizeof(buf) - off, " %s",
-				     name ? PyBytes_AS_STRING(name) : "?");
+				     name ? PyString_AS_STRING(name) : "?");
 		Py_XDECREF(name);
 		if (--n && (size_t)(off+1) < sizeof(buf)) {
 			buf[off++] = ',';
@@ -1749,7 +1749,7 @@
 	PyObject *descr;
 
 	if (dict_str == NULL) {
-		dict_str = PyBytes_InternFromString("__dict__");
+		dict_str = PyString_InternFromString("__dict__");
 		if (dict_str == NULL)
 			return NULL;
 	}
@@ -1898,14 +1898,14 @@
 	unsigned char *p;
 	Py_ssize_t i, n;
 
-	if (!PyBytes_Check(s)) {
+	if (!PyString_Check(s)) {
 		PyErr_Format(PyExc_TypeError,
 			     "__slots__ items must be strings, not '%.200s'",
 			     Py_TYPE(s)->tp_name);
 		return 0;
 	}
-	p = (unsigned char *) PyBytes_AS_STRING(s);
-	n = PyBytes_GET_SIZE(s);
+	p = (unsigned char *) PyString_AS_STRING(s);
+	n = PyString_GET_SIZE(s);
 	/* We must reject an empty name.  As a hack, we bump the
 	   length to 1 so that the loop will balk on the trailing \0. */
 	if (n == 0)
@@ -2107,7 +2107,7 @@
 		/* Have slots */
 
 		/* Make it into a tuple */
-		if (PyBytes_Check(slots) || PyUnicode_Check(slots))
+		if (PyString_Check(slots) || PyUnicode_Check(slots))
 			slots = PyTuple_Pack(1, slots);
 		else
 			slots = PySequence_Tuple(slots);
@@ -2145,8 +2145,8 @@
 			char *s;
 			if (!valid_identifier(tmp))
 				goto bad_slots;
-			assert(PyBytes_Check(tmp));
-			s = PyBytes_AS_STRING(tmp);
+			assert(PyString_Check(tmp));
+			s = PyString_AS_STRING(tmp);
 			if (strcmp(s, "__dict__") == 0) {
 				if (!may_add_dict || add_dict) {
 					PyErr_SetString(PyExc_TypeError,
@@ -2178,7 +2178,7 @@
 		for (i = j = 0; i < nslots; i++) {
 			char *s;
 			tmp = PyTuple_GET_ITEM(slots, i);
-			s = PyBytes_AS_STRING(tmp);
+			s = PyString_AS_STRING(tmp);
 			if ((add_dict && strcmp(s, "__dict__") == 0) ||
 			    (add_weak && strcmp(s, "__weakref__") == 0))
 				continue;
@@ -2271,7 +2271,7 @@
 	type->tp_as_sequence = &et->as_sequence;
 	type->tp_as_mapping = &et->as_mapping;
 	type->tp_as_buffer = &et->as_buffer;
-	type->tp_name = PyBytes_AS_STRING(name);
+	type->tp_name = PyString_AS_STRING(name);
 
 	/* Set tp_base and tp_bases */
 	type->tp_bases = bases;
@@ -2304,14 +2304,14 @@
 	*/
 	{
 		PyObject *doc = PyDict_GetItemString(dict, "__doc__");
-		if (doc != NULL && PyBytes_Check(doc)) {
-			const size_t n = (size_t)PyBytes_GET_SIZE(doc);
+		if (doc != NULL && PyString_Check(doc)) {
+			const size_t n = (size_t)PyString_GET_SIZE(doc);
 			char *tp_doc = (char *)PyObject_MALLOC(n+1);
 			if (tp_doc == NULL) {
 				Py_DECREF(type);
 				return NULL;
 			}
-			memcpy(tp_doc, PyBytes_AS_STRING(doc), n+1);
+			memcpy(tp_doc, PyString_AS_STRING(doc), n+1);
 			type->tp_doc = tp_doc;
 		}
 	}
@@ -2334,7 +2334,7 @@
 	slotoffset = base->tp_basicsize;
 	if (slots != NULL) {
 		for (i = 0; i < nslots; i++, mp++) {
-			mp->name = PyBytes_AS_STRING(
+			mp->name = PyString_AS_STRING(
 				PyTuple_GET_ITEM(slots, i));
 			mp->type = T_OBJECT_EX;
 			mp->offset = slotoffset;
@@ -2535,7 +2535,7 @@
 	/* Give up */
 	PyErr_Format(PyExc_AttributeError,
 			 "type object '%.50s' has no attribute '%.400s'",
-			 type->tp_name, PyBytes_AS_STRING(name));
+			 type->tp_name, PyString_AS_STRING(name));
 	return NULL;
 }
 
@@ -2854,7 +2854,7 @@
 		if (sorted_methods == NULL)
 			goto error;
 		if (comma == NULL) {
-			comma = PyBytes_InternFromString(", ");
+			comma = PyString_InternFromString(", ");
 			if (comma == NULL)
 				goto error;
 		}
@@ -2862,7 +2862,7 @@
 					     "O",  sorted_methods);
 		if (joined == NULL)
 			goto error;
-		joined_str = PyBytes_AsString(joined);
+		joined_str = PyString_AsString(joined);
 		if (joined_str == NULL)
 			goto error;
 
@@ -2896,20 +2896,20 @@
 	mod = type_module(type, NULL);
 	if (mod == NULL)
 		PyErr_Clear();
-	else if (!PyBytes_Check(mod)) {
+	else if (!PyString_Check(mod)) {
 		Py_DECREF(mod);
 		mod = NULL;
 	}
 	name = type_name(type, NULL);
 	if (name == NULL)
 		return NULL;
-	if (mod != NULL && strcmp(PyBytes_AS_STRING(mod), "__builtin__"))
-		rtn = PyBytes_FromFormat("<%s.%s object at %p>",
-					  PyBytes_AS_STRING(mod),
-					  PyBytes_AS_STRING(name),
+	if (mod != NULL && strcmp(PyString_AS_STRING(mod), "__builtin__"))
+		rtn = PyString_FromFormat("<%s.%s object at %p>",
+					  PyString_AS_STRING(mod),
+					  PyString_AS_STRING(name),
 					  self);
 	else
-		rtn = PyBytes_FromFormat("<%s object at %p>",
+		rtn = PyString_FromFormat("<%s object at %p>",
 					  type->tp_name, self);
 	Py_XDECREF(mod);
 	Py_DECREF(name);
@@ -3069,7 +3069,7 @@
 	static PyObject *copyreg_str;
 
 	if (!copyreg_str) {
-		copyreg_str = PyBytes_InternFromString("copy_reg");
+		copyreg_str = PyString_InternFromString("copy_reg");
 		if (copyreg_str == NULL)
 			return NULL;
 	}
@@ -3375,7 +3375,7 @@
                 return NULL;
 	if (PyUnicode_Check(format_spec)) {
 	        self_as_str = PyObject_Unicode(self);
-	} else if (PyBytes_Check(format_spec)) {
+	} else if (PyString_Check(format_spec)) {
 	        self_as_str = PyObject_Str(self);
 	} else {
 	        PyErr_SetString(PyExc_TypeError, "argument to __format__ must be unicode or str");
@@ -3634,7 +3634,7 @@
 		type->tp_flags |= Py_TPFLAGS_INT_SUBCLASS;
 	else if (PyType_IsSubtype(base, &PyLong_Type))
 		type->tp_flags |= Py_TPFLAGS_LONG_SUBCLASS;
-	else if (PyType_IsSubtype(base, &PyBytes_Type))
+	else if (PyType_IsSubtype(base, &PyString_Type))
 		type->tp_flags |= Py_TPFLAGS_STRING_SUBCLASS;
 #ifdef Py_USING_UNICODE
 	else if (PyType_IsSubtype(base, &PyUnicode_Type))
@@ -3973,7 +3973,7 @@
 	 */
 	if (PyDict_GetItemString(type->tp_dict, "__doc__") == NULL) {
 		if (type->tp_doc != NULL) {
-			PyObject *doc = PyBytes_FromString(type->tp_doc);
+			PyObject *doc = PyString_FromString(type->tp_doc);
 			if (doc == NULL)
 				goto error;
 			PyDict_SetItemString(type->tp_dict, "__doc__", doc);
@@ -4861,7 +4861,7 @@
 	descrgetfunc f;
 
 	if (getitem_str == NULL) {
-		getitem_str = PyBytes_InternFromString("__getitem__");
+		getitem_str = PyString_InternFromString("__getitem__");
 		if (getitem_str == NULL)
 			return NULL;
 	}
@@ -5229,7 +5229,7 @@
 		return res;
 	}
 	PyErr_Clear();
-	return PyBytes_FromFormat("<%s object at %p>",
+	return PyString_FromFormat("<%s object at %p>",
 				   Py_TYPE(self)->tp_name, self);
 }
 
@@ -5337,13 +5337,13 @@
 	static PyObject *getattr_str = NULL;
 
 	if (getattr_str == NULL) {
-		getattr_str = PyBytes_InternFromString("__getattr__");
+		getattr_str = PyString_InternFromString("__getattr__");
 		if (getattr_str == NULL)
 			return NULL;
 	}
 	if (getattribute_str == NULL) {
 		getattribute_str =
-			PyBytes_InternFromString("__getattribute__");
+			PyString_InternFromString("__getattribute__");
 		if (getattribute_str == NULL)
 			return NULL;
 	}
@@ -5484,7 +5484,7 @@
 	static PyObject *get_str = NULL;
 
 	if (get_str == NULL) {
-		get_str = PyBytes_InternFromString("__get__");
+		get_str = PyString_InternFromString("__get__");
 		if (get_str == NULL)
 			return NULL;
 	}
@@ -5554,7 +5554,7 @@
 	Py_ssize_t i, n;
 
 	if (new_str == NULL) {
-		new_str = PyBytes_InternFromString("__new__");
+		new_str = PyString_InternFromString("__new__");
 		if (new_str == NULL)
 			return NULL;
 	}
@@ -6084,7 +6084,7 @@
 	if (initialized)
 		return;
 	for (p = slotdefs; p->name; p++) {
-		p->name_strobj = PyBytes_InternFromString(p->name);
+		p->name_strobj = PyString_InternFromString(p->name);
 		if (!p->name_strobj)
 			Py_FatalError("Out of memory interning slotdef names");
 	}
@@ -6299,12 +6299,12 @@
 	superobject *su = (superobject *)self;
 
 	if (su->obj_type)
-		return PyBytes_FromFormat(
+		return PyString_FromFormat(
 			"<super: <class '%s'>, <%s object>>",
 			su->type ? su->type->tp_name : "NULL",
 			su->obj_type->tp_name);
 	else
-		return PyBytes_FromFormat(
+		return PyString_FromFormat(
 			"<super: <class '%s'>, NULL>",
 			su->type ? su->type->tp_name : "NULL");
 }
@@ -6318,9 +6318,9 @@
 	if (!skip) {
 		/* We want __class__ to return the class of the super object
 		   (i.e. super, or a subclass), not the class of su->obj. */
-		skip = (PyBytes_Check(name) &&
-			PyBytes_GET_SIZE(name) == 9 &&
-			strcmp(PyBytes_AS_STRING(name), "__class__") == 0);
+		skip = (PyString_Check(name) &&
+			PyString_GET_SIZE(name) == 9 &&
+			strcmp(PyString_AS_STRING(name), "__class__") == 0);
 	}
 
 	if (!skip) {
@@ -6412,7 +6412,7 @@
 		PyObject *class_attr;
 
 		if (class_str == NULL) {
-			class_str = PyBytes_FromString("__class__");
+			class_str = PyString_FromString("__class__");
 			if (class_str == NULL)
 				return NULL;
 		}
diff --git a/Objects/unicodeobject.c b/Objects/unicodeobject.c
index 3ffe99c..873f1c4 100644
--- a/Objects/unicodeobject.c
+++ b/Objects/unicodeobject.c
@@ -1078,9 +1078,9 @@
 #endif
 
     /* Coerce object */
-    if (PyBytes_Check(obj)) {
-	    s = PyBytes_AS_STRING(obj);
-	    len = PyBytes_GET_SIZE(obj);
+    if (PyString_Check(obj)) {
+	    s = PyString_AS_STRING(obj);
+	    len = PyString_GET_SIZE(obj);
     }
     else if (PyByteArray_Check(obj)) {
         /* Python 2.x specific */
@@ -1252,7 +1252,7 @@
     v = PyCodec_Encode(unicode, encoding, errors);
     if (v == NULL)
         goto onError;
-    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);
@@ -1652,13 +1652,13 @@
     char * start;
 
     if (size == 0)
-		return PyBytes_FromStringAndSize(NULL, 0);
+		return PyString_FromStringAndSize(NULL, 0);
 
-    v = PyBytes_FromStringAndSize(NULL, cbAllocated);
+    v = PyString_FromStringAndSize(NULL, cbAllocated);
     if (v == NULL)
         return NULL;
 
-    start = out = PyBytes_AS_STRING(v);
+    start = out = PyString_AS_STRING(v);
     for (;i < size; ++i) {
         Py_UNICODE ch = s[i];
 
@@ -1724,7 +1724,7 @@
         *out++ = '-';
     }
 
-    _PyBytes_Resize(&v, out - start);
+    _PyString_Resize(&v, out - start);
     return v;
 }
 
@@ -1989,10 +1989,10 @@
         nallocated = size * 4;
         if (nallocated / 4 != size)  /* overflow! */
             return PyErr_NoMemory();
-        v = PyBytes_FromStringAndSize(NULL, nallocated);
+        v = PyString_FromStringAndSize(NULL, nallocated);
         if (v == NULL)
             return NULL;
-        p = PyBytes_AS_STRING(v);
+        p = PyString_AS_STRING(v);
     }
 
     for (i = 0; i < size;) {
@@ -2040,13 +2040,13 @@
         /* This was stack allocated. */
         nneeded = p - stackbuf;
         assert(nneeded <= nallocated);
-        v = PyBytes_FromStringAndSize(stackbuf, nneeded);
+        v = PyString_FromStringAndSize(stackbuf, nneeded);
     }
     else {
     	/* Cut back to size actually needed. */
-        nneeded = p - PyBytes_AS_STRING(v);
+        nneeded = p - PyString_AS_STRING(v);
         assert(nneeded <= nallocated);
-        _PyBytes_Resize(&v, nneeded);
+        _PyString_Resize(&v, nneeded);
     }
     return v;
 
@@ -2274,12 +2274,12 @@
 	    0xDC00 <= s[i+1] && s[i+1] <= 0xDFFF)
 	    pairs++;
 #endif
-    v = PyBytes_FromStringAndSize(NULL,
+    v = PyString_FromStringAndSize(NULL,
 		  4 * (size - pairs + (byteorder == 0)));
     if (v == NULL)
         return NULL;
 
-    p = (unsigned char *)PyBytes_AS_STRING(v);
+    p = (unsigned char *)PyString_AS_STRING(v);
     if (byteorder == 0)
 	STORECHAR(0xFEFF);
     if (size == 0)
@@ -2539,12 +2539,12 @@
 	if (s[i] >= 0x10000)
 	    pairs++;
 #endif
-    v = PyBytes_FromStringAndSize(NULL,
+    v = PyString_FromStringAndSize(NULL,
 		  2 * (size + pairs + (byteorder == 0)));
     if (v == NULL)
         return NULL;
 
-    p = (unsigned char *)PyBytes_AS_STRING(v);
+    p = (unsigned char *)PyString_AS_STRING(v);
     if (byteorder == 0)
 	STORECHAR(0xFEFF);
     if (size == 0)
@@ -2887,7 +2887,7 @@
        escape.
     */
 
-    repr = PyBytes_FromStringAndSize(NULL,
+    repr = PyString_FromStringAndSize(NULL,
         2
 #ifdef Py_UNICODE_WIDE
         + 10*size
@@ -2898,7 +2898,7 @@
     if (repr == NULL)
         return NULL;
 
-    p = PyBytes_AS_STRING(repr);
+    p = PyString_AS_STRING(repr);
 
     if (quotes) {
         *p++ = 'u';
@@ -2910,7 +2910,7 @@
 
         /* Escape quotes and backslashes */
         if ((quotes &&
-	     ch == (Py_UNICODE) PyBytes_AS_STRING(repr)[1]) || ch == '\\') {
+	     ch == (Py_UNICODE) PyString_AS_STRING(repr)[1]) || ch == '\\') {
             *p++ = '\\';
             *p++ = (char) ch;
 	    continue;
@@ -2996,10 +2996,10 @@
             *p++ = (char) ch;
     }
     if (quotes)
-        *p++ = PyBytes_AS_STRING(repr)[1];
+        *p++ = PyString_AS_STRING(repr)[1];
 
     *p = '\0';
-    _PyBytes_Resize(&repr, p - PyBytes_AS_STRING(repr));
+    _PyString_Resize(&repr, p - PyString_AS_STRING(repr));
     return repr;
 }
 
@@ -3148,16 +3148,16 @@
     static const char *hexdigit = "0123456789abcdef";
 
 #ifdef Py_UNICODE_WIDE
-    repr = PyBytes_FromStringAndSize(NULL, 10 * size);
+    repr = PyString_FromStringAndSize(NULL, 10 * size);
 #else
-    repr = PyBytes_FromStringAndSize(NULL, 6 * size);
+    repr = PyString_FromStringAndSize(NULL, 6 * size);
 #endif
     if (repr == NULL)
         return NULL;
     if (size == 0)
 	return repr;
 
-    p = q = PyBytes_AS_STRING(repr);
+    p = q = PyString_AS_STRING(repr);
     while (size-- > 0) {
         Py_UNICODE ch = *s++;
 #ifdef Py_UNICODE_WIDE
@@ -3216,7 +3216,7 @@
             *p++ = (char) ch;
     }
     *p = '\0';
-    _PyBytes_Resize(&repr, p - q);
+    _PyString_Resize(&repr, p - q);
     return repr;
 }
 
@@ -3456,12 +3456,12 @@
 
     /* allocate enough for a simple encoding without
        replacements, if we need more, we'll resize */
-    res = PyBytes_FromStringAndSize(NULL, size);
+    res = PyString_FromStringAndSize(NULL, size);
     if (res == NULL)
         goto onError;
     if (size == 0)
 	return res;
-    str = PyBytes_AS_STRING(res);
+    str = PyString_AS_STRING(res);
     ressize = size;
 
     while (p<endp) {
@@ -3511,7 +3511,7 @@
 		    p = collend;
 		    break;
 		case 4: /* xmlcharrefreplace */
-		    respos = str-PyBytes_AS_STRING(res);
+		    respos = str-PyString_AS_STRING(res);
 		    /* determine replacement size (temporarily (mis)uses p) */
 		    for (p = collstart, repsize = 0; p < collend; ++p) {
 			if (*p<10)
@@ -3538,9 +3538,9 @@
 		    if (requiredsize > ressize) {
 			if (requiredsize<2*ressize)
 			    requiredsize = 2*ressize;
-			if (_PyBytes_Resize(&res, requiredsize))
+			if (_PyString_Resize(&res, requiredsize))
 			    goto onError;
-			str = PyBytes_AS_STRING(res) + respos;
+			str = PyString_AS_STRING(res) + respos;
 			ressize = requiredsize;
 		    }
 		    /* generate replacement (temporarily (mis)uses p) */
@@ -3558,17 +3558,17 @@
 		    /* need more space? (at least enough for what we
 		       have+the replacement+the rest of the string, so
 		       we won't have to check space for encodable characters) */
-		    respos = str-PyBytes_AS_STRING(res);
+		    respos = str-PyString_AS_STRING(res);
 		    repsize = PyUnicode_GET_SIZE(repunicode);
 		    requiredsize = respos+repsize+(endp-collend);
 		    if (requiredsize > ressize) {
 			if (requiredsize<2*ressize)
 			    requiredsize = 2*ressize;
-			if (_PyBytes_Resize(&res, requiredsize)) {
+			if (_PyString_Resize(&res, requiredsize)) {
 			    Py_DECREF(repunicode);
 			    goto onError;
 			}
-			str = PyBytes_AS_STRING(res) + respos;
+			str = PyString_AS_STRING(res) + respos;
 			ressize = requiredsize;
 		    }
 		    /* check if there is anything unencodable in the replacement
@@ -3589,10 +3589,10 @@
 	}
     }
     /* Resize if we allocated to much */
-    respos = str-PyBytes_AS_STRING(res);
+    respos = str-PyString_AS_STRING(res);
     if (respos<ressize)
        /* If this falls res will be NULL */
-	_PyBytes_Resize(&res, respos);
+	_PyString_Resize(&res, respos);
     Py_XDECREF(errorHandler);
     Py_XDECREF(exc);
     return res;
@@ -3669,7 +3669,7 @@
 		goto onError;
 	}
     }
-    if (p - PyUnicode_AS_UNICODE(v) < PyBytes_GET_SIZE(v))
+    if (p - PyUnicode_AS_UNICODE(v) < PyString_GET_SIZE(v))
 	if (_PyUnicode_Resize(&v, p - PyUnicode_AS_UNICODE(v)) < 0)
 	    goto onError;
     Py_XDECREF(errorHandler);
@@ -3847,20 +3847,20 @@
 
     if (*repr == NULL) {
 	/* Create string object */
-	*repr = PyBytes_FromStringAndSize(NULL, mbcssize);
+	*repr = PyString_FromStringAndSize(NULL, mbcssize);
 	if (*repr == NULL)
 	    return -1;
     }
     else {
 	/* Extend string object */
-	n = PyBytes_Size(*repr);
-	if (_PyBytes_Resize(repr, n + mbcssize) < 0)
+	n = PyString_Size(*repr);
+	if (_PyString_Resize(repr, n + mbcssize) < 0)
 	    return -1;
     }
 
     /* Do the conversion */
     if (size > 0) {
-	char *s = PyBytes_AS_STRING(*repr) + n;
+	char *s = PyString_AS_STRING(*repr) + n;
 	if (0 == WideCharToMultiByte(CP_ACP, 0, p, size, s, mbcssize, NULL, NULL)) {
 	    PyErr_SetFromWindowsErrWithFilename(0, NULL);
 	    return -1;
@@ -4327,7 +4327,7 @@
 	}
 	return x;
     }
-    else if (PyBytes_Check(x))
+    else if (PyString_Check(x))
 	return x;
     else {
 	/* wrong return value */
@@ -4341,11 +4341,11 @@
 static int
 charmapencode_resize(PyObject **outobj, Py_ssize_t *outpos, Py_ssize_t requiredsize)
 {
-	Py_ssize_t outsize = PyBytes_GET_SIZE(*outobj);
+	Py_ssize_t outsize = PyString_GET_SIZE(*outobj);
 	/* exponentially overallocate to minimize reallocations */
 	if (requiredsize < 2*outsize)
 	    requiredsize = 2*outsize;
-	if (_PyBytes_Resize(outobj, requiredsize)) {
+	if (_PyString_Resize(outobj, requiredsize)) {
 	    return 0;
 	}
 	return 1;
@@ -4366,7 +4366,7 @@
 {
     PyObject *rep;
     char *outstart;
-    Py_ssize_t outsize = PyBytes_GET_SIZE(*outobj);
+    Py_ssize_t outsize = PyString_GET_SIZE(*outobj);
 
     if (Py_TYPE(mapping) == &EncodingMapType) {
         int res = encoding_map_lookup(c, mapping);
@@ -4376,7 +4376,7 @@
 	if (outsize<requiredsize) 
 	    if (!charmapencode_resize(outobj, outpos, requiredsize))
 		return enc_EXCEPTION;
-        outstart = PyBytes_AS_STRING(*outobj);
+        outstart = PyString_AS_STRING(*outobj);
 	outstart[(*outpos)++] = (char)res;
 	return enc_SUCCESS;
     }
@@ -4395,19 +4395,19 @@
 		    Py_DECREF(rep);
 		    return enc_EXCEPTION;
 		}
-            outstart = PyBytes_AS_STRING(*outobj);
+            outstart = PyString_AS_STRING(*outobj);
 	    outstart[(*outpos)++] = (char)PyInt_AS_LONG(rep);
 	}
 	else {
-	    const char *repchars = PyBytes_AS_STRING(rep);
-	    Py_ssize_t repsize = PyBytes_GET_SIZE(rep);
+	    const char *repchars = PyString_AS_STRING(rep);
+	    Py_ssize_t repsize = PyString_GET_SIZE(rep);
 	    Py_ssize_t requiredsize = *outpos+repsize;
 	    if (outsize<requiredsize)
 		if (!charmapencode_resize(outobj, outpos, requiredsize)) {
 		    Py_DECREF(rep);
 		    return enc_EXCEPTION;
 		}
-            outstart = PyBytes_AS_STRING(*outobj);
+            outstart = PyString_AS_STRING(*outobj);
 	    memcpy(outstart + *outpos, repchars, repsize);
 	    *outpos += repsize;
 	}
@@ -4558,7 +4558,7 @@
 
     /* allocate enough for a simple encoding without
        replacements, if we need more, we'll resize */
-    res = PyBytes_FromStringAndSize(NULL, size);
+    res = PyString_FromStringAndSize(NULL, size);
     if (res == NULL)
         goto onError;
     if (size == 0)
@@ -4583,8 +4583,8 @@
     }
 
     /* Resize if we allocated to much */
-    if (respos<PyBytes_GET_SIZE(res)) {
-	if (_PyBytes_Resize(&res, respos))
+    if (respos<PyString_GET_SIZE(res)) {
+	if (_PyString_Resize(&res, respos))
 	    goto onError;
     }
     Py_XDECREF(exc);
@@ -5482,7 +5482,7 @@
 
 	item = PySequence_Fast_GET_ITEM(fseq, i);
 	/* Convert item to Unicode. */
-	if (! PyUnicode_Check(item) && ! PyBytes_Check(item)) {
+	if (! PyUnicode_Check(item) && ! PyString_Check(item)) {
 	    PyErr_Format(PyExc_TypeError,
 			 "sequence item %zd: expected string or Unicode,"
 			 " %.80s found",
@@ -6486,7 +6486,7 @@
     v = PyUnicode_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)",
@@ -6522,7 +6522,7 @@
     v = PyUnicode_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)",
@@ -7152,7 +7152,7 @@
 	if (sep != NULL && sep != Py_None) {
 		if (PyUnicode_Check(sep))
 			return _PyUnicode_XStrip(self, striptype, sep);
-		else if (PyBytes_Check(sep)) {
+		else if (PyString_Check(sep)) {
 			PyObject *res;
 			sep = PyUnicode_FromObject(sep);
 			if (sep==NULL)
@@ -8098,8 +8098,8 @@
     str = _PyUnicode_AsDefaultEncodedString((PyObject *)self, NULL);
     if (str == NULL)
 	return -1;
-    *ptr = (void *) PyBytes_AS_STRING(str);
-    return PyBytes_GET_SIZE(str);
+    *ptr = (void *) PyString_AS_STRING(str);
+    return PyString_GET_SIZE(str);
 }
 
 /* Helpers for PyUnicode_Format() */
@@ -8218,7 +8218,7 @@
 	PyObject *str; /* temporary string object. */
 	PyUnicodeObject *result;
 
-	str = _PyBytes_FormatLong(val, flags, prec, type, &buf, &len);
+	str = _PyString_FormatLong(val, flags, prec, type, &buf, &len);
 	if (!str)
 		return NULL;
 	result = _PyUnicode_New(len);
@@ -8320,10 +8320,10 @@
 	buf[0] = PyUnicode_AS_UNICODE(v)[0];
     }
 
-    else if (PyBytes_Check(v)) {
-	if (PyBytes_GET_SIZE(v) != 1)
+    else if (PyString_Check(v)) {
+	if (PyString_GET_SIZE(v) != 1)
 	    goto onError;
-	buf[0] = (Py_UNICODE)PyBytes_AS_STRING(v)[0];
+	buf[0] = (Py_UNICODE)PyString_AS_STRING(v)[0];
     }
 
     else {
@@ -8606,10 +8606,10 @@
 			goto onError;
                     if (PyUnicode_Check(temp))
                         /* nothing to do */;
-                    else if (PyBytes_Check(temp)) {
+                    else if (PyString_Check(temp)) {
                         /* convert to string to Unicode */
-		        unicode = PyUnicode_Decode(PyBytes_AS_STRING(temp),
-						   PyBytes_GET_SIZE(temp),
+		        unicode = PyUnicode_Decode(PyString_AS_STRING(temp),
+						   PyString_GET_SIZE(temp),
 						   NULL,
 						   "strict");
 		        Py_DECREF(temp);
diff --git a/Objects/weakrefobject.c b/Objects/weakrefobject.c
index 2899bc70..1aee5a5 100644
--- a/Objects/weakrefobject.c
+++ b/Objects/weakrefobject.c
@@ -166,8 +166,8 @@
 						   "__name__");
 	if (nameobj == NULL)
 		PyErr_Clear();
-	else if (PyBytes_Check(nameobj))
-		name = PyBytes_AS_STRING(nameobj);
+	else if (PyString_Check(nameobj))
+		name = PyString_AS_STRING(nameobj);
         PyOS_snprintf(buffer, sizeof(buffer),
 		      name ? "<weakref at %p; to '%.50s' at %p (%s)>"
 		           : "<weakref at %p; to '%.50s' at %p>",
@@ -177,7 +177,7 @@
 		      name);
 	Py_XDECREF(nameobj);
     }
-    return PyBytes_FromString(buffer);
+    return PyString_FromString(buffer);
 }
 
 /* Weak references only support equality, not ordering. Two weak references
@@ -448,7 +448,7 @@
 		  "<weakproxy at %p to %.100s at %p>", proxy,
 		  Py_TYPE(PyWeakref_GET_OBJECT(proxy))->tp_name,
 		  PyWeakref_GET_OBJECT(proxy));
-    return PyBytes_FromString(buf);
+    return PyString_FromString(buf);
 }