Merging the py3k-pep3137 branch back into the py3k branch.
No detailed change log; just check out the change log for the py3k-pep3137
branch. The most obvious changes:
- str8 renamed to bytes (PyString at the C level);
- bytes renamed to buffer (PyBytes at the C level);
- PyString and PyUnicode are no longer compatible.
I.e. we now have an immutable bytes type and a mutable bytes type.
The behavior of PyString was modified quite a bit, to make it more
bytes-like. Some changes are still on the to-do list.
diff --git a/Modules/_bsddb.c b/Modules/_bsddb.c
index bd1c271..0587071 100644
--- a/Modules/_bsddb.c
+++ b/Modules/_bsddb.c
@@ -1171,13 +1171,16 @@
else if (PyInt_Check(result)) {
retval = PyInt_AsLong(result);
}
- else if (PyBytes_Check(result)) {
+ else if (PyBytes_Check(result) || PyString_Check(result)) {
char* data;
Py_ssize_t size;
CLEAR_DBT(*secKey);
- size = PyBytes_Size(result);
- data = PyBytes_AsString(result);
+ size = Py_Size(result);
+ if (PyBytes_Check(result))
+ data = PyBytes_AS_STRING(result);
+ else
+ data = PyString_AS_STRING(result);
secKey->flags = DB_DBT_APPMALLOC; /* DB will free */
secKey->data = malloc(size); /* TODO, check this */
if (secKey->data) {
@@ -1517,7 +1520,7 @@
retval = Py_BuildValue("y#y#", key.data, key.size, data.data,
data.size);
else /* return just the data */
- retval = PyBytes_FromStringAndSize((char*)data.data, data.size);
+ retval = PyString_FromStringAndSize((char*)data.data, data.size);
free_dbt(&data);
}
FREE_DBT_VIEW(key, keyobj, key_buf_view);
@@ -1587,13 +1590,13 @@
else if (!err) {
PyObject *pkeyObj;
PyObject *dataObj;
- dataObj = PyBytes_FromStringAndSize(data.data, data.size);
+ dataObj = PyString_FromStringAndSize(data.data, data.size);
if (self->primaryDBType == DB_RECNO ||
self->primaryDBType == DB_QUEUE)
pkeyObj = PyInt_FromLong(*(int *)pkey.data);
else
- pkeyObj = PyBytes_FromStringAndSize(pkey.data, pkey.size);
+ pkeyObj = PyString_FromStringAndSize(pkey.data, pkey.size);
if (flags & DB_SET_RECNO) /* return key , pkey and data */
{
@@ -1602,7 +1605,7 @@
if (type == DB_RECNO || type == DB_QUEUE)
keyObj = PyInt_FromLong(*(int *)key.data);
else
- keyObj = PyBytes_FromStringAndSize(key.data, key.size);
+ keyObj = PyString_FromStringAndSize(key.data, key.size);
#if (PY_VERSION_HEX >= 0x02040000)
retval = PyTuple_Pack(3, keyObj, pkeyObj, dataObj);
#else
@@ -1729,7 +1732,8 @@
else if (!err) {
/* XXX(nnorwitz): can we do: retval = dataobj; Py_INCREF(retval); */
/* XXX(gps) I think not: buffer API input vs. bytes object output. */
- retval = PyBytes_FromStringAndSize((char*)data.data, data.size);
+ /* XXX(guido) But what if the input is PyString? */
+ retval = PyString_FromStringAndSize((char*)data.data, data.size);
/* Even though the flags require DB_DBT_MALLOC, data is not always
allocated. 4.4: allocated, 4.5: *not* allocated. :-( */
@@ -2773,7 +2777,7 @@
retval = NULL;
}
else {
- retval = PyBytes_FromStringAndSize((char*)data.data, data.size);
+ retval = PyString_FromStringAndSize((char*)data.data, data.size);
free_dbt(&data);
}
@@ -2928,7 +2932,7 @@
case DB_BTREE:
case DB_HASH:
default:
- item = PyBytes_FromStringAndSize((char*)key.data, key.size);
+ item = PyString_FromStringAndSize((char*)key.data, key.size);
break;
case DB_RECNO:
case DB_QUEUE:
@@ -2938,7 +2942,7 @@
break;
case _VALUES_LIST:
- item = PyBytes_FromStringAndSize((char*)data.data, data.size);
+ item = PyString_FromStringAndSize((char*)data.data, data.size);
break;
case _ITEMS_LIST:
@@ -3286,13 +3290,13 @@
else {
PyObject *pkeyObj;
PyObject *dataObj;
- dataObj = PyBytes_FromStringAndSize(data.data, data.size);
+ dataObj = PyString_FromStringAndSize(data.data, data.size);
if (self->mydb->primaryDBType == DB_RECNO ||
self->mydb->primaryDBType == DB_QUEUE)
pkeyObj = PyInt_FromLong(*(int *)pkey.data);
else
- pkeyObj = PyBytes_FromStringAndSize(pkey.data, pkey.size);
+ pkeyObj = PyString_FromStringAndSize(pkey.data, pkey.size);
if (key.data && key.size) /* return key, pkey and data */
{
@@ -3301,7 +3305,7 @@
if (type == DB_RECNO || type == DB_QUEUE)
keyObj = PyInt_FromLong(*(int *)key.data);
else
- keyObj = PyBytes_FromStringAndSize(key.data, key.size);
+ keyObj = PyString_FromStringAndSize(key.data, key.size);
retval = PyTuple_Pack(3, keyObj, pkeyObj, dataObj);
Py_DECREF(keyObj);
}
@@ -4909,7 +4913,7 @@
MYDB_END_ALLOW_THREADS
if (!err)
- retval = PyBytes_FromStringAndSize(key.data, key.size);
+ retval = PyString_FromStringAndSize(key.data, key.size);
free_dbt(&key);
RETURN_IF_ERR();
diff --git a/Modules/_codecsmodule.c b/Modules/_codecsmodule.c
index e3933e7..caee3fd 100644
--- a/Modules/_codecsmodule.c
+++ b/Modules/_codecsmodule.c
@@ -180,7 +180,7 @@
"string is too large to encode");
return NULL;
}
- v = PyBytes_FromStringAndSize(NULL, newsize);
+ v = PyString_FromStringAndSize(NULL, newsize);
if (v == NULL) {
return NULL;
@@ -188,11 +188,11 @@
else {
register Py_ssize_t i;
register char c;
- register char *p = PyBytes_AS_STRING(v);
+ register char *p = PyString_AS_STRING(v);
for (i = 0; i < size; i++) {
/* There's at least enough room for a hex escape */
- assert(newsize - (p - PyBytes_AS_STRING(v)) >= 4);
+ assert(newsize - (p - PyString_AS_STRING(v)) >= 4);
c = PyString_AS_STRING(str)[i];
if (c == '\'' || c == '\\')
*p++ = '\\', *p++ = c;
@@ -212,13 +212,12 @@
*p++ = c;
}
*p = '\0';
- if (PyBytes_Resize(v, (p - PyBytes_AS_STRING(v)))) {
- Py_DECREF(v);
+ if (_PyString_Resize(&v, (p - PyString_AS_STRING(v)))) {
return NULL;
}
}
- return codec_tuple(v, PyBytes_Size(v));
+ return codec_tuple(v, PyString_Size(v));
}
/* --- Decoder ------------------------------------------------------------ */
@@ -654,7 +653,7 @@
&data, &size, &errors))
return NULL;
- return codec_tuple(PyBytes_FromStringAndSize(data, size), size);
+ return codec_tuple(PyString_FromStringAndSize(data, size), size);
}
static PyObject *
@@ -669,7 +668,7 @@
&data, &size, &errors))
return NULL;
- return codec_tuple(PyBytes_FromStringAndSize(data, size), size);
+ return codec_tuple(PyString_FromStringAndSize(data, size), size);
}
static PyObject *
@@ -688,12 +687,12 @@
if (PyUnicode_Check(obj)) {
data = PyUnicode_AS_DATA(obj);
size = PyUnicode_GET_DATA_SIZE(obj);
- return codec_tuple(PyBytes_FromStringAndSize(data, size), size);
+ return codec_tuple(PyString_FromStringAndSize(data, size), size);
}
else {
if (PyObject_AsReadBuffer(obj, (const void **)&data, &size))
return NULL;
- return codec_tuple(PyBytes_FromStringAndSize(data, size), size);
+ return codec_tuple(PyString_FromStringAndSize(data, size), size);
}
}
diff --git a/Modules/_ctypes/_ctypes.c b/Modules/_ctypes/_ctypes.c
index 81276fa..39dfdef 100644
--- a/Modules/_ctypes/_ctypes.c
+++ b/Modules/_ctypes/_ctypes.c
@@ -763,7 +763,7 @@
static PyObject *
CharArray_get_raw(CDataObject *self)
{
- return PyBytes_FromStringAndSize(self->b_ptr, self->b_size);
+ return PyString_FromStringAndSize(self->b_ptr, self->b_size);
}
static PyObject *
@@ -774,7 +774,7 @@
for (i = 0; i < self->b_size; ++i)
if (*ptr++ == '\0')
break;
- return PyBytes_FromStringAndSize(self->b_ptr, i);
+ return PyString_FromStringAndSize(self->b_ptr, i);
}
static int
@@ -789,14 +789,14 @@
conversion_mode_errors);
if (!value)
return -1;
- } else if (!PyBytes_Check(value)) {
+ } else if (!PyString_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 = PyBytes_GET_SIZE(value);
+ size = PyString_GET_SIZE(value);
if (size > self->b_size) {
PyErr_SetString(PyExc_ValueError,
"string too long");
@@ -804,7 +804,7 @@
return -1;
}
- ptr = PyBytes_AS_STRING(value);
+ ptr = PyString_AS_STRING(value);
memcpy(self->b_ptr, ptr, size);
if (size < self->b_size)
self->b_ptr[size] = '\0';
@@ -838,7 +838,7 @@
{
Py_ssize_t result = 0;
- if (PyBytes_Check(value)) {
+ if (PyString_Check(value)) {
value = PyUnicode_FromEncodedObject(value,
conversion_mode_encoding,
conversion_mode_errors);
@@ -1106,7 +1106,7 @@
Py_INCREF(Py_None);
return Py_None;
}
- if (PyUnicode_Check(value) || PyBytes_Check(value)) {
+ if (PyUnicode_Check(value) || PyString_Check(value)) {
PyCArgObject *parg;
struct fielddesc *fd = getentry("Z");
@@ -1167,7 +1167,7 @@
Py_INCREF(Py_None);
return Py_None;
}
- if (PyBytes_Check(value) || PyUnicode_Check(value)) {
+ if (PyString_Check(value) || PyUnicode_Check(value)) {
PyCArgObject *parg;
struct fielddesc *fd = getentry("z");
@@ -1251,7 +1251,7 @@
}
/* XXX struni: remove later */
/* string */
- if (PyBytes_Check(value)) {
+ if (PyString_Check(value)) {
PyCArgObject *parg;
struct fielddesc *fd = getentry("z");
@@ -2705,8 +2705,8 @@
return 1;
}
#endif
- if (PyBytes_Check(obj)) {
- *pname = PyBytes_AS_STRING(obj);
+ if (PyString_Check(obj)) {
+ *pname = PyString_AS_STRING(obj);
return *pname ? 1 : 0;
}
if (PyUnicode_Check(obj)) {
@@ -3734,9 +3734,9 @@
char *dest;
if (slicelen <= 0)
- return PyBytes_FromStringAndSize("", 0);
+ return PyString_FromStringAndSize("", 0);
if (step == 1) {
- return PyBytes_FromStringAndSize(ptr + start,
+ return PyString_FromStringAndSize(ptr + start,
slicelen);
}
dest = (char *)PyMem_Malloc(slicelen);
@@ -3749,7 +3749,7 @@
dest[i] = ptr[cur];
}
- np = PyBytes_FromStringAndSize(dest, slicelen);
+ np = PyString_FromStringAndSize(dest, slicelen);
PyMem_Free(dest);
return np;
}
@@ -4411,9 +4411,9 @@
char *dest;
if (len <= 0)
- return PyBytes_FromStringAndSize("", 0);
+ return PyString_FromStringAndSize("", 0);
if (step == 1) {
- return PyBytes_FromStringAndSize(ptr + start,
+ return PyString_FromStringAndSize(ptr + start,
len);
}
dest = (char *)PyMem_Malloc(len);
@@ -4422,7 +4422,7 @@
for (cur = start, i = 0; i < len; cur += step, i++) {
dest[i] = ptr[cur];
}
- np = PyBytes_FromStringAndSize(dest, len);
+ np = PyString_FromStringAndSize(dest, len);
PyMem_Free(dest);
return np;
}
@@ -4658,8 +4658,8 @@
string_at(const char *ptr, int size)
{
if (size == -1)
- return PyBytes_FromStringAndSize(ptr, strlen(ptr));
- return PyBytes_FromStringAndSize(ptr, size);
+ return PyString_FromStringAndSize(ptr, strlen(ptr));
+ return PyString_FromStringAndSize(ptr, size);
}
static int
diff --git a/Modules/_ctypes/callproc.c b/Modules/_ctypes/callproc.c
index bc524f7..69129f7 100644
--- a/Modules/_ctypes/callproc.c
+++ b/Modules/_ctypes/callproc.c
@@ -507,9 +507,9 @@
return 0;
}
- if (PyBytes_Check(obj)) {
+ if (PyString_Check(obj)) {
pa->ffi_type = &ffi_type_pointer;
- pa->value.p = PyBytes_AsString(obj);
+ pa->value.p = PyString_AsString(obj);
Py_INCREF(obj);
pa->keep = obj;
return 0;
diff --git a/Modules/_ctypes/cfield.c b/Modules/_ctypes/cfield.c
index 910470a..2ec7b3a 100644
--- a/Modules/_ctypes/cfield.c
+++ b/Modules/_ctypes/cfield.c
@@ -1157,16 +1157,20 @@
conversion_mode_errors);
if (value == NULL)
return NULL;
- if (PyBytes_GET_SIZE(value) != 1) {
+ if (PyString_GET_SIZE(value) != 1) {
Py_DECREF(value);
goto error;
}
- *(char *)ptr = PyBytes_AsString(value)[0];
+ *(char *)ptr = PyString_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];
+ _RET(value);
+ }
if (PyBytes_Check(value) && PyBytes_GET_SIZE(value) == 1) {
- *(char *)ptr = PyBytes_AsString(value)[0];
+ *(char *)ptr = PyBytes_AS_STRING(value)[0];
_RET(value);
}
if (PyInt_Check(value))
@@ -1187,7 +1191,7 @@
static PyObject *
c_get(void *ptr, Py_ssize_t size)
{
- return PyBytes_FromStringAndSize((char *)ptr, 1);
+ return PyString_FromStringAndSize((char *)ptr, 1);
}
#ifdef CTYPES_UNICODE
@@ -1196,7 +1200,7 @@
u_set(void *ptr, PyObject *value, Py_ssize_t size)
{
Py_ssize_t len;
- if (PyBytes_Check(value)) {
+ if (PyString_Check(value)) {
value = PyUnicode_FromEncodedObject(value,
conversion_mode_encoding,
conversion_mode_errors);
@@ -1271,7 +1275,7 @@
/* It's easier to calculate in characters than in bytes */
length /= sizeof(wchar_t);
- if (PyBytes_Check(value)) {
+ if (PyString_Check(value)) {
value = PyUnicode_FromEncodedObject(value,
conversion_mode_encoding,
conversion_mode_errors);
@@ -1327,8 +1331,8 @@
conversion_mode_errors);
if (value == NULL)
return NULL;
- assert(PyBytes_Check(value));
- } else if(PyBytes_Check(value)) {
+ assert(PyString_Check(value));
+ } else if(PyString_Check(value)) {
Py_INCREF(value);
} else {
PyErr_Format(PyExc_TypeError,
@@ -1337,10 +1341,10 @@
return NULL;
}
- data = PyBytes_AsString(value);
+ data = PyString_AS_STRING(value);
if (!data)
return NULL;
- size = strlen(data);
+ size = strlen(data); /* XXX Why not Py_Size(value)? */
if (size < length) {
/* This will copy the leading NUL character
* if there is space for it.
@@ -1368,8 +1372,8 @@
Py_INCREF(value);
return value;
}
- if (PyBytes_Check(value)) {
- *(char **)ptr = PyBytes_AsString(value);
+ if (PyString_Check(value)) {
+ *(char **)ptr = PyString_AsString(value);
Py_INCREF(value);
return value;
} else if (PyUnicode_Check(value)) {
@@ -1378,8 +1382,7 @@
conversion_mode_errors);
if (str == NULL)
return NULL;
- assert(PyBytes_Check(str));
- *(char **)ptr = PyBytes_AS_STRING(str);
+ *(char **)ptr = PyString_AS_STRING(str);
return str;
} else if (PyInt_Check(value)) {
#if SIZEOF_VOID_P == SIZEOF_LONG_LONG
@@ -1433,7 +1436,7 @@
Py_INCREF(Py_None);
return Py_None;
}
- if (PyBytes_Check(value)) {
+ if (PyString_Check(value)) {
value = PyUnicode_FromEncodedObject(value,
conversion_mode_encoding,
conversion_mode_errors);
@@ -1516,7 +1519,7 @@
/* convert value into a PyUnicodeObject or NULL */
if (Py_None == value) {
value = NULL;
- } else if (PyBytes_Check(value)) {
+ } else if (PyString_Check(value)) {
value = PyUnicode_FromEncodedObject(value,
conversion_mode_encoding,
conversion_mode_errors);
diff --git a/Modules/_cursesmodule.c b/Modules/_cursesmodule.c
index a1d7e2e..cf412d8 100644
--- a/Modules/_cursesmodule.c
+++ b/Modules/_cursesmodule.c
@@ -1796,7 +1796,7 @@
remove(fn);
return NULL;
}
- if (!PyBytes_Check(data)) {
+ if (!PyString_Check(data)) {
PyErr_Format(PyExc_TypeError,
"f.read() returned %.100s instead of bytes",
data->ob_type->tp_name);
@@ -1805,7 +1805,7 @@
remove(fn);
return NULL;
}
- fwrite(PyBytes_AS_STRING(data), 1, PyBytes_GET_SIZE(data), fp);
+ fwrite(PyString_AS_STRING(data), 1, PyString_GET_SIZE(data), fp);
Py_DECREF(data);
fseek(fp, 0, 0);
win = getwin(fp);
diff --git a/Modules/_fileio.c b/Modules/_fileio.c
index f02c5ef..c357a73 100644
--- a/Modules/_fileio.c
+++ b/Modules/_fileio.c
@@ -400,14 +400,14 @@
Py_ssize_t total = 0;
int n;
- result = PyBytes_FromStringAndSize(NULL, DEFAULT_BUFFER_SIZE);
+ result = PyString_FromStringAndSize(NULL, DEFAULT_BUFFER_SIZE);
if (result == NULL)
return NULL;
while (1) {
Py_ssize_t newsize = total + DEFAULT_BUFFER_SIZE;
- if (PyBytes_GET_SIZE(result) < newsize) {
- if (PyBytes_Resize(result, newsize) < 0) {
+ if (PyString_GET_SIZE(result) < newsize) {
+ if (_PyString_Resize(&result, newsize) < 0) {
if (total == 0) {
Py_DECREF(result);
return NULL;
@@ -419,7 +419,7 @@
Py_BEGIN_ALLOW_THREADS
errno = 0;
n = read(self->fd,
- PyBytes_AS_STRING(result) + total,
+ PyString_AS_STRING(result) + total,
newsize - total);
Py_END_ALLOW_THREADS
if (n == 0)
@@ -438,8 +438,8 @@
total += n;
}
- if (PyBytes_GET_SIZE(result) > total) {
- if (PyBytes_Resize(result, total) < 0) {
+ if (PyString_GET_SIZE(result) > total) {
+ if (_PyString_Resize(&result, total) < 0) {
/* This should never happen, but just in case */
Py_DECREF(result);
return NULL;
@@ -468,10 +468,10 @@
return fileio_readall(self);
}
- bytes = PyBytes_FromStringAndSize(NULL, size);
+ bytes = PyString_FromStringAndSize(NULL, size);
if (bytes == NULL)
return NULL;
- ptr = PyBytes_AsString(bytes);
+ ptr = PyString_AS_STRING(bytes);
Py_BEGIN_ALLOW_THREADS
errno = 0;
@@ -486,7 +486,7 @@
}
if (n != size) {
- if (PyBytes_Resize(bytes, n) < 0) {
+ if (_PyString_Resize(&bytes, n) < 0) {
Py_DECREF(bytes);
return NULL;
}
diff --git a/Modules/_hashopenssl.c b/Modules/_hashopenssl.c
index 252a2ae..0f460bf 100644
--- a/Modules/_hashopenssl.c
+++ b/Modules/_hashopenssl.c
@@ -108,7 +108,7 @@
digest_size = EVP_MD_CTX_size(&temp_ctx);
EVP_DigestFinal(&temp_ctx, digest, NULL);
- retval = PyBytes_FromStringAndSize((const char *)digest, digest_size);
+ retval = PyString_FromStringAndSize((const char *)digest, digest_size);
EVP_MD_CTX_cleanup(&temp_ctx);
return retval;
}
diff --git a/Modules/_sqlite/cache.c b/Modules/_sqlite/cache.c
index 829c175..2f50e6a 100644
--- a/Modules/_sqlite/cache.c
+++ b/Modules/_sqlite/cache.c
@@ -241,12 +241,12 @@
if (!fmt_args) {
return NULL;
}
- template = PyString_FromString("%s <- %s ->%s\n");
+ template = PyUnicode_FromString("%s <- %s ->%s\n");
if (!template) {
Py_DECREF(fmt_args);
return NULL;
}
- display_str = PyString_Format(template, fmt_args);
+ display_str = PyUnicode_Format(template, fmt_args);
Py_DECREF(template);
Py_DECREF(fmt_args);
if (!display_str) {
diff --git a/Modules/_sqlite/connection.c b/Modules/_sqlite/connection.c
index 5f899e8..d4318de 100644
--- a/Modules/_sqlite/connection.c
+++ b/Modules/_sqlite/connection.c
@@ -425,8 +425,6 @@
sqlite3_result_int64(context, (PY_LONG_LONG)longval);
} else if (PyFloat_Check(py_val)) {
sqlite3_result_double(context, PyFloat_AsDouble(py_val));
- } else if (PyString_Check(py_val)) {
- sqlite3_result_text(context, PyString_AsString(py_val), -1, SQLITE_TRANSIENT);
} else if (PyUnicode_Check(py_val)) {
sqlite3_result_text(context, PyUnicode_AsString(py_val), -1, SQLITE_TRANSIENT);
} else if (PyObject_CheckBuffer(py_val)) {
@@ -467,7 +465,7 @@
break;
case SQLITE_TEXT:
val_str = (const char*)sqlite3_value_text(cur_value);
- cur_py_value = PyUnicode_DecodeUTF8(val_str, strlen(val_str), NULL);
+ cur_py_value = PyUnicode_FromString(val_str);
/* TODO: have a way to show errors here */
if (!cur_py_value) {
PyErr_Clear();
@@ -477,7 +475,7 @@
break;
case SQLITE_BLOB:
buflen = sqlite3_value_bytes(cur_value);
- cur_py_value = PyBytes_FromStringAndSize(
+ cur_py_value = PyString_FromStringAndSize(
sqlite3_value_blob(cur_value), buflen);
break;
case SQLITE_NULL:
@@ -1023,8 +1021,8 @@
goto finally;
}
- string1 = PyString_FromStringAndSize((const char*)text1_data, text1_length);
- string2 = PyString_FromStringAndSize((const char*)text2_data, text2_length);
+ string1 = PyUnicode_FromStringAndSize((const char*)text1_data, text1_length);
+ string2 = PyUnicode_FromStringAndSize((const char*)text2_data, text2_length);
if (!string1 || !string2) {
goto finally; /* failed to allocate strings */
@@ -1093,7 +1091,7 @@
goto finally;
}
- chk = PyString_AsString(uppercase_name);
+ chk = PyUnicode_AsString(uppercase_name);
while (*chk) {
if ((*chk >= '0' && *chk <= '9')
|| (*chk >= 'A' && *chk <= 'Z')
@@ -1118,7 +1116,7 @@
}
rc = sqlite3_create_collation(self->db,
- PyString_AsString(uppercase_name),
+ PyUnicode_AsString(uppercase_name),
SQLITE_UTF8,
(callable != Py_None) ? callable : NULL,
(callable != Py_None) ? pysqlite_collation_callback : NULL);
diff --git a/Modules/_sqlite/cursor.c b/Modules/_sqlite/cursor.c
index c789faf..c51c92e 100644
--- a/Modules/_sqlite/cursor.c
+++ b/Modules/_sqlite/cursor.c
@@ -272,11 +272,7 @@
}
}
- if (is_ascii) {
- return PyString_FromString(val_str);
- } else {
- return PyUnicode_DecodeUTF8(val_str, strlen(val_str), NULL);
- }
+ return PyUnicode_FromString(val_str);
}
/*
@@ -379,7 +375,7 @@
} else {
/* coltype == SQLITE_BLOB */
nbytes = sqlite3_column_bytes(self->statement->st, i);
- buffer = PyBytes_FromStringAndSize(
+ buffer = PyString_FromStringAndSize(
sqlite3_column_blob(self->statement->st, i), nbytes);
if (!buffer) {
break;
@@ -436,8 +432,8 @@
return NULL;
}
- if (!PyString_Check(operation) && !PyUnicode_Check(operation)) {
- PyErr_SetString(PyExc_ValueError, "operation parameter must be str or unicode");
+ if (!PyUnicode_Check(operation)) {
+ PyErr_SetString(PyExc_ValueError, "operation parameter must be str");
return NULL;
}
@@ -458,8 +454,8 @@
return NULL;
}
- if (!PyString_Check(operation) && !PyUnicode_Check(operation)) {
- PyErr_SetString(PyExc_ValueError, "operation parameter must be str or unicode");
+ if (!PyUnicode_Check(operation)) {
+ PyErr_SetString(PyExc_ValueError, "operation parameter must be str");
return NULL;
}
diff --git a/Modules/_sqlite/module.c b/Modules/_sqlite/module.c
index 61ac0a1..107d61a 100644
--- a/Modules/_sqlite/module.c
+++ b/Modules/_sqlite/module.c
@@ -146,7 +146,7 @@
PyObject* callable;
PyObject* retval = NULL;
- if (!PyArg_ParseTuple(args, "SO", &orig_name, &callable)) {
+ if (!PyArg_ParseTuple(args, "UO", &orig_name, &callable)) {
return NULL;
}
diff --git a/Modules/_sqlite/row.c b/Modules/_sqlite/row.c
index 2f3ba69..dfb6363 100644
--- a/Modules/_sqlite/row.c
+++ b/Modules/_sqlite/row.c
@@ -87,7 +87,7 @@
nitems = PyTuple_Size(self->description);
for (i = 0; i < nitems; i++) {
- compare_key = PyString_AsString(PyTuple_GET_ITEM(PyTuple_GET_ITEM(self->description, i), 0));
+ compare_key = PyUnicode_AsString(PyTuple_GET_ITEM(PyTuple_GET_ITEM(self->description, i), 0));
if (!compare_key) {
return NULL;
}
diff --git a/Modules/_sqlite/statement.c b/Modules/_sqlite/statement.c
index 1cc3cdd..98cc68a 100644
--- a/Modules/_sqlite/statement.c
+++ b/Modules/_sqlite/statement.c
@@ -105,15 +105,10 @@
#endif
} else if (PyFloat_Check(parameter)) {
rc = sqlite3_bind_double(self->st, pos, PyFloat_AsDouble(parameter));
- } else if PyString_Check(parameter) {
- string = PyString_AsString(parameter);
- rc = sqlite3_bind_text(self->st, pos, string, -1, SQLITE_TRANSIENT);
} else if PyUnicode_Check(parameter) {
- stringval = PyUnicode_AsUTF8String(parameter);
- string = PyBytes_AsString(stringval);
+ string = PyUnicode_AsString(parameter);
rc = sqlite3_bind_text(self->st, pos, string, -1, SQLITE_TRANSIENT);
- Py_DECREF(stringval);
} else if (PyObject_CheckBuffer(parameter)) {
if (PyObject_AsCharBuffer(parameter, &buffer, &buflen) == 0) {
rc = sqlite3_bind_blob(self->st, pos, buffer, buflen, SQLITE_TRANSIENT);
diff --git a/Modules/_struct.c b/Modules/_struct.c
index 84aa828..8f66a96 100644
--- a/Modules/_struct.c
+++ b/Modules/_struct.c
@@ -12,11 +12,6 @@
static PyTypeObject PyStructType;
-/* compatibility macros */
-#if (PY_VERSION_HEX < 0x02050000)
-typedef int Py_ssize_t;
-#endif
-
/* If PY_STRUCT_OVERFLOW_MASKING is defined, the struct module will wrap all input
numbers for explicit endians such that they fit in the given type, much
like explicit casting in C. A warning will be raised if the number did
@@ -411,7 +406,7 @@
if (msg == NULL)
return -1;
rval = PyErr_WarnEx(PyExc_DeprecationWarning,
- PyString_AS_STRING(msg), 2);
+ PyUnicode_AsString(msg), 2);
Py_DECREF(msg);
if (rval == 0)
return 0;
@@ -1535,37 +1530,26 @@
strings.");
static PyObject *
-s_unpack(PyObject *self, PyObject *inputstr)
+s_unpack(PyObject *self, PyObject *input)
{
- char *start;
- Py_ssize_t len;
- PyObject *args=NULL, *result;
+ Py_buffer vbuf;
+ PyObject *result;
PyStructObject *soself = (PyStructObject *)self;
+
assert(PyStruct_Check(self));
assert(soself->s_codes != NULL);
- if (inputstr == NULL)
- goto fail;
- if (PyString_Check(inputstr) &&
- PyString_GET_SIZE(inputstr) == soself->s_size) {
- return s_unpack_internal(soself, PyString_AS_STRING(inputstr));
- }
- args = PyTuple_Pack(1, inputstr);
- if (args == NULL)
+ if (PyObject_GetBuffer(input, &vbuf, PyBUF_SIMPLE) < 0)
return NULL;
- if (!PyArg_ParseTuple(args, "s#:unpack", &start, &len))
- goto fail;
- if (soself->s_size != len)
- goto fail;
- result = s_unpack_internal(soself, start);
- Py_DECREF(args);
+ if (vbuf.len != soself->s_size) {
+ PyErr_Format(StructError,
+ "unpack requires a bytes argument of length %zd",
+ soself->s_size);
+ PyObject_ReleaseBuffer(input, &vbuf);
+ return NULL;
+ }
+ result = s_unpack_internal(soself, vbuf.buf);
+ PyObject_ReleaseBuffer(input, &vbuf);
return result;
-
-fail:
- Py_XDECREF(args);
- PyErr_Format(StructError,
- "unpack requires a string argument of length %zd",
- soself->s_size);
- return NULL;
}
PyDoc_STRVAR(s_unpack_from__doc__,
@@ -1580,37 +1564,34 @@
s_unpack_from(PyObject *self, PyObject *args, PyObject *kwds)
{
static char *kwlist[] = {"buffer", "offset", 0};
-#if (PY_VERSION_HEX < 0x02050000)
- static char *fmt = "z#|i:unpack_from";
-#else
- static char *fmt = "z#|n:unpack_from";
-#endif
- Py_ssize_t buffer_len = 0, offset = 0;
- char *buffer = NULL;
+
+ PyObject *input;
+ Py_ssize_t offset = 0;
+ Py_buffer vbuf;
+ PyObject *result;
PyStructObject *soself = (PyStructObject *)self;
+
assert(PyStruct_Check(self));
assert(soself->s_codes != NULL);
- if (!PyArg_ParseTupleAndKeywords(args, kwds, fmt, kwlist,
- &buffer, &buffer_len, &offset))
+ if (!PyArg_ParseTupleAndKeywords(args, kwds,
+ "O|n:unpack_from", kwlist,
+ &input, &offset))
return NULL;
-
- if (buffer == NULL) {
- PyErr_Format(StructError,
- "unpack_from requires a buffer argument");
+ if (PyObject_GetBuffer(input, &vbuf, PyBUF_SIMPLE) < 0)
return NULL;
- }
-
if (offset < 0)
- offset += buffer_len;
-
- if (offset < 0 || (buffer_len - offset) < soself->s_size) {
+ offset += vbuf.len;
+ if (offset < 0 || vbuf.len - offset < soself->s_size) {
PyErr_Format(StructError,
"unpack_from requires a buffer of at least %zd bytes",
soself->s_size);
+ PyObject_ReleaseBuffer(input, &vbuf);
return NULL;
}
- return s_unpack_internal(soself, buffer + offset);
+ result = s_unpack_internal(soself, (char*)vbuf.buf + offset);
+ PyObject_ReleaseBuffer(input, &vbuf);
+ return result;
}
diff --git a/Modules/arraymodule.c b/Modules/arraymodule.c
index 8a24a7e..c7aeb5b 100644
--- a/Modules/arraymodule.c
+++ b/Modules/arraymodule.c
@@ -1212,14 +1212,14 @@
if (b == NULL)
return NULL;
- if (!PyBytes_Check(b)) {
+ if (!PyString_Check(b)) {
PyErr_SetString(PyExc_TypeError,
"read() didn't return bytes");
Py_DECREF(b);
return NULL;
}
- if (PyBytes_GET_SIZE(b) != nbytes) {
+ if (PyString_GET_SIZE(b) != nbytes) {
PyErr_SetString(PyExc_EOFError,
"read() didn't return enough bytes");
Py_DECREF(b);
@@ -1263,7 +1263,7 @@
PyObject *bytes, *res;
if (i*BLOCKSIZE + size > nbytes)
size = nbytes - i*BLOCKSIZE;
- bytes = PyBytes_FromStringAndSize(ptr, size);
+ bytes = PyString_FromStringAndSize(ptr, size);
if (bytes == NULL)
return NULL;
res = PyObject_CallMethod(f, "write", "O", bytes);
@@ -1395,7 +1395,7 @@
static PyObject *
array_tostring(arrayobject *self, PyObject *unused)
{
- return PyBytes_FromStringAndSize(self->ob_item,
+ return PyString_FromStringAndSize(self->ob_item,
Py_Size(self) * self->ob_descr->itemsize);
}
@@ -1861,6 +1861,7 @@
if (!(initial == NULL || PyList_Check(initial)
|| PyBytes_Check(initial)
+ || PyString_Check(initial)
|| PyTuple_Check(initial)
|| ((c=='u') && PyUnicode_Check(initial)))) {
it = PyObject_GetIter(initial);
@@ -1904,7 +1905,9 @@
}
Py_DECREF(v);
}
- } else if (initial != NULL && PyBytes_Check(initial)) {
+ }
+ else if (initial != NULL && (PyBytes_Check(initial) ||
+ PyString_Check(initial))) {
PyObject *t_initial, *v;
t_initial = PyTuple_Pack(1, initial);
if (t_initial == NULL) {
@@ -1919,7 +1922,8 @@
return NULL;
}
Py_DECREF(v);
- } else if (initial != NULL && PyUnicode_Check(initial)) {
+ }
+ else if (initial != NULL && PyUnicode_Check(initial)) {
Py_ssize_t n = PyUnicode_GET_DATA_SIZE(initial);
if (n > 0) {
arrayobject *self = (arrayobject *)a;
diff --git a/Modules/binascii.c b/Modules/binascii.c
index 3b55a35..62fc8c2 100644
--- a/Modules/binascii.c
+++ b/Modules/binascii.c
@@ -200,9 +200,9 @@
ascii_len--;
/* Allocate the buffer */
- if ( (rv=PyBytes_FromStringAndSize(NULL, bin_len)) == NULL )
+ if ( (rv=PyString_FromStringAndSize(NULL, bin_len)) == NULL )
return NULL;
- bin_data = (unsigned char *)PyBytes_AS_STRING(rv);
+ bin_data = (unsigned char *)PyString_AS_STRING(rv);
for( ; bin_len > 0 ; ascii_len--, ascii_data++ ) {
/* XXX is it really best to add NULs if there's no more data */
@@ -277,9 +277,9 @@
}
/* We're lazy and allocate to much (fixed up later) */
- if ( (rv=PyBytes_FromStringAndSize(NULL, bin_len*2+2)) == NULL )
+ if ( (rv=PyString_FromStringAndSize(NULL, bin_len*2+2)) == NULL )
return NULL;
- ascii_data = (unsigned char *)PyBytes_AS_STRING(rv);
+ ascii_data = (unsigned char *)PyString_AS_STRING(rv);
/* Store the length */
*ascii_data++ = ' ' + (bin_len & 077);
@@ -301,9 +301,9 @@
}
*ascii_data++ = '\n'; /* Append a courtesy newline */
- if (PyBytes_Resize(rv,
+ if (_PyString_Resize(&rv,
(ascii_data -
- (unsigned char *)PyBytes_AS_STRING(rv))) < 0) {
+ (unsigned char *)PyString_AS_STRING(rv))) < 0) {
Py_DECREF(rv);
rv = NULL;
}
@@ -355,9 +355,9 @@
bin_len = ((ascii_len+3)/4)*3; /* Upper bound, corrected later */
/* Allocate the buffer */
- if ( (rv=PyBytes_FromStringAndSize(NULL, bin_len)) == NULL )
+ if ( (rv=PyString_FromStringAndSize(NULL, bin_len)) == NULL )
return NULL;
- bin_data = (unsigned char *)PyBytes_AS_STRING(rv);
+ bin_data = (unsigned char *)PyString_AS_STRING(rv);
bin_len = 0;
for( ; ascii_len > 0; ascii_len--, ascii_data++) {
@@ -416,17 +416,17 @@
/* And set string size correctly. If the result string is empty
** (because the input was all invalid) return the shared empty
- ** string instead; PyBytes_Resize() won't do this for us.
+ ** string instead; _PyString_Resize() won't do this for us.
*/
if (bin_len > 0) {
- if (PyBytes_Resize(rv, bin_len) < 0) {
+ if (_PyString_Resize(&rv, bin_len) < 0) {
Py_DECREF(rv);
rv = NULL;
}
}
else {
Py_DECREF(rv);
- rv = PyBytes_FromStringAndSize("", 0);
+ rv = PyString_FromStringAndSize("", 0);
}
return rv;
}
@@ -453,9 +453,9 @@
/* We're lazy and allocate too much (fixed up later).
"+3" leaves room for up to two pad characters and a trailing
newline. Note that 'b' gets encoded as 'Yg==\n' (1 in, 5 out). */
- if ( (rv=PyBytes_FromStringAndSize(NULL, bin_len*2 + 3)) == NULL )
+ if ( (rv=PyString_FromStringAndSize(NULL, bin_len*2 + 3)) == NULL )
return NULL;
- ascii_data = (unsigned char *)PyBytes_AS_STRING(rv);
+ ascii_data = (unsigned char *)PyString_AS_STRING(rv);
for( ; bin_len > 0 ; bin_len--, bin_data++ ) {
/* Shift the data into our buffer */
@@ -479,9 +479,9 @@
}
*ascii_data++ = '\n'; /* Append a courtesy newline */
- if (PyBytes_Resize(rv,
+ if (_PyString_Resize(&rv,
(ascii_data -
- (unsigned char *)PyBytes_AS_STRING(rv))) < 0) {
+ (unsigned char *)PyString_AS_STRING(rv))) < 0) {
Py_DECREF(rv);
rv = NULL;
}
@@ -507,9 +507,9 @@
/* Allocate a string that is too big (fixed later)
Add two to the initial length to prevent interning which
would preclude subsequent resizing. */
- if ( (rv=PyBytes_FromStringAndSize(NULL, len+2)) == NULL )
+ if ( (rv=PyString_FromStringAndSize(NULL, len+2)) == NULL )
return NULL;
- bin_data = (unsigned char *)PyBytes_AS_STRING(rv);
+ bin_data = (unsigned char *)PyString_AS_STRING(rv);
for( ; len > 0 ; len--, ascii_data++ ) {
/* Get the byte and look it up */
@@ -543,9 +543,9 @@
Py_DECREF(rv);
return NULL;
}
- if (PyBytes_Resize(rv,
+ if (_PyString_Resize(&rv,
(bin_data -
- (unsigned char *)PyBytes_AS_STRING(rv))) < 0) {
+ (unsigned char *)PyString_AS_STRING(rv))) < 0) {
Py_DECREF(rv);
rv = NULL;
}
@@ -572,9 +572,9 @@
return NULL;
/* Worst case: output is twice as big as input (fixed later) */
- if ( (rv=PyBytes_FromStringAndSize(NULL, len*2+2)) == NULL )
+ if ( (rv=PyString_FromStringAndSize(NULL, len*2+2)) == NULL )
return NULL;
- out_data = (unsigned char *)PyBytes_AS_STRING(rv);
+ out_data = (unsigned char *)PyString_AS_STRING(rv);
for( in=0; in<len; in++) {
ch = in_data[in];
@@ -600,9 +600,9 @@
}
}
}
- if (PyBytes_Resize(rv,
+ if (_PyString_Resize(&rv,
(out_data -
- (unsigned char *)PyBytes_AS_STRING(rv))) < 0) {
+ (unsigned char *)PyString_AS_STRING(rv))) < 0) {
Py_DECREF(rv);
rv = NULL;
}
@@ -625,9 +625,9 @@
return NULL;
/* Allocate a buffer that is at least large enough */
- if ( (rv=PyBytes_FromStringAndSize(NULL, len*2+2)) == NULL )
+ if ( (rv=PyString_FromStringAndSize(NULL, len*2+2)) == NULL )
return NULL;
- ascii_data = (unsigned char *)PyBytes_AS_STRING(rv);
+ ascii_data = (unsigned char *)PyString_AS_STRING(rv);
for( ; len > 0 ; len--, bin_data++ ) {
/* Shift into our buffer, and output any 6bits ready */
@@ -644,9 +644,9 @@
leftchar <<= (6-leftbits);
*ascii_data++ = table_b2a_hqx[leftchar & 0x3f];
}
- if (PyBytes_Resize(rv,
+ if (_PyString_Resize(&rv,
(ascii_data -
- (unsigned char *)PyBytes_AS_STRING(rv))) < 0) {
+ (unsigned char *)PyString_AS_STRING(rv))) < 0) {
Py_DECREF(rv);
rv = NULL;
}
@@ -668,14 +668,14 @@
/* Empty string is a special case */
if ( in_len == 0 )
- return PyBytes_FromStringAndSize("", 0);
+ return PyString_FromStringAndSize("", 0);
/* Allocate a buffer of reasonable size. Resized when needed */
out_len = in_len*2;
- if ( (rv=PyBytes_FromStringAndSize(NULL, out_len)) == NULL )
+ if ( (rv=PyString_FromStringAndSize(NULL, out_len)) == NULL )
return NULL;
out_len_left = out_len;
- out_data = (unsigned char *)PyBytes_AS_STRING(rv);
+ out_data = (unsigned char *)PyString_AS_STRING(rv);
/*
** We need two macros here to get/put bytes and handle
@@ -694,9 +694,9 @@
#define OUTBYTE(b) \
do { \
if ( --out_len_left < 0 ) { \
- if (PyBytes_Resize(rv, 2*out_len) < 0) \
+ if (_PyString_Resize(&rv, 2*out_len) < 0) \
{ Py_DECREF(rv); return NULL; } \
- out_data = (unsigned char *)PyBytes_AS_STRING(rv) \
+ out_data = (unsigned char *)PyString_AS_STRING(rv) \
+ out_len; \
out_len_left = out_len-1; \
out_len = out_len * 2; \
@@ -744,9 +744,9 @@
OUTBYTE(in_byte);
}
}
- if (PyBytes_Resize(rv,
+ if (_PyString_Resize(&rv,
(out_data -
- (unsigned char *)PyBytes_AS_STRING(rv))) < 0) {
+ (unsigned char *)PyString_AS_STRING(rv))) < 0) {
Py_DECREF(rv);
rv = NULL;
}
@@ -940,10 +940,10 @@
if (!PyArg_ParseTuple(args, "s#:b2a_hex", &argbuf, &arglen))
return NULL;
- retval = PyBytes_FromStringAndSize(NULL, arglen*2);
+ retval = PyString_FromStringAndSize(NULL, arglen*2);
if (!retval)
return NULL;
- retbuf = PyBytes_AS_STRING(retval);
+ retbuf = PyString_AS_STRING(retval);
/* make hex version of string, taken from shamodule.c */
for (i=j=0; i < arglen; i++) {
@@ -1000,10 +1000,10 @@
return NULL;
}
- retval = PyBytes_FromStringAndSize(NULL, (arglen/2));
+ retval = PyString_FromStringAndSize(NULL, (arglen/2));
if (!retval)
return NULL;
- retbuf = PyBytes_AS_STRING(retval);
+ retbuf = PyString_AS_STRING(retval);
for (i=j=0; i < arglen; i += 2) {
int top = to_int(Py_CHARMASK(argbuf[i]));
@@ -1115,7 +1115,7 @@
out++;
}
}
- if ((rv = PyBytes_FromStringAndSize((char *)odata, out)) == NULL) {
+ if ((rv = PyString_FromStringAndSize((char *)odata, out)) == NULL) {
PyMem_Free(odata);
return NULL;
}
@@ -1315,7 +1315,7 @@
}
}
}
- if ((rv = PyBytes_FromStringAndSize((char *)odata, out)) == NULL) {
+ if ((rv = PyString_FromStringAndSize((char *)odata, out)) == NULL) {
PyMem_Free(odata);
return NULL;
}
diff --git a/Modules/bz2module.c b/Modules/bz2module.c
index 15b6e44..e0fbb57 100644
--- a/Modules/bz2module.c
+++ b/Modules/bz2module.c
@@ -34,7 +34,7 @@
#error "Large file support, but neither off_t nor fpos_t is large enough."
#endif
-#define BUF(v) PyBytes_AS_STRING(v)
+#define BUF(v) PyString_AS_STRING(v)
#define MODE_CLOSED 0
#define MODE_READ 1
@@ -232,7 +232,7 @@
int bytes_read;
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;
@@ -272,8 +272,7 @@
Py_DECREF(v);
return NULL;
}
- if (PyBytes_Resize(v, total_v_size) < 0) {
- Py_DECREF(v);
+ if (_PyString_Resize(&v, total_v_size) < 0) {
return NULL;
}
buf = BUF(v) + used_v_size;
@@ -282,8 +281,7 @@
used_v_size = buf - BUF(v);
if (used_v_size != total_v_size) {
- if (PyBytes_Resize(v, used_v_size) < 0) {
- Py_DECREF(v);
+ if (_PyString_Resize(&v, used_v_size) < 0) {
v = NULL;
}
}
@@ -340,10 +338,10 @@
/* This is a hacked version of Python's
* fileobject.c:readahead_get_line_skip(). */
-static PyBytesObject *
+static PyStringObject *
Util_ReadAheadGetLineSkip(BZ2FileObject *f, int skip, int bufsize)
{
- PyBytesObject* s;
+ PyStringObject* s;
char *bufptr;
char *buf;
int len;
@@ -354,17 +352,17 @@
len = f->f_bufend - f->f_bufptr;
if (len == 0)
- return (PyBytesObject *)
- PyBytes_FromStringAndSize(NULL, skip);
+ return (PyStringObject *)
+ PyString_FromStringAndSize(NULL, skip);
bufptr = 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)
Util_DropReadAhead(f);
@@ -378,7 +376,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;
@@ -411,7 +409,7 @@
case MODE_READ:
break;
case MODE_READ_EOF:
- ret = PyBytes_FromStringAndSize("", 0);
+ ret = PyString_FromStringAndSize("", 0);
goto cleanup;
case MODE_CLOSED:
PyErr_SetString(PyExc_ValueError,
@@ -433,7 +431,7 @@
"more than a Python string can hold");
goto cleanup;
}
- ret = PyBytes_FromStringAndSize((char *)NULL, buffersize);
+ ret = PyString_FromStringAndSize((char *)NULL, buffersize);
if (ret == NULL || buffersize == 0)
goto cleanup;
bytesread = 0;
@@ -458,8 +456,7 @@
}
if (bytesrequested < 0) {
buffersize = Util_NewBufferSize(buffersize);
- if (PyBytes_Resize(ret, buffersize) < 0) {
- Py_DECREF(ret);
+ if (_PyString_Resize(&ret, buffersize) < 0) {
ret = NULL;
goto cleanup;
}
@@ -468,8 +465,7 @@
}
}
if (bytesread != buffersize) {
- if (PyBytes_Resize(ret, bytesread) < 0) {
- Py_DECREF(ret);
+ if (_PyString_Resize(&ret, bytesread) < 0) {
ret = NULL;
}
}
@@ -502,7 +498,7 @@
case MODE_READ:
break;
case MODE_READ_EOF:
- ret = PyBytes_FromStringAndSize("", 0);
+ ret = PyString_FromStringAndSize("", 0);
goto cleanup;
case MODE_CLOSED:
PyErr_SetString(PyExc_ValueError,
@@ -515,7 +511,7 @@
}
if (sizehint == 0)
- ret = PyBytes_FromStringAndSize("", 0);
+ ret = PyString_FromStringAndSize("", 0);
else
ret = Util_GetLine(self, (sizehint < 0) ? 0 : sizehint);
@@ -608,21 +604,20 @@
}
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){
- Py_DECREF(big_buffer);
+ if (_PyString_Resize(&big_buffer, buffersize) < 0){
big_buffer = NULL;
goto error;
}
- buffer = PyBytes_AS_STRING(big_buffer);
+ buffer = PyString_AS_STRING(big_buffer);
}
continue;
}
@@ -631,7 +626,7 @@
while (p != NULL) {
/* 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);
@@ -654,21 +649,18 @@
}
if (nfilled != 0) {
/* Partial last line */
- line = PyBytes_FromStringAndSize(buffer, nfilled);
+ line = PyString_FromStringAndSize(buffer, nfilled);
if (line == NULL)
goto error;
if (sizehint > 0) {
/* Need to complete the last line */
PyObject *rest = Util_GetLine(self, 0);
- PyObject *new;
if (rest == NULL) {
Py_DECREF(line);
goto error;
}
- new = PyBytes_Concat(line, rest);
- Py_DECREF(line);
+ PyString_Concat(&line, rest);
Py_DECREF(rest);
- line = new;
if (line == NULL)
goto error;
}
@@ -702,7 +694,7 @@
int len;
int bzerror;
- if (!PyArg_ParseTuple(args, "s#:write", &buf, &len))
+ if (!PyArg_ParseTuple(args, "y#:write", &buf, &len))
return NULL;
ACQUIRE_LOCK(self);
@@ -820,7 +812,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;
Py_ssize_t len;
if (PyObject_AsCharBuffer(v, &buffer, &len)) {
@@ -831,7 +823,7 @@
"bytes objects");
goto error;
}
- line = PyBytes_FromStringAndSize(buffer,
+ line = PyString_FromStringAndSize(buffer,
len);
if (line == NULL)
goto error;
@@ -845,9 +837,9 @@
Py_BEGIN_ALLOW_THREADS
for (i = 0; i < j; i++) {
line = PyList_GET_ITEM(list, i);
- len = PyBytes_GET_SIZE(line);
+ len = PyString_GET_SIZE(line);
BZ2_bzWrite (&bzerror, self->fp,
- PyBytes_AS_STRING(line), len);
+ PyString_AS_STRING(line), len);
if (bzerror != BZ_OK) {
Py_BLOCK_THREADS
Util_CatchBZ2Error(bzerror);
@@ -1269,7 +1261,7 @@
static PyObject *
BZ2File_iternext(BZ2FileObject *self)
{
- PyBytesObject* ret;
+ PyStringObject* ret;
ACQUIRE_LOCK(self);
if (self->mode == MODE_CLOSED) {
PyErr_SetString(PyExc_ValueError,
@@ -1278,7 +1270,7 @@
}
ret = Util_ReadAheadGetLineSkip(self, 0, READAHEAD_BUFSIZE);
RELEASE_LOCK(self);
- if (ret == NULL || PyBytes_GET_SIZE(ret) == 0) {
+ if (ret == NULL || PyString_GET_SIZE(ret) == 0) {
Py_XDECREF(ret);
return NULL;
}
@@ -1367,11 +1359,11 @@
bz_stream *bzs = &self->bzs;
int bzerror;
- if (!PyArg_ParseTuple(args, "s#:compress", &data, &datasize))
+ if (!PyArg_ParseTuple(args, "y#:compress", &data, &datasize))
return NULL;
if (datasize == 0)
- return PyBytes_FromStringAndSize("", 0);
+ return PyString_FromStringAndSize("", 0);
ACQUIRE_LOCK(self);
if (!self->running) {
@@ -1380,7 +1372,7 @@
goto error;
}
- ret = PyBytes_FromStringAndSize(NULL, bufsize);
+ ret = PyString_FromStringAndSize(NULL, bufsize);
if (!ret)
goto error;
@@ -1403,7 +1395,7 @@
break; /* no more input data */
if (bzs->avail_out == 0) {
bufsize = Util_NewBufferSize(bufsize);
- if (PyBytes_Resize(ret, bufsize) < 0) {
+ if (_PyString_Resize(&ret, bufsize) < 0) {
BZ2_bzCompressEnd(bzs);
goto error;
}
@@ -1413,7 +1405,7 @@
}
}
- if (PyBytes_Resize(ret,
+ if (_PyString_Resize(&ret,
(Py_ssize_t)(BZS_TOTAL_OUT(bzs) - totalout)) < 0)
goto error;
@@ -1450,7 +1442,7 @@
}
self->running = 0;
- ret = PyBytes_FromStringAndSize(NULL, bufsize);
+ ret = PyString_FromStringAndSize(NULL, bufsize);
if (!ret)
goto error;
@@ -1471,7 +1463,7 @@
}
if (bzs->avail_out == 0) {
bufsize = Util_NewBufferSize(bufsize);
- if (PyBytes_Resize(ret, bufsize) < 0)
+ if (_PyString_Resize(&ret, bufsize) < 0)
goto error;
bzs->next_out = BUF(ret);
bzs->next_out = BUF(ret) + (BZS_TOTAL_OUT(bzs)
@@ -1481,7 +1473,7 @@
}
if (bzs->avail_out != 0) {
- if (PyBytes_Resize(ret,
+ if (_PyString_Resize(&ret,
(Py_ssize_t)(BZS_TOTAL_OUT(bzs) - totalout)) < 0)
goto error;
}
@@ -1656,7 +1648,7 @@
bz_stream *bzs = &self->bzs;
int bzerror;
- if (!PyArg_ParseTuple(args, "s#:decompress", &data, &datasize))
+ if (!PyArg_ParseTuple(args, "y#:decompress", &data, &datasize))
return NULL;
ACQUIRE_LOCK(self);
@@ -1666,7 +1658,7 @@
goto error;
}
- ret = PyBytes_FromStringAndSize(NULL, bufsize);
+ ret = PyString_FromStringAndSize(NULL, bufsize);
if (!ret)
goto error;
@@ -1685,7 +1677,7 @@
if (bzs->avail_in != 0) {
Py_DECREF(self->unused_data);
self->unused_data =
- PyBytes_FromStringAndSize(bzs->next_in,
+ PyString_FromStringAndSize(bzs->next_in,
bzs->avail_in);
}
self->running = 0;
@@ -1699,7 +1691,7 @@
break; /* no more input data */
if (bzs->avail_out == 0) {
bufsize = Util_NewBufferSize(bufsize);
- if (PyBytes_Resize(ret, bufsize) < 0) {
+ if (_PyString_Resize(&ret, bufsize) < 0) {
BZ2_bzDecompressEnd(bzs);
goto error;
}
@@ -1711,7 +1703,7 @@
}
if (bzs->avail_out != 0) {
- if (PyBytes_Resize(ret,
+ if (_PyString_Resize(&ret,
(Py_ssize_t)(BZS_TOTAL_OUT(bzs) - totalout)) < 0)
goto error;
}
@@ -1750,7 +1742,7 @@
}
#endif
- self->unused_data = PyBytes_FromStringAndSize("", 0);
+ self->unused_data = PyString_FromStringAndSize("", 0);
if (!self->unused_data)
goto error;
@@ -1868,7 +1860,7 @@
int bzerror;
static char *kwlist[] = {"data", "compresslevel", 0};
- if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|i",
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs, "y#|i",
kwlist, &data, &datasize,
&compresslevel))
return NULL;
@@ -1883,7 +1875,7 @@
* data in one shot. We will check it later anyway. */
bufsize = datasize + (datasize/100+1) + 600;
- ret = PyBytes_FromStringAndSize(NULL, bufsize);
+ ret = PyString_FromStringAndSize(NULL, bufsize);
if (!ret)
return NULL;
@@ -1915,9 +1907,8 @@
}
if (bzs->avail_out == 0) {
bufsize = Util_NewBufferSize(bufsize);
- if (PyBytes_Resize(ret, bufsize) < 0) {
+ if (_PyString_Resize(&ret, bufsize) < 0) {
BZ2_bzCompressEnd(bzs);
- Py_DECREF(ret);
return NULL;
}
bzs->next_out = BUF(ret) + BZS_TOTAL_OUT(bzs);
@@ -1926,8 +1917,7 @@
}
if (bzs->avail_out != 0) {
- if (PyBytes_Resize(ret, (Py_ssize_t)BZS_TOTAL_OUT(bzs)) < 0) {
- Py_DECREF(ret);
+ if (_PyString_Resize(&ret, (Py_ssize_t)BZS_TOTAL_OUT(bzs)) < 0) {
ret = NULL;
}
}
@@ -1954,13 +1944,13 @@
bz_stream *bzs = &_bzs;
int bzerror;
- if (!PyArg_ParseTuple(args, "s#:decompress", &data, &datasize))
+ if (!PyArg_ParseTuple(args, "y#:decompress", &data, &datasize))
return NULL;
if (datasize == 0)
- return PyBytes_FromStringAndSize("", 0);
+ return PyString_FromStringAndSize("", 0);
- ret = PyBytes_FromStringAndSize(NULL, bufsize);
+ ret = PyString_FromStringAndSize(NULL, bufsize);
if (!ret)
return NULL;
@@ -1999,9 +1989,8 @@
}
if (bzs->avail_out == 0) {
bufsize = Util_NewBufferSize(bufsize);
- if (PyBytes_Resize(ret, bufsize) < 0) {
+ if (_PyString_Resize(&ret, bufsize) < 0) {
BZ2_bzDecompressEnd(bzs);
- Py_DECREF(ret);
return NULL;
}
bzs->next_out = BUF(ret) + BZS_TOTAL_OUT(bzs);
@@ -2010,8 +1999,7 @@
}
if (bzs->avail_out != 0) {
- if (PyBytes_Resize(ret, (Py_ssize_t)BZS_TOTAL_OUT(bzs)) < 0) {
- Py_DECREF(ret);
+ if (_PyString_Resize(&ret, (Py_ssize_t)BZS_TOTAL_OUT(bzs)) < 0) {
ret = NULL;
}
}
diff --git a/Modules/cjkcodecs/multibytecodec.c b/Modules/cjkcodecs/multibytecodec.c
index 7ab3145..701b112 100644
--- a/Modules/cjkcodecs/multibytecodec.c
+++ b/Modules/cjkcodecs/multibytecodec.c
@@ -175,15 +175,15 @@
Py_ssize_t orgpos, orgsize;
orgpos = (Py_ssize_t)((char *)buf->outbuf -
- PyBytes_AS_STRING(buf->outobj));
- orgsize = PyBytes_GET_SIZE(buf->outobj);
- if (PyBytes_Resize(buf->outobj, orgsize + (
+ PyString_AS_STRING(buf->outobj));
+ orgsize = PyString_GET_SIZE(buf->outobj);
+ if (_PyString_Resize(&buf->outobj, orgsize + (
esize < (orgsize >> 1) ? (orgsize >> 1) | 1 : esize)) == -1)
return -1;
- buf->outbuf = (unsigned char *)PyBytes_AS_STRING(buf->outobj) +orgpos;
- buf->outbuf_end = (unsigned char *)PyBytes_AS_STRING(buf->outobj)
- + PyBytes_GET_SIZE(buf->outobj);
+ buf->outbuf = (unsigned char *)PyString_AS_STRING(buf->outobj) +orgpos;
+ buf->outbuf_end = (unsigned char *)PyString_AS_STRING(buf->outobj)
+ + PyString_GET_SIZE(buf->outobj);
return 0;
}
@@ -330,11 +330,11 @@
goto errorexit;
}
- assert(PyBytes_Check(retstr));
- retstrsize = PyBytes_GET_SIZE(retstr);
+ assert(PyString_Check(retstr));
+ retstrsize = PyString_GET_SIZE(retstr);
REQUIRE_ENCODEBUFFER(buf, retstrsize);
- memcpy(buf->outbuf, PyBytes_AS_STRING(retstr), retstrsize);
+ memcpy(buf->outbuf, PyString_AS_STRING(retstr), retstrsize);
buf->outbuf += retstrsize;
newpos = PyInt_AsSsize_t(PyTuple_GET_ITEM(retobj, 1));
@@ -476,16 +476,16 @@
Py_ssize_t finalsize, r = 0;
if (datalen == 0)
- return PyBytes_FromStringAndSize(NULL, 0);
+ return PyString_FromStringAndSize(NULL, 0);
buf.excobj = NULL;
buf.inbuf = buf.inbuf_top = *data;
buf.inbuf_end = buf.inbuf_top + datalen;
- buf.outobj = PyBytes_FromStringAndSize(NULL, datalen * 2 + 16);
+ buf.outobj = PyString_FromStringAndSize(NULL, datalen * 2 + 16);
if (buf.outobj == NULL)
goto errorexit;
- buf.outbuf = (unsigned char *)PyBytes_AS_STRING(buf.outobj);
- buf.outbuf_end = buf.outbuf + PyBytes_GET_SIZE(buf.outobj);
+ buf.outbuf = (unsigned char *)PyString_AS_STRING(buf.outobj);
+ buf.outbuf_end = buf.outbuf + PyString_GET_SIZE(buf.outobj);
while (buf.inbuf < buf.inbuf_end) {
Py_ssize_t inleft, outleft;
@@ -520,10 +520,10 @@
}
finalsize = (Py_ssize_t)((char *)buf.outbuf -
- PyBytes_AS_STRING(buf.outobj));
+ PyString_AS_STRING(buf.outobj));
- if (finalsize != PyBytes_GET_SIZE(buf.outobj))
- if (PyBytes_Resize(buf.outobj, finalsize) == -1)
+ if (finalsize != PyString_GET_SIZE(buf.outobj))
+ if (_PyString_Resize(&buf.outobj, finalsize) == -1)
goto errorexit;
Py_XDECREF(buf.excobj);
@@ -1611,8 +1611,8 @@
if (pwrt == NULL)
return NULL;
- assert(PyBytes_Check(pwrt));
- if (PyBytes_Size(pwrt) > 0) {
+ assert(PyString_Check(pwrt));
+ if (PyString_Size(pwrt) > 0) {
PyObject *wr;
wr = PyObject_CallMethod(self->stream, "write", "O", pwrt);
if (wr == NULL) {
diff --git a/Modules/datetimemodule.c b/Modules/datetimemodule.c
index 6f13a85..6b2cd5a 100644
--- a/Modules/datetimemodule.c
+++ b/Modules/datetimemodule.c
@@ -1133,7 +1133,7 @@
{
PyObject *temp;
PyObject *tzinfo = get_tzinfo_member(object);
- PyObject *Zreplacement = PyBytes_FromStringAndSize("", 0);
+ PyObject *Zreplacement = PyUnicode_FromStringAndSize(NULL, 0);
if (Zreplacement == NULL)
return NULL;
if (tzinfo == Py_None || tzinfo == NULL)
@@ -1158,14 +1158,7 @@
Py_DECREF(temp);
if (Zreplacement == NULL)
return NULL;
- if (PyUnicode_Check(Zreplacement)) {
- PyObject *tmp = PyUnicode_AsUTF8String(Zreplacement);
- Py_DECREF(Zreplacement);
- if (tmp == NULL)
- return NULL;
- Zreplacement = tmp;
- }
- if (!PyBytes_Check(Zreplacement)) {
+ if (!PyUnicode_Check(Zreplacement)) {
PyErr_SetString(PyExc_TypeError,
"tzname.replace() did not return a string");
goto Error;
@@ -1297,9 +1290,10 @@
goto Done;
}
assert(Zreplacement != NULL);
- assert(PyBytes_Check(Zreplacement));
- ptoappend = PyBytes_AS_STRING(Zreplacement);
- ntoappend = PyBytes_GET_SIZE(Zreplacement);
+ assert(PyUnicode_Check(Zreplacement));
+ ptoappend = PyUnicode_AsStringAndSize(Zreplacement,
+ &ntoappend);
+ ntoappend = Py_Size(Zreplacement);
}
else {
/* percent followed by neither z nor Z */
@@ -3194,7 +3188,7 @@
PyObject *tuple;
static char *keywords[] = {"format", NULL};
- if (! PyArg_ParseTupleAndKeywords(args, kw, "S:strftime", keywords,
+ if (! PyArg_ParseTupleAndKeywords(args, kw, "U:strftime", keywords,
&format))
return NULL;
diff --git a/Modules/dbmmodule.c b/Modules/dbmmodule.c
index 5660882..6b05fad 100644
--- a/Modules/dbmmodule.c
+++ b/Modules/dbmmodule.c
@@ -219,14 +219,14 @@
if (arg == NULL)
return -1;
}
- if (!PyBytes_Check(arg)) {
+ if (!PyString_Check(arg)) {
PyErr_Format(PyExc_TypeError,
"dbm key must be string, not %.100s",
arg->ob_type->tp_name);
return -1;
}
- key.dptr = PyBytes_AS_STRING(arg);
- key.dsize = PyBytes_GET_SIZE(arg);
+ key.dptr = PyString_AS_STRING(arg);
+ key.dsize = PyString_GET_SIZE(arg);
val = dbm_fetch(dp->di_dbm, key);
return val.dptr != NULL;
}
diff --git a/Modules/gdbmmodule.c b/Modules/gdbmmodule.c
index 5ee9c9a..86f98c0 100644
--- a/Modules/gdbmmodule.c
+++ b/Modules/gdbmmodule.c
@@ -251,14 +251,14 @@
"GDBM object has already been closed");
return -1;
}
- if (!PyBytes_Check(arg)) {
+ if (!PyString_Check(arg)) {
PyErr_Format(PyExc_TypeError,
"gdbm key must be bytes, not %.100s",
arg->ob_type->tp_name);
return -1;
}
- key.dptr = PyBytes_AsString(arg);
- key.dsize = PyBytes_Size(arg);
+ key.dptr = PyString_AS_STRING(arg);
+ key.dsize = PyString_GET_SIZE(arg);
return gdbm_exists(dp->di_dbm, key);
}
diff --git a/Modules/main.c b/Modules/main.c
index b15f1714..ee4a1b8 100644
--- a/Modules/main.c
+++ b/Modules/main.c
@@ -44,7 +44,7 @@
static int orig_argc;
/* command line options */
-#define BASE_OPTS "c:dEhim:OStuvVW:xX?"
+#define BASE_OPTS "bc:dEhim:OStuvVW:xX?"
#define PROGRAM_OPTS BASE_OPTS
@@ -55,32 +55,34 @@
/* Long usage message, split into parts < 512 bytes */
static char *usage_1 = "\
Options and arguments (and corresponding environment variables):\n\
+-b : issue warnings about str(bytes_instance), str(buffer_instance)\n\
+ and comparing bytes/buffer with str. (-bb: issue errors)\n\
-c cmd : program passed in as string (terminates option list)\n\
-d : debug output from parser; also PYTHONDEBUG=x\n\
-E : ignore environment variables (such as PYTHONPATH)\n\
-h : print this help message and exit (also --help)\n\
--i : inspect interactively after running script; forces a prompt even\n\
- if stdin does not appear to be a terminal; also PYTHONINSPECT=x\n\
";
static char *usage_2 = "\
+-i : inspect interactively after running script; forces a prompt even\n\
+ if stdin does not appear to be a terminal; also PYTHONINSPECT=x\n\
-m mod : run library module as a script (terminates option list)\n\
-O : optimize generated bytecode slightly; also PYTHONOPTIMIZE=x\n\
-OO : remove doc-strings in addition to the -O optimizations\n\
-S : don't imply 'import site' on initialization\n\
-t : issue warnings about inconsistent tab usage (-tt: issue errors)\n\
--u : unbuffered binary stdout and stderr; also PYTHONUNBUFFERED=x\n\
";
static char *usage_3 = "\
+-u : unbuffered binary stdout and stderr; also PYTHONUNBUFFERED=x\n\
see man page for details on internal buffering relating to '-u'\n\
-v : verbose (trace import statements); also PYTHONVERBOSE=x\n\
can be supplied multiple times to increase verbosity\n\
-V : print the Python version number and exit (also --version)\n\
-W arg : warning control; arg is action:message:category:module:lineno\n\
-x : skip first line of source, allowing use of non-Unix forms of #!cmd\n\
-file : program read from script file\n\
-- : program read from stdin (default; interactive mode if a tty)\n\
";
static char *usage_4 = "\
+file : program read from script file\n\
+- : program read from stdin (default; interactive mode if a tty)\n\
arg ...: arguments passed to program in sys.argv[1:]\n\n\
Other environment variables:\n\
PYTHONSTARTUP: file executed on interactive startup (no default)\n\
@@ -252,6 +254,9 @@
}
switch (c) {
+ case 'b':
+ Py_BytesWarningFlag++;
+ break;
case 'd':
Py_DebugFlag++;
diff --git a/Modules/md5module.c b/Modules/md5module.c
index 26f0e4c..c5770b3 100644
--- a/Modules/md5module.c
+++ b/Modules/md5module.c
@@ -363,7 +363,7 @@
temp = self->hash_state;
md5_done(&temp, digest);
- return PyBytes_FromStringAndSize((const char *)digest, MD5_DIGESTSIZE);
+ return PyString_FromStringAndSize((const char *)digest, MD5_DIGESTSIZE);
}
PyDoc_STRVAR(MD5_hexdigest__doc__,
diff --git a/Modules/mmapmodule.c b/Modules/mmapmodule.c
index e5d7711..1a58f3d 100644
--- a/Modules/mmapmodule.c
+++ b/Modules/mmapmodule.c
@@ -305,7 +305,7 @@
return 0;
}
if ((self->access == ACCESS_WRITE) || (self->access == ACCESS_DEFAULT))
- return 1;
+ return 1;
PyErr_Format(PyExc_TypeError,
"mmap can't resize a readonly or copy-on-write memory map.");
return 0;
@@ -621,10 +621,10 @@
/* Functions for treating an mmap'ed file as a buffer */
static int
-mmap_buffer_getbuf(mmap_object *self, Py_buffer *view, int flags)
+mmap_buffer_getbuf(mmap_object *self, Py_buffer *view, int flags)
{
CHECK_VALID(-1);
- if (PyBuffer_FillInfo(view, self->data, self->size,
+ if (PyBuffer_FillInfo(view, self->data, self->size,
(self->access == ACCESS_READ), flags) < 0)
return -1;
self->exports++;
@@ -676,7 +676,7 @@
"mmap index out of range");
return NULL;
}
- return PyBytes_FromStringAndSize(self->data + i, 1);
+ return PyInt_FromLong(Py_CHARMASK(self->data[i]));
}
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelen;
@@ -685,12 +685,12 @@
&start, &stop, &step, &slicelen) < 0) {
return NULL;
}
-
+
if (slicelen <= 0)
- return PyBytes_FromStringAndSize("", 0);
+ return PyString_FromStringAndSize("", 0);
else if (step == 1)
- return PyBytes_FromStringAndSize(self->data + start,
- slicelen);
+ return PyString_FromStringAndSize(self->data + start,
+ slicelen);
else {
char *result_buf = (char *)PyMem_Malloc(slicelen);
Py_ssize_t cur, i;
@@ -702,8 +702,8 @@
cur += step, i++) {
result_buf[i] = self->data[cur];
}
- result = PyBytes_FromStringAndSize(result_buf,
- slicelen);
+ result = PyString_FromStringAndSize(result_buf,
+ slicelen);
PyMem_Free(result_buf);
return result;
}
@@ -765,9 +765,12 @@
{
CHECK_VALID(-1);
+ if (!is_writable(self))
+ return -1;
+
if (PyIndex_Check(item)) {
Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
- const char *buf;
+ Py_ssize_t v;
if (i == -1 && PyErr_Occurred())
return -1;
@@ -775,28 +778,35 @@
i += self->size;
if (i < 0 || (size_t)i > self->size) {
PyErr_SetString(PyExc_IndexError,
- "mmap index out of range");
+ "mmap index out of range");
return -1;
}
if (value == NULL) {
PyErr_SetString(PyExc_TypeError,
- "mmap object doesn't support item deletion");
+ "mmap doesn't support item deletion");
return -1;
}
- if (!PyBytes_Check(value) || PyBytes_Size(value) != 1) {
- PyErr_SetString(PyExc_IndexError,
- "mmap assignment must be length-1 bytes()");
+ if (!PyIndex_Check(value)) {
+ PyErr_SetString(PyExc_TypeError,
+ "mmap item value must be an int");
return -1;
}
- if (!is_writable(self))
+ v = PyNumber_AsSsize_t(value, PyExc_TypeError);
+ if (v == -1 && PyErr_Occurred())
return -1;
- buf = PyBytes_AsString(value);
- self->data[i] = buf[0];
+ if (v < 0 || v > 255) {
+ PyErr_SetString(PyExc_ValueError,
+ "mmap item value must be "
+ "in range(0, 256)");
+ return -1;
+ }
+ self->data[i] = v;
return 0;
}
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelen;
-
+ Py_buffer vbuf;
+
if (PySlice_GetIndicesEx((PySliceObject *)item,
self->size, &start, &stop,
&step, &slicelen) < 0) {
@@ -807,41 +817,32 @@
"mmap object doesn't support slice deletion");
return -1;
}
- if (!PyBytes_Check(value)) {
- PyErr_SetString(PyExc_IndexError,
- "mmap slice assignment must be bytes");
+ if (PyObject_GetBuffer(value, &vbuf, PyBUF_SIMPLE) < 0)
return -1;
- }
- if (PyBytes_Size(value) != slicelen) {
+ if (vbuf.len != slicelen) {
PyErr_SetString(PyExc_IndexError,
"mmap slice assignment is wrong size");
+ PyObject_ReleaseBuffer(value, &vbuf);
return -1;
}
- if (!is_writable(self))
- return -1;
- if (slicelen == 0)
- return 0;
+ if (slicelen == 0) {
+ }
else if (step == 1) {
- const char *buf = PyBytes_AsString(value);
-
- if (buf == NULL)
- return -1;
- memcpy(self->data + start, buf, slicelen);
- return 0;
+ memcpy(self->data + start, vbuf.buf, slicelen);
}
else {
Py_ssize_t cur, i;
- const char *buf = PyBytes_AsString(value);
-
- if (buf == NULL)
- return -1;
- for (cur = start, i = 0; i < slicelen;
- cur += step, i++) {
- self->data[cur] = buf[i];
+
+ for (cur = start, i = 0;
+ i < slicelen;
+ cur += step, i++)
+ {
+ self->data[cur] = ((char *)vbuf.buf)[i];
}
- return 0;
}
+ PyObject_ReleaseBuffer(value, &vbuf);
+ return 0;
}
else {
PyErr_SetString(PyExc_TypeError,
@@ -908,9 +909,9 @@
return 0;
if (PyIndex_Check(o)) {
Py_ssize_t i = PyNumber_AsSsize_t(o, PyExc_OverflowError);
- if (i==-1 && PyErr_Occurred())
+ if (i==-1 && PyErr_Occurred())
return -1;
- if (i < 0) {
+ if (i < 0) {
PyErr_Format(PyExc_OverflowError,
"memory mapped %s must be positive",
param);
@@ -1151,8 +1152,8 @@
(dwErr = GetLastError()) != NO_ERROR) {
Py_DECREF(m_obj);
return PyErr_SetFromWindowsErr(dwErr);
- }
-
+ }
+
#if SIZEOF_SIZE_T > 4
m_obj->size = (((size_t)high)<<32) + low;
#else
diff --git a/Modules/posixmodule.c b/Modules/posixmodule.c
index acd01da..cb74f84 100644
--- a/Modules/posixmodule.c
+++ b/Modules/posixmodule.c
@@ -357,12 +357,12 @@
char *p = strchr(*e, '=');
if (p == NULL)
continue;
- k = PyString_FromStringAndSize(*e, (int)(p-*e));
+ k = PyUnicode_FromStringAndSize(*e, (int)(p-*e));
if (k == NULL) {
PyErr_Clear();
continue;
}
- v = PyString_FromString(p+1);
+ v = PyUnicode_FromString(p+1);
if (v == NULL) {
PyErr_Clear();
Py_DECREF(k);
diff --git a/Modules/pyexpat.c b/Modules/pyexpat.c
index ae6f143..658569e 100644
--- a/Modules/pyexpat.c
+++ b/Modules/pyexpat.c
@@ -858,6 +858,7 @@
PyObject *bytes = NULL;
PyObject *str = NULL;
int len = -1;
+ char *ptr;
if ((bytes = PyInt_FromLong(buf_size)) == NULL)
goto finally;
@@ -877,14 +878,17 @@
if (str == NULL)
goto finally;
- /* XXX what to do if it returns a Unicode string? */
- if (!PyBytes_Check(str)) {
+ if (PyString_Check(str))
+ ptr = PyString_AS_STRING(str);
+ else if (PyBytes_Check(str))
+ ptr = PyBytes_AS_STRING(str);
+ else {
PyErr_Format(PyExc_TypeError,
"read() did not return a bytes object (type=%.400s)",
Py_Type(str)->tp_name);
goto finally;
}
- len = PyBytes_GET_SIZE(str);
+ len = Py_Size(str);
if (len > buf_size) {
PyErr_Format(PyExc_ValueError,
"read() returned too much data: "
@@ -892,7 +896,7 @@
buf_size, len);
goto finally;
}
- memcpy(buf, PyBytes_AsString(str), len);
+ memcpy(buf, ptr, len);
finally:
Py_XDECREF(arg);
Py_XDECREF(str);
@@ -998,7 +1002,7 @@
= XML_GetInputContext(self->itself, &offset, &size);
if (buffer != NULL)
- return PyBytes_FromStringAndSize(buffer + offset,
+ return PyString_FromStringAndSize(buffer + offset,
size - offset);
else
Py_RETURN_NONE;
diff --git a/Modules/sha1module.c b/Modules/sha1module.c
index d96fe35..6ba03ad 100644
--- a/Modules/sha1module.c
+++ b/Modules/sha1module.c
@@ -339,7 +339,7 @@
temp = self->hash_state;
sha1_done(&temp, digest);
- return PyBytes_FromStringAndSize((const char *)digest, SHA1_DIGESTSIZE);
+ return PyString_FromStringAndSize((const char *)digest, SHA1_DIGESTSIZE);
}
PyDoc_STRVAR(SHA1_hexdigest__doc__,
diff --git a/Modules/sha256module.c b/Modules/sha256module.c
index da31d18..a5dc9ad 100644
--- a/Modules/sha256module.c
+++ b/Modules/sha256module.c
@@ -432,7 +432,7 @@
SHAcopy(self, &temp);
sha_final(digest, &temp);
- return PyBytes_FromStringAndSize((const char *)digest, self->digestsize);
+ return PyString_FromStringAndSize((const char *)digest, self->digestsize);
}
PyDoc_STRVAR(SHA256_hexdigest__doc__,
diff --git a/Modules/sha512module.c b/Modules/sha512module.c
index 8b33bb0..c330e1b 100644
--- a/Modules/sha512module.c
+++ b/Modules/sha512module.c
@@ -498,7 +498,7 @@
SHAcopy(self, &temp);
sha512_final(digest, &temp);
- return PyBytes_FromStringAndSize((const char *)digest, self->digestsize);
+ return PyString_FromStringAndSize((const char *)digest, self->digestsize);
}
PyDoc_STRVAR(SHA512_hexdigest__doc__,
diff --git a/Modules/socketmodule.c b/Modules/socketmodule.c
index 7fe562e..78aeb55 100644
--- a/Modules/socketmodule.c
+++ b/Modules/socketmodule.c
@@ -3659,8 +3659,8 @@
idna = PyObject_CallMethod(hobj, "encode", "s", "idna");
if (!idna)
return NULL;
- assert(PyBytes_Check(idna));
- hptr = PyBytes_AsString(idna);
+ assert(PyString_Check(idna));
+ hptr = PyString_AS_STRING(idna);
} else if (PyString_Check(hobj)) {
hptr = PyString_AsString(hobj);
} else {