Renamed PyString to PyBytes

4 files changed, 41 insertions, 41 deletions

diff --git a/Modules/_ctypes/_ctypes.c b/Modules/_ctypes/_ctypes.c
index 1d548dc..fe33253 100644
--- a/Modules/_ctypes/_ctypes.c
+++ b/Modules/_ctypes/_ctypes.c
@@ -1049,7 +1049,7 @@ CharArray_set_raw(CDataObject *self, PyObject *value)
 static PyObject *
 CharArray_get_raw(CDataObject *self)
 {
-	return PyString_FromStringAndSize(self->b_ptr, self->b_size);
+	return PyBytes_FromStringAndSize(self->b_ptr, self->b_size);
 }
 
 static PyObject *
@@ -1060,7 +1060,7 @@ CharArray_get_value(CDataObject *self)
 	for (i = 0; i < self->b_size; ++i)
 		if (*ptr++ == '\0')
 			break;
-	return PyString_FromStringAndSize(self->b_ptr, i);
+	return PyBytes_FromStringAndSize(self->b_ptr, i);
 }
 
 static int
@@ -1081,14 +1081,14 @@ CharArray_set_value(CDataObject *self, PyObject *value)
 						  conversion_mode_errors);
 		if (!value)
 			return -1;
-	} else if (!PyString_Check(value)) {
+	} else if (!PyBytes_Check(value)) {
 		PyErr_Format(PyExc_TypeError,
 			     "str/bytes expected instead of %s instance",
 			     Py_TYPE(value)->tp_name);
 		return -1;
 	} else
 		Py_INCREF(value);
-	size = PyString_GET_SIZE(value);
+	size = PyBytes_GET_SIZE(value);
 	if (size > self->b_size) {
 		PyErr_SetString(PyExc_ValueError,
 				"string too long");
@@ -1096,7 +1096,7 @@ CharArray_set_value(CDataObject *self, PyObject *value)
 		return -1;
 	}
 
-	ptr = PyString_AS_STRING(value);
+	ptr = PyBytes_AS_STRING(value);
 	memcpy(self->b_ptr, ptr, size);
 	if (size < self->b_size)
 		self->b_ptr[size] = '\0';
@@ -1135,7 +1135,7 @@ WCharArray_set_value(CDataObject *self, PyObject *value)
 				"can't delete attribute");
 		return -1;
 	}
-	if (PyString_Check(value)) {
+	if (PyBytes_Check(value)) {
 		value = PyUnicode_FromEncodedObject(value,
 						    conversion_mode_encoding,
 						    conversion_mode_errors);
@@ -1434,7 +1434,7 @@ c_wchar_p_from_param(PyObject *type, PyObject *value)
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
-	if (PyUnicode_Check(value) || PyString_Check(value)) {
+	if (PyUnicode_Check(value) || PyBytes_Check(value)) {
 		PyCArgObject *parg;
 		struct fielddesc *fd = getentry("Z");
 
@@ -1495,7 +1495,7 @@ c_char_p_from_param(PyObject *type, PyObject *value)
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
-	if (PyString_Check(value) || PyUnicode_Check(value)) {
+	if (PyBytes_Check(value) || PyUnicode_Check(value)) {
 		PyCArgObject *parg;
 		struct fielddesc *fd = getentry("z");
 
@@ -1579,7 +1579,7 @@ c_void_p_from_param(PyObject *type, PyObject *value)
 	}
 	/* XXX struni: remove later */
 /* string */
-	if (PyString_Check(value)) {
+	if (PyBytes_Check(value)) {
 		PyCArgObject *parg;
 		struct fielddesc *fd = getentry("z");
 
@@ -1828,8 +1828,8 @@ SimpleType_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 		PyObject *v = _PyUnicode_AsDefaultEncodedString(proto, NULL);
 		if (!v)
 			goto error;
-		proto_str = PyString_AS_STRING(v);
-		proto_len = PyString_GET_SIZE(v);
+		proto_str = PyBytes_AS_STRING(v);
+		proto_len = PyBytes_GET_SIZE(v);
 	} else {
 		PyErr_SetString(PyExc_TypeError,
 			"class must define a '_type_' string attribute");
@@ -2501,7 +2501,7 @@ CData_reduce(PyObject *_self, PyObject *args)
 			     _unpickle,
 			     Py_TYPE(_self),
 			     PyObject_GetAttrString(_self, "__dict__"),
-			     PyString_FromStringAndSize(self->b_ptr, self->b_size));
+			     PyBytes_FromStringAndSize(self->b_ptr, self->b_size));
 }
 
 static PyObject *
@@ -3137,8 +3137,8 @@ _get_name(PyObject *obj, char **pname)
 		return 1;
 	}
 #endif
-	if (PyString_Check(obj)) {
-		*pname = PyString_AS_STRING(obj);
+	if (PyBytes_Check(obj)) {
+		*pname = PyBytes_AS_STRING(obj);
 		return *pname ? 1 : 0;
 	}
 	if (PyUnicode_Check(obj)) {
@@ -3953,7 +3953,7 @@ Struct_init(PyObject *self, PyObject *args, PyObject *kwds)
 			}
 
 			if (kwds && PyDict_GetItem(kwds, name)) {
-				char *field = PyString_AsString(name);
+				char *field = PyBytes_AsString(name);
 				if (field == NULL) {
 					PyErr_Clear();
 					field = "???";
@@ -4166,9 +4166,9 @@ Array_subscript(PyObject *_self, PyObject *item)
 			char *dest;
 
 			if (slicelen <= 0)
-				return PyString_FromStringAndSize("", 0);
+				return PyBytes_FromStringAndSize("", 0);
 			if (step == 1) {
-				return PyString_FromStringAndSize(ptr + start,
+				return PyBytes_FromStringAndSize(ptr + start,
 								 slicelen);
 			}
 			dest = (char *)PyMem_Malloc(slicelen);
@@ -4181,7 +4181,7 @@ Array_subscript(PyObject *_self, PyObject *item)
 				dest[i] = ptr[cur];
 			}
 
-			np = PyString_FromStringAndSize(dest, slicelen);
+			np = PyBytes_FromStringAndSize(dest, slicelen);
 			PyMem_Free(dest);
 			return np;
 		}
@@ -4859,9 +4859,9 @@ Pointer_subscript(PyObject *_self, PyObject *item)
 			char *dest;
 			
 			if (len <= 0)
-                        	return PyString_FromStringAndSize("", 0);
+                        	return PyBytes_FromStringAndSize("", 0);
 			if (step == 1) {
-				return PyString_FromStringAndSize(ptr + start,
+				return PyBytes_FromStringAndSize(ptr + start,
 								 len);
 			}
 			dest = (char *)PyMem_Malloc(len);
@@ -4870,7 +4870,7 @@ Pointer_subscript(PyObject *_self, PyObject *item)
 			for (cur = start, i = 0; i < len; cur += step, i++) {
 				dest[i] = ptr[cur];
 			}
-			np = PyString_FromStringAndSize(dest, len);
+			np = PyBytes_FromStringAndSize(dest, len);
 			PyMem_Free(dest);
 			return np;
 		}
@@ -5105,8 +5105,8 @@ static PyObject *
 string_at(const char *ptr, int size)
 {
 	if (size == -1)
-		return PyString_FromStringAndSize(ptr, strlen(ptr));
-	return PyString_FromStringAndSize(ptr, size);
+		return PyBytes_FromStringAndSize(ptr, strlen(ptr));
+	return PyBytes_FromStringAndSize(ptr, size);
 }
 
 static int
diff --git a/Modules/_ctypes/callbacks.c b/Modules/_ctypes/callbacks.c
index 94c6096..87e3df7 100644
--- a/Modules/_ctypes/callbacks.c
+++ b/Modules/_ctypes/callbacks.c
@@ -110,7 +110,7 @@ void _AddTraceback(char *funcname, char *filename, int lineno)
 	if (!py_globals) goto bad;
 	empty_tuple = PyTuple_New(0);
 	if (!empty_tuple) goto bad;
-	empty_string = PyString_FromString("");
+	empty_string = PyBytes_FromString("");
 	if (!empty_string) goto bad;
 	py_code = PyCode_New(
 		0,            /*int argcount,*/
diff --git a/Modules/_ctypes/callproc.c b/Modules/_ctypes/callproc.c
index 437cce7..fd66216 100644
--- a/Modules/_ctypes/callproc.c
+++ b/Modules/_ctypes/callproc.c
@@ -507,9 +507,9 @@ static int ConvParam(PyObject *obj, Py_ssize_t index, struct argument *pa)
 		return 0;
 	}
 
-	if (PyString_Check(obj)) {
+	if (PyBytes_Check(obj)) {
 		pa->ffi_type = &ffi_type_pointer;
-		pa->value.p = PyString_AsString(obj);
+		pa->value.p = PyBytes_AsString(obj);
 		Py_INCREF(obj);
 		pa->keep = obj;
 		return 0;
diff --git a/Modules/_ctypes/cfield.c b/Modules/_ctypes/cfield.c
index 86f6b53..6cf56a8 100644
--- a/Modules/_ctypes/cfield.c
+++ b/Modules/_ctypes/cfield.c
@@ -1160,16 +1160,16 @@ c_set(void *ptr, PyObject *value, Py_ssize_t size)
 						  conversion_mode_errors);
 		if (value == NULL)
 			return NULL;
-		if (PyString_GET_SIZE(value) != 1) {
+		if (PyBytes_GET_SIZE(value) != 1) {
 			Py_DECREF(value);
 			goto error;
 		}
-		*(char *)ptr = PyString_AS_STRING(value)[0];
+		*(char *)ptr = PyBytes_AS_STRING(value)[0];
 		Py_DECREF(value);
 		_RET(value);
 	}
-	if (PyString_Check(value) && PyString_GET_SIZE(value) == 1) {
-		*(char *)ptr = PyString_AS_STRING(value)[0];
+	if (PyBytes_Check(value) && PyBytes_GET_SIZE(value) == 1) {
+		*(char *)ptr = PyBytes_AS_STRING(value)[0];
 		_RET(value);
 	}
 	if (PyByteArray_Check(value) && PyByteArray_GET_SIZE(value) == 1) {
@@ -1194,7 +1194,7 @@ c_set(void *ptr, PyObject *value, Py_ssize_t size)
 static PyObject *
 c_get(void *ptr, Py_ssize_t size)
 {
-	return PyString_FromStringAndSize((char *)ptr, 1);
+	return PyBytes_FromStringAndSize((char *)ptr, 1);
 }
 
 #ifdef CTYPES_UNICODE
@@ -1203,7 +1203,7 @@ static PyObject *
 u_set(void *ptr, PyObject *value, Py_ssize_t size)
 {
 	Py_ssize_t len;
-	if (PyString_Check(value)) {
+	if (PyBytes_Check(value)) {
 		value = PyUnicode_FromEncodedObject(value,
 						    conversion_mode_encoding,
 						    conversion_mode_errors);
@@ -1278,7 +1278,7 @@ U_set(void *ptr, PyObject *value, Py_ssize_t length)
 	/* It's easier to calculate in characters than in bytes */
 	length /= sizeof(wchar_t);
 
-	if (PyString_Check(value)) {
+	if (PyBytes_Check(value)) {
 		value = PyUnicode_FromEncodedObject(value,
 						    conversion_mode_encoding,
 						    conversion_mode_errors);
@@ -1334,8 +1334,8 @@ s_set(void *ptr, PyObject *value, Py_ssize_t length)
 						  conversion_mode_errors);
 		if (value == NULL)
 			return NULL;
-		assert(PyString_Check(value));
-	} else if(PyString_Check(value)) {
+		assert(PyBytes_Check(value));
+	} else if(PyBytes_Check(value)) {
 		Py_INCREF(value);
 	} else {
 		PyErr_Format(PyExc_TypeError,
@@ -1344,7 +1344,7 @@ s_set(void *ptr, PyObject *value, Py_ssize_t length)
 		return NULL;
 	}
 
-	data = PyString_AS_STRING(value);
+	data = PyBytes_AS_STRING(value);
 	if (!data)
 		return NULL;
 	size = strlen(data); /* XXX Why not Py_SIZE(value)? */
@@ -1375,8 +1375,8 @@ z_set(void *ptr, PyObject *value, Py_ssize_t size)
 		Py_INCREF(value);
 		return value;
 	}
-	if (PyString_Check(value)) {
-		*(char **)ptr = PyString_AsString(value);
+	if (PyBytes_Check(value)) {
+		*(char **)ptr = PyBytes_AsString(value);
 		Py_INCREF(value);
 		return value;
 	} else if (PyUnicode_Check(value)) {
@@ -1385,7 +1385,7 @@ z_set(void *ptr, PyObject *value, Py_ssize_t size)
 							  conversion_mode_errors);
 		if (str == NULL)
 			return NULL;
-		*(char **)ptr = PyString_AS_STRING(str);
+		*(char **)ptr = PyBytes_AS_STRING(str);
 		return str;
 	} else if (PyLong_Check(value)) {
 #if SIZEOF_VOID_P == SIZEOF_LONG_LONG
@@ -1439,7 +1439,7 @@ Z_set(void *ptr, PyObject *value, Py_ssize_t size)
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
-	if (PyString_Check(value)) {
+	if (PyBytes_Check(value)) {
 		value = PyUnicode_FromEncodedObject(value,
 						    conversion_mode_encoding,
 						    conversion_mode_errors);
@@ -1522,7 +1522,7 @@ BSTR_set(void *ptr, PyObject *value, Py_ssize_t size)
 	/* convert value into a PyUnicodeObject or NULL */
 	if (Py_None == value) {
 		value = NULL;
-	} else if (PyString_Check(value)) {
+	} else if (PyBytes_Check(value)) {
 		value = PyUnicode_FromEncodedObject(value,
 						    conversion_mode_encoding,
 						    conversion_mode_errors);