Renamed PyString to PyBytes
diff --git a/Objects/abstract.c b/Objects/abstract.c
index 83de88f..3e6feb5 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 = PyString_InternFromString("__length_hint__");
+ hintstrobj = PyBytes_InternFromString("__length_hint__");
if (hintstrobj == NULL)
goto defaultcase;
}
@@ -227,7 +227,7 @@
null_error();
return -1;
}
- okey = PyString_FromString(key);
+ okey = PyBytes_FromString(key);
if (okey == NULL)
return -1;
ret = PyObject_DelItem(o, okey);
@@ -729,21 +729,21 @@
/* Initialize cached value */
if (str__format__ == NULL) {
/* Initialize static variable needed by _PyType_Lookup */
- str__format__ = PyString_InternFromString("__format__");
+ str__format__ = PyBytes_InternFromString("__format__");
if (str__format__ == NULL)
goto done;
}
/* If no format_spec is provided, use an empty string */
if (format_spec == NULL) {
- empty = PyString_FromStringAndSize(NULL, 0);
+ empty = PyBytes_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 (PyString_Check(format_spec))
+ else if (PyBytes_Check(format_spec))
spec_is_unicode = 0;
else {
PyErr_Format(PyExc_TypeError,
@@ -823,7 +823,7 @@
/* Check the result type, and make sure it's str or unicode */
if (PyUnicode_Check(result))
result_is_unicode = 1;
- else if (PyString_Check(result))
+ else if (PyBytes_Check(result))
result_is_unicode = 0;
else {
PyErr_Format(PyExc_TypeError,
@@ -1541,7 +1541,7 @@
const char *type_name;
static PyObject *int_name = NULL;
if (int_name == NULL) {
- int_name = PyString_InternFromString("__int__");
+ int_name = PyBytes_InternFromString("__int__");
if (int_name == NULL)
return NULL;
}
@@ -1567,7 +1567,7 @@
non_integral_error:
if (PyInstance_Check(integral)) {
- type_name = PyString_AS_STRING(((PyInstanceObject *)integral)
+ type_name = PyBytes_AS_STRING(((PyInstanceObject *)integral)
->in_class->cl_name);
}
else {
@@ -1589,7 +1589,7 @@
Py_ssize_t buffer_len;
if (trunc_name == NULL) {
- trunc_name = PyString_InternFromString("__trunc__");
+ trunc_name = PyBytes_InternFromString("__trunc__");
if (trunc_name == NULL)
return NULL;
}
@@ -1629,9 +1629,9 @@
}
PyErr_Clear(); /* It's not an error if o.__trunc__ doesn't exist. */
- if (PyString_Check(o))
- return int_from_string(PyString_AS_STRING(o),
- PyString_GET_SIZE(o));
+ if (PyBytes_Check(o))
+ return int_from_string(PyBytes_AS_STRING(o),
+ PyBytes_GET_SIZE(o));
#ifdef Py_USING_UNICODE
if (PyUnicode_Check(o))
return PyInt_FromUnicode(PyUnicode_AS_UNICODE(o),
@@ -1674,7 +1674,7 @@
Py_ssize_t buffer_len;
if (trunc_name == NULL) {
- trunc_name = PyString_InternFromString("__trunc__");
+ trunc_name = PyBytes_InternFromString("__trunc__");
if (trunc_name == NULL)
return NULL;
}
@@ -1716,13 +1716,13 @@
}
PyErr_Clear(); /* It's not an error if o.__trunc__ doesn't exist. */
- if (PyString_Check(o))
+ if (PyBytes_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(PyString_AS_STRING(o),
- PyString_GET_SIZE(o));
+ return long_from_string(PyBytes_AS_STRING(o),
+ PyBytes_GET_SIZE(o));
#ifdef Py_USING_UNICODE
if (PyUnicode_Check(o))
/* The above check is done in PyLong_FromUnicode(). */
@@ -2413,7 +2413,7 @@
if (key == NULL)
return null_error();
- okey = PyString_FromString(key);
+ okey = PyBytes_FromString(key);
if (okey == NULL)
return NULL;
r = PyObject_GetItem(o, okey);
@@ -2432,7 +2432,7 @@
return -1;
}
- okey = PyString_FromString(key);
+ okey = PyBytes_FromString(key);
if (okey == NULL)
return -1;
r = PyObject_SetItem(o, okey, value);
@@ -2760,7 +2760,7 @@
PyObject *bases;
if (__bases__ == NULL) {
- __bases__ = PyString_InternFromString("__bases__");
+ __bases__ = PyBytes_InternFromString("__bases__");
if (__bases__ == NULL)
return NULL;
}
@@ -2838,7 +2838,7 @@
int retval = 0;
if (__class__ == NULL) {
- __class__ = PyString_InternFromString("__class__");
+ __class__ = PyBytes_InternFromString("__class__");
if (__class__ == NULL)
return -1;
}
@@ -2914,7 +2914,7 @@
return 1;
if (name == NULL) {
- name = PyString_InternFromString("__instancecheck__");
+ name = PyBytes_InternFromString("__instancecheck__");
if (name == NULL)
return -1;
}
@@ -2998,7 +2998,7 @@
PyErr_Fetch(&t, &v, &tb);
if (name == NULL) {
- name = PyString_InternFromString("__subclasscheck__");
+ name = PyBytes_InternFromString("__subclasscheck__");
if (name == NULL)
return -1;
}
diff --git a/Objects/boolobject.c b/Objects/boolobject.c
index fd73d28..93affd1 100644
--- a/Objects/boolobject.c
+++ b/Objects/boolobject.c
@@ -25,10 +25,10 @@
if (self->ob_ival)
s = true_str ? true_str :
- (true_str = PyString_InternFromString("True"));
+ (true_str = PyBytes_InternFromString("True"));
else
s = false_str ? false_str :
- (false_str = PyString_InternFromString("False"));
+ (false_str = PyBytes_InternFromString("False"));
Py_XINCREF(s);
return s;
}
diff --git a/Objects/bufferobject.c b/Objects/bufferobject.c
index 37d9bcb..ee8dd3d 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 PyString_FromFormat("<%s buffer ptr %p, size %zd at %p>",
+ return PyBytes_FromFormat("<%s buffer ptr %p, size %zd at %p>",
status,
self->b_ptr,
self->b_size,
self);
else
- return PyString_FromFormat(
+ return PyBytes_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. PyString_Check() is true). Another idea would
+ * be immutable (e.g. PyBytes_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 PyString_FromStringAndSize((const char *)ptr, size);
+ return PyBytes_FromStringAndSize((const char *)ptr, size);
}
/* Sequence methods */
@@ -401,10 +401,10 @@
if ( (count = (*pb->bf_getreadbuffer)(other, 0, &ptr2)) < 0 )
return NULL;
- ob = PyString_FromStringAndSize(NULL, size + count);
+ ob = PyBytes_FromStringAndSize(NULL, size + count);
if ( ob == NULL )
return NULL;
- p = PyString_AS_STRING(ob);
+ p = PyBytes_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 = PyString_FromStringAndSize(NULL, size * count);
+ ob = PyBytes_FromStringAndSize(NULL, size * count);
if ( ob == NULL )
return NULL;
- p = PyString_AS_STRING(ob);
+ p = PyBytes_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 PyString_FromStringAndSize((char *)ptr + idx, 1);
+ return PyBytes_FromStringAndSize((char *)ptr + idx, 1);
}
static PyObject *
@@ -472,7 +472,7 @@
right = size;
if ( right < left )
right = left;
- return PyString_FromStringAndSize((char *)ptr + left,
+ return PyBytes_FromStringAndSize((char *)ptr + left,
right - left);
}
@@ -501,9 +501,9 @@
}
if (slicelength <= 0)
- return PyString_FromStringAndSize("", 0);
+ return PyBytes_FromStringAndSize("", 0);
else if (step == 1)
- return PyString_FromStringAndSize((char *)p + start,
+ return PyBytes_FromStringAndSize((char *)p + start,
stop - start);
else {
PyObject *result;
@@ -518,7 +518,7 @@
result_buf[i] = source_buf[cur];
}
- result = PyString_FromStringAndSize(result_buf,
+ result = PyBytes_FromStringAndSize(result_buf,
slicelength);
PyMem_Free(result_buf);
return result;
diff --git a/Objects/bytes_methods.c b/Objects/bytes_methods.c
index de87905..2d55601 100644
--- a/Objects/bytes_methods.c
+++ b/Objects/bytes_methods.c
@@ -462,11 +462,11 @@
Py_ssize_t i;
/*
- newobj = PyString_FromStringAndSize(NULL, len);
+ newobj = PyBytes_FromStringAndSize(NULL, len);
if (!newobj)
return NULL;
- s = PyString_AS_STRING(newobj);
+ s = PyBytes_AS_STRING(newobj);
*/
Py_MEMCPY(result, cptr, len);
@@ -490,11 +490,11 @@
Py_ssize_t i;
/*
- newobj = PyString_FromStringAndSize(NULL, len);
+ newobj = PyBytes_FromStringAndSize(NULL, len);
if (!newobj)
return NULL;
- s = PyString_AS_STRING(newobj);
+ s = PyBytes_AS_STRING(newobj);
*/
Py_MEMCPY(result, cptr, len);
@@ -520,10 +520,10 @@
int previous_is_cased = 0;
/*
- newobj = PyString_FromStringAndSize(NULL, len);
+ newobj = PyBytes_FromStringAndSize(NULL, len);
if (newobj == NULL)
return NULL;
- s_new = PyString_AsString(newobj);
+ s_new = PyBytes_AsString(newobj);
*/
for (i = 0; i < len; i++) {
int c = Py_CHARMASK(*s++);
@@ -553,10 +553,10 @@
Py_ssize_t i;
/*
- newobj = PyString_FromStringAndSize(NULL, len);
+ newobj = PyBytes_FromStringAndSize(NULL, len);
if (newobj == NULL)
return NULL;
- s_new = PyString_AsString(newobj);
+ s_new = PyBytes_AsString(newobj);
*/
if (0 < len) {
int c = Py_CHARMASK(*s++);
@@ -589,10 +589,10 @@
Py_ssize_t i;
/*
- newobj = PyString_FromStringAndSize(NULL, len);
+ newobj = PyBytes_FromStringAndSize(NULL, len);
if (newobj == NULL)
return NULL;
- s_new = PyString_AsString(newobj);
+ s_new = PyBytes_AsString(newobj);
*/
for (i = 0; i < len; i++) {
int c = Py_CHARMASK(*s++);
diff --git a/Objects/bytesobject.c b/Objects/bytesobject.c
index 25fec6d..6e5df19 100644
--- a/Objects/bytesobject.c
+++ b/Objects/bytesobject.c
@@ -41,12 +41,12 @@
return 0;
}
}
- else if (PyString_CheckExact(arg)) {
+ else if (PyBytes_CheckExact(arg)) {
if (Py_SIZE(arg) != 1) {
PyErr_SetString(PyExc_ValueError, "string must be of size 1");
return 0;
}
- face_value = Py_CHARMASK(((PyStringObject*)arg)->ob_sval[0]);
+ face_value = Py_CHARMASK(((PyBytesObject*)arg)->ob_sval[0]);
}
else {
PyErr_Format(PyExc_TypeError, "an integer or string of size 1 is required");
@@ -768,13 +768,13 @@
return 0;
}
- if (PyString_Check(arg)) {
+ if (PyBytes_Check(arg)) {
PyObject *new, *encoded;
if (encoding != NULL) {
encoded = PyCodec_Encode(arg, encoding, errors);
if (encoded == NULL)
return -1;
- assert(PyString_Check(encoded));
+ assert(PyBytes_Check(encoded));
}
else {
encoded = arg;
@@ -799,7 +799,7 @@
encoded = PyCodec_Encode(arg, encoding, errors);
if (encoded == NULL)
return -1;
- assert(PyString_Check(encoded));
+ assert(PyBytes_Check(encoded));
new = bytes_iconcat(self, encoded);
Py_DECREF(encoded);
if (new == NULL)
@@ -1002,7 +1002,7 @@
}
return bytes_repr((PyByteArrayObject*)op);
#endif
- return PyString_FromStringAndSize(((PyByteArrayObject*)op)->ob_bytes, Py_SIZE(op));
+ return PyBytes_FromStringAndSize(((PyByteArrayObject*)op)->ob_bytes, Py_SIZE(op));
}
static PyObject *
@@ -2969,7 +2969,7 @@
/* XXX Shouldn't we use _getbuffer() on these items instead? */
for (i = 0; i < n; i++) {
PyObject *obj = items[i];
- if (!PyByteArray_Check(obj) && !PyString_Check(obj)) {
+ if (!PyByteArray_Check(obj) && !PyBytes_Check(obj)) {
PyErr_Format(PyExc_TypeError,
"can only join an iterable of bytes "
"(item %ld has type '%.100s')",
@@ -2998,7 +2998,7 @@
if (PyByteArray_Check(obj))
buf = PyByteArray_AS_STRING(obj);
else
- buf = PyString_AS_STRING(obj);
+ buf = PyBytes_AS_STRING(obj);
if (i) {
memcpy(dest, self->ob_bytes, mysize);
dest += mysize;
diff --git a/Objects/cellobject.c b/Objects/cellobject.c
index 4e0bcf8..16bb150 100644
--- a/Objects/cellobject.c
+++ b/Objects/cellobject.c
@@ -73,9 +73,9 @@
cell_repr(PyCellObject *op)
{
if (op->ob_ref == NULL)
- return PyString_FromFormat("<cell at %p: empty>", op);
+ return PyBytes_FromFormat("<cell at %p: empty>", op);
- return PyString_FromFormat("<cell at %p: %.80s object at %p>",
+ return PyBytes_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 caf6b3e..372a40e 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= PyString_InternFromString("__doc__");
+ docstr= PyBytes_InternFromString("__doc__");
if (docstr == NULL)
return NULL;
}
if (modstr == NULL) {
- modstr= PyString_InternFromString("__module__");
+ modstr= PyBytes_InternFromString("__module__");
if (modstr == NULL)
return NULL;
}
if (namestr == NULL) {
- namestr= PyString_InternFromString("__name__");
+ namestr= PyBytes_InternFromString("__name__");
if (namestr == NULL)
return NULL;
}
- if (name == NULL || !PyString_Check(name)) {
+ if (name == NULL || !PyBytes_Check(name)) {
PyErr_SetString(PyExc_TypeError,
"PyClass_New: name must be a string");
return NULL;
@@ -101,13 +101,13 @@
}
if (getattrstr == NULL) {
- getattrstr = PyString_InternFromString("__getattr__");
+ getattrstr = PyBytes_InternFromString("__getattr__");
if (getattrstr == NULL)
goto alloc_error;
- setattrstr = PyString_InternFromString("__setattr__");
+ setattrstr = PyBytes_InternFromString("__setattr__");
if (setattrstr == NULL)
goto alloc_error;
- delattrstr = PyString_InternFromString("__delattr__");
+ delattrstr = PyBytes_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 = PyString_AsString(name);
+ register char *sname = PyBytes_AsString(name);
PyClassObject *klass;
descrgetfunc f;
@@ -253,7 +253,7 @@
if (v == NULL) {
PyErr_Format(PyExc_AttributeError,
"class %.50s has no attribute '%.400s'",
- PyString_AS_STRING(op->cl_name), sname);
+ PyBytes_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 || !PyString_Check(v))
+ if (v == NULL || !PyBytes_Check(v))
return "__name__ must be a string object";
- if (strlen(PyString_AS_STRING(v)) != (size_t)PyString_GET_SIZE(v))
+ if (strlen(PyBytes_AS_STRING(v)) != (size_t)PyBytes_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 = PyString_AsString(name);
+ sname = PyBytes_AsString(name);
if (sname[0] == '_' && sname[1] == '_') {
- Py_ssize_t n = PyString_Size(name);
+ Py_ssize_t n = PyBytes_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'",
- PyString_AS_STRING(op->cl_name), sname);
+ PyBytes_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 || !PyString_Check(op->cl_name))
+ if (op->cl_name == NULL || !PyBytes_Check(op->cl_name))
name = "?";
else
- name = PyString_AsString(op->cl_name);
- if (mod == NULL || !PyString_Check(mod))
- return PyString_FromFormat("<class ?.%s at %p>", name, op);
+ name = PyBytes_AsString(op->cl_name);
+ if (mod == NULL || !PyBytes_Check(mod))
+ return PyBytes_FromFormat("<class ?.%s at %p>", name, op);
else
- return PyString_FromFormat("<class %s.%s at %p>",
- PyString_AsString(mod),
+ return PyBytes_FromFormat("<class %s.%s at %p>",
+ PyBytes_AsString(mod),
name, op);
}
@@ -397,21 +397,21 @@
PyObject *res;
Py_ssize_t m, n;
- if (name == NULL || !PyString_Check(name))
+ if (name == NULL || !PyBytes_Check(name))
return class_repr(op);
- if (mod == NULL || !PyString_Check(mod)) {
+ if (mod == NULL || !PyBytes_Check(mod)) {
Py_INCREF(name);
return name;
}
- m = PyString_GET_SIZE(mod);
- n = PyString_GET_SIZE(name);
- res = PyString_FromStringAndSize((char *)NULL, m+1+n);
+ m = PyBytes_GET_SIZE(mod);
+ n = PyBytes_GET_SIZE(name);
+ res = PyBytes_FromStringAndSize((char *)NULL, m+1+n);
if (res != NULL) {
- char *s = PyString_AS_STRING(res);
- memcpy(s, PyString_AS_STRING(mod), m);
+ char *s = PyBytes_AS_STRING(res);
+ memcpy(s, PyBytes_AS_STRING(mod), m);
s += m;
*s++ = '.';
- memcpy(s, PyString_AS_STRING(name), n);
+ memcpy(s, PyBytes_AS_STRING(name), n);
}
return res;
}
@@ -541,7 +541,7 @@
static PyObject *initstr;
if (initstr == NULL) {
- initstr = PyString_InternFromString("__init__");
+ initstr = PyBytes_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 = PyString_InternFromString("__del__");
+ delstr = PyBytes_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 = PyString_AsString(name);
+ register char *sname = PyBytes_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'",
- PyString_AS_STRING(inst->in_class->cl_name), sname);
+ PyBytes_AS_STRING(inst->in_class->cl_name), sname);
}
return v;
}
@@ -779,7 +779,7 @@
assert(PyInstance_Check(pinst));
inst = (PyInstanceObject *)pinst;
- assert(PyString_Check(name));
+ assert(PyBytes_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'",
- PyString_AS_STRING(inst->in_class->cl_name),
- PyString_AS_STRING(name));
+ PyBytes_AS_STRING(inst->in_class->cl_name),
+ PyBytes_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 = PyString_AsString(name);
+ char *sname = PyBytes_AsString(name);
if (sname[0] == '_' && sname[1] == '_') {
- Py_ssize_t n = PyString_Size(name);
+ Py_ssize_t n = PyBytes_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 = PyString_InternFromString("__repr__");
+ reprstr = PyBytes_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 && PyString_Check(classname))
- cname = PyString_AsString(classname);
+ if (classname != NULL && PyBytes_Check(classname))
+ cname = PyBytes_AsString(classname);
else
cname = "?";
- if (mod == NULL || !PyString_Check(mod))
- return PyString_FromFormat("<?.%s instance at %p>",
+ if (mod == NULL || !PyBytes_Check(mod))
+ return PyBytes_FromFormat("<?.%s instance at %p>",
cname, inst);
else
- return PyString_FromFormat("<%s.%s instance at %p>",
- PyString_AsString(mod),
+ return PyBytes_FromFormat("<%s.%s instance at %p>",
+ PyBytes_AsString(mod),
cname, inst);
}
res = PyEval_CallObject(func, (PyObject *)NULL);
@@ -914,7 +914,7 @@
static PyObject *strstr;
if (strstr == NULL) {
- strstr = PyString_InternFromString("__str__");
+ strstr = PyBytes_InternFromString("__str__");
if (strstr == NULL)
return NULL;
}
@@ -939,7 +939,7 @@
static PyObject *hashstr, *eqstr, *cmpstr;
if (hashstr == NULL) {
- hashstr = PyString_InternFromString("__hash__");
+ hashstr = PyBytes_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 = PyString_InternFromString("__eq__");
+ eqstr = PyBytes_InternFromString("__eq__");
if (eqstr == NULL)
return -1;
}
@@ -962,7 +962,7 @@
return -1;
PyErr_Clear();
if (cmpstr == NULL) {
- cmpstr = PyString_InternFromString("__cmp__");
+ cmpstr = PyBytes_InternFromString("__cmp__");
if (cmpstr == NULL)
return -1;
}
@@ -1014,7 +1014,7 @@
Py_ssize_t outcome;
if (lenstr == NULL) {
- lenstr = PyString_InternFromString("__len__");
+ lenstr = PyBytes_InternFromString("__len__");
if (lenstr == NULL)
return -1;
}
@@ -1063,7 +1063,7 @@
PyObject *res;
if (getitemstr == NULL) {
- getitemstr = PyString_InternFromString("__getitem__");
+ getitemstr = PyBytes_InternFromString("__getitem__");
if (getitemstr == NULL)
return NULL;
}
@@ -1090,7 +1090,7 @@
if (value == NULL) {
if (delitemstr == NULL) {
- delitemstr = PyString_InternFromString("__delitem__");
+ delitemstr = PyBytes_InternFromString("__delitem__");
if (delitemstr == NULL)
return -1;
}
@@ -1098,7 +1098,7 @@
}
else {
if (setitemstr == NULL) {
- setitemstr = PyString_InternFromString("__setitem__");
+ setitemstr = PyBytes_InternFromString("__setitem__");
if (setitemstr == NULL)
return -1;
}
@@ -1135,7 +1135,7 @@
PyObject *func, *res;
if (getitemstr == NULL) {
- getitemstr = PyString_InternFromString("__getitem__");
+ getitemstr = PyBytes_InternFromString("__getitem__");
if (getitemstr == NULL)
return NULL;
}
@@ -1154,7 +1154,7 @@
static PyObject *getslicestr;
if (getslicestr == NULL) {
- getslicestr = PyString_InternFromString("__getslice__");
+ getslicestr = PyBytes_InternFromString("__getslice__");
if (getslicestr == NULL)
return NULL;
}
@@ -1166,7 +1166,7 @@
PyErr_Clear();
if (getitemstr == NULL) {
- getitemstr = PyString_InternFromString("__getitem__");
+ getitemstr = PyBytes_InternFromString("__getitem__");
if (getitemstr == NULL)
return NULL;
}
@@ -1194,7 +1194,7 @@
if (item == NULL) {
if (delitemstr == NULL) {
- delitemstr = PyString_InternFromString("__delitem__");
+ delitemstr = PyBytes_InternFromString("__delitem__");
if (delitemstr == NULL)
return -1;
}
@@ -1202,7 +1202,7 @@
}
else {
if (setitemstr == NULL) {
- setitemstr = PyString_InternFromString("__setitem__");
+ setitemstr = PyBytes_InternFromString("__setitem__");
if (setitemstr == NULL)
return -1;
}
@@ -1236,7 +1236,7 @@
if (value == NULL) {
if (delslicestr == NULL) {
delslicestr =
- PyString_InternFromString("__delslice__");
+ PyBytes_InternFromString("__delslice__");
if (delslicestr == NULL)
return -1;
}
@@ -1247,7 +1247,7 @@
PyErr_Clear();
if (delitemstr == NULL) {
delitemstr =
- PyString_InternFromString("__delitem__");
+ PyBytes_InternFromString("__delitem__");
if (delitemstr == NULL)
return -1;
}
@@ -1263,7 +1263,7 @@
else {
if (setslicestr == NULL) {
setslicestr =
- PyString_InternFromString("__setslice__");
+ PyBytes_InternFromString("__setslice__");
if (setslicestr == NULL)
return -1;
}
@@ -1274,7 +1274,7 @@
PyErr_Clear();
if (setitemstr == NULL) {
setitemstr =
- PyString_InternFromString("__setitem__");
+ PyBytes_InternFromString("__setitem__");
if (setitemstr == NULL)
return -1;
}
@@ -1311,7 +1311,7 @@
*/
if(__contains__ == NULL) {
- __contains__ = PyString_InternFromString("__contains__");
+ __contains__ = PyBytes_InternFromString("__contains__");
if(__contains__ == NULL)
return -1;
}
@@ -1417,7 +1417,7 @@
}
if (coerce_obj == NULL) {
- coerce_obj = PyString_InternFromString("__coerce__");
+ coerce_obj = PyBytes_InternFromString("__coerce__");
if (coerce_obj == NULL)
return NULL;
}
@@ -1504,7 +1504,7 @@
PyObject *coerced;
if (coerce_obj == NULL) {
- coerce_obj = PyString_InternFromString("__coerce__");
+ coerce_obj = PyBytes_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 = PyString_InternFromString(methodname); \
+ if (o == NULL) { o = PyBytes_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 = PyString_InternFromString(methodname); \
+ if (o == NULL) { o = PyBytes_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 = PyString_InternFromString("__cmp__");
+ cmp_obj = PyBytes_InternFromString("__cmp__");
if (cmp_obj == NULL)
return -2;
}
@@ -1738,7 +1738,7 @@
static PyObject *nonzerostr;
if (nonzerostr == NULL) {
- nonzerostr = PyString_InternFromString("__nonzero__");
+ nonzerostr = PyBytes_InternFromString("__nonzero__");
if (nonzerostr == NULL)
return -1;
}
@@ -1747,7 +1747,7 @@
return -1;
PyErr_Clear();
if (lenstr == NULL) {
- lenstr = PyString_InternFromString("__len__");
+ lenstr = PyBytes_InternFromString("__len__");
if (lenstr == NULL)
return -1;
}
@@ -1787,7 +1787,7 @@
static PyObject *indexstr = NULL;
if (indexstr == NULL) {
- indexstr = PyString_InternFromString("__index__");
+ indexstr = PyBytes_InternFromString("__index__");
if (indexstr == NULL)
return NULL;
}
@@ -1814,7 +1814,7 @@
PyObject *truncated;
static PyObject *int_name;
if (int_name == NULL) {
- int_name = PyString_InternFromString("__int__");
+ int_name = PyBytes_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] = PyString_InternFromString(_name_op[i]);
+ name_op[i] = PyBytes_InternFromString(_name_op[i]);
if (name_op[i] == NULL)
return -1;
}
@@ -2012,12 +2012,12 @@
PyObject *func;
if (iterstr == NULL) {
- iterstr = PyString_InternFromString("__iter__");
+ iterstr = PyBytes_InternFromString("__iter__");
if (iterstr == NULL)
return NULL;
}
if (getitemstr == NULL) {
- getitemstr = PyString_InternFromString("__getitem__");
+ getitemstr = PyBytes_InternFromString("__getitem__");
if (getitemstr == NULL)
return NULL;
}
@@ -2055,7 +2055,7 @@
PyObject *func;
if (nextstr == NULL) {
- nextstr = PyString_InternFromString("next");
+ nextstr = PyBytes_InternFromString("next");
if (nextstr == NULL)
return NULL;
}
@@ -2087,7 +2087,7 @@
PyErr_Clear();
PyErr_Format(PyExc_AttributeError,
"%.200s instance has no __call__ method",
- PyString_AsString(inst->in_class->cl_name));
+ PyBytes_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= PyString_InternFromString("__doc__");
+ docstr= PyBytes_InternFromString("__doc__");
if (docstr == NULL)
return NULL;
}
@@ -2384,12 +2384,12 @@
return NULL;
PyErr_Clear();
}
- else if (!PyString_Check(funcname)) {
+ else if (!PyBytes_Check(funcname)) {
Py_DECREF(funcname);
funcname = NULL;
}
else
- sfuncname = PyString_AS_STRING(funcname);
+ sfuncname = PyBytes_AS_STRING(funcname);
if (klass == NULL)
klassname = NULL;
else {
@@ -2399,28 +2399,28 @@
return NULL;
PyErr_Clear();
}
- else if (!PyString_Check(klassname)) {
+ else if (!PyBytes_Check(klassname)) {
Py_DECREF(klassname);
klassname = NULL;
}
else
- sklassname = PyString_AS_STRING(klassname);
+ sklassname = PyBytes_AS_STRING(klassname);
}
if (self == NULL)
- result = PyString_FromFormat("<unbound method %s.%s>",
+ result = PyBytes_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 (!PyString_Check(selfrepr)) {
+ if (!PyBytes_Check(selfrepr)) {
Py_DECREF(selfrepr);
goto fail;
}
- result = PyString_FromFormat("<bound method %s.%s of %s>",
+ result = PyBytes_FromFormat("<bound method %s.%s of %s>",
sklassname, sfuncname,
- PyString_AS_STRING(selfrepr));
+ PyBytes_AS_STRING(selfrepr));
Py_DECREF(selfrepr);
}
fail:
@@ -2472,8 +2472,8 @@
PyErr_Clear();
return;
}
- if (PyString_Check(name)) {
- strncpy(buf, PyString_AS_STRING(name), bufsize);
+ if (PyBytes_Check(name)) {
+ strncpy(buf, PyBytes_AS_STRING(name), bufsize);
buf[bufsize-1] = '\0';
}
Py_DECREF(name);
diff --git a/Objects/codeobject.c b/Objects/codeobject.c
index e94b4cc..9892d9c 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 || !PyString_CheckExact(v)) {
+ if (v == NULL || !PyBytes_CheckExact(v)) {
Py_FatalError("non-string found in code slot");
}
- PyString_InternInPlace(&PyTuple_GET_ITEM(tuple, i));
+ PyBytes_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 || !PyString_Check(name) ||
- filename == NULL || !PyString_Check(filename) ||
- lnotab == NULL || !PyString_Check(lnotab) ||
+ name == NULL || !PyBytes_Check(name) ||
+ filename == NULL || !PyBytes_Check(filename) ||
+ lnotab == NULL || !PyBytes_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 (!PyString_Check(v))
+ if (!PyBytes_Check(v))
continue;
- if (!all_name_chars((unsigned char *)PyString_AS_STRING(v)))
+ if (!all_name_chars((unsigned char *)PyBytes_AS_STRING(v)))
continue;
- PyString_InternInPlace(&PyTuple_GET_ITEM(consts, i));
+ PyBytes_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 (PyString_CheckExact(item)) {
+ if (PyBytes_CheckExact(item)) {
Py_INCREF(item);
}
- else if (!PyString_Check(item)) {
+ else if (!PyBytes_Check(item)) {
PyErr_Format(
PyExc_TypeError,
"name tuples must contain only "
@@ -158,9 +158,9 @@
return NULL;
}
else {
- item = PyString_FromStringAndSize(
- PyString_AS_STRING(item),
- PyString_GET_SIZE(item));
+ item = PyBytes_FromStringAndSize(
+ PyBytes_AS_STRING(item),
+ PyBytes_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 && 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);
+ 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);
PyOS_snprintf(buf, sizeof(buf),
"<code object %.100s at %p, file \"%.300s\", line %d>",
name, co, filename, lineno);
- return PyString_FromString(buf);
+ return PyBytes_FromString(buf);
}
static int
@@ -508,8 +508,8 @@
int
PyCode_Addr2Line(PyCodeObject *co, int addrq)
{
- int size = PyString_Size(co->co_lnotab) / 2;
- unsigned char *p = (unsigned char*)PyString_AsString(co->co_lnotab);
+ int size = PyBytes_Size(co->co_lnotab) / 2;
+ unsigned char *p = (unsigned char*)PyBytes_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*)PyString_AS_STRING(co->co_lnotab);
- size = PyString_GET_SIZE(co->co_lnotab) / 2;
+ p = (unsigned char*)PyBytes_AS_STRING(co->co_lnotab);
+ size = PyBytes_GET_SIZE(co->co_lnotab) / 2;
addr = 0;
line = co->co_firstlineno;
diff --git a/Objects/complexobject.c b/Objects/complexobject.c
index 6e0fbb2..e22c200 100644
--- a/Objects/complexobject.c
+++ b/Objects/complexobject.c
@@ -303,7 +303,7 @@
cv.imag = 0.;
if (complex_str == NULL) {
- if (!(complex_str = PyString_InternFromString("__complex__")))
+ if (!(complex_str = PyBytes_InternFromString("__complex__")))
return cv;
}
@@ -421,7 +421,7 @@
{
char buf[100];
complex_to_buf(buf, sizeof(buf), v, PREC_REPR);
- return PyString_FromString(buf);
+ return PyBytes_FromString(buf);
}
static PyObject *
@@ -429,7 +429,7 @@
{
char buf[100];
complex_to_buf(buf, sizeof(buf), v, PREC_STR);
- return PyString_FromString(buf);
+ return PyBytes_FromString(buf);
}
static long
@@ -876,9 +876,9 @@
#endif
Py_ssize_t len;
- if (PyString_Check(v)) {
- s = PyString_AS_STRING(v);
- len = PyString_GET_SIZE(v);
+ if (PyBytes_Check(v)) {
+ s = PyBytes_AS_STRING(v);
+ len = PyBytes_GET_SIZE(v);
}
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(v)) {
@@ -1064,7 +1064,7 @@
Py_INCREF(r);
return r;
}
- if (PyString_Check(r) || PyUnicode_Check(r)) {
+ if (PyBytes_Check(r) || PyUnicode_Check(r)) {
if (i != NULL) {
PyErr_SetString(PyExc_TypeError,
"complex() can't take second arg"
@@ -1073,7 +1073,7 @@
}
return complex_subtype_from_string(type, r);
}
- if (i != NULL && (PyString_Check(i) || PyUnicode_Check(i))) {
+ if (i != NULL && (PyBytes_Check(i) || PyUnicode_Check(i))) {
PyErr_SetString(PyExc_TypeError,
"complex() second arg can't be a string");
return NULL;
@@ -1081,7 +1081,7 @@
/* XXX Hack to support classes with __complex__ method */
if (complexstr == NULL) {
- complexstr = PyString_InternFromString("__complex__");
+ complexstr = PyBytes_InternFromString("__complex__");
if (complexstr == NULL)
return NULL;
}
diff --git a/Objects/descrobject.c b/Objects/descrobject.c
index fcc174e..7cf5e62 100644
--- a/Objects/descrobject.c
+++ b/Objects/descrobject.c
@@ -15,8 +15,8 @@
static char *
descr_name(PyDescrObject *descr)
{
- if (descr->d_name != NULL && PyString_Check(descr->d_name))
- return PyString_AS_STRING(descr->d_name);
+ if (descr->d_name != NULL && PyBytes_Check(descr->d_name))
+ return PyBytes_AS_STRING(descr->d_name);
else
return "?";
}
@@ -24,7 +24,7 @@
static PyObject *
descr_repr(PyDescrObject *descr, char *format)
{
- return PyString_FromFormat(format, descr_name(descr),
+ return PyBytes_FromFormat(format, descr_name(descr),
descr->d_type->tp_name);
}
@@ -314,7 +314,7 @@
Py_INCREF(Py_None);
return Py_None;
}
- return PyString_FromString(descr->d_method->ml_doc);
+ return PyBytes_FromString(descr->d_method->ml_doc);
}
static PyMemberDef descr_members[] = {
@@ -335,7 +335,7 @@
Py_INCREF(Py_None);
return Py_None;
}
- return PyString_FromString(descr->d_member->doc);
+ return PyBytes_FromString(descr->d_member->doc);
}
static PyGetSetDef member_getset[] = {
@@ -350,7 +350,7 @@
Py_INCREF(Py_None);
return Py_None;
}
- return PyString_FromString(descr->d_getset->doc);
+ return PyBytes_FromString(descr->d_getset->doc);
}
static PyGetSetDef getset_getset[] = {
@@ -365,7 +365,7 @@
Py_INCREF(Py_None);
return Py_None;
}
- return PyString_FromString(descr->d_base->doc);
+ return PyBytes_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 = PyString_InternFromString(name);
+ descr->d_name = PyBytes_InternFromString(name);
if (descr->d_name == NULL) {
Py_DECREF(descr);
descr = NULL;
@@ -922,7 +922,7 @@
static PyObject *
wrapper_repr(wrapperobject *wp)
{
- return PyString_FromFormat("<method-wrapper '%s' of %s object at %p>",
+ return PyBytes_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 PyString_FromString(s);
+ return PyBytes_FromString(s);
}
static PyObject *
@@ -960,7 +960,7 @@
return Py_None;
}
else {
- return PyString_FromString(s);
+ return PyBytes_FromString(s);
}
}
diff --git a/Objects/dictobject.c b/Objects/dictobject.c
index 102ea98..cdf0dfa 100644
--- a/Objects/dictobject.c
+++ b/Objects/dictobject.c
@@ -224,7 +224,7 @@
{
register PyDictObject *mp;
if (dummy == NULL) { /* Auto-initialize dummy */
- dummy = PyString_FromString("<dummy key>");
+ dummy = PyBytes_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 _PyString_Eq() directly.
+ * use _PyBytes_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 (!PyString_CheckExact(key)) {
+ if (!PyBytes_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 && _PyString_Eq(ep->me_key, key))
+ if (ep->me_hash == hash && _PyBytes_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
- && _PyString_Eq(ep->me_key, key)))
+ && _PyBytes_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 (!PyString_CheckExact(key) ||
- (hash = ((PyStringObject *) key)->ob_shash) == -1)
+ if (!PyBytes_CheckExact(key) ||
+ (hash = ((PyBytesObject *) key)->ob_shash) == -1)
{
hash = PyObject_Hash(key);
if (hash == -1) {
@@ -680,8 +680,8 @@
assert(key);
assert(value);
mp = (PyDictObject *)op;
- if (PyString_CheckExact(key)) {
- hash = ((PyStringObject *)key)->ob_shash;
+ if (PyBytes_CheckExact(key)) {
+ hash = ((PyBytesObject *)key)->ob_shash;
if (hash == -1)
hash = PyObject_Hash(key);
}
@@ -728,8 +728,8 @@
return -1;
}
assert(key);
- if (!PyString_CheckExact(key) ||
- (hash = ((PyStringObject *) key)->ob_shash) == -1) {
+ if (!PyBytes_CheckExact(key) ||
+ (hash = ((PyBytesObject *) 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 ? PyString_FromString("{...}") : NULL;
+ return i > 0 ? PyBytes_FromString("{...}") : NULL;
}
if (mp->ma_used == 0) {
- result = PyString_FromString("{}");
+ result = PyBytes_FromString("{}");
goto Done;
}
@@ -994,7 +994,7 @@
if (pieces == NULL)
goto Done;
- colon = PyString_FromString(": ");
+ colon = PyBytes_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);
- PyString_Concat(&s, colon);
- PyString_ConcatAndDel(&s, PyObject_Repr(value));
+ PyBytes_Concat(&s, colon);
+ PyBytes_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 = PyString_FromString("{");
+ s = PyBytes_FromString("{");
if (s == NULL)
goto Done;
temp = PyList_GET_ITEM(pieces, 0);
- PyString_ConcatAndDel(&s, temp);
+ PyBytes_ConcatAndDel(&s, temp);
PyList_SET_ITEM(pieces, 0, s);
if (s == NULL)
goto Done;
- s = PyString_FromString("}");
+ s = PyBytes_FromString("}");
if (s == NULL)
goto Done;
temp = PyList_GET_ITEM(pieces, PyList_GET_SIZE(pieces) - 1);
- PyString_ConcatAndDel(&temp, s);
+ PyBytes_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 = PyString_FromString(", ");
+ s = PyBytes_FromString(", ");
if (s == NULL)
goto Done;
- result = _PyString_Join(s, pieces);
+ result = _PyBytes_Join(s, pieces);
Py_DECREF(s);
Done:
@@ -1064,8 +1064,8 @@
long hash;
PyDictEntry *ep;
assert(mp->ma_table != NULL);
- if (!PyString_CheckExact(key) ||
- (hash = ((PyStringObject *) key)->ob_shash) == -1) {
+ if (!PyBytes_CheckExact(key) ||
+ (hash = ((PyBytesObject *) 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 =
- PyString_InternFromString("__missing__");
+ PyBytes_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 (!PyString_CheckExact(key) ||
- (hash = ((PyStringObject *) key)->ob_shash) == -1) {
+ if (!PyBytes_CheckExact(key) ||
+ (hash = ((PyBytesObject *) 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 (!PyString_CheckExact(key) ||
- (hash = ((PyStringObject *) key)->ob_shash) == -1) {
+ if (!PyBytes_CheckExact(key) ||
+ (hash = ((PyBytesObject *) 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 (!PyString_CheckExact(key) ||
- (hash = ((PyStringObject *) key)->ob_shash) == -1) {
+ if (!PyBytes_CheckExact(key) ||
+ (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
hash = PyObject_Hash(key);
if (hash == -1)
return NULL;
@@ -1902,8 +1902,8 @@
"pop(): dictionary is empty");
return NULL;
}
- if (!PyString_CheckExact(key) ||
- (hash = ((PyStringObject *) key)->ob_shash) == -1) {
+ if (!PyBytes_CheckExact(key) ||
+ (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
hash = PyObject_Hash(key);
if (hash == -1)
return NULL;
@@ -2133,8 +2133,8 @@
PyDictObject *mp = (PyDictObject *)op;
PyDictEntry *ep;
- if (!PyString_CheckExact(key) ||
- (hash = ((PyStringObject *) key)->ob_shash) == -1) {
+ if (!PyBytes_CheckExact(key) ||
+ (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
hash = PyObject_Hash(key);
if (hash == -1)
return -1;
@@ -2260,7 +2260,7 @@
PyDict_GetItemString(PyObject *v, const char *key)
{
PyObject *kv, *rv;
- kv = PyString_FromString(key);
+ kv = PyBytes_FromString(key);
if (kv == NULL)
return NULL;
rv = PyDict_GetItem(v, kv);
@@ -2273,10 +2273,10 @@
{
PyObject *kv;
int err;
- kv = PyString_FromString(key);
+ kv = PyBytes_FromString(key);
if (kv == NULL)
return -1;
- PyString_InternInPlace(&kv); /* XXX Should we really? */
+ PyBytes_InternInPlace(&kv); /* XXX Should we really? */
err = PyDict_SetItem(v, kv, item);
Py_DECREF(kv);
return err;
@@ -2287,7 +2287,7 @@
{
PyObject *kv;
int err;
- kv = PyString_FromString(key);
+ kv = PyBytes_FromString(key);
if (kv == NULL)
return -1;
err = PyDict_DelItem(v, kv);
diff --git a/Objects/exceptions.c b/Objects/exceptions.c
index 48b47b0..085ef36 100644
--- a/Objects/exceptions.c
+++ b/Objects/exceptions.c
@@ -44,7 +44,7 @@
return NULL;
}
- self->message = PyString_FromString("");
+ self->message = PyBytes_FromString("");
if (!self->message) {
Py_DECREF(self);
return NULL;
@@ -104,7 +104,7 @@
switch (PyTuple_GET_SIZE(self->args)) {
case 0:
- out = PyString_FromString("");
+ out = PyBytes_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 = PyString_FromString(name);
+ repr = PyBytes_FromString(name);
if (!repr) {
Py_DECREF(repr_suffix);
return NULL;
}
- PyString_ConcatAndDel(&repr, repr_suffix);
+ PyBytes_ConcatAndDel(&repr, repr_suffix);
return repr;
}
@@ -610,7 +610,7 @@
PyObject *repr;
PyObject *tuple;
- fmt = PyString_FromString("[Errno %s] %s: %s");
+ fmt = PyBytes_FromString("[Errno %s] %s: %s");
if (!fmt)
return NULL;
@@ -645,7 +645,7 @@
PyTuple_SET_ITEM(tuple, 2, repr);
- rtnval = PyString_Format(fmt, tuple);
+ rtnval = PyBytes_Format(fmt, tuple);
Py_DECREF(fmt);
Py_DECREF(tuple);
@@ -654,7 +654,7 @@
PyObject *fmt;
PyObject *tuple;
- fmt = PyString_FromString("[Errno %s] %s");
+ fmt = PyBytes_FromString("[Errno %s] %s");
if (!fmt)
return NULL;
@@ -681,7 +681,7 @@
PyTuple_SET_ITEM(tuple, 1, Py_None);
}
- rtnval = PyString_Format(fmt, tuple);
+ rtnval = PyBytes_Format(fmt, tuple);
Py_DECREF(fmt);
Py_DECREF(tuple);
@@ -841,7 +841,7 @@
PyObject *repr;
PyObject *tuple;
- fmt = PyString_FromString("[Error %s] %s: %s");
+ fmt = PyBytes_FromString("[Error %s] %s: %s");
if (!fmt)
return NULL;
@@ -876,7 +876,7 @@
PyTuple_SET_ITEM(tuple, 2, repr);
- rtnval = PyString_Format(fmt, tuple);
+ rtnval = PyBytes_Format(fmt, tuple);
Py_DECREF(fmt);
Py_DECREF(tuple);
@@ -885,7 +885,7 @@
PyObject *fmt;
PyObject *tuple;
- fmt = PyString_FromString("[Error %s] %s");
+ fmt = PyBytes_FromString("[Error %s] %s");
if (!fmt)
return NULL;
@@ -912,7 +912,7 @@
PyTuple_SET_ITEM(tuple, 1, Py_None);
}
- rtnval = PyString_Format(fmt, tuple);
+ rtnval = PyBytes_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 (!PyString_Check(str)) return str;
+ if (!PyBytes_Check(str)) return str;
/* XXX -- do all the additional formatting with filename and
lineno here */
have_filename = (self->filename != NULL) &&
- PyString_Check(self->filename);
+ PyBytes_Check(self->filename);
have_lineno = (self->lineno != NULL) && PyInt_Check(self->lineno);
if (!have_filename && !have_lineno)
return str;
- bufsize = PyString_GET_SIZE(str) + 64;
+ bufsize = PyBytes_GET_SIZE(str) + 64;
if (have_filename)
- bufsize += PyString_GET_SIZE(self->filename);
+ bufsize += PyBytes_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)",
- PyString_AS_STRING(str),
- my_basename(PyString_AS_STRING(self->filename)),
+ PyBytes_AS_STRING(str),
+ my_basename(PyBytes_AS_STRING(self->filename)),
PyInt_AsLong(self->lineno));
else if (have_filename)
PyOS_snprintf(buffer, bufsize, "%s (%s)",
- PyString_AS_STRING(str),
- my_basename(PyString_AS_STRING(self->filename)));
+ PyBytes_AS_STRING(str),
+ my_basename(PyBytes_AS_STRING(self->filename)));
else /* only have_lineno */
PyOS_snprintf(buffer, bufsize, "%s (line %ld)",
- PyString_AS_STRING(str),
+ PyBytes_AS_STRING(str),
PyInt_AsLong(self->lineno));
- result = PyString_FromString(buffer);
+ result = PyBytes_FromString(buffer);
PyMem_FREE(buffer);
if (result == NULL)
@@ -1250,7 +1250,7 @@
return NULL;
}
- if (!PyString_Check(attr)) {
+ if (!PyBytes_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 = PyString_FromString(value);
+ PyObject *obj = PyBytes_FromString(value);
if (!obj)
return -1;
Py_CLEAR(*attr);
@@ -1345,7 +1345,7 @@
"object");
if (!obj)
return -1;
- size = PyString_GET_SIZE(obj);
+ size = PyBytes_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 = PyString_GET_SIZE(obj);
+ size = PyBytes_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!",
- &PyString_Type, &self->encoding,
+ &PyBytes_Type, &self->encoding,
objecttype, &self->object,
&self->start,
&self->end,
- &PyString_Type, &self->reason)) {
+ &PyBytes_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 PyString_FromFormat(
+ return PyBytes_FromFormat(
"'%.400s' codec can't encode character u'\\%s' in position %zd: %.400s",
- PyString_AS_STRING(uself->encoding),
+ PyBytes_AS_STRING(uself->encoding),
badchar_str,
uself->start,
- PyString_AS_STRING(uself->reason)
+ PyBytes_AS_STRING(uself->reason)
);
}
- return PyString_FromFormat(
+ return PyBytes_FromFormat(
"'%.400s' codec can't encode characters in position %zd-%zd: %.400s",
- PyString_AS_STRING(uself->encoding),
+ PyBytes_AS_STRING(uself->encoding),
uself->start,
uself->end-1,
- PyString_AS_STRING(uself->reason)
+ PyBytes_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, &PyString_Type);
+ kwds, &PyBytes_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)PyString_AS_STRING(uself->object)[uself->start])&0xff);
- return PyString_FromFormat(
+ ((int)PyBytes_AS_STRING(uself->object)[uself->start])&0xff);
+ return PyBytes_FromFormat(
"'%.400s' codec can't decode byte 0x%s in position %zd: %.400s",
- PyString_AS_STRING(uself->encoding),
+ PyBytes_AS_STRING(uself->encoding),
byte,
uself->start,
- PyString_AS_STRING(uself->reason)
+ PyBytes_AS_STRING(uself->reason)
);
}
- return PyString_FromFormat(
+ return PyBytes_FromFormat(
"'%.400s' codec can't decode bytes in position %zd-%zd: %.400s",
- PyString_AS_STRING(uself->encoding),
+ PyBytes_AS_STRING(uself->encoding),
uself->start,
uself->end-1,
- PyString_AS_STRING(uself->reason)
+ PyBytes_AS_STRING(uself->reason)
);
}
@@ -1718,7 +1718,7 @@
&PyUnicode_Type, &self->object,
&self->start,
&self->end,
- &PyString_Type, &self->reason)) {
+ &PyBytes_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 PyString_FromFormat(
+ return PyBytes_FromFormat(
"can't translate character u'\\%s' in position %zd: %.400s",
badchar_str,
uself->start,
- PyString_AS_STRING(uself->reason)
+ PyBytes_AS_STRING(uself->reason)
);
}
- return PyString_FromFormat(
+ return PyBytes_FromFormat(
"can't translate characters in position %zd-%zd: %.400s",
uself->start,
uself->end-1,
- PyString_AS_STRING(uself->reason)
+ PyBytes_AS_STRING(uself->reason)
);
}
@@ -2111,7 +2111,7 @@
(PyBaseExceptionObject *)PyExc_RecursionErrorInst;
PyObject *args_tuple;
PyObject *exc_message;
- exc_message = PyString_FromString("maximum recursion depth exceeded");
+ exc_message = PyBytes_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 4f8c46b..86f3a14 100644
--- a/Objects/fileobject.c
+++ b/Objects/fileobject.c
@@ -26,7 +26,7 @@
#include <io.h>
#endif
-#define BUF(v) PyString_AS_STRING((PyStringObject *)v)
+#define BUF(v) PyBytes_AS_STRING((PyBytesObject *)v)
#ifndef DONT_HAVE_ERRNO_H
#include <errno.h>
@@ -159,7 +159,7 @@
Py_INCREF(name);
f->f_name = name;
- f->f_mode = PyString_FromString(mode);
+ f->f_mode = PyBytes_FromString(mode);
f->f_close = close;
f->f_softspace = 0;
@@ -367,7 +367,7 @@
PyFileObject *f = (PyFileObject *)PyFile_Type.tp_new(&PyFile_Type,
NULL, NULL);
if (f != NULL) {
- PyObject *o_name = PyString_FromString(name);
+ PyObject *o_name = PyBytes_FromString(name);
if (o_name == NULL)
return NULL;
if (fill_file_fields(f, fp, o_name, mode, close) == NULL) {
@@ -441,7 +441,7 @@
PyFile_SetEncoding(PyObject *f, const char *enc)
{
PyFileObject *file = (PyFileObject*)f;
- PyObject *str = PyString_FromString(enc);
+ PyObject *str = PyBytes_FromString(enc);
assert(PyFile_Check(f));
if (!str)
@@ -502,20 +502,20 @@
#ifdef Py_USING_UNICODE
PyObject *ret = NULL;
PyObject *name = PyUnicode_AsUnicodeEscapeString(f->f_name);
- const char *name_str = name ? PyString_AsString(name) : "?";
- ret = PyString_FromFormat("<%s file u'%s', mode '%s' at %p>",
+ const char *name_str = name ? PyBytes_AsString(name) : "?";
+ ret = PyBytes_FromFormat("<%s file u'%s', mode '%s' at %p>",
f->f_fp == NULL ? "closed" : "open",
name_str,
- PyString_AsString(f->f_mode),
+ PyBytes_AsString(f->f_mode),
f);
Py_XDECREF(name);
return ret;
#endif
} else {
- return PyString_FromFormat("<%s file '%s', mode '%s' at %p>",
+ return PyBytes_FromFormat("<%s file '%s', mode '%s' at %p>",
f->f_fp == NULL ? "closed" : "open",
- PyString_AsString(f->f_name),
- PyString_AsString(f->f_mode),
+ PyBytes_AsString(f->f_name),
+ PyBytes_AsString(f->f_mode),
f);
}
}
@@ -935,7 +935,7 @@
"requested number of bytes is more than a Python string can hold");
return NULL;
}
- v = PyString_FromStringAndSize((char *)NULL, buffersize);
+ v = PyBytes_FromStringAndSize((char *)NULL, buffersize);
if (v == NULL)
return NULL;
bytesread = 0;
@@ -966,7 +966,7 @@
}
if (bytesrequested < 0) {
buffersize = new_buffersize(f, buffersize);
- if (_PyString_Resize(&v, buffersize) < 0)
+ if (_PyBytes_Resize(&v, buffersize) < 0)
return NULL;
} else {
/* Got what was requested. */
@@ -974,7 +974,7 @@
}
}
if (bytesread != buffersize)
- _PyString_Resize(&v, bytesread);
+ _PyBytes_Resize(&v, bytesread);
return v;
}
@@ -1092,7 +1092,7 @@
size_t increment; /* amount to increment the buffer */
size_t prev_v_size;
- /* Optimize for normal case: avoid _PyString_Resize if at all
+ /* Optimize for normal case: avoid _PyBytes_Resize if at all
* possible via first reading into stack buffer "buf".
*/
total_v_size = INITBUFSIZE; /* start small and pray */
@@ -1110,7 +1110,7 @@
clearerr(fp);
if (PyErr_CheckSignals())
return NULL;
- v = PyString_FromStringAndSize(buf, pvfree - buf);
+ v = PyBytes_FromStringAndSize(buf, pvfree - buf);
return v;
}
/* fgets read *something* */
@@ -1139,7 +1139,7 @@
assert(p > pvfree && *(p-1) == '\0');
--p; /* don't include \0 from fgets */
}
- v = PyString_FromStringAndSize(buf, p - buf);
+ v = PyBytes_FromStringAndSize(buf, p - buf);
return v;
}
/* yuck: fgets overwrote all the newlines, i.e. the entire
@@ -1160,7 +1160,7 @@
* into its buffer.
*/
total_v_size = MAXBUFSIZE << 1;
- v = PyString_FromStringAndSize((char*)NULL, (int)total_v_size);
+ v = PyBytes_FromStringAndSize((char*)NULL, (int)total_v_size);
if (v == NULL)
return v;
/* copy over everything except the last null byte */
@@ -1215,13 +1215,13 @@
Py_DECREF(v);
return NULL;
}
- if (_PyString_Resize(&v, (int)total_v_size) < 0)
+ if (_PyBytes_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)
- _PyString_Resize(&v, p - BUF(v));
+ _PyBytes_Resize(&v, p - BUF(v));
return v;
#undef INITBUFSIZE
#undef MAXBUFSIZE
@@ -1253,7 +1253,7 @@
return getline_via_fgets(f, fp);
#endif
total_v_size = n > 0 ? n : 100;
- v = PyString_FromStringAndSize((char *)NULL, total_v_size);
+ v = PyBytes_FromStringAndSize((char *)NULL, total_v_size);
if (v == NULL)
return NULL;
buf = BUF(v);
@@ -1326,7 +1326,7 @@
Py_DECREF(v);
return NULL;
}
- if (_PyString_Resize(&v, total_v_size) < 0)
+ if (_PyBytes_Resize(&v, total_v_size) < 0)
return NULL;
buf = BUF(v) + used_v_size;
end = BUF(v) + total_v_size;
@@ -1334,7 +1334,7 @@
used_v_size = buf - BUF(v);
if (used_v_size != total_v_size)
- _PyString_Resize(&v, used_v_size);
+ _PyBytes_Resize(&v, used_v_size);
return v;
}
@@ -1379,7 +1379,7 @@
result = PyEval_CallObject(reader, args);
Py_DECREF(reader);
Py_DECREF(args);
- if (result != NULL && !PyString_Check(result) &&
+ if (result != NULL && !PyBytes_Check(result) &&
!PyUnicode_Check(result)) {
Py_DECREF(result);
result = NULL;
@@ -1388,9 +1388,9 @@
}
}
- if (n < 0 && result != NULL && PyString_Check(result)) {
- char *s = PyString_AS_STRING(result);
- Py_ssize_t len = PyString_GET_SIZE(result);
+ if (n < 0 && result != NULL && PyBytes_Check(result)) {
+ char *s = PyBytes_AS_STRING(result);
+ Py_ssize_t len = PyBytes_GET_SIZE(result);
if (len == 0) {
Py_DECREF(result);
result = NULL;
@@ -1399,10 +1399,10 @@
}
else if (s[len-1] == '\n') {
if (result->ob_refcnt == 1)
- _PyString_Resize(&result, len-1);
+ _PyBytes_Resize(&result, len-1);
else {
PyObject *v;
- v = PyString_FromStringAndSize(s, len-1);
+ v = PyBytes_FromStringAndSize(s, len-1);
Py_DECREF(result);
result = v;
}
@@ -1450,7 +1450,7 @@
if (!PyArg_ParseTuple(args, "|i:readline", &n))
return NULL;
if (n == 0)
- return PyString_FromString("");
+ return PyBytes_FromString("");
if (n < 0)
n = 0;
return get_line(f, n);
@@ -1516,18 +1516,18 @@
}
if (big_buffer == NULL) {
/* Create the big buffer */
- big_buffer = PyString_FromStringAndSize(
+ big_buffer = PyBytes_FromStringAndSize(
NULL, buffersize);
if (big_buffer == NULL)
goto error;
- buffer = PyString_AS_STRING(big_buffer);
+ buffer = PyBytes_AS_STRING(big_buffer);
memcpy(buffer, small_buffer, nfilled);
}
else {
/* Grow the big buffer */
- if ( _PyString_Resize(&big_buffer, buffersize) < 0 )
+ if ( _PyBytes_Resize(&big_buffer, buffersize) < 0 )
goto error;
- buffer = PyString_AS_STRING(big_buffer);
+ buffer = PyBytes_AS_STRING(big_buffer);
}
continue;
}
@@ -1536,7 +1536,7 @@
do {
/* Process complete lines */
p++;
- line = PyString_FromStringAndSize(q, p-q);
+ line = PyBytes_FromStringAndSize(q, p-q);
if (line == NULL)
goto error;
err = PyList_Append(list, line);
@@ -1555,7 +1555,7 @@
}
if (nfilled != 0) {
/* Partial last line */
- line = PyString_FromStringAndSize(buffer, nfilled);
+ line = PyBytes_FromStringAndSize(buffer, nfilled);
if (line == NULL)
goto error;
if (sizehint > 0) {
@@ -1565,7 +1565,7 @@
Py_DECREF(line);
goto error;
}
- PyString_Concat(&line, rest);
+ PyBytes_Concat(&line, rest);
Py_DECREF(rest);
if (line == NULL)
goto error;
@@ -1672,7 +1672,7 @@
could potentially execute Python code. */
for (i = 0; i < j; i++) {
PyObject *v = PyList_GET_ITEM(list, i);
- if (!PyString_Check(v)) {
+ if (!PyBytes_Check(v)) {
const char *buffer;
if (((f->f_binary &&
PyObject_AsReadBuffer(v,
@@ -1685,7 +1685,7 @@
"writelines() argument must be a sequence of strings");
goto error;
}
- line = PyString_FromStringAndSize(buffer,
+ line = PyBytes_FromStringAndSize(buffer,
len);
if (line == NULL)
goto error;
@@ -1701,8 +1701,8 @@
errno = 0;
for (i = 0; i < j; i++) {
line = PyList_GET_ITEM(list, i);
- len = PyString_GET_SIZE(line);
- nwritten = fwrite(PyString_AS_STRING(line),
+ len = PyBytes_GET_SIZE(line);
+ nwritten = fwrite(PyBytes_AS_STRING(line),
1, len, f->f_fp);
if (nwritten != len) {
FILE_ABORT_ALLOW_THREADS(f)
@@ -1896,13 +1896,13 @@
Py_INCREF(Py_None);
return Py_None;
case NEWLINE_CR:
- return PyString_FromString("\r");
+ return PyBytes_FromString("\r");
case NEWLINE_LF:
- return PyString_FromString("\n");
+ return PyBytes_FromString("\n");
case NEWLINE_CR|NEWLINE_LF:
return Py_BuildValue("(ss)", "\r", "\n");
case NEWLINE_CRLF:
- return PyString_FromString("\r\n");
+ return PyBytes_FromString("\r\n");
case NEWLINE_CR|NEWLINE_CRLF:
return Py_BuildValue("(ss)", "\r", "\r\n");
case NEWLINE_LF|NEWLINE_CRLF:
@@ -2004,10 +2004,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 PyStringObject *
+static PyBytesObject *
readahead_get_line_skip(PyFileObject *f, int skip, int bufsize)
{
- PyStringObject* s;
+ PyBytesObject* s;
char *bufptr;
char *buf;
Py_ssize_t len;
@@ -2018,17 +2018,17 @@
len = f->f_bufend - f->f_bufptr;
if (len == 0)
- return (PyStringObject *)
- PyString_FromStringAndSize(NULL, skip);
+ return (PyBytesObject *)
+ PyBytes_FromStringAndSize(NULL, skip);
bufptr = (char *)memchr(f->f_bufptr, '\n', len);
if (bufptr != NULL) {
bufptr++; /* Count the '\n' */
len = bufptr - f->f_bufptr;
- s = (PyStringObject *)
- PyString_FromStringAndSize(NULL, skip+len);
+ s = (PyBytesObject *)
+ PyBytes_FromStringAndSize(NULL, skip+len);
if (s == NULL)
return NULL;
- memcpy(PyString_AS_STRING(s)+skip, f->f_bufptr, len);
+ memcpy(PyBytes_AS_STRING(s)+skip, f->f_bufptr, len);
f->f_bufptr = bufptr;
if (bufptr == f->f_bufend)
drop_readahead(f);
@@ -2043,7 +2043,7 @@
PyMem_Free(buf);
return NULL;
}
- memcpy(PyString_AS_STRING(s)+skip, bufptr, len);
+ memcpy(PyBytes_AS_STRING(s)+skip, bufptr, len);
PyMem_Free(buf);
}
return s;
@@ -2055,13 +2055,13 @@
static PyObject *
file_iternext(PyFileObject *f)
{
- PyStringObject* l;
+ PyBytesObject* l;
if (f->f_fp == NULL)
return err_closed();
l = readahead_get_line_skip(f, 0, READAHEAD_BUFSIZE);
- if (l == NULL || PyString_GET_SIZE(l) == 0) {
+ if (l == NULL || PyBytes_GET_SIZE(l) == 0) {
Py_XDECREF(l);
return NULL;
}
@@ -2078,7 +2078,7 @@
assert(type != NULL && type->tp_alloc != NULL);
if (not_yet_string == NULL) {
- not_yet_string = PyString_InternFromString("<uninitialized file>");
+ not_yet_string = PyBytes_InternFromString("<uninitialized file>");
if (not_yet_string == NULL)
return NULL;
}
@@ -2294,7 +2294,7 @@
#ifdef Py_USING_UNICODE
if ((flags & Py_PRINT_RAW) &&
PyUnicode_Check(v) && enc != Py_None) {
- char *cenc = PyString_AS_STRING(enc);
+ char *cenc = PyBytes_AS_STRING(enc);
value = PyUnicode_AsEncodedString(v, cenc, "strict");
if (value == NULL)
return -1;
@@ -2365,7 +2365,7 @@
return 0;
}
else if (!PyErr_Occurred()) {
- PyObject *v = PyString_FromString(s);
+ PyObject *v = PyBytes_FromString(s);
int err;
if (v == NULL)
return -1;
diff --git a/Objects/floatobject.c b/Objects/floatobject.c
index ceb0b6d..3b49341 100644
--- a/Objects/floatobject.c
+++ b/Objects/floatobject.c
@@ -185,9 +185,9 @@
if (pend)
*pend = NULL;
- if (PyString_Check(v)) {
- s = PyString_AS_STRING(v);
- len = PyString_GET_SIZE(v);
+ if (PyBytes_Check(v)) {
+ s = PyBytes_AS_STRING(v);
+ len = PyBytes_GET_SIZE(v);
}
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(v)) {
@@ -488,7 +488,7 @@
char buf[100];
format_float(buf, sizeof(buf), v, PREC_REPR);
- return PyString_FromString(buf);
+ return PyBytes_FromString(buf);
}
static PyObject *
@@ -496,7 +496,7 @@
{
char buf[100];
format_float(buf, sizeof(buf), v, PREC_STR);
- return PyString_FromString(buf);
+ return PyBytes_FromString(buf);
}
/* Comparison is pretty much a nightmare. When comparing float to float,
@@ -1221,7 +1221,7 @@
return float_subtype_new(type, args, kwds); /* Wimp out */
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O:float", kwlist, &x))
return NULL;
- if (PyString_Check(x))
+ if (PyBytes_Check(x))
return PyFloat_FromString(x, NULL);
return PyNumber_Float(x);
}
@@ -1272,13 +1272,13 @@
char* s;
float_format_type r;
- if (!PyString_Check(arg)) {
+ if (!PyBytes_Check(arg)) {
PyErr_Format(PyExc_TypeError,
"__getformat__() argument must be string, not %.500s",
Py_TYPE(arg)->tp_name);
return NULL;
}
- s = PyString_AS_STRING(arg);
+ s = PyBytes_AS_STRING(arg);
if (strcmp(s, "double") == 0) {
r = double_format;
}
@@ -1294,11 +1294,11 @@
switch (r) {
case unknown_format:
- return PyString_FromString("unknown");
+ return PyBytes_FromString("unknown");
case ieee_little_endian_format:
- return PyString_FromString("IEEE, little-endian");
+ return PyBytes_FromString("IEEE, little-endian");
case ieee_big_endian_format:
- return PyString_FromString("IEEE, big-endian");
+ return PyBytes_FromString("IEEE, big-endian");
default:
Py_FatalError("insane float_format or double_format");
return NULL;
@@ -1397,7 +1397,7 @@
if (!PyArg_ParseTuple(args, "O:__format__", &format_spec))
return NULL;
- if (PyString_Check(format_spec))
+ if (PyBytes_Check(format_spec))
return string_float__format__(self, args);
if (PyUnicode_Check(format_spec)) {
/* Convert format_spec to a str */
diff --git a/Objects/frameobject.c b/Objects/frameobject.c
index 025431e..36c1fc2 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. */
- PyString_AsStringAndSize(f->f_code->co_lnotab, &lnotab, &lnotab_len);
+ PyBytes_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. */
- PyString_AsStringAndSize(f->f_code->co_code, (char **)&code, &code_len);
+ PyBytes_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 = PyString_InternFromString("__builtins__");
+ builtin_object = PyBytes_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(PyString_Check(key));
+ assert(PyBytes_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(PyString_Check(key));
+ assert(PyBytes_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 a2e87b7..216b6da 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 (!PyString_Check(doc) && !PyUnicode_Check(doc))
+ if (!PyBytes_Check(doc) && !PyUnicode_Check(doc))
doc = Py_None;
}
else
@@ -42,7 +42,7 @@
Otherwise, use None.
*/
if (!__name__) {
- __name__ = PyString_InternFromString("__name__");
+ __name__ = PyBytes_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",
- PyString_AsString(op->func_name),
+ PyBytes_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 || !PyString_Check(value)) {
+ if (value == NULL || !PyBytes_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 && !PyString_Check(name)) {
+ if (name != Py_None && !PyBytes_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",
- PyString_AS_STRING(code->co_name),
+ PyBytes_AS_STRING(code->co_name),
nfree, nclosure);
if (nclosure) {
Py_ssize_t i;
@@ -465,8 +465,8 @@
static PyObject*
func_repr(PyFunctionObject *op)
{
- return PyString_FromFormat("<function %s at %p>",
- PyString_AsString(op->func_name),
+ return PyBytes_FromFormat("<function %s at %p>",
+ PyBytes_AsString(op->func_name),
op);
}
diff --git a/Objects/genobject.c b/Objects/genobject.c
index d2ef508..b1c51a8 100644
--- a/Objects/genobject.c
+++ b/Objects/genobject.c
@@ -285,10 +285,10 @@
gen_repr(PyGenObject *gen)
{
char *code_name;
- code_name = PyString_AsString(((PyCodeObject *)gen->gi_code)->co_name);
+ code_name = PyBytes_AsString(((PyCodeObject *)gen->gi_code)->co_name);
if (code_name == NULL)
return NULL;
- return PyString_FromFormat("<generator object %.200s at %p>",
+ return PyBytes_FromFormat("<generator object %.200s at %p>",
code_name, gen);
}
diff --git a/Objects/intobject.c b/Objects/intobject.c
index eacad9d..2af9451 100644
--- a/Objects/intobject.c
+++ b/Objects/intobject.c
@@ -368,7 +368,7 @@
if (*end != '\0') {
bad:
slen = strlen(s) < 200 ? strlen(s) : 200;
- sobj = PyString_FromStringAndSize(s, slen);
+ sobj = PyBytes_FromStringAndSize(s, slen);
if (sobj == NULL)
return NULL;
srepr = PyObject_Repr(sobj);
@@ -377,7 +377,7 @@
return NULL;
PyErr_Format(PyExc_ValueError,
"invalid literal for int() with base %d: %s",
- base, PyString_AS_STRING(srepr));
+ base, PyBytes_AS_STRING(srepr));
Py_DECREF(srepr);
return NULL;
}
@@ -965,11 +965,11 @@
return PyInt_FromLong(0L);
if (base == -909)
return PyNumber_Int(x);
- if (PyString_Check(x)) {
+ if (PyBytes_Check(x)) {
/* Since PyInt_FromString doesn't have a length parameter,
* check here for possible NULs in the string. */
- char *string = PyString_AS_STRING(x);
- if (strlen(string) != PyString_Size(x)) {
+ char *string = PyBytes_AS_STRING(x);
+ if (strlen(string) != PyBytes_Size(x)) {
/* create a repr() of the input string,
* just like PyInt_FromString does */
PyObject *srepr;
@@ -978,7 +978,7 @@
return NULL;
PyErr_Format(PyExc_ValueError,
"invalid literal for int() with base %d: %s",
- base, PyString_AS_STRING(srepr));
+ base, PyBytes_AS_STRING(srepr));
Py_DECREF(srepr);
return NULL;
}
@@ -1106,7 +1106,7 @@
if (negative)
*--p = '-';
- return PyString_FromStringAndSize(p, &buf[sizeof(buf)] - p);
+ return PyBytes_FromStringAndSize(p, &buf[sizeof(buf)] - p);
}
static PyObject *
@@ -1116,7 +1116,7 @@
if (!PyArg_ParseTuple(args, "O:__format__", &format_spec))
return NULL;
- if (PyString_Check(format_spec))
+ if (PyBytes_Check(format_spec))
return string_int__format__(self, args);
if (PyUnicode_Check(format_spec)) {
/* Convert format_spec to a str */
diff --git a/Objects/listobject.c b/Objects/listobject.c
index ee2fda1..9d742d8 100644
--- a/Objects/listobject.c
+++ b/Objects/listobject.c
@@ -174,7 +174,7 @@
}
if (i < 0 || i >= Py_SIZE(op)) {
if (indexerr == NULL)
- indexerr = PyString_FromString(
+ indexerr = PyBytes_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 ? PyString_FromString("[...]") : NULL;
+ return i > 0 ? PyBytes_FromString("[...]") : NULL;
}
if (Py_SIZE(v) == 0) {
- result = PyString_FromString("[]");
+ result = PyBytes_FromString("[]");
goto Done;
}
@@ -379,29 +379,29 @@
/* Add "[]" decorations to the first and last items. */
assert(PyList_GET_SIZE(pieces) > 0);
- s = PyString_FromString("[");
+ s = PyBytes_FromString("[");
if (s == NULL)
goto Done;
temp = PyList_GET_ITEM(pieces, 0);
- PyString_ConcatAndDel(&s, temp);
+ PyBytes_ConcatAndDel(&s, temp);
PyList_SET_ITEM(pieces, 0, s);
if (s == NULL)
goto Done;
- s = PyString_FromString("]");
+ s = PyBytes_FromString("]");
if (s == NULL)
goto Done;
temp = PyList_GET_ITEM(pieces, PyList_GET_SIZE(pieces) - 1);
- PyString_ConcatAndDel(&temp, s);
+ PyBytes_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 = PyString_FromString(", ");
+ s = PyBytes_FromString(", ");
if (s == NULL)
goto Done;
- result = _PyString_Join(s, pieces);
+ result = _PyBytes_Join(s, pieces);
Py_DECREF(s);
Done:
@@ -433,7 +433,7 @@
{
if (i < 0 || i >= Py_SIZE(a)) {
if (indexerr == NULL)
- indexerr = PyString_FromString(
+ indexerr = PyBytes_FromString(
"list index out of range");
PyErr_SetObject(PyExc_IndexError, indexerr);
return NULL;
diff --git a/Objects/longobject.c b/Objects/longobject.c
index 7fc4576..5922aa5 100644
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -1200,7 +1200,7 @@
_PyLong_Format(PyObject *aa, int base, int addL, int newstyle)
{
register PyLongObject *a = (PyLongObject *)aa;
- PyStringObject *str;
+ PyBytesObject *str;
Py_ssize_t i, j, sz;
Py_ssize_t size_a;
char *p;
@@ -1229,10 +1229,10 @@
"long is too large to format");
return NULL;
}
- str = (PyStringObject *) PyString_FromStringAndSize((char *)0, sz);
+ str = (PyBytesObject *) PyBytes_FromStringAndSize((char *)0, sz);
if (str == NULL)
return NULL;
- p = PyString_AS_STRING(str) + sz;
+ p = PyBytes_AS_STRING(str) + sz;
*p = '\0';
if (addL)
*--p = 'L';
@@ -1258,7 +1258,7 @@
do {
char cdigit = (char)(accum & (base - 1));
cdigit += (cdigit < 10) ? '0' : 'a'-10;
- assert(p > PyString_AS_STRING(str));
+ assert(p > PyBytes_AS_STRING(str));
*--p = cdigit;
accumbits -= basebits;
accum >>= basebits;
@@ -1310,7 +1310,7 @@
do {
digit nextrem = (digit)(rem / base);
char c = (char)(rem - nextrem * base);
- assert(p > PyString_AS_STRING(str));
+ assert(p > PyBytes_AS_STRING(str));
c += (c < 10) ? '0' : 'a'-10;
*--p = c;
rem = nextrem;
@@ -1348,14 +1348,14 @@
}
if (sign)
*--p = sign;
- if (p != PyString_AS_STRING(str)) {
- char *q = PyString_AS_STRING(str);
+ if (p != PyBytes_AS_STRING(str)) {
+ char *q = PyBytes_AS_STRING(str);
assert(p > q);
do {
} while ((*q++ = *p++) != '\0');
q--;
- _PyString_Resize((PyObject **)&str,
- (Py_ssize_t) (q - PyString_AS_STRING(str)));
+ _PyBytes_Resize((PyObject **)&str,
+ (Py_ssize_t) (q - PyBytes_AS_STRING(str)));
}
return (PyObject *)str;
}
@@ -1719,7 +1719,7 @@
onError:
Py_XDECREF(z);
slen = strlen(orig_str) < 200 ? strlen(orig_str) : 200;
- strobj = PyString_FromStringAndSize(orig_str, slen);
+ strobj = PyBytes_FromStringAndSize(orig_str, slen);
if (strobj == NULL)
return NULL;
strrepr = PyObject_Repr(strobj);
@@ -1728,7 +1728,7 @@
return NULL;
PyErr_Format(PyExc_ValueError,
"invalid literal for long() with base %d: %s",
- base, PyString_AS_STRING(strrepr));
+ base, PyBytes_AS_STRING(strrepr));
Py_DECREF(strrepr);
return NULL;
}
@@ -3332,11 +3332,11 @@
return PyLong_FromLong(0L);
if (base == -909)
return PyNumber_Long(x);
- else if (PyString_Check(x)) {
+ else if (PyBytes_Check(x)) {
/* Since PyLong_FromString doesn't have a length parameter,
* check here for possible NULs in the string. */
- char *string = PyString_AS_STRING(x);
- if (strlen(string) != PyString_Size(x)) {
+ char *string = PyBytes_AS_STRING(x);
+ if (strlen(string) != PyBytes_Size(x)) {
/* create a repr() of the input string,
* just like PyLong_FromString does. */
PyObject *srepr;
@@ -3345,11 +3345,11 @@
return NULL;
PyErr_Format(PyExc_ValueError,
"invalid literal for long() with base %d: %s",
- base, PyString_AS_STRING(srepr));
+ base, PyBytes_AS_STRING(srepr));
Py_DECREF(srepr);
return NULL;
}
- return PyLong_FromString(PyString_AS_STRING(x), NULL, base);
+ return PyLong_FromString(PyBytes_AS_STRING(x), NULL, base);
}
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(x))
@@ -3414,7 +3414,7 @@
if (!PyArg_ParseTuple(args, "O:__format__", &format_spec))
return NULL;
- if (PyString_Check(format_spec))
+ if (PyBytes_Check(format_spec))
return string_long__format__(self, args);
if (PyUnicode_Check(format_spec)) {
/* Convert format_spec to a str */
diff --git a/Objects/methodobject.c b/Objects/methodobject.c
index 737a3f7..57ab5c5 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 PyString_FromString(doc);
+ return PyBytes_FromString(doc);
Py_INCREF(Py_None);
return Py_None;
}
@@ -157,7 +157,7 @@
static PyObject *
meth_get__name__(PyCFunctionObject *m, void *closure)
{
- return PyString_FromString(m->m_ml->ml_name);
+ return PyBytes_FromString(m->m_ml->ml_name);
}
static int
@@ -202,9 +202,9 @@
meth_repr(PyCFunctionObject *m)
{
if (m->m_self == NULL)
- return PyString_FromFormat("<built-in function %s>",
+ return PyBytes_FromFormat("<built-in function %s>",
m->m_ml->ml_name);
- return PyString_FromFormat("<built-in method %s of %s object at %p>",
+ return PyBytes_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, PyString_FromString(ml->ml_name));
+ PyList_SetItem(v, i, PyBytes_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 PyString_FromString(doc);
+ return PyBytes_FromString(doc);
}
}
while (chain != NULL) {
diff --git a/Objects/moduleobject.c b/Objects/moduleobject.c
index d1aa771..fa3daa9 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 = PyString_FromString(name);
+ nameobj = PyBytes_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 ||
- !PyString_Check(nameobj))
+ !PyBytes_Check(nameobj))
{
PyErr_SetString(PyExc_SystemError, "nameless module");
return NULL;
}
- return PyString_AsString(nameobj);
+ return PyBytes_AsString(nameobj);
}
char *
@@ -88,12 +88,12 @@
d = ((PyModuleObject *)m)->md_dict;
if (d == NULL ||
(fileobj = PyDict_GetItemString(d, "__file__")) == NULL ||
- !PyString_Check(fileobj))
+ !PyBytes_Check(fileobj))
{
PyErr_SetString(PyExc_SystemError, "module filename missing");
return NULL;
}
- return PyString_AsString(fileobj);
+ return PyBytes_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 && PyString_Check(key)) {
- char *s = PyString_AsString(key);
+ if (value != Py_None && PyBytes_Check(key)) {
+ char *s = PyBytes_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 && PyString_Check(key)) {
- char *s = PyString_AsString(key);
+ if (value != Py_None && PyBytes_Check(key)) {
+ char *s = PyBytes_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 PyString_FromFormat("<module '%s' (built-in)>", name);
+ return PyBytes_FromFormat("<module '%s' (built-in)>", name);
}
- return PyString_FromFormat("<module '%s' from '%s'>", name, filename);
+ return PyBytes_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 ccb5ab7..8f9d731 100644
--- a/Objects/object.c
+++ b/Objects/object.c
@@ -357,9 +357,9 @@
}
#endif
if (v == NULL)
- return PyString_FromString("<NULL>");
+ return PyBytes_FromString("<NULL>");
else if (Py_TYPE(v)->tp_repr == NULL)
- return PyString_FromFormat("<%s object at %p>",
+ return PyBytes_FromFormat("<%s object at %p>",
Py_TYPE(v)->tp_name, v);
else {
PyObject *res;
@@ -377,7 +377,7 @@
return NULL;
}
#endif
- if (!PyString_Check(res)) {
+ if (!PyBytes_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 PyString_FromString("<NULL>");
- if (PyString_CheckExact(v)) {
+ return PyBytes_FromString("<NULL>");
+ if (PyBytes_CheckExact(v)) {
Py_INCREF(v);
return v;
}
@@ -416,7 +416,7 @@
Py_LeaveRecursiveCall();
if (res == NULL)
return NULL;
- type_ok = PyString_Check(res);
+ type_ok = PyBytes_Check(res);
#ifdef Py_USING_UNICODE
type_ok = type_ok || PyUnicode_Check(res);
#endif
@@ -447,7 +447,7 @@
return NULL;
}
#endif
- assert(PyString_Check(res));
+ assert(PyBytes_Check(res));
return res;
}
@@ -461,7 +461,7 @@
static PyObject *unicodestr;
if (v == NULL) {
- res = PyString_FromString("<NULL>");
+ res = PyBytes_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= PyString_InternFromString("__unicode__");
+ unicodestr= PyBytes_InternFromString("__unicode__");
if (unicodestr == NULL)
return NULL;
}
@@ -492,7 +492,7 @@
return PyUnicode_FromUnicode(PyUnicode_AS_UNICODE(v),
PyUnicode_GET_SIZE(v));
}
- if (PyString_CheckExact(v)) {
+ if (PyBytes_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 = PyString_InternFromString(name);
+ w = PyBytes_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 = PyString_InternFromString(name);
+ s = PyBytes_InternFromString(name);
if (s == NULL)
return -1;
res = PyObject_SetAttr(v, s, w);
@@ -1125,7 +1125,7 @@
{
PyTypeObject *tp = Py_TYPE(v);
- if (!PyString_Check(name)) {
+ if (!PyBytes_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, PyString_AS_STRING(name));
+ return (*tp->tp_getattr)(v, PyBytes_AS_STRING(name));
PyErr_Format(PyExc_AttributeError,
"'%.50s' object has no attribute '%.400s'",
- tp->tp_name, PyString_AS_STRING(name));
+ tp->tp_name, PyBytes_AS_STRING(name));
return NULL;
}
@@ -1172,7 +1172,7 @@
PyTypeObject *tp = Py_TYPE(v);
int err;
- if (!PyString_Check(name)){
+ if (!PyBytes_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);
- PyString_InternInPlace(&name);
+ PyBytes_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, PyString_AS_STRING(name), value);
+ err = (*tp->tp_setattr)(v, PyBytes_AS_STRING(name), value);
Py_DECREF(name);
return err;
}
@@ -1212,14 +1212,14 @@
"(%s .%.100s)",
tp->tp_name,
value==NULL ? "del" : "assign to",
- PyString_AS_STRING(name));
+ PyBytes_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",
- PyString_AS_STRING(name));
+ PyBytes_AS_STRING(name));
return -1;
}
@@ -1271,7 +1271,7 @@
Py_ssize_t dictoffset;
PyObject **dictptr;
- if (!PyString_Check(name)){
+ if (!PyBytes_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, PyString_AS_STRING(name));
+ tp->tp_name, PyBytes_AS_STRING(name));
done:
Py_DECREF(name);
return res;
@@ -1401,7 +1401,7 @@
PyObject **dictptr;
int res = -1;
- if (!PyString_Check(name)){
+ if (!PyBytes_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, PyString_AS_STRING(name));
+ tp->tp_name, PyBytes_AS_STRING(name));
goto done;
}
PyErr_Format(PyExc_AttributeError,
"'%.50s' object attribute '%.400s' is read-only",
- tp->tp_name, PyString_AS_STRING(name));
+ tp->tp_name, PyBytes_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 (PyString_Check(item)) {
+ if (PyBytes_Check(item)) {
result = PyDict_SetItem(dict, item, Py_None);
if (result < 0)
break;
@@ -1904,7 +1904,7 @@
static PyObject *
none_repr(PyObject *op)
{
- return PyString_FromString("None");
+ return PyBytes_FromString("None");
}
/* ARGUSED */
@@ -1946,7 +1946,7 @@
static PyObject *
NotImplemented_repr(PyObject *op)
{
- return PyString_FromString("NotImplemented");
+ return PyBytes_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(&PyString_Type) < 0)
+ if (PyType_Ready(&PyBytes_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 da4356b..b3ed673 100644
--- a/Objects/rangeobject.c
+++ b/Objects/rangeobject.c
@@ -113,16 +113,16 @@
PyObject *rtn;
if (r->start == 0 && r->step == 1)
- rtn = PyString_FromFormat("xrange(%ld)",
+ rtn = PyBytes_FromFormat("xrange(%ld)",
r->start + r->len * r->step);
else if (r->step == 1)
- rtn = PyString_FromFormat("xrange(%ld, %ld)",
+ rtn = PyBytes_FromFormat("xrange(%ld, %ld)",
r->start,
r->start + r->len * r->step);
else
- rtn = PyString_FromFormat("xrange(%ld, %ld, %ld)",
+ rtn = PyBytes_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 b379845..f63aa75 100644
--- a/Objects/setobject.c
+++ b/Objects/setobject.c
@@ -147,7 +147,7 @@
/*
* Hacked up version of set_lookkey which can assume keys are always strings;
- * This means we can always use _PyString_Eq directly and not have to check to
+ * This means we can always use _PyBytes_Eq directly and not have to check to
* see if the comparison altered the table.
*/
static setentry *
@@ -164,7 +164,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 (!PyString_CheckExact(key)) {
+ if (!PyBytes_CheckExact(key)) {
so->lookup = set_lookkey;
return set_lookkey(so, key, hash);
}
@@ -175,7 +175,7 @@
if (entry->key == dummy)
freeslot = entry;
else {
- if (entry->hash == hash && _PyString_Eq(entry->key, key))
+ if (entry->hash == hash && _PyBytes_Eq(entry->key, key))
return entry;
freeslot = NULL;
}
@@ -190,7 +190,7 @@
if (entry->key == key
|| (entry->hash == hash
&& entry->key != dummy
- && _PyString_Eq(entry->key, key)))
+ && _PyBytes_Eq(entry->key, key)))
return entry;
if (entry->key == dummy && freeslot == NULL)
freeslot = entry;
@@ -377,8 +377,8 @@
register long hash;
register Py_ssize_t n_used;
- if (!PyString_CheckExact(key) ||
- (hash = ((PyStringObject *) key)->ob_shash) == -1) {
+ if (!PyBytes_CheckExact(key) ||
+ (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
hash = PyObject_Hash(key);
if (hash == -1)
return -1;
@@ -424,8 +424,8 @@
PyObject *old_key;
assert (PyAnySet_Check(so));
- if (!PyString_CheckExact(key) ||
- (hash = ((PyStringObject *) key)->ob_shash) == -1) {
+ if (!PyBytes_CheckExact(key) ||
+ (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
hash = PyObject_Hash(key);
if (hash == -1)
return -1;
@@ -614,7 +614,7 @@
if (status != 0) {
if (status < 0)
return NULL;
- return PyString_FromFormat("%s(...)", so->ob_type->tp_name);
+ return PyBytes_FromFormat("%s(...)", so->ob_type->tp_name);
}
keys = PySequence_List((PyObject *)so);
@@ -625,8 +625,8 @@
if (listrepr == NULL)
goto done;
- result = PyString_FromFormat("%s(%s)", so->ob_type->tp_name,
- PyString_AS_STRING(listrepr));
+ result = PyBytes_FromFormat("%s(%s)", so->ob_type->tp_name,
+ PyBytes_AS_STRING(listrepr));
Py_DECREF(listrepr);
done:
Py_ReprLeave((PyObject*)so);
@@ -681,8 +681,8 @@
long hash;
setentry *entry;
- if (!PyString_CheckExact(key) ||
- (hash = ((PyStringObject *) key)->ob_shash) == -1) {
+ if (!PyBytes_CheckExact(key) ||
+ (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
hash = PyObject_Hash(key);
if (hash == -1)
return -1;
@@ -979,7 +979,7 @@
register PySetObject *so = NULL;
if (dummy == NULL) { /* Auto-initialize dummy */
- dummy = PyString_FromString("<dummy key>");
+ dummy = PyBytes_FromString("<dummy key>");
if (dummy == NULL)
return NULL;
}
@@ -2318,7 +2318,7 @@
/* Exercise direct iteration */
i = 0, count = 0;
while (_PySet_Next((PyObject *)dup, &i, &x)) {
- s = PyString_AsString(x);
+ s = PyBytes_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 075418e..75048e3 100644
--- a/Objects/sliceobject.c
+++ b/Objects/sliceobject.c
@@ -19,7 +19,7 @@
static PyObject *
ellipsis_repr(PyObject *op)
{
- return PyString_FromString("Ellipsis");
+ return PyBytes_FromString("Ellipsis");
}
static PyTypeObject PyEllipsis_Type = {
@@ -228,14 +228,14 @@
{
PyObject *s, *comma;
- 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(")"));
+ 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(")"));
Py_DECREF(comma);
return s;
}
diff --git a/Objects/stringlib/formatter.h b/Objects/stringlib/formatter.h
index 22dd292..05ccfea 100644
--- a/Objects/stringlib/formatter.h
+++ b/Objects/stringlib/formatter.h
@@ -778,7 +778,7 @@
/* This is to allow things like u''.format('') */
if (!PyArg_ParseTuple(args, "O:__format__", &format_spec))
goto done;
- if (!(PyString_Check(format_spec) || PyUnicode_Check(format_spec))) {
+ if (!(PyBytes_Check(format_spec) || PyUnicode_Check(format_spec))) {
PyErr_Format(PyExc_TypeError, "__format__ arg must be str "
"or unicode, not %s", Py_TYPE(format_spec)->tp_name);
goto done;
diff --git a/Objects/stringlib/string_format.h b/Objects/stringlib/string_format.h
index be8e808..2e9c7ef 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(PyString_Check(result) || PyUnicode_Check(result));
+ assert(PyBytes_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 daaa2e2..bdc3a29 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 PyStringObject
+#define STRINGLIB_OBJECT PyBytesObject
#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 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_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_CMP memcmp
#define STRINGLIB_TOSTR PyObject_Str
-#define STRINGLIB_GROUPING _PyString_InsertThousandsGrouping
+#define STRINGLIB_GROUPING _PyBytes_InsertThousandsGrouping
#endif /* !STRINGLIB_STRINGDEFS_H */
diff --git a/Objects/stringobject.c b/Objects/stringobject.c
index ea1069d..0f4d4c3 100644
--- a/Objects/stringobject.c
+++ b/Objects/stringobject.c
@@ -12,8 +12,8 @@
int null_strings, one_strings;
#endif
-static PyStringObject *characters[UCHAR_MAX + 1];
-static PyStringObject *nullstring;
+static PyBytesObject *characters[UCHAR_MAX + 1];
+static PyBytesObject *nullstring;
/* This dictionary holds all interned strings. Note that references to
strings in this dictionary are *not* counted in the string's ob_refcnt.
@@ -26,19 +26,19 @@
static PyObject *interned;
/*
- For both PyString_FromString() and PyString_FromStringAndSize(), the
+ For both PyBytes_FromString() and PyBytes_FromStringAndSize(), the
parameter `size' denotes number of characters to allocate, not counting any
null terminating character.
- For PyString_FromString(), the parameter `str' points to a null-terminated
+ For PyBytes_FromString(), the parameter `str' points to a null-terminated
string containing exactly `size' bytes.
- For PyString_FromStringAndSize(), the parameter the parameter `str' is
+ For PyBytes_FromStringAndSize(), the parameter the parameter `str' is
either NULL or else points to a string containing at least `size' bytes.
- For PyString_FromStringAndSize(), the string in the `str' parameter does
+ For PyBytes_FromStringAndSize(), the string in the `str' parameter does
not have to be null-terminated. (Therefore it is safe to construct a
- substring by calling `PyString_FromStringAndSize(origstring, substrlen)'.)
- If `str' is NULL then PyString_FromStringAndSize() will allocate `size+1'
+ substring by calling `PyBytes_FromStringAndSize(origstring, substrlen)'.)
+ If `str' is NULL then PyBytes_FromStringAndSize() will allocate `size+1'
bytes (setting the last byte to the null terminating character) and you can
fill in the data yourself. If `str' is non-NULL then the resulting
PyString object must be treated as immutable and you must not fill in nor
@@ -48,16 +48,16 @@
items" in a variable-size object, will contain the number of bytes
allocated for string data, not counting the null terminating character. It
is therefore equal to the equal to the `size' parameter (for
- PyString_FromStringAndSize()) or the length of the string in the `str'
- parameter (for PyString_FromString()).
+ PyBytes_FromStringAndSize()) or the length of the string in the `str'
+ parameter (for PyBytes_FromString()).
*/
PyObject *
-PyString_FromStringAndSize(const char *str, Py_ssize_t size)
+PyBytes_FromStringAndSize(const char *str, Py_ssize_t size)
{
- register PyStringObject *op;
+ register PyBytesObject *op;
if (size < 0) {
PyErr_SetString(PyExc_SystemError,
- "Negative size passed to PyString_FromStringAndSize");
+ "Negative size passed to PyBytes_FromStringAndSize");
return NULL;
}
if (size == 0 && (op = nullstring) != NULL) {
@@ -78,10 +78,10 @@
}
/* Inline PyObject_NewVar */
- op = (PyStringObject *)PyObject_MALLOC(sizeof(PyStringObject) + size);
+ op = (PyBytesObject *)PyObject_MALLOC(sizeof(PyBytesObject) + size);
if (op == NULL)
return PyErr_NoMemory();
- PyObject_INIT_VAR(op, &PyString_Type, size);
+ PyObject_INIT_VAR(op, &PyBytes_Type, size);
op->ob_shash = -1;
op->ob_sstate = SSTATE_NOT_INTERNED;
if (str != NULL)
@@ -90,14 +90,14 @@
/* share short strings */
if (size == 0) {
PyObject *t = (PyObject *)op;
- PyString_InternInPlace(&t);
- op = (PyStringObject *)t;
+ PyBytes_InternInPlace(&t);
+ op = (PyBytesObject *)t;
nullstring = op;
Py_INCREF(op);
} else if (size == 1 && str != NULL) {
PyObject *t = (PyObject *)op;
- PyString_InternInPlace(&t);
- op = (PyStringObject *)t;
+ PyBytes_InternInPlace(&t);
+ op = (PyBytesObject *)t;
characters[*str & UCHAR_MAX] = op;
Py_INCREF(op);
}
@@ -105,10 +105,10 @@
}
PyObject *
-PyString_FromString(const char *str)
+PyBytes_FromString(const char *str)
{
register size_t size;
- register PyStringObject *op;
+ register PyBytesObject *op;
assert(str != NULL);
size = strlen(str);
@@ -133,24 +133,24 @@
}
/* Inline PyObject_NewVar */
- op = (PyStringObject *)PyObject_MALLOC(sizeof(PyStringObject) + size);
+ op = (PyBytesObject *)PyObject_MALLOC(sizeof(PyBytesObject) + size);
if (op == NULL)
return PyErr_NoMemory();
- PyObject_INIT_VAR(op, &PyString_Type, size);
+ PyObject_INIT_VAR(op, &PyBytes_Type, size);
op->ob_shash = -1;
op->ob_sstate = SSTATE_NOT_INTERNED;
Py_MEMCPY(op->ob_sval, str, size+1);
/* share short strings */
if (size == 0) {
PyObject *t = (PyObject *)op;
- PyString_InternInPlace(&t);
- op = (PyStringObject *)t;
+ PyBytes_InternInPlace(&t);
+ op = (PyBytesObject *)t;
nullstring = op;
Py_INCREF(op);
} else if (size == 1) {
PyObject *t = (PyObject *)op;
- PyString_InternInPlace(&t);
- op = (PyStringObject *)t;
+ PyBytes_InternInPlace(&t);
+ op = (PyBytesObject *)t;
characters[*str & UCHAR_MAX] = op;
Py_INCREF(op);
}
@@ -158,7 +158,7 @@
}
PyObject *
-PyString_FromFormatV(const char *format, va_list vargs)
+PyBytes_FromFormatV(const char *format, va_list vargs)
{
va_list count;
Py_ssize_t n = 0;
@@ -233,11 +233,11 @@
/* step 2: fill the buffer */
/* Since we've analyzed how much space we need for the worst case,
use sprintf directly instead of the slower PyOS_snprintf. */
- string = PyString_FromStringAndSize(NULL, n);
+ string = PyBytes_FromStringAndSize(NULL, n);
if (!string)
return NULL;
- s = PyString_AsString(string);
+ s = PyBytes_AsString(string);
for (f = format; *f; f++) {
if (*f == '%') {
@@ -337,12 +337,12 @@
}
end:
- _PyString_Resize(&string, s - PyString_AS_STRING(string));
+ _PyBytes_Resize(&string, s - PyBytes_AS_STRING(string));
return string;
}
PyObject *
-PyString_FromFormat(const char *format, ...)
+PyBytes_FromFormat(const char *format, ...)
{
PyObject* ret;
va_list vargs;
@@ -352,34 +352,34 @@
#else
va_start(vargs);
#endif
- ret = PyString_FromFormatV(format, vargs);
+ ret = PyBytes_FromFormatV(format, vargs);
va_end(vargs);
return ret;
}
-PyObject *PyString_Decode(const char *s,
+PyObject *PyBytes_Decode(const char *s,
Py_ssize_t size,
const char *encoding,
const char *errors)
{
PyObject *v, *str;
- str = PyString_FromStringAndSize(s, size);
+ str = PyBytes_FromStringAndSize(s, size);
if (str == NULL)
return NULL;
- v = PyString_AsDecodedString(str, encoding, errors);
+ v = PyBytes_AsDecodedString(str, encoding, errors);
Py_DECREF(str);
return v;
}
-PyObject *PyString_AsDecodedObject(PyObject *str,
+PyObject *PyBytes_AsDecodedObject(PyObject *str,
const char *encoding,
const char *errors)
{
PyObject *v;
- if (!PyString_Check(str)) {
+ if (!PyBytes_Check(str)) {
PyErr_BadArgument();
goto onError;
}
@@ -404,13 +404,13 @@
return NULL;
}
-PyObject *PyString_AsDecodedString(PyObject *str,
+PyObject *PyBytes_AsDecodedString(PyObject *str,
const char *encoding,
const char *errors)
{
PyObject *v;
- v = PyString_AsDecodedObject(str, encoding, errors);
+ v = PyBytes_AsDecodedObject(str, encoding, errors);
if (v == NULL)
goto onError;
@@ -424,7 +424,7 @@
goto onError;
}
#endif
- if (!PyString_Check(v)) {
+ if (!PyBytes_Check(v)) {
PyErr_Format(PyExc_TypeError,
"decoder did not return a string object (type=%.400s)",
Py_TYPE(v)->tp_name);
@@ -438,28 +438,28 @@
return NULL;
}
-PyObject *PyString_Encode(const char *s,
+PyObject *PyBytes_Encode(const char *s,
Py_ssize_t size,
const char *encoding,
const char *errors)
{
PyObject *v, *str;
- str = PyString_FromStringAndSize(s, size);
+ str = PyBytes_FromStringAndSize(s, size);
if (str == NULL)
return NULL;
- v = PyString_AsEncodedString(str, encoding, errors);
+ v = PyBytes_AsEncodedString(str, encoding, errors);
Py_DECREF(str);
return v;
}
-PyObject *PyString_AsEncodedObject(PyObject *str,
+PyObject *PyBytes_AsEncodedObject(PyObject *str,
const char *encoding,
const char *errors)
{
PyObject *v;
- if (!PyString_Check(str)) {
+ if (!PyBytes_Check(str)) {
PyErr_BadArgument();
goto onError;
}
@@ -484,13 +484,13 @@
return NULL;
}
-PyObject *PyString_AsEncodedString(PyObject *str,
+PyObject *PyBytes_AsEncodedString(PyObject *str,
const char *encoding,
const char *errors)
{
PyObject *v;
- v = PyString_AsEncodedObject(str, encoding, errors);
+ v = PyBytes_AsEncodedObject(str, encoding, errors);
if (v == NULL)
goto onError;
@@ -504,7 +504,7 @@
goto onError;
}
#endif
- if (!PyString_Check(v)) {
+ if (!PyBytes_Check(v)) {
PyErr_Format(PyExc_TypeError,
"encoder did not return a string object (type=%.400s)",
Py_TYPE(v)->tp_name);
@@ -521,7 +521,7 @@
static void
string_dealloc(PyObject *op)
{
- switch (PyString_CHECK_INTERNED(op)) {
+ switch (PyBytes_CHECK_INTERNED(op)) {
case SSTATE_NOT_INTERNED:
break;
@@ -547,7 +547,7 @@
the string is UTF-8 encoded and should be re-encoded in the
specified encoding. */
-PyObject *PyString_DecodeEscape(const char *s,
+PyObject *PyBytes_DecodeEscape(const char *s,
Py_ssize_t len,
const char *errors,
Py_ssize_t unicode,
@@ -558,10 +558,10 @@
const char *end;
PyObject *v;
Py_ssize_t newlen = recode_encoding ? 4*len:len;
- v = PyString_FromStringAndSize((char *)NULL, newlen);
+ v = PyBytes_FromStringAndSize((char *)NULL, newlen);
if (v == NULL)
return NULL;
- p = buf = PyString_AsString(v);
+ p = buf = PyBytes_AsString(v);
end = s + len;
while (s < end) {
if (*s != '\\') {
@@ -585,9 +585,9 @@
if (!w) goto failed;
/* Append bytes to output buffer. */
- assert(PyString_Check(w));
- r = PyString_AS_STRING(w);
- rn = PyString_GET_SIZE(w);
+ assert(PyBytes_Check(w));
+ r = PyBytes_AS_STRING(w);
+ rn = PyBytes_GET_SIZE(w);
Py_MEMCPY(p, r, rn);
p += rn;
Py_DECREF(w);
@@ -690,7 +690,7 @@
}
}
if (p-buf < newlen)
- _PyString_Resize(&v, p - buf);
+ _PyBytes_Resize(&v, p - buf);
return v;
failed:
Py_DECREF(v);
@@ -705,7 +705,7 @@
{
char *s;
Py_ssize_t len;
- if (PyString_AsStringAndSize(op, &s, &len))
+ if (PyBytes_AsStringAndSize(op, &s, &len))
return -1;
return len;
}
@@ -715,29 +715,29 @@
{
char *s;
Py_ssize_t len;
- if (PyString_AsStringAndSize(op, &s, &len))
+ if (PyBytes_AsStringAndSize(op, &s, &len))
return NULL;
return s;
}
Py_ssize_t
-PyString_Size(register PyObject *op)
+PyBytes_Size(register PyObject *op)
{
- if (!PyString_Check(op))
+ if (!PyBytes_Check(op))
return string_getsize(op);
return Py_SIZE(op);
}
/*const*/ char *
-PyString_AsString(register PyObject *op)
+PyBytes_AsString(register PyObject *op)
{
- if (!PyString_Check(op))
+ if (!PyBytes_Check(op))
return string_getbuffer(op);
- return ((PyStringObject *)op) -> ob_sval;
+ return ((PyBytesObject *)op) -> ob_sval;
}
int
-PyString_AsStringAndSize(register PyObject *obj,
+PyBytes_AsStringAndSize(register PyObject *obj,
register char **s,
register Py_ssize_t *len)
{
@@ -746,7 +746,7 @@
return -1;
}
- if (!PyString_Check(obj)) {
+ if (!PyBytes_Check(obj)) {
#ifdef Py_USING_UNICODE
if (PyUnicode_Check(obj)) {
obj = _PyUnicode_AsDefaultEncodedString(obj, NULL);
@@ -763,10 +763,10 @@
}
}
- *s = PyString_AS_STRING(obj);
+ *s = PyBytes_AS_STRING(obj);
if (len != NULL)
- *len = PyString_GET_SIZE(obj);
- else if (strlen(*s) != (size_t)PyString_GET_SIZE(obj)) {
+ *len = PyBytes_GET_SIZE(obj);
+ else if (strlen(*s) != (size_t)PyBytes_GET_SIZE(obj)) {
PyErr_SetString(PyExc_TypeError,
"expected string without null bytes");
return -1;
@@ -784,23 +784,23 @@
#include "stringlib/find.h"
#include "stringlib/partition.h"
-#define _Py_InsertThousandsGrouping _PyString_InsertThousandsGrouping
+#define _Py_InsertThousandsGrouping _PyBytes_InsertThousandsGrouping
#include "stringlib/localeutil.h"
static int
-string_print(PyStringObject *op, FILE *fp, int flags)
+string_print(PyBytesObject *op, FILE *fp, int flags)
{
Py_ssize_t i, str_len;
char c;
int quote;
/* XXX Ought to check for interrupts when writing long strings */
- if (! PyString_CheckExact(op)) {
+ if (! PyBytes_CheckExact(op)) {
int ret;
/* A str subclass may have its own __str__ method. */
- op = (PyStringObject *) PyObject_Str((PyObject *)op);
+ op = (PyBytesObject *) PyObject_Str((PyObject *)op);
if (op == NULL)
return -1;
ret = string_print(op, fp, flags);
@@ -863,9 +863,9 @@
}
PyObject *
-PyString_Repr(PyObject *obj, int smartquotes)
+PyBytes_Repr(PyObject *obj, int smartquotes)
{
- register PyStringObject* op = (PyStringObject*) obj;
+ register PyBytesObject* op = (PyBytesObject*) obj;
size_t newsize = 2 + 4 * Py_SIZE(op);
PyObject *v;
if (newsize > PY_SSIZE_T_MAX || newsize / 4 != Py_SIZE(op)) {
@@ -873,7 +873,7 @@
"string is too large to make repr");
return NULL;
}
- v = PyString_FromStringAndSize((char *)NULL, newsize);
+ v = PyBytes_FromStringAndSize((char *)NULL, newsize);
if (v == NULL) {
return NULL;
}
@@ -890,12 +890,12 @@
!memchr(op->ob_sval, '"', Py_SIZE(op)))
quote = '"';
- p = PyString_AS_STRING(v);
+ p = PyBytes_AS_STRING(v);
*p++ = quote;
for (i = 0; i < Py_SIZE(op); i++) {
/* There's at least enough room for a hex escape
and a closing quote. */
- assert(newsize - (p - PyString_AS_STRING(v)) >= 5);
+ assert(newsize - (p - PyBytes_AS_STRING(v)) >= 5);
c = op->ob_sval[i];
if (c == quote || c == '\\')
*p++ = '\\', *p++ = c;
@@ -915,11 +915,11 @@
else
*p++ = c;
}
- assert(newsize - (p - PyString_AS_STRING(v)) >= 1);
+ assert(newsize - (p - PyBytes_AS_STRING(v)) >= 1);
*p++ = quote;
*p = '\0';
- _PyString_Resize(
- &v, (p - PyString_AS_STRING(v)));
+ _PyBytes_Resize(
+ &v, (p - PyBytes_AS_STRING(v)));
return v;
}
}
@@ -927,36 +927,36 @@
static PyObject *
string_repr(PyObject *op)
{
- return PyString_Repr(op, 1);
+ return PyBytes_Repr(op, 1);
}
static PyObject *
string_str(PyObject *s)
{
- assert(PyString_Check(s));
- if (PyString_CheckExact(s)) {
+ assert(PyBytes_Check(s));
+ if (PyBytes_CheckExact(s)) {
Py_INCREF(s);
return s;
}
else {
/* Subtype -- return genuine string with the same value. */
- PyStringObject *t = (PyStringObject *) s;
- return PyString_FromStringAndSize(t->ob_sval, Py_SIZE(t));
+ PyBytesObject *t = (PyBytesObject *) s;
+ return PyBytes_FromStringAndSize(t->ob_sval, Py_SIZE(t));
}
}
static Py_ssize_t
-string_length(PyStringObject *a)
+string_length(PyBytesObject *a)
{
return Py_SIZE(a);
}
static PyObject *
-string_concat(register PyStringObject *a, register PyObject *bb)
+string_concat(register PyBytesObject *a, register PyObject *bb)
{
register Py_ssize_t size;
- register PyStringObject *op;
- if (!PyString_Check(bb)) {
+ register PyBytesObject *op;
+ if (!PyBytes_Check(bb)) {
#ifdef Py_USING_UNICODE
if (PyUnicode_Check(bb))
return PyUnicode_Concat((PyObject *)a, bb);
@@ -968,10 +968,10 @@
Py_TYPE(bb)->tp_name);
return NULL;
}
-#define b ((PyStringObject *)bb)
+#define b ((PyBytesObject *)bb)
/* Optimize cases with empty left or right operand */
if ((Py_SIZE(a) == 0 || Py_SIZE(b) == 0) &&
- PyString_CheckExact(a) && PyString_CheckExact(b)) {
+ PyBytes_CheckExact(a) && PyBytes_CheckExact(b)) {
if (Py_SIZE(a) == 0) {
Py_INCREF(bb);
return bb;
@@ -987,10 +987,10 @@
}
/* Inline PyObject_NewVar */
- op = (PyStringObject *)PyObject_MALLOC(sizeof(PyStringObject) + size);
+ op = (PyBytesObject *)PyObject_MALLOC(sizeof(PyBytesObject) + size);
if (op == NULL)
return PyErr_NoMemory();
- PyObject_INIT_VAR(op, &PyString_Type, size);
+ PyObject_INIT_VAR(op, &PyBytes_Type, size);
op->ob_shash = -1;
op->ob_sstate = SSTATE_NOT_INTERNED;
Py_MEMCPY(op->ob_sval, a->ob_sval, Py_SIZE(a));
@@ -1001,12 +1001,12 @@
}
static PyObject *
-string_repeat(register PyStringObject *a, register Py_ssize_t n)
+string_repeat(register PyBytesObject *a, register Py_ssize_t n)
{
register Py_ssize_t i;
register Py_ssize_t j;
register Py_ssize_t size;
- register PyStringObject *op;
+ register PyBytesObject *op;
size_t nbytes;
if (n < 0)
n = 0;
@@ -1019,21 +1019,21 @@
"repeated string is too long");
return NULL;
}
- if (size == Py_SIZE(a) && PyString_CheckExact(a)) {
+ if (size == Py_SIZE(a) && PyBytes_CheckExact(a)) {
Py_INCREF(a);
return (PyObject *)a;
}
nbytes = (size_t)size;
- if (nbytes + sizeof(PyStringObject) <= nbytes) {
+ if (nbytes + sizeof(PyBytesObject) <= nbytes) {
PyErr_SetString(PyExc_OverflowError,
"repeated string is too long");
return NULL;
}
- op = (PyStringObject *)
- PyObject_MALLOC(sizeof(PyStringObject) + nbytes);
+ op = (PyBytesObject *)
+ PyObject_MALLOC(sizeof(PyBytesObject) + nbytes);
if (op == NULL)
return PyErr_NoMemory();
- PyObject_INIT_VAR(op, &PyString_Type, size);
+ PyObject_INIT_VAR(op, &PyBytes_Type, size);
op->ob_shash = -1;
op->ob_sstate = SSTATE_NOT_INTERNED;
op->ob_sval[size] = '\0';
@@ -1057,7 +1057,7 @@
/* String slice a[i:j] consists of characters a[i] ... a[j-1] */
static PyObject *
-string_slice(register PyStringObject *a, register Py_ssize_t i,
+string_slice(register PyBytesObject *a, register Py_ssize_t i,
register Py_ssize_t j)
/* j -- may be negative! */
{
@@ -1067,25 +1067,25 @@
j = 0; /* Avoid signed/unsigned bug in next line */
if (j > Py_SIZE(a))
j = Py_SIZE(a);
- if (i == 0 && j == Py_SIZE(a) && PyString_CheckExact(a)) {
+ if (i == 0 && j == Py_SIZE(a) && PyBytes_CheckExact(a)) {
/* It's the same as a */
Py_INCREF(a);
return (PyObject *)a;
}
if (j < i)
j = i;
- return PyString_FromStringAndSize(a->ob_sval + i, j-i);
+ return PyBytes_FromStringAndSize(a->ob_sval + i, j-i);
}
static int
string_contains(PyObject *str_obj, PyObject *sub_obj)
{
- if (!PyString_CheckExact(sub_obj)) {
+ if (!PyBytes_CheckExact(sub_obj)) {
#ifdef Py_USING_UNICODE
if (PyUnicode_Check(sub_obj))
return PyUnicode_Contains(str_obj, sub_obj);
#endif
- if (!PyString_Check(sub_obj)) {
+ if (!PyBytes_Check(sub_obj)) {
PyErr_Format(PyExc_TypeError,
"'in <string>' requires string as left operand, "
"not %.200s", Py_TYPE(sub_obj)->tp_name);
@@ -1097,7 +1097,7 @@
}
static PyObject *
-string_item(PyStringObject *a, register Py_ssize_t i)
+string_item(PyBytesObject *a, register Py_ssize_t i)
{
char pchar;
PyObject *v;
@@ -1108,7 +1108,7 @@
pchar = a->ob_sval[i];
v = (PyObject *)characters[pchar & UCHAR_MAX];
if (v == NULL)
- v = PyString_FromStringAndSize(&pchar, 1);
+ v = PyBytes_FromStringAndSize(&pchar, 1);
else {
#ifdef COUNT_ALLOCS
one_strings++;
@@ -1119,7 +1119,7 @@
}
static PyObject*
-string_richcompare(PyStringObject *a, PyStringObject *b, int op)
+string_richcompare(PyBytesObject *a, PyBytesObject *b, int op)
{
int c;
Py_ssize_t len_a, len_b;
@@ -1127,7 +1127,7 @@
PyObject *result;
/* Make sure both arguments are strings. */
- if (!(PyString_Check(a) && PyString_Check(b))) {
+ if (!(PyBytes_Check(a) && PyBytes_Check(b))) {
result = Py_NotImplemented;
goto out;
}
@@ -1181,17 +1181,17 @@
}
int
-_PyString_Eq(PyObject *o1, PyObject *o2)
+_PyBytes_Eq(PyObject *o1, PyObject *o2)
{
- PyStringObject *a = (PyStringObject*) o1;
- PyStringObject *b = (PyStringObject*) o2;
+ PyBytesObject *a = (PyBytesObject*) o1;
+ PyBytesObject *b = (PyBytesObject*) o2;
return Py_SIZE(a) == Py_SIZE(b)
&& *a->ob_sval == *b->ob_sval
&& memcmp(a->ob_sval, b->ob_sval, Py_SIZE(a)) == 0;
}
static long
-string_hash(PyStringObject *a)
+string_hash(PyBytesObject *a)
{
register Py_ssize_t len;
register unsigned char *p;
@@ -1212,14 +1212,14 @@
}
static PyObject*
-string_subscript(PyStringObject* self, PyObject* item)
+string_subscript(PyBytesObject* self, PyObject* item)
{
if (PyIndex_Check(item)) {
Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
if (i == -1 && PyErr_Occurred())
return NULL;
if (i < 0)
- i += PyString_GET_SIZE(self);
+ i += PyBytes_GET_SIZE(self);
return string_item(self, i);
}
else if (PySlice_Check(item)) {
@@ -1229,27 +1229,27 @@
PyObject* result;
if (PySlice_GetIndicesEx((PySliceObject*)item,
- PyString_GET_SIZE(self),
+ PyBytes_GET_SIZE(self),
&start, &stop, &step, &slicelength) < 0) {
return NULL;
}
if (slicelength <= 0) {
- return PyString_FromStringAndSize("", 0);
+ return PyBytes_FromStringAndSize("", 0);
}
else if (start == 0 && step == 1 &&
- slicelength == PyString_GET_SIZE(self) &&
- PyString_CheckExact(self)) {
+ slicelength == PyBytes_GET_SIZE(self) &&
+ PyBytes_CheckExact(self)) {
Py_INCREF(self);
return (PyObject *)self;
}
else if (step == 1) {
- return PyString_FromStringAndSize(
- PyString_AS_STRING(self) + start,
+ return PyBytes_FromStringAndSize(
+ PyBytes_AS_STRING(self) + start,
slicelength);
}
else {
- source_buf = PyString_AsString((PyObject*)self);
+ source_buf = PyBytes_AsString((PyObject*)self);
result_buf = (char *)PyMem_Malloc(slicelength);
if (result_buf == NULL)
return PyErr_NoMemory();
@@ -1259,7 +1259,7 @@
result_buf[i] = source_buf[cur];
}
- result = PyString_FromStringAndSize(result_buf,
+ result = PyBytes_FromStringAndSize(result_buf,
slicelength);
PyMem_Free(result_buf);
return result;
@@ -1274,7 +1274,7 @@
}
static Py_ssize_t
-string_buffer_getreadbuf(PyStringObject *self, Py_ssize_t index, const void **ptr)
+string_buffer_getreadbuf(PyBytesObject *self, Py_ssize_t index, const void **ptr)
{
if ( index != 0 ) {
PyErr_SetString(PyExc_SystemError,
@@ -1286,7 +1286,7 @@
}
static Py_ssize_t
-string_buffer_getwritebuf(PyStringObject *self, Py_ssize_t index, const void **ptr)
+string_buffer_getwritebuf(PyBytesObject *self, Py_ssize_t index, const void **ptr)
{
PyErr_SetString(PyExc_TypeError,
"Cannot use string as modifiable buffer");
@@ -1294,7 +1294,7 @@
}
static Py_ssize_t
-string_buffer_getsegcount(PyStringObject *self, Py_ssize_t *lenp)
+string_buffer_getsegcount(PyBytesObject *self, Py_ssize_t *lenp)
{
if ( lenp )
*lenp = Py_SIZE(self);
@@ -1302,7 +1302,7 @@
}
static Py_ssize_t
-string_buffer_getcharbuf(PyStringObject *self, Py_ssize_t index, const char **ptr)
+string_buffer_getcharbuf(PyBytesObject *self, Py_ssize_t index, const char **ptr)
{
if ( index != 0 ) {
PyErr_SetString(PyExc_SystemError,
@@ -1314,7 +1314,7 @@
}
static int
-string_buffer_getbuffer(PyStringObject *self, Py_buffer *view, int flags)
+string_buffer_getbuffer(PyBytesObject *self, Py_buffer *view, int flags)
{
return PyBuffer_FillInfo(view, (void *)self->ob_sval, Py_SIZE(self),
0, flags);
@@ -1379,7 +1379,7 @@
(maxsplit >= MAX_PREALLOC ? MAX_PREALLOC : maxsplit+1)
#define SPLIT_APPEND(data, left, right) \
- str = PyString_FromStringAndSize((data) + (left), \
+ str = PyBytes_FromStringAndSize((data) + (left), \
(right) - (left)); \
if (str == NULL) \
goto onError; \
@@ -1391,7 +1391,7 @@
Py_DECREF(str);
#define SPLIT_ADD(data, left, right) { \
- str = PyString_FromStringAndSize((data) + (left), \
+ str = PyBytes_FromStringAndSize((data) + (left), \
(right) - (left)); \
if (str == NULL) \
goto onError; \
@@ -1416,9 +1416,9 @@
#define RSKIP_NONSPACE(s, i) { while (i>=0 && !isspace(Py_CHARMASK(s[i]))) i--; }
Py_LOCAL_INLINE(PyObject *)
-split_whitespace(PyStringObject *self, Py_ssize_t len, Py_ssize_t maxsplit)
+split_whitespace(PyBytesObject *self, Py_ssize_t len, Py_ssize_t maxsplit)
{
- const char *s = PyString_AS_STRING(self);
+ const char *s = PyBytes_AS_STRING(self);
Py_ssize_t i, j, count=0;
PyObject *str;
PyObject *list = PyList_New(PREALLOC_SIZE(maxsplit));
@@ -1433,7 +1433,7 @@
if (i==len) break;
j = i; i++;
SKIP_NONSPACE(s, i, len);
- if (j == 0 && i == len && PyString_CheckExact(self)) {
+ if (j == 0 && i == len && PyBytes_CheckExact(self)) {
/* No whitespace in self, so just use it as list[0] */
Py_INCREF(self);
PyList_SET_ITEM(list, 0, (PyObject *)self);
@@ -1458,9 +1458,9 @@
}
Py_LOCAL_INLINE(PyObject *)
-split_char(PyStringObject *self, Py_ssize_t len, char ch, Py_ssize_t maxcount)
+split_char(PyBytesObject *self, Py_ssize_t len, char ch, Py_ssize_t maxcount)
{
- const char *s = PyString_AS_STRING(self);
+ const char *s = PyBytes_AS_STRING(self);
register Py_ssize_t i, j, count=0;
PyObject *str;
PyObject *list = PyList_New(PREALLOC_SIZE(maxcount));
@@ -1479,7 +1479,7 @@
}
}
}
- if (i == 0 && count == 0 && PyString_CheckExact(self)) {
+ if (i == 0 && count == 0 && PyBytes_CheckExact(self)) {
/* ch not in self, so just use self as list[0] */
Py_INCREF(self);
PyList_SET_ITEM(list, 0, (PyObject *)self);
@@ -1506,11 +1506,11 @@
from the result.");
static PyObject *
-string_split(PyStringObject *self, PyObject *args)
+string_split(PyBytesObject *self, PyObject *args)
{
- Py_ssize_t len = PyString_GET_SIZE(self), n, i, j;
+ Py_ssize_t len = PyBytes_GET_SIZE(self), n, i, j;
Py_ssize_t maxsplit = -1, count=0;
- const char *s = PyString_AS_STRING(self), *sub;
+ const char *s = PyBytes_AS_STRING(self), *sub;
PyObject *list, *str, *subobj = Py_None;
#ifdef USE_FAST
Py_ssize_t pos;
@@ -1522,9 +1522,9 @@
maxsplit = PY_SSIZE_T_MAX;
if (subobj == Py_None)
return split_whitespace(self, len, maxsplit);
- if (PyString_Check(subobj)) {
- sub = PyString_AS_STRING(subobj);
- n = PyString_GET_SIZE(subobj);
+ if (PyBytes_Check(subobj)) {
+ sub = PyBytes_AS_STRING(subobj);
+ n = PyBytes_GET_SIZE(subobj);
}
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(subobj))
@@ -1583,14 +1583,14 @@
found, returns S and two empty strings.");
static PyObject *
-string_partition(PyStringObject *self, PyObject *sep_obj)
+string_partition(PyBytesObject *self, PyObject *sep_obj)
{
const char *sep;
Py_ssize_t sep_len;
- if (PyString_Check(sep_obj)) {
- sep = PyString_AS_STRING(sep_obj);
- sep_len = PyString_GET_SIZE(sep_obj);
+ if (PyBytes_Check(sep_obj)) {
+ sep = PyBytes_AS_STRING(sep_obj);
+ sep_len = PyBytes_GET_SIZE(sep_obj);
}
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(sep_obj))
@@ -1601,7 +1601,7 @@
return stringlib_partition(
(PyObject*) self,
- PyString_AS_STRING(self), PyString_GET_SIZE(self),
+ PyBytes_AS_STRING(self), PyBytes_GET_SIZE(self),
sep_obj, sep, sep_len
);
}
@@ -1614,14 +1614,14 @@
separator is not found, returns two empty strings and S.");
static PyObject *
-string_rpartition(PyStringObject *self, PyObject *sep_obj)
+string_rpartition(PyBytesObject *self, PyObject *sep_obj)
{
const char *sep;
Py_ssize_t sep_len;
- if (PyString_Check(sep_obj)) {
- sep = PyString_AS_STRING(sep_obj);
- sep_len = PyString_GET_SIZE(sep_obj);
+ if (PyBytes_Check(sep_obj)) {
+ sep = PyBytes_AS_STRING(sep_obj);
+ sep_len = PyBytes_GET_SIZE(sep_obj);
}
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(sep_obj))
@@ -1632,15 +1632,15 @@
return stringlib_rpartition(
(PyObject*) self,
- PyString_AS_STRING(self), PyString_GET_SIZE(self),
+ PyBytes_AS_STRING(self), PyBytes_GET_SIZE(self),
sep_obj, sep, sep_len
);
}
Py_LOCAL_INLINE(PyObject *)
-rsplit_whitespace(PyStringObject *self, Py_ssize_t len, Py_ssize_t maxsplit)
+rsplit_whitespace(PyBytesObject *self, Py_ssize_t len, Py_ssize_t maxsplit)
{
- const char *s = PyString_AS_STRING(self);
+ const char *s = PyBytes_AS_STRING(self);
Py_ssize_t i, j, count=0;
PyObject *str;
PyObject *list = PyList_New(PREALLOC_SIZE(maxsplit));
@@ -1655,7 +1655,7 @@
if (i<0) break;
j = i; i--;
RSKIP_NONSPACE(s, i);
- if (j == len-1 && i < 0 && PyString_CheckExact(self)) {
+ if (j == len-1 && i < 0 && PyBytes_CheckExact(self)) {
/* No whitespace in self, so just use it as list[0] */
Py_INCREF(self);
PyList_SET_ITEM(list, 0, (PyObject *)self);
@@ -1682,9 +1682,9 @@
}
Py_LOCAL_INLINE(PyObject *)
-rsplit_char(PyStringObject *self, Py_ssize_t len, char ch, Py_ssize_t maxcount)
+rsplit_char(PyBytesObject *self, Py_ssize_t len, char ch, Py_ssize_t maxcount)
{
- const char *s = PyString_AS_STRING(self);
+ const char *s = PyBytes_AS_STRING(self);
register Py_ssize_t i, j, count=0;
PyObject *str;
PyObject *list = PyList_New(PREALLOC_SIZE(maxcount));
@@ -1702,7 +1702,7 @@
}
}
}
- if (i < 0 && count == 0 && PyString_CheckExact(self)) {
+ if (i < 0 && count == 0 && PyBytes_CheckExact(self)) {
/* ch not in self, so just use self as list[0] */
Py_INCREF(self);
PyList_SET_ITEM(list, 0, (PyObject *)self);
@@ -1731,9 +1731,9 @@
is a separator.");
static PyObject *
-string_rsplit(PyStringObject *self, PyObject *args)
+string_rsplit(PyBytesObject *self, PyObject *args)
{
- Py_ssize_t len = PyString_GET_SIZE(self), n, i, j;
+ Py_ssize_t len = PyBytes_GET_SIZE(self), n, i, j;
Py_ssize_t maxsplit = -1, count=0;
const char *s, *sub;
PyObject *list, *str, *subobj = Py_None;
@@ -1744,9 +1744,9 @@
maxsplit = PY_SSIZE_T_MAX;
if (subobj == Py_None)
return rsplit_whitespace(self, len, maxsplit);
- if (PyString_Check(subobj)) {
- sub = PyString_AS_STRING(subobj);
- n = PyString_GET_SIZE(subobj);
+ if (PyBytes_Check(subobj)) {
+ sub = PyBytes_AS_STRING(subobj);
+ n = PyBytes_GET_SIZE(subobj);
}
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(subobj))
@@ -1769,7 +1769,7 @@
j = len;
i = j - n;
- s = PyString_AS_STRING(self);
+ s = PyBytes_AS_STRING(self);
while ( (i >= 0) && (maxsplit-- > 0) ) {
for (; i>=0; i--) {
if (Py_STRING_MATCH(s, i, sub, n)) {
@@ -1799,10 +1799,10 @@
sequence. The separator between elements is S.");
static PyObject *
-string_join(PyStringObject *self, PyObject *orig)
+string_join(PyBytesObject *self, PyObject *orig)
{
- char *sep = PyString_AS_STRING(self);
- const Py_ssize_t seplen = PyString_GET_SIZE(self);
+ char *sep = PyBytes_AS_STRING(self);
+ const Py_ssize_t seplen = PyBytes_GET_SIZE(self);
PyObject *res = NULL;
char *p;
Py_ssize_t seqlen = 0;
@@ -1818,11 +1818,11 @@
seqlen = PySequence_Size(seq);
if (seqlen == 0) {
Py_DECREF(seq);
- return PyString_FromString("");
+ return PyBytes_FromString("");
}
if (seqlen == 1) {
item = PySequence_Fast_GET_ITEM(seq, 0);
- if (PyString_CheckExact(item) || PyUnicode_CheckExact(item)) {
+ if (PyBytes_CheckExact(item) || PyUnicode_CheckExact(item)) {
Py_INCREF(item);
Py_DECREF(seq);
return item;
@@ -1838,7 +1838,7 @@
for (i = 0; i < seqlen; i++) {
const size_t old_sz = sz;
item = PySequence_Fast_GET_ITEM(seq, i);
- if (!PyString_Check(item)){
+ if (!PyBytes_Check(item)){
#ifdef Py_USING_UNICODE
if (PyUnicode_Check(item)) {
/* Defer to Unicode join.
@@ -1859,7 +1859,7 @@
Py_DECREF(seq);
return NULL;
}
- sz += PyString_GET_SIZE(item);
+ sz += PyBytes_GET_SIZE(item);
if (i != 0)
sz += seplen;
if (sz < old_sz || sz > PY_SSIZE_T_MAX) {
@@ -1871,19 +1871,19 @@
}
/* Allocate result space. */
- res = PyString_FromStringAndSize((char*)NULL, sz);
+ res = PyBytes_FromStringAndSize((char*)NULL, sz);
if (res == NULL) {
Py_DECREF(seq);
return NULL;
}
/* Catenate everything. */
- p = PyString_AS_STRING(res);
+ p = PyBytes_AS_STRING(res);
for (i = 0; i < seqlen; ++i) {
size_t n;
item = PySequence_Fast_GET_ITEM(seq, i);
- n = PyString_GET_SIZE(item);
- Py_MEMCPY(p, PyString_AS_STRING(item), n);
+ n = PyBytes_GET_SIZE(item);
+ Py_MEMCPY(p, PyBytes_AS_STRING(item), n);
p += n;
if (i < seqlen - 1) {
Py_MEMCPY(p, sep, seplen);
@@ -1896,11 +1896,11 @@
}
PyObject *
-_PyString_Join(PyObject *sep, PyObject *x)
+_PyBytes_Join(PyObject *sep, PyObject *x)
{
- assert(sep != NULL && PyString_Check(sep));
+ assert(sep != NULL && PyBytes_Check(sep));
assert(x != NULL);
- return string_join((PyStringObject *)sep, x);
+ return string_join((PyBytesObject *)sep, x);
}
Py_LOCAL_INLINE(void)
@@ -1919,7 +1919,7 @@
}
Py_LOCAL_INLINE(Py_ssize_t)
-string_find_internal(PyStringObject *self, PyObject *args, int dir)
+string_find_internal(PyBytesObject *self, PyObject *args, int dir)
{
PyObject *subobj;
const char *sub;
@@ -1940,9 +1940,9 @@
if (!_PyEval_SliceIndex(obj_end, &end))
return -2;
- if (PyString_Check(subobj)) {
- sub = PyString_AS_STRING(subobj);
- sub_len = PyString_GET_SIZE(subobj);
+ if (PyBytes_Check(subobj)) {
+ sub = PyBytes_AS_STRING(subobj);
+ sub_len = PyBytes_GET_SIZE(subobj);
}
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(subobj))
@@ -1956,11 +1956,11 @@
if (dir > 0)
return stringlib_find_slice(
- PyString_AS_STRING(self), PyString_GET_SIZE(self),
+ PyBytes_AS_STRING(self), PyBytes_GET_SIZE(self),
sub, sub_len, start, end);
else
return stringlib_rfind_slice(
- PyString_AS_STRING(self), PyString_GET_SIZE(self),
+ PyBytes_AS_STRING(self), PyBytes_GET_SIZE(self),
sub, sub_len, start, end);
}
@@ -1975,7 +1975,7 @@
Return -1 on failure.");
static PyObject *
-string_find(PyStringObject *self, PyObject *args)
+string_find(PyBytesObject *self, PyObject *args)
{
Py_ssize_t result = string_find_internal(self, args, +1);
if (result == -2)
@@ -1990,7 +1990,7 @@
Like S.find() but raise ValueError when the substring is not found.");
static PyObject *
-string_index(PyStringObject *self, PyObject *args)
+string_index(PyBytesObject *self, PyObject *args)
{
Py_ssize_t result = string_find_internal(self, args, +1);
if (result == -2)
@@ -2014,7 +2014,7 @@
Return -1 on failure.");
static PyObject *
-string_rfind(PyStringObject *self, PyObject *args)
+string_rfind(PyBytesObject *self, PyObject *args)
{
Py_ssize_t result = string_find_internal(self, args, -1);
if (result == -2)
@@ -2029,7 +2029,7 @@
Like S.rfind() but raise ValueError when the substring is not found.");
static PyObject *
-string_rindex(PyStringObject *self, PyObject *args)
+string_rindex(PyBytesObject *self, PyObject *args)
{
Py_ssize_t result = string_find_internal(self, args, -1);
if (result == -2)
@@ -2044,12 +2044,12 @@
Py_LOCAL_INLINE(PyObject *)
-do_xstrip(PyStringObject *self, int striptype, PyObject *sepobj)
+do_xstrip(PyBytesObject *self, int striptype, PyObject *sepobj)
{
- char *s = PyString_AS_STRING(self);
- Py_ssize_t len = PyString_GET_SIZE(self);
- char *sep = PyString_AS_STRING(sepobj);
- Py_ssize_t seplen = PyString_GET_SIZE(sepobj);
+ char *s = PyBytes_AS_STRING(self);
+ Py_ssize_t len = PyBytes_GET_SIZE(self);
+ char *sep = PyBytes_AS_STRING(sepobj);
+ Py_ssize_t seplen = PyBytes_GET_SIZE(sepobj);
Py_ssize_t i, j;
i = 0;
@@ -2067,20 +2067,20 @@
j++;
}
- if (i == 0 && j == len && PyString_CheckExact(self)) {
+ if (i == 0 && j == len && PyBytes_CheckExact(self)) {
Py_INCREF(self);
return (PyObject*)self;
}
else
- return PyString_FromStringAndSize(s+i, j-i);
+ return PyBytes_FromStringAndSize(s+i, j-i);
}
Py_LOCAL_INLINE(PyObject *)
-do_strip(PyStringObject *self, int striptype)
+do_strip(PyBytesObject *self, int striptype)
{
- char *s = PyString_AS_STRING(self);
- Py_ssize_t len = PyString_GET_SIZE(self), i, j;
+ char *s = PyBytes_AS_STRING(self);
+ Py_ssize_t len = PyBytes_GET_SIZE(self), i, j;
i = 0;
if (striptype != RIGHTSTRIP) {
@@ -2097,17 +2097,17 @@
j++;
}
- if (i == 0 && j == len && PyString_CheckExact(self)) {
+ if (i == 0 && j == len && PyBytes_CheckExact(self)) {
Py_INCREF(self);
return (PyObject*)self;
}
else
- return PyString_FromStringAndSize(s+i, j-i);
+ return PyBytes_FromStringAndSize(s+i, j-i);
}
Py_LOCAL_INLINE(PyObject *)
-do_argstrip(PyStringObject *self, int striptype, PyObject *args)
+do_argstrip(PyBytesObject *self, int striptype, PyObject *args)
{
PyObject *sep = NULL;
@@ -2115,7 +2115,7 @@
return NULL;
if (sep != NULL && sep != Py_None) {
- if (PyString_Check(sep))
+ if (PyBytes_Check(sep))
return do_xstrip(self, striptype, sep);
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(sep)) {
@@ -2152,7 +2152,7 @@
If chars is unicode, S will be converted to unicode before stripping");
static PyObject *
-string_strip(PyStringObject *self, PyObject *args)
+string_strip(PyBytesObject *self, PyObject *args)
{
if (PyTuple_GET_SIZE(args) == 0)
return do_strip(self, BOTHSTRIP); /* Common case */
@@ -2169,7 +2169,7 @@
If chars is unicode, S will be converted to unicode before stripping");
static PyObject *
-string_lstrip(PyStringObject *self, PyObject *args)
+string_lstrip(PyBytesObject *self, PyObject *args)
{
if (PyTuple_GET_SIZE(args) == 0)
return do_strip(self, LEFTSTRIP); /* Common case */
@@ -2186,7 +2186,7 @@
If chars is unicode, S will be converted to unicode before stripping");
static PyObject *
-string_rstrip(PyStringObject *self, PyObject *args)
+string_rstrip(PyBytesObject *self, PyObject *args)
{
if (PyTuple_GET_SIZE(args) == 0)
return do_strip(self, RIGHTSTRIP); /* Common case */
@@ -2206,19 +2206,19 @@
#endif
static PyObject *
-string_lower(PyStringObject *self)
+string_lower(PyBytesObject *self)
{
char *s;
- Py_ssize_t i, n = PyString_GET_SIZE(self);
+ Py_ssize_t i, n = PyBytes_GET_SIZE(self);
PyObject *newobj;
- newobj = PyString_FromStringAndSize(NULL, n);
+ newobj = PyBytes_FromStringAndSize(NULL, n);
if (!newobj)
return NULL;
- s = PyString_AS_STRING(newobj);
+ s = PyBytes_AS_STRING(newobj);
- Py_MEMCPY(s, PyString_AS_STRING(self), n);
+ Py_MEMCPY(s, PyBytes_AS_STRING(self), n);
for (i = 0; i < n; i++) {
int c = Py_CHARMASK(s[i]);
@@ -2239,19 +2239,19 @@
#endif
static PyObject *
-string_upper(PyStringObject *self)
+string_upper(PyBytesObject *self)
{
char *s;
- Py_ssize_t i, n = PyString_GET_SIZE(self);
+ Py_ssize_t i, n = PyBytes_GET_SIZE(self);
PyObject *newobj;
- newobj = PyString_FromStringAndSize(NULL, n);
+ newobj = PyBytes_FromStringAndSize(NULL, n);
if (!newobj)
return NULL;
- s = PyString_AS_STRING(newobj);
+ s = PyBytes_AS_STRING(newobj);
- Py_MEMCPY(s, PyString_AS_STRING(self), n);
+ Py_MEMCPY(s, PyBytes_AS_STRING(self), n);
for (i = 0; i < n; i++) {
int c = Py_CHARMASK(s[i]);
@@ -2269,17 +2269,17 @@
characters, all remaining cased characters have lowercase.");
static PyObject*
-string_title(PyStringObject *self)
+string_title(PyBytesObject *self)
{
- char *s = PyString_AS_STRING(self), *s_new;
- Py_ssize_t i, n = PyString_GET_SIZE(self);
+ char *s = PyBytes_AS_STRING(self), *s_new;
+ Py_ssize_t i, n = PyBytes_GET_SIZE(self);
int previous_is_cased = 0;
PyObject *newobj;
- newobj = PyString_FromStringAndSize(NULL, n);
+ newobj = PyBytes_FromStringAndSize(NULL, n);
if (newobj == NULL)
return NULL;
- s_new = PyString_AsString(newobj);
+ s_new = PyBytes_AsString(newobj);
for (i = 0; i < n; i++) {
int c = Py_CHARMASK(*s++);
if (islower(c)) {
@@ -2304,16 +2304,16 @@
capitalized.");
static PyObject *
-string_capitalize(PyStringObject *self)
+string_capitalize(PyBytesObject *self)
{
- char *s = PyString_AS_STRING(self), *s_new;
- Py_ssize_t i, n = PyString_GET_SIZE(self);
+ char *s = PyBytes_AS_STRING(self), *s_new;
+ Py_ssize_t i, n = PyBytes_GET_SIZE(self);
PyObject *newobj;
- newobj = PyString_FromStringAndSize(NULL, n);
+ newobj = PyBytes_FromStringAndSize(NULL, n);
if (newobj == NULL)
return NULL;
- s_new = PyString_AsString(newobj);
+ s_new = PyBytes_AsString(newobj);
if (0 < n) {
int c = Py_CHARMASK(*s++);
if (islower(c))
@@ -2342,10 +2342,10 @@
as in slice notation.");
static PyObject *
-string_count(PyStringObject *self, PyObject *args)
+string_count(PyBytesObject *self, PyObject *args)
{
PyObject *sub_obj;
- const char *str = PyString_AS_STRING(self), *sub;
+ const char *str = PyBytes_AS_STRING(self), *sub;
Py_ssize_t sub_len;
Py_ssize_t start = 0, end = PY_SSIZE_T_MAX;
@@ -2353,9 +2353,9 @@
_PyEval_SliceIndex, &start, _PyEval_SliceIndex, &end))
return NULL;
- if (PyString_Check(sub_obj)) {
- sub = PyString_AS_STRING(sub_obj);
- sub_len = PyString_GET_SIZE(sub_obj);
+ if (PyBytes_Check(sub_obj)) {
+ sub = PyBytes_AS_STRING(sub_obj);
+ sub_len = PyBytes_GET_SIZE(sub_obj);
}
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(sub_obj)) {
@@ -2370,7 +2370,7 @@
else if (PyObject_AsCharBuffer(sub_obj, &sub, &sub_len))
return NULL;
- string_adjust_indices(&start, &end, PyString_GET_SIZE(self));
+ string_adjust_indices(&start, &end, PyBytes_GET_SIZE(self));
return PyInt_FromSsize_t(
stringlib_count(str + start, end - start, sub, sub_len)
@@ -2384,16 +2384,16 @@
converted to lowercase and vice versa.");
static PyObject *
-string_swapcase(PyStringObject *self)
+string_swapcase(PyBytesObject *self)
{
- char *s = PyString_AS_STRING(self), *s_new;
- Py_ssize_t i, n = PyString_GET_SIZE(self);
+ char *s = PyBytes_AS_STRING(self), *s_new;
+ Py_ssize_t i, n = PyBytes_GET_SIZE(self);
PyObject *newobj;
- newobj = PyString_FromStringAndSize(NULL, n);
+ newobj = PyBytes_FromStringAndSize(NULL, n);
if (newobj == NULL)
return NULL;
- s_new = PyString_AsString(newobj);
+ s_new = PyBytes_AsString(newobj);
for (i = 0; i < n; i++) {
int c = Py_CHARMASK(*s++);
if (islower(c)) {
@@ -2419,7 +2419,7 @@
translation table, which must be a string of length 256.");
static PyObject *
-string_translate(PyStringObject *self, PyObject *args)
+string_translate(PyBytesObject *self, PyObject *args)
{
register char *input, *output;
const char *table;
@@ -2435,9 +2435,9 @@
&tableobj, &delobj))
return NULL;
- if (PyString_Check(tableobj)) {
- table = PyString_AS_STRING(tableobj);
- tablen = PyString_GET_SIZE(tableobj);
+ if (PyBytes_Check(tableobj)) {
+ table = PyBytes_AS_STRING(tableobj);
+ tablen = PyBytes_GET_SIZE(tableobj);
}
else if (tableobj == Py_None) {
table = NULL;
@@ -2466,9 +2466,9 @@
}
if (delobj != NULL) {
- if (PyString_Check(delobj)) {
- del_table = PyString_AS_STRING(delobj);
- dellen = PyString_GET_SIZE(delobj);
+ if (PyBytes_Check(delobj)) {
+ del_table = PyBytes_AS_STRING(delobj);
+ dellen = PyBytes_GET_SIZE(delobj);
}
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(delobj)) {
@@ -2485,12 +2485,12 @@
dellen = 0;
}
- inlen = PyString_GET_SIZE(input_obj);
- result = PyString_FromStringAndSize((char *)NULL, inlen);
+ inlen = PyBytes_GET_SIZE(input_obj);
+ result = PyBytes_FromStringAndSize((char *)NULL, inlen);
if (result == NULL)
return NULL;
- output_start = output = PyString_AsString(result);
- input = PyString_AS_STRING(input_obj);
+ output_start = output = PyBytes_AsString(result);
+ input = PyBytes_AS_STRING(input_obj);
if (dellen == 0 && table != NULL) {
/* If no deletions are required, use faster code */
@@ -2499,7 +2499,7 @@
if (Py_CHARMASK((*output++ = table[c])) != c)
changed = 1;
}
- if (changed || !PyString_CheckExact(input_obj))
+ if (changed || !PyBytes_CheckExact(input_obj))
return result;
Py_DECREF(result);
Py_INCREF(input_obj);
@@ -2524,14 +2524,14 @@
continue;
changed = 1;
}
- if (!changed && PyString_CheckExact(input_obj)) {
+ if (!changed && PyBytes_CheckExact(input_obj)) {
Py_DECREF(result);
Py_INCREF(input_obj);
return input_obj;
}
/* Fix the size of the resulting string */
if (inlen > 0)
- _PyString_Resize(&result, output - output_start);
+ _PyBytes_Resize(&result, output - output_start);
return result;
}
@@ -2546,16 +2546,16 @@
/* String ops must return a string. */
/* If the object is subclass of string, create a copy */
-Py_LOCAL(PyStringObject *)
-return_self(PyStringObject *self)
+Py_LOCAL(PyBytesObject *)
+return_self(PyBytesObject *self)
{
- if (PyString_CheckExact(self)) {
+ if (PyBytes_CheckExact(self)) {
Py_INCREF(self);
return self;
}
- return (PyStringObject *)PyString_FromStringAndSize(
- PyString_AS_STRING(self),
- PyString_GET_SIZE(self));
+ return (PyBytesObject *)PyBytes_FromStringAndSize(
+ PyBytes_AS_STRING(self),
+ PyBytes_GET_SIZE(self));
}
Py_LOCAL_INLINE(Py_ssize_t)
@@ -2665,17 +2665,17 @@
/* Algorithms for different cases of string replacement */
/* len(self)>=1, from="", len(to)>=1, maxcount>=1 */
-Py_LOCAL(PyStringObject *)
-replace_interleave(PyStringObject *self,
+Py_LOCAL(PyBytesObject *)
+replace_interleave(PyBytesObject *self,
const char *to_s, Py_ssize_t to_len,
Py_ssize_t maxcount)
{
char *self_s, *result_s;
Py_ssize_t self_len, result_len;
Py_ssize_t count, i, product;
- PyStringObject *result;
+ PyBytesObject *result;
- self_len = PyString_GET_SIZE(self);
+ self_len = PyBytes_GET_SIZE(self);
/* 1 at the end plus 1 after every character */
count = self_len+1;
@@ -2697,12 +2697,12 @@
return NULL;
}
- if (! (result = (PyStringObject *)
- PyString_FromStringAndSize(NULL, result_len)) )
+ if (! (result = (PyBytesObject *)
+ PyBytes_FromStringAndSize(NULL, result_len)) )
return NULL;
- self_s = PyString_AS_STRING(self);
- result_s = PyString_AS_STRING(result);
+ self_s = PyBytes_AS_STRING(self);
+ result_s = PyBytes_AS_STRING(result);
/* TODO: special case single character, which doesn't need memcpy */
@@ -2725,18 +2725,18 @@
/* Special case for deleting a single character */
/* len(self)>=1, len(from)==1, to="", maxcount>=1 */
-Py_LOCAL(PyStringObject *)
-replace_delete_single_character(PyStringObject *self,
+Py_LOCAL(PyBytesObject *)
+replace_delete_single_character(PyBytesObject *self,
char from_c, Py_ssize_t maxcount)
{
char *self_s, *result_s;
char *start, *next, *end;
Py_ssize_t self_len, result_len;
Py_ssize_t count;
- PyStringObject *result;
+ PyBytesObject *result;
- self_len = PyString_GET_SIZE(self);
- self_s = PyString_AS_STRING(self);
+ self_len = PyBytes_GET_SIZE(self);
+ self_s = PyBytes_AS_STRING(self);
count = countchar(self_s, self_len, from_c, maxcount);
if (count == 0) {
@@ -2746,10 +2746,10 @@
result_len = self_len - count; /* from_len == 1 */
assert(result_len>=0);
- if ( (result = (PyStringObject *)
- PyString_FromStringAndSize(NULL, result_len)) == NULL)
+ if ( (result = (PyBytesObject *)
+ PyBytes_FromStringAndSize(NULL, result_len)) == NULL)
return NULL;
- result_s = PyString_AS_STRING(result);
+ result_s = PyBytes_AS_STRING(result);
start = self_s;
end = self_s + self_len;
@@ -2768,18 +2768,18 @@
/* len(self)>=1, len(from)>=2, to="", maxcount>=1 */
-Py_LOCAL(PyStringObject *)
-replace_delete_substring(PyStringObject *self,
+Py_LOCAL(PyBytesObject *)
+replace_delete_substring(PyBytesObject *self,
const char *from_s, Py_ssize_t from_len,
Py_ssize_t maxcount) {
char *self_s, *result_s;
char *start, *next, *end;
Py_ssize_t self_len, result_len;
Py_ssize_t count, offset;
- PyStringObject *result;
+ PyBytesObject *result;
- self_len = PyString_GET_SIZE(self);
- self_s = PyString_AS_STRING(self);
+ self_len = PyBytes_GET_SIZE(self);
+ self_s = PyBytes_AS_STRING(self);
count = countstring(self_s, self_len,
from_s, from_len,
@@ -2794,11 +2794,11 @@
result_len = self_len - (count * from_len);
assert (result_len>=0);
- if ( (result = (PyStringObject *)
- PyString_FromStringAndSize(NULL, result_len)) == NULL )
+ if ( (result = (PyBytesObject *)
+ PyBytes_FromStringAndSize(NULL, result_len)) == NULL )
return NULL;
- result_s = PyString_AS_STRING(result);
+ result_s = PyBytes_AS_STRING(result);
start = self_s;
end = self_s + self_len;
@@ -2820,18 +2820,18 @@
}
/* len(self)>=1, len(from)==len(to)==1, maxcount>=1 */
-Py_LOCAL(PyStringObject *)
-replace_single_character_in_place(PyStringObject *self,
+Py_LOCAL(PyBytesObject *)
+replace_single_character_in_place(PyBytesObject *self,
char from_c, char to_c,
Py_ssize_t maxcount)
{
char *self_s, *result_s, *start, *end, *next;
Py_ssize_t self_len;
- PyStringObject *result;
+ PyBytesObject *result;
/* The result string will be the same size */
- self_s = PyString_AS_STRING(self);
- self_len = PyString_GET_SIZE(self);
+ self_s = PyBytes_AS_STRING(self);
+ self_len = PyBytes_GET_SIZE(self);
next = findchar(self_s, self_len, from_c);
@@ -2841,10 +2841,10 @@
}
/* Need to make a new string */
- result = (PyStringObject *) PyString_FromStringAndSize(NULL, self_len);
+ result = (PyBytesObject *) PyBytes_FromStringAndSize(NULL, self_len);
if (result == NULL)
return NULL;
- result_s = PyString_AS_STRING(result);
+ result_s = PyBytes_AS_STRING(result);
Py_MEMCPY(result_s, self_s, self_len);
/* change everything in-place, starting with this one */
@@ -2865,8 +2865,8 @@
}
/* len(self)>=1, len(from)==len(to)>=2, maxcount>=1 */
-Py_LOCAL(PyStringObject *)
-replace_substring_in_place(PyStringObject *self,
+Py_LOCAL(PyBytesObject *)
+replace_substring_in_place(PyBytesObject *self,
const char *from_s, Py_ssize_t from_len,
const char *to_s, Py_ssize_t to_len,
Py_ssize_t maxcount)
@@ -2874,12 +2874,12 @@
char *result_s, *start, *end;
char *self_s;
Py_ssize_t self_len, offset;
- PyStringObject *result;
+ PyBytesObject *result;
/* The result string will be the same size */
- self_s = PyString_AS_STRING(self);
- self_len = PyString_GET_SIZE(self);
+ self_s = PyBytes_AS_STRING(self);
+ self_len = PyBytes_GET_SIZE(self);
offset = findstring(self_s, self_len,
from_s, from_len,
@@ -2890,10 +2890,10 @@
}
/* Need to make a new string */
- result = (PyStringObject *) PyString_FromStringAndSize(NULL, self_len);
+ result = (PyBytesObject *) PyBytes_FromStringAndSize(NULL, self_len);
if (result == NULL)
return NULL;
- result_s = PyString_AS_STRING(result);
+ result_s = PyBytes_AS_STRING(result);
Py_MEMCPY(result_s, self_s, self_len);
/* change everything in-place, starting with this one */
@@ -2916,8 +2916,8 @@
}
/* len(self)>=1, len(from)==1, len(to)>=2, maxcount>=1 */
-Py_LOCAL(PyStringObject *)
-replace_single_character(PyStringObject *self,
+Py_LOCAL(PyBytesObject *)
+replace_single_character(PyBytesObject *self,
char from_c,
const char *to_s, Py_ssize_t to_len,
Py_ssize_t maxcount)
@@ -2926,10 +2926,10 @@
char *start, *next, *end;
Py_ssize_t self_len, result_len;
Py_ssize_t count, product;
- PyStringObject *result;
+ PyBytesObject *result;
- self_s = PyString_AS_STRING(self);
- self_len = PyString_GET_SIZE(self);
+ self_s = PyBytes_AS_STRING(self);
+ self_len = PyBytes_GET_SIZE(self);
count = countchar(self_s, self_len, from_c, maxcount);
if (count == 0) {
@@ -2950,10 +2950,10 @@
return NULL;
}
- if ( (result = (PyStringObject *)
- PyString_FromStringAndSize(NULL, result_len)) == NULL)
+ if ( (result = (PyBytesObject *)
+ PyBytes_FromStringAndSize(NULL, result_len)) == NULL)
return NULL;
- result_s = PyString_AS_STRING(result);
+ result_s = PyBytes_AS_STRING(result);
start = self_s;
end = self_s + self_len;
@@ -2983,8 +2983,8 @@
}
/* len(self)>=1, len(from)>=2, len(to)>=2, maxcount>=1 */
-Py_LOCAL(PyStringObject *)
-replace_substring(PyStringObject *self,
+Py_LOCAL(PyBytesObject *)
+replace_substring(PyBytesObject *self,
const char *from_s, Py_ssize_t from_len,
const char *to_s, Py_ssize_t to_len,
Py_ssize_t maxcount) {
@@ -2992,10 +2992,10 @@
char *start, *next, *end;
Py_ssize_t self_len, result_len;
Py_ssize_t count, offset, product;
- PyStringObject *result;
+ PyBytesObject *result;
- self_s = PyString_AS_STRING(self);
- self_len = PyString_GET_SIZE(self);
+ self_s = PyBytes_AS_STRING(self);
+ self_len = PyBytes_GET_SIZE(self);
count = countstring(self_s, self_len,
from_s, from_len,
@@ -3018,10 +3018,10 @@
return NULL;
}
- if ( (result = (PyStringObject *)
- PyString_FromStringAndSize(NULL, result_len)) == NULL)
+ if ( (result = (PyBytesObject *)
+ PyBytes_FromStringAndSize(NULL, result_len)) == NULL)
return NULL;
- result_s = PyString_AS_STRING(result);
+ result_s = PyBytes_AS_STRING(result);
start = self_s;
end = self_s + self_len;
@@ -3053,15 +3053,15 @@
}
-Py_LOCAL(PyStringObject *)
-replace(PyStringObject *self,
+Py_LOCAL(PyBytesObject *)
+replace(PyBytesObject *self,
const char *from_s, Py_ssize_t from_len,
const char *to_s, Py_ssize_t to_len,
Py_ssize_t maxcount)
{
if (maxcount < 0) {
maxcount = PY_SSIZE_T_MAX;
- } else if (maxcount == 0 || PyString_GET_SIZE(self) == 0) {
+ } else if (maxcount == 0 || PyBytes_GET_SIZE(self) == 0) {
/* nothing to do; return the original string */
return return_self(self);
}
@@ -3084,7 +3084,7 @@
/* Except for "".replace("", "A") == "A" there is no way beyond this */
/* point for an empty self string to generate a non-empty string */
/* Special case so the remaining code always gets a non-empty string */
- if (PyString_GET_SIZE(self) == 0) {
+ if (PyBytes_GET_SIZE(self) == 0) {
return return_self(self);
}
@@ -3131,7 +3131,7 @@
given, only the first count occurrences are replaced.");
static PyObject *
-string_replace(PyStringObject *self, PyObject *args)
+string_replace(PyBytesObject *self, PyObject *args)
{
Py_ssize_t count = -1;
PyObject *from, *to;
@@ -3141,9 +3141,9 @@
if (!PyArg_ParseTuple(args, "OO|n:replace", &from, &to, &count))
return NULL;
- if (PyString_Check(from)) {
- from_s = PyString_AS_STRING(from);
- from_len = PyString_GET_SIZE(from);
+ if (PyBytes_Check(from)) {
+ from_s = PyBytes_AS_STRING(from);
+ from_len = PyBytes_GET_SIZE(from);
}
#ifdef Py_USING_UNICODE
if (PyUnicode_Check(from))
@@ -3153,9 +3153,9 @@
else if (PyObject_AsCharBuffer(from, &from_s, &from_len))
return NULL;
- if (PyString_Check(to)) {
- to_s = PyString_AS_STRING(to);
- to_len = PyString_GET_SIZE(to);
+ if (PyBytes_Check(to)) {
+ to_s = PyBytes_AS_STRING(to);
+ to_len = PyBytes_GET_SIZE(to);
}
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(to))
@@ -3165,7 +3165,7 @@
else if (PyObject_AsCharBuffer(to, &to_s, &to_len))
return NULL;
- return (PyObject *)replace((PyStringObject *) self,
+ return (PyObject *)replace((PyBytesObject *) self,
from_s, from_len,
to_s, to_len, count);
}
@@ -3177,17 +3177,17 @@
* -1 on error, 0 if not found and 1 if found.
*/
Py_LOCAL(int)
-_string_tailmatch(PyStringObject *self, PyObject *substr, Py_ssize_t start,
+_string_tailmatch(PyBytesObject *self, PyObject *substr, Py_ssize_t start,
Py_ssize_t end, int direction)
{
- Py_ssize_t len = PyString_GET_SIZE(self);
+ Py_ssize_t len = PyBytes_GET_SIZE(self);
Py_ssize_t slen;
const char* sub;
const char* str;
- if (PyString_Check(substr)) {
- sub = PyString_AS_STRING(substr);
- slen = PyString_GET_SIZE(substr);
+ if (PyBytes_Check(substr)) {
+ sub = PyBytes_AS_STRING(substr);
+ slen = PyBytes_GET_SIZE(substr);
}
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(substr))
@@ -3196,7 +3196,7 @@
#endif
else if (PyObject_AsCharBuffer(substr, &sub, &slen))
return -1;
- str = PyString_AS_STRING(self);
+ str = PyBytes_AS_STRING(self);
string_adjust_indices(&start, &end, len);
@@ -3227,7 +3227,7 @@
prefix can also be a tuple of strings to try.");
static PyObject *
-string_startswith(PyStringObject *self, PyObject *args)
+string_startswith(PyBytesObject *self, PyObject *args)
{
Py_ssize_t start = 0;
Py_ssize_t end = PY_SSIZE_T_MAX;
@@ -3268,7 +3268,7 @@
suffix can also be a tuple of strings to try.");
static PyObject *
-string_endswith(PyStringObject *self, PyObject *args)
+string_endswith(PyBytesObject *self, PyObject *args)
{
Py_ssize_t start = 0;
Py_ssize_t end = PY_SSIZE_T_MAX;
@@ -3311,7 +3311,7 @@
codecs.register_error that is able to handle UnicodeEncodeErrors.");
static PyObject *
-string_encode(PyStringObject *self, PyObject *args)
+string_encode(PyBytesObject *self, PyObject *args)
{
char *encoding = NULL;
char *errors = NULL;
@@ -3319,10 +3319,10 @@
if (!PyArg_ParseTuple(args, "|ss:encode", &encoding, &errors))
return NULL;
- v = PyString_AsEncodedObject((PyObject *)self, encoding, errors);
+ v = PyBytes_AsEncodedObject((PyObject *)self, encoding, errors);
if (v == NULL)
goto onError;
- if (!PyString_Check(v) && !PyUnicode_Check(v)) {
+ if (!PyBytes_Check(v) && !PyUnicode_Check(v)) {
PyErr_Format(PyExc_TypeError,
"encoder did not return a string/unicode object "
"(type=%.400s)",
@@ -3348,7 +3348,7 @@
able to handle UnicodeDecodeErrors.");
static PyObject *
-string_decode(PyStringObject *self, PyObject *args)
+string_decode(PyBytesObject *self, PyObject *args)
{
char *encoding = NULL;
char *errors = NULL;
@@ -3356,10 +3356,10 @@
if (!PyArg_ParseTuple(args, "|ss:decode", &encoding, &errors))
return NULL;
- v = PyString_AsDecodedObject((PyObject *)self, encoding, errors);
+ v = PyBytes_AsDecodedObject((PyObject *)self, encoding, errors);
if (v == NULL)
goto onError;
- if (!PyString_Check(v) && !PyUnicode_Check(v)) {
+ if (!PyBytes_Check(v) && !PyUnicode_Check(v)) {
PyErr_Format(PyExc_TypeError,
"decoder did not return a string/unicode object "
"(type=%.400s)",
@@ -3381,7 +3381,7 @@
If tabsize is not given, a tab size of 8 characters is assumed.");
static PyObject*
-string_expandtabs(PyStringObject *self, PyObject *args)
+string_expandtabs(PyBytesObject *self, PyObject *args)
{
const char *e, *p, *qe;
char *q;
@@ -3395,8 +3395,8 @@
/* First pass: determine size of output string */
i = 0; /* chars up to and including most recent \n or \r */
j = 0; /* chars since most recent \n or \r (use in tab calculations) */
- e = PyString_AS_STRING(self) + PyString_GET_SIZE(self); /* end of input */
- for (p = PyString_AS_STRING(self); p < e; p++)
+ e = PyBytes_AS_STRING(self) + PyBytes_GET_SIZE(self); /* end of input */
+ for (p = PyBytes_AS_STRING(self); p < e; p++)
if (*p == '\t') {
if (tabsize > 0) {
incr = tabsize - (j % tabsize);
@@ -3421,15 +3421,15 @@
goto overflow1;
/* Second pass: create output string and fill it */
- u = PyString_FromStringAndSize(NULL, i + j);
+ u = PyBytes_FromStringAndSize(NULL, i + j);
if (!u)
return NULL;
j = 0; /* same as in first pass */
- q = PyString_AS_STRING(u); /* next output char */
- qe = PyString_AS_STRING(u) + PyString_GET_SIZE(u); /* end of output */
+ q = PyBytes_AS_STRING(u); /* next output char */
+ qe = PyBytes_AS_STRING(u) + PyBytes_GET_SIZE(u); /* end of output */
- for (p = PyString_AS_STRING(self); p < e; p++)
+ for (p = PyBytes_AS_STRING(self); p < e; p++)
if (*p == '\t') {
if (tabsize > 0) {
i = tabsize - (j % tabsize);
@@ -3460,7 +3460,7 @@
}
Py_LOCAL_INLINE(PyObject *)
-pad(PyStringObject *self, Py_ssize_t left, Py_ssize_t right, char fill)
+pad(PyBytesObject *self, Py_ssize_t left, Py_ssize_t right, char fill)
{
PyObject *u;
@@ -3469,21 +3469,21 @@
if (right < 0)
right = 0;
- if (left == 0 && right == 0 && PyString_CheckExact(self)) {
+ if (left == 0 && right == 0 && PyBytes_CheckExact(self)) {
Py_INCREF(self);
return (PyObject *)self;
}
- u = PyString_FromStringAndSize(NULL,
- left + PyString_GET_SIZE(self) + right);
+ u = PyBytes_FromStringAndSize(NULL,
+ left + PyBytes_GET_SIZE(self) + right);
if (u) {
if (left)
- memset(PyString_AS_STRING(u), fill, left);
- Py_MEMCPY(PyString_AS_STRING(u) + left,
- PyString_AS_STRING(self),
- PyString_GET_SIZE(self));
+ memset(PyBytes_AS_STRING(u), fill, left);
+ Py_MEMCPY(PyBytes_AS_STRING(u) + left,
+ PyBytes_AS_STRING(self),
+ PyBytes_GET_SIZE(self));
if (right)
- memset(PyString_AS_STRING(u) + left + PyString_GET_SIZE(self),
+ memset(PyBytes_AS_STRING(u) + left + PyBytes_GET_SIZE(self),
fill, right);
}
@@ -3497,7 +3497,7 @@
"done using the specified fill character (default is a space).");
static PyObject *
-string_ljust(PyStringObject *self, PyObject *args)
+string_ljust(PyBytesObject *self, PyObject *args)
{
Py_ssize_t width;
char fillchar = ' ';
@@ -3505,12 +3505,12 @@
if (!PyArg_ParseTuple(args, "n|c:ljust", &width, &fillchar))
return NULL;
- if (PyString_GET_SIZE(self) >= width && PyString_CheckExact(self)) {
+ if (PyBytes_GET_SIZE(self) >= width && PyBytes_CheckExact(self)) {
Py_INCREF(self);
return (PyObject*) self;
}
- return pad(self, 0, width - PyString_GET_SIZE(self), fillchar);
+ return pad(self, 0, width - PyBytes_GET_SIZE(self), fillchar);
}
@@ -3521,7 +3521,7 @@
"done using the specified fill character (default is a space)");
static PyObject *
-string_rjust(PyStringObject *self, PyObject *args)
+string_rjust(PyBytesObject *self, PyObject *args)
{
Py_ssize_t width;
char fillchar = ' ';
@@ -3529,12 +3529,12 @@
if (!PyArg_ParseTuple(args, "n|c:rjust", &width, &fillchar))
return NULL;
- if (PyString_GET_SIZE(self) >= width && PyString_CheckExact(self)) {
+ if (PyBytes_GET_SIZE(self) >= width && PyBytes_CheckExact(self)) {
Py_INCREF(self);
return (PyObject*) self;
}
- return pad(self, width - PyString_GET_SIZE(self), 0, fillchar);
+ return pad(self, width - PyBytes_GET_SIZE(self), 0, fillchar);
}
@@ -3545,7 +3545,7 @@
"done using the specified fill character (default is a space)");
static PyObject *
-string_center(PyStringObject *self, PyObject *args)
+string_center(PyBytesObject *self, PyObject *args)
{
Py_ssize_t marg, left;
Py_ssize_t width;
@@ -3554,12 +3554,12 @@
if (!PyArg_ParseTuple(args, "n|c:center", &width, &fillchar))
return NULL;
- if (PyString_GET_SIZE(self) >= width && PyString_CheckExact(self)) {
+ if (PyBytes_GET_SIZE(self) >= width && PyBytes_CheckExact(self)) {
Py_INCREF(self);
return (PyObject*) self;
}
- marg = width - PyString_GET_SIZE(self);
+ marg = width - PyBytes_GET_SIZE(self);
left = marg / 2 + (marg & width & 1);
return pad(self, left, marg - left, fillchar);
@@ -3572,7 +3572,7 @@
"of the specified width. The string S is never truncated.");
static PyObject *
-string_zfill(PyStringObject *self, PyObject *args)
+string_zfill(PyBytesObject *self, PyObject *args)
{
Py_ssize_t fill;
PyObject *s;
@@ -3582,26 +3582,26 @@
if (!PyArg_ParseTuple(args, "n:zfill", &width))
return NULL;
- if (PyString_GET_SIZE(self) >= width) {
- if (PyString_CheckExact(self)) {
+ if (PyBytes_GET_SIZE(self) >= width) {
+ if (PyBytes_CheckExact(self)) {
Py_INCREF(self);
return (PyObject*) self;
}
else
- return PyString_FromStringAndSize(
- PyString_AS_STRING(self),
- PyString_GET_SIZE(self)
+ return PyBytes_FromStringAndSize(
+ PyBytes_AS_STRING(self),
+ PyBytes_GET_SIZE(self)
);
}
- fill = width - PyString_GET_SIZE(self);
+ fill = width - PyBytes_GET_SIZE(self);
s = pad(self, fill, 0, '0');
if (s == NULL)
return NULL;
- p = PyString_AS_STRING(s);
+ p = PyBytes_AS_STRING(s);
if (p[fill] == '+' || p[fill] == '-') {
/* move sign to beginning of string */
p[0] = p[fill];
@@ -3618,22 +3618,22 @@
and there is at least one character in S, False otherwise.");
static PyObject*
-string_isspace(PyStringObject *self)
+string_isspace(PyBytesObject *self)
{
register const unsigned char *p
- = (unsigned char *) PyString_AS_STRING(self);
+ = (unsigned char *) PyBytes_AS_STRING(self);
register const unsigned char *e;
/* Shortcut for single character strings */
- if (PyString_GET_SIZE(self) == 1 &&
+ if (PyBytes_GET_SIZE(self) == 1 &&
isspace(*p))
return PyBool_FromLong(1);
/* Special case for empty strings */
- if (PyString_GET_SIZE(self) == 0)
+ if (PyBytes_GET_SIZE(self) == 0)
return PyBool_FromLong(0);
- e = p + PyString_GET_SIZE(self);
+ e = p + PyBytes_GET_SIZE(self);
for (; p < e; p++) {
if (!isspace(*p))
return PyBool_FromLong(0);
@@ -3649,22 +3649,22 @@
and there is at least one character in S, False otherwise.");
static PyObject*
-string_isalpha(PyStringObject *self)
+string_isalpha(PyBytesObject *self)
{
register const unsigned char *p
- = (unsigned char *) PyString_AS_STRING(self);
+ = (unsigned char *) PyBytes_AS_STRING(self);
register const unsigned char *e;
/* Shortcut for single character strings */
- if (PyString_GET_SIZE(self) == 1 &&
+ if (PyBytes_GET_SIZE(self) == 1 &&
isalpha(*p))
return PyBool_FromLong(1);
/* Special case for empty strings */
- if (PyString_GET_SIZE(self) == 0)
+ if (PyBytes_GET_SIZE(self) == 0)
return PyBool_FromLong(0);
- e = p + PyString_GET_SIZE(self);
+ e = p + PyBytes_GET_SIZE(self);
for (; p < e; p++) {
if (!isalpha(*p))
return PyBool_FromLong(0);
@@ -3680,22 +3680,22 @@
and there is at least one character in S, False otherwise.");
static PyObject*
-string_isalnum(PyStringObject *self)
+string_isalnum(PyBytesObject *self)
{
register const unsigned char *p
- = (unsigned char *) PyString_AS_STRING(self);
+ = (unsigned char *) PyBytes_AS_STRING(self);
register const unsigned char *e;
/* Shortcut for single character strings */
- if (PyString_GET_SIZE(self) == 1 &&
+ if (PyBytes_GET_SIZE(self) == 1 &&
isalnum(*p))
return PyBool_FromLong(1);
/* Special case for empty strings */
- if (PyString_GET_SIZE(self) == 0)
+ if (PyBytes_GET_SIZE(self) == 0)
return PyBool_FromLong(0);
- e = p + PyString_GET_SIZE(self);
+ e = p + PyBytes_GET_SIZE(self);
for (; p < e; p++) {
if (!isalnum(*p))
return PyBool_FromLong(0);
@@ -3711,22 +3711,22 @@
and there is at least one character in S, False otherwise.");
static PyObject*
-string_isdigit(PyStringObject *self)
+string_isdigit(PyBytesObject *self)
{
register const unsigned char *p
- = (unsigned char *) PyString_AS_STRING(self);
+ = (unsigned char *) PyBytes_AS_STRING(self);
register const unsigned char *e;
/* Shortcut for single character strings */
- if (PyString_GET_SIZE(self) == 1 &&
+ if (PyBytes_GET_SIZE(self) == 1 &&
isdigit(*p))
return PyBool_FromLong(1);
/* Special case for empty strings */
- if (PyString_GET_SIZE(self) == 0)
+ if (PyBytes_GET_SIZE(self) == 0)
return PyBool_FromLong(0);
- e = p + PyString_GET_SIZE(self);
+ e = p + PyBytes_GET_SIZE(self);
for (; p < e; p++) {
if (!isdigit(*p))
return PyBool_FromLong(0);
@@ -3742,22 +3742,22 @@
at least one cased character in S, False otherwise.");
static PyObject*
-string_islower(PyStringObject *self)
+string_islower(PyBytesObject *self)
{
register const unsigned char *p
- = (unsigned char *) PyString_AS_STRING(self);
+ = (unsigned char *) PyBytes_AS_STRING(self);
register const unsigned char *e;
int cased;
/* Shortcut for single character strings */
- if (PyString_GET_SIZE(self) == 1)
+ if (PyBytes_GET_SIZE(self) == 1)
return PyBool_FromLong(islower(*p) != 0);
/* Special case for empty strings */
- if (PyString_GET_SIZE(self) == 0)
+ if (PyBytes_GET_SIZE(self) == 0)
return PyBool_FromLong(0);
- e = p + PyString_GET_SIZE(self);
+ e = p + PyBytes_GET_SIZE(self);
cased = 0;
for (; p < e; p++) {
if (isupper(*p))
@@ -3776,22 +3776,22 @@
at least one cased character in S, False otherwise.");
static PyObject*
-string_isupper(PyStringObject *self)
+string_isupper(PyBytesObject *self)
{
register const unsigned char *p
- = (unsigned char *) PyString_AS_STRING(self);
+ = (unsigned char *) PyBytes_AS_STRING(self);
register const unsigned char *e;
int cased;
/* Shortcut for single character strings */
- if (PyString_GET_SIZE(self) == 1)
+ if (PyBytes_GET_SIZE(self) == 1)
return PyBool_FromLong(isupper(*p) != 0);
/* Special case for empty strings */
- if (PyString_GET_SIZE(self) == 0)
+ if (PyBytes_GET_SIZE(self) == 0)
return PyBool_FromLong(0);
- e = p + PyString_GET_SIZE(self);
+ e = p + PyBytes_GET_SIZE(self);
cased = 0;
for (; p < e; p++) {
if (islower(*p))
@@ -3812,22 +3812,22 @@
otherwise.");
static PyObject*
-string_istitle(PyStringObject *self, PyObject *uncased)
+string_istitle(PyBytesObject *self, PyObject *uncased)
{
register const unsigned char *p
- = (unsigned char *) PyString_AS_STRING(self);
+ = (unsigned char *) PyBytes_AS_STRING(self);
register const unsigned char *e;
int cased, previous_is_cased;
/* Shortcut for single character strings */
- if (PyString_GET_SIZE(self) == 1)
+ if (PyBytes_GET_SIZE(self) == 1)
return PyBool_FromLong(isupper(*p) != 0);
/* Special case for empty strings */
- if (PyString_GET_SIZE(self) == 0)
+ if (PyBytes_GET_SIZE(self) == 0)
return PyBool_FromLong(0);
- e = p + PyString_GET_SIZE(self);
+ e = p + PyBytes_GET_SIZE(self);
cased = 0;
previous_is_cased = 0;
for (; p < e; p++) {
@@ -3860,7 +3860,7 @@
is given and true.");
static PyObject*
-string_splitlines(PyStringObject *self, PyObject *args)
+string_splitlines(PyBytesObject *self, PyObject *args)
{
register Py_ssize_t i;
register Py_ssize_t j;
@@ -3873,8 +3873,8 @@
if (!PyArg_ParseTuple(args, "|i:splitlines", &keepends))
return NULL;
- data = PyString_AS_STRING(self);
- len = PyString_GET_SIZE(self);
+ data = PyBytes_AS_STRING(self);
+ len = PyBytes_GET_SIZE(self);
/* This does not use the preallocated list because splitlines is
usually run with hundreds of newlines. The overhead of
@@ -3926,7 +3926,7 @@
#undef PREALLOC_SIZE
static PyObject *
-string_getnewargs(PyStringObject *v)
+string_getnewargs(PyBytesObject *v)
{
return Py_BuildValue("(s#)", v->ob_sval, Py_SIZE(v));
}
@@ -4011,12 +4011,12 @@
PyObject *x = NULL;
static char *kwlist[] = {"object", 0};
- if (type != &PyString_Type)
+ if (type != &PyBytes_Type)
return str_subtype_new(type, args, kwds);
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O:str", kwlist, &x))
return NULL;
if (x == NULL)
- return PyString_FromString("");
+ return PyBytes_FromString("");
return PyObject_Str(x);
}
@@ -4026,18 +4026,18 @@
PyObject *tmp, *pnew;
Py_ssize_t n;
- assert(PyType_IsSubtype(type, &PyString_Type));
- tmp = string_new(&PyString_Type, args, kwds);
+ assert(PyType_IsSubtype(type, &PyBytes_Type));
+ tmp = string_new(&PyBytes_Type, args, kwds);
if (tmp == NULL)
return NULL;
- assert(PyString_CheckExact(tmp));
- n = PyString_GET_SIZE(tmp);
+ assert(PyBytes_CheckExact(tmp));
+ n = PyBytes_GET_SIZE(tmp);
pnew = type->tp_alloc(type, n);
if (pnew != NULL) {
- Py_MEMCPY(PyString_AS_STRING(pnew), PyString_AS_STRING(tmp), n+1);
- ((PyStringObject *)pnew)->ob_shash =
- ((PyStringObject *)tmp)->ob_shash;
- ((PyStringObject *)pnew)->ob_sstate = SSTATE_NOT_INTERNED;
+ Py_MEMCPY(PyBytes_AS_STRING(pnew), PyBytes_AS_STRING(tmp), n+1);
+ ((PyBytesObject *)pnew)->ob_shash =
+ ((PyBytesObject *)tmp)->ob_shash;
+ ((PyBytesObject *)pnew)->ob_sstate = SSTATE_NOT_INTERNED;
}
Py_DECREF(tmp);
return pnew;
@@ -4054,11 +4054,11 @@
static PyObject *
string_mod(PyObject *v, PyObject *w)
{
- if (!PyString_Check(v)) {
+ if (!PyBytes_Check(v)) {
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
- return PyString_Format(v, w);
+ return PyBytes_Format(v, w);
}
PyDoc_STRVAR(basestring_doc,
@@ -4121,10 +4121,10 @@
Return a nice string representation of the object.\n\
If the argument is a string, the return value is the same object.");
-PyTypeObject PyString_Type = {
+PyTypeObject PyBytes_Type = {
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"str",
- sizeof(PyStringObject),
+ sizeof(PyBytesObject),
sizeof(char),
string_dealloc, /* tp_dealloc */
(printfunc)string_print, /* tp_print */
@@ -4166,25 +4166,25 @@
};
void
-PyString_Concat(register PyObject **pv, register PyObject *w)
+PyBytes_Concat(register PyObject **pv, register PyObject *w)
{
register PyObject *v;
if (*pv == NULL)
return;
- if (w == NULL || !PyString_Check(*pv)) {
+ if (w == NULL || !PyBytes_Check(*pv)) {
Py_DECREF(*pv);
*pv = NULL;
return;
}
- v = string_concat((PyStringObject *) *pv, w);
+ v = string_concat((PyBytesObject *) *pv, w);
Py_DECREF(*pv);
*pv = v;
}
void
-PyString_ConcatAndDel(register PyObject **pv, register PyObject *w)
+PyBytes_ConcatAndDel(register PyObject **pv, register PyObject *w)
{
- PyString_Concat(pv, w);
+ PyBytes_Concat(pv, w);
Py_XDECREF(w);
}
@@ -4204,13 +4204,13 @@
*/
int
-_PyString_Resize(PyObject **pv, Py_ssize_t newsize)
+_PyBytes_Resize(PyObject **pv, Py_ssize_t newsize)
{
register PyObject *v;
- register PyStringObject *sv;
+ register PyBytesObject *sv;
v = *pv;
- if (!PyString_Check(v) || Py_REFCNT(v) != 1 || newsize < 0 ||
- PyString_CHECK_INTERNED(v)) {
+ if (!PyBytes_Check(v) || Py_REFCNT(v) != 1 || newsize < 0 ||
+ PyBytes_CHECK_INTERNED(v)) {
*pv = 0;
Py_DECREF(v);
PyErr_BadInternalCall();
@@ -4220,14 +4220,14 @@
_Py_DEC_REFTOTAL;
_Py_ForgetReference(v);
*pv = (PyObject *)
- PyObject_REALLOC((char *)v, sizeof(PyStringObject) + newsize);
+ PyObject_REALLOC((char *)v, sizeof(PyBytesObject) + newsize);
if (*pv == NULL) {
PyObject_Del(v);
PyErr_NoMemory();
return -1;
}
_Py_NewReference(*pv);
- sv = (PyStringObject *) *pv;
+ sv = (PyBytesObject *) *pv;
Py_SIZE(sv) = newsize;
sv->ob_sval[newsize] = '\0';
sv->ob_shash = -1; /* invalidate cached hash value */
@@ -4313,7 +4313,7 @@
return (int)strlen(buf);
}
-/* _PyString_FormatLong emulates the format codes d, u, o, x and X, and
+/* _PyBytes_FormatLong emulates the format codes d, u, o, x and X, and
* the F_ALT flag, for Python's long (unbounded) ints. It's not used for
* Python's regular ints.
* Return value: a new PyString*, or NULL if error.
@@ -4335,7 +4335,7 @@
* produce a '-' sign, but can for Python's unbounded ints.
*/
PyObject*
-_PyString_FormatLong(PyObject *val, int flags, int prec, int type,
+_PyBytes_FormatLong(PyObject *val, int flags, int prec, int type,
char **pbuf, int *plen)
{
PyObject *result = NULL;
@@ -4366,7 +4366,7 @@
if (!result)
return NULL;
- buf = PyString_AsString(result);
+ buf = PyBytes_AsString(result);
if (!buf) {
Py_DECREF(result);
return NULL;
@@ -4377,9 +4377,9 @@
PyErr_BadInternalCall();
return NULL;
}
- llen = PyString_Size(result);
+ llen = PyBytes_Size(result);
if (llen > INT_MAX) {
- PyErr_SetString(PyExc_ValueError, "string too large in _PyString_FormatLong");
+ PyErr_SetString(PyExc_ValueError, "string too large in _PyBytes_FormatLong");
return NULL;
}
len = (int)llen;
@@ -4425,14 +4425,14 @@
/* Fill with leading zeroes to meet minimum width. */
if (prec > numdigits) {
- PyObject *r1 = PyString_FromStringAndSize(NULL,
+ PyObject *r1 = PyBytes_FromStringAndSize(NULL,
numnondigits + prec);
char *b1;
if (!r1) {
Py_DECREF(result);
return NULL;
}
- b1 = PyString_AS_STRING(r1);
+ b1 = PyBytes_AS_STRING(r1);
for (i = 0; i < numnondigits; ++i)
*b1++ = *buf++;
for (i = 0; i < prec - numdigits; i++)
@@ -4442,7 +4442,7 @@
*b1 = '\0';
Py_DECREF(result);
result = r1;
- buf = PyString_AS_STRING(result);
+ buf = PyBytes_AS_STRING(result);
len = numnondigits + prec;
}
@@ -4536,7 +4536,7 @@
formatchar(char *buf, size_t buflen, PyObject *v)
{
/* presume that the buffer is at least 2 characters long */
- if (PyString_Check(v)) {
+ if (PyBytes_Check(v)) {
if (!PyArg_Parse(v, "c;%c requires int or char", &buf[0]))
return -1;
}
@@ -4559,7 +4559,7 @@
#define FORMATBUFLEN (size_t)120
PyObject *
-PyString_Format(PyObject *format, PyObject *args)
+PyBytes_Format(PyObject *format, PyObject *args)
{
char *fmt, *res;
Py_ssize_t arglen, argidx;
@@ -4570,18 +4570,18 @@
PyObject *v, *w;
#endif
PyObject *dict = NULL;
- if (format == NULL || !PyString_Check(format) || args == NULL) {
+ if (format == NULL || !PyBytes_Check(format) || args == NULL) {
PyErr_BadInternalCall();
return NULL;
}
orig_args = args;
- fmt = PyString_AS_STRING(format);
- fmtcnt = PyString_GET_SIZE(format);
+ fmt = PyBytes_AS_STRING(format);
+ fmtcnt = PyBytes_GET_SIZE(format);
reslen = rescnt = fmtcnt + 100;
- result = PyString_FromStringAndSize((char *)NULL, reslen);
+ result = PyBytes_FromStringAndSize((char *)NULL, reslen);
if (result == NULL)
return NULL;
- res = PyString_AsString(result);
+ res = PyBytes_AsString(result);
if (PyTuple_Check(args)) {
arglen = PyTuple_GET_SIZE(args);
argidx = 0;
@@ -4598,9 +4598,9 @@
if (--rescnt < 0) {
rescnt = fmtcnt + 100;
reslen += rescnt;
- if (_PyString_Resize(&result, reslen) < 0)
+ if (_PyBytes_Resize(&result, reslen) < 0)
return NULL;
- res = PyString_AS_STRING(result)
+ res = PyBytes_AS_STRING(result)
+ reslen - rescnt;
--rescnt;
}
@@ -4655,7 +4655,7 @@
"incomplete format key");
goto error;
}
- key = PyString_FromStringAndSize(keystart,
+ key = PyBytes_FromStringAndSize(keystart,
keylen);
if (key == NULL)
goto error;
@@ -4796,14 +4796,14 @@
temp = PyObject_Repr(v);
if (temp == NULL)
goto error;
- if (!PyString_Check(temp)) {
+ if (!PyBytes_Check(temp)) {
PyErr_SetString(PyExc_TypeError,
"%s argument has non-string str()");
Py_DECREF(temp);
goto error;
}
- pbuf = PyString_AS_STRING(temp);
- len = PyString_GET_SIZE(temp);
+ pbuf = PyBytes_AS_STRING(temp);
+ len = PyBytes_GET_SIZE(temp);
if (prec >= 0 && len > prec)
len = prec;
break;
@@ -4843,7 +4843,7 @@
int ilen;
isnumok = 1;
- temp = _PyString_FormatLong(iobj, flags,
+ temp = _PyBytes_FormatLong(iobj, flags,
prec, c, &pbuf, &ilen);
Py_DECREF(iobj);
len = ilen;
@@ -4901,7 +4901,7 @@
"at index %zd",
c, c,
(Py_ssize_t)(fmt - 1 -
- PyString_AsString(format)));
+ PyBytes_AsString(format)));
goto error;
}
if (sign) {
@@ -4927,11 +4927,11 @@
Py_XDECREF(temp);
return PyErr_NoMemory();
}
- if (_PyString_Resize(&result, reslen) < 0) {
+ if (_PyBytes_Resize(&result, reslen) < 0) {
Py_XDECREF(temp);
return NULL;
}
- res = PyString_AS_STRING(result)
+ res = PyBytes_AS_STRING(result)
+ reslen - rescnt;
}
if (sign) {
@@ -4995,7 +4995,7 @@
if (args_owned) {
Py_DECREF(args);
}
- _PyString_Resize(&result, reslen - rescnt);
+ _PyBytes_Resize(&result, reslen - rescnt);
return result;
#ifdef Py_USING_UNICODE
@@ -5024,11 +5024,11 @@
args_owned = 1;
/* Take what we have of the result and let the Unicode formatting
function format the rest of the input. */
- rescnt = res - PyString_AS_STRING(result);
- if (_PyString_Resize(&result, rescnt))
+ rescnt = res - PyBytes_AS_STRING(result);
+ if (_PyBytes_Resize(&result, rescnt))
goto error;
- fmtcnt = PyString_GET_SIZE(format) - \
- (fmt - PyString_AS_STRING(format));
+ fmtcnt = PyBytes_GET_SIZE(format) - \
+ (fmt - PyBytes_AS_STRING(format));
format = PyUnicode_Decode(fmt, fmtcnt, NULL, NULL);
if (format == NULL)
goto error;
@@ -5054,17 +5054,17 @@
}
void
-PyString_InternInPlace(PyObject **p)
+PyBytes_InternInPlace(PyObject **p)
{
- register PyStringObject *s = (PyStringObject *)(*p);
+ register PyBytesObject *s = (PyBytesObject *)(*p);
PyObject *t;
- if (s == NULL || !PyString_Check(s))
- Py_FatalError("PyString_InternInPlace: strings only please!");
+ if (s == NULL || !PyBytes_Check(s))
+ Py_FatalError("PyBytes_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 (!PyString_CheckExact(s))
+ if (!PyBytes_CheckExact(s))
return;
- if (PyString_CHECK_INTERNED(s))
+ if (PyBytes_CHECK_INTERNED(s))
return;
if (interned == NULL) {
interned = PyDict_New();
@@ -5088,32 +5088,32 @@
/* The two references in interned are not counted by refcnt.
The string deallocator will take care of this */
Py_REFCNT(s) -= 2;
- PyString_CHECK_INTERNED(s) = SSTATE_INTERNED_MORTAL;
+ PyBytes_CHECK_INTERNED(s) = SSTATE_INTERNED_MORTAL;
}
void
-PyString_InternImmortal(PyObject **p)
+PyBytes_InternImmortal(PyObject **p)
{
- PyString_InternInPlace(p);
- if (PyString_CHECK_INTERNED(*p) != SSTATE_INTERNED_IMMORTAL) {
- PyString_CHECK_INTERNED(*p) = SSTATE_INTERNED_IMMORTAL;
+ PyBytes_InternInPlace(p);
+ if (PyBytes_CHECK_INTERNED(*p) != SSTATE_INTERNED_IMMORTAL) {
+ PyBytes_CHECK_INTERNED(*p) = SSTATE_INTERNED_IMMORTAL;
Py_INCREF(*p);
}
}
PyObject *
-PyString_InternFromString(const char *cp)
+PyBytes_InternFromString(const char *cp)
{
- PyObject *s = PyString_FromString(cp);
+ PyObject *s = PyBytes_FromString(cp);
if (s == NULL)
return NULL;
- PyString_InternInPlace(&s);
+ PyBytes_InternInPlace(&s);
return s;
}
void
-PyString_Fini(void)
+PyBytes_Fini(void)
{
int i;
for (i = 0; i < UCHAR_MAX + 1; i++) {
@@ -5127,7 +5127,7 @@
void _Py_ReleaseInternedStrings(void)
{
PyObject *keys;
- PyStringObject *s;
+ PyBytesObject *s;
Py_ssize_t i, n;
Py_ssize_t immortal_size = 0, mortal_size = 0;
@@ -5148,7 +5148,7 @@
fprintf(stderr, "releasing %" PY_FORMAT_SIZE_T "d interned strings\n",
n);
for (i = 0; i < n; i++) {
- s = (PyStringObject *) PyList_GET_ITEM(keys, i);
+ s = (PyBytesObject *) PyList_GET_ITEM(keys, i);
switch (s->ob_sstate) {
case SSTATE_NOT_INTERNED:
/* XXX Shouldn't happen */
diff --git a/Objects/structseq.c b/Objects/structseq.c
index b6126ba..c348254 100644
--- a/Objects/structseq.c
+++ b/Objects/structseq.c
@@ -270,7 +270,7 @@
Py_DECREF(tup);
return NULL;
}
- crepr = PyString_AsString(repr);
+ crepr = PyBytes_AsString(repr);
if (crepr == NULL) {
Py_DECREF(tup);
Py_DECREF(repr);
@@ -306,7 +306,7 @@
*pbuf++ = ')';
*pbuf = '\0';
- return PyString_FromString(buf);
+ return PyBytes_FromString(buf);
}
static PyObject *
diff --git a/Objects/tupleobject.c b/Objects/tupleobject.c
index e9cb3ef..0524aae 100644
--- a/Objects/tupleobject.c
+++ b/Objects/tupleobject.c
@@ -218,7 +218,7 @@
n = Py_SIZE(v);
if (n == 0)
- return PyString_FromString("()");
+ return PyBytes_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 ? PyString_FromString("(...)") : NULL;
+ return i > 0 ? PyBytes_FromString("(...)") : NULL;
}
pieces = PyTuple_New(n);
@@ -246,29 +246,29 @@
/* Add "()" decorations to the first and last items. */
assert(n > 0);
- s = PyString_FromString("(");
+ s = PyBytes_FromString("(");
if (s == NULL)
goto Done;
temp = PyTuple_GET_ITEM(pieces, 0);
- PyString_ConcatAndDel(&s, temp);
+ PyBytes_ConcatAndDel(&s, temp);
PyTuple_SET_ITEM(pieces, 0, s);
if (s == NULL)
goto Done;
- s = PyString_FromString(n == 1 ? ",)" : ")");
+ s = PyBytes_FromString(n == 1 ? ",)" : ")");
if (s == NULL)
goto Done;
temp = PyTuple_GET_ITEM(pieces, n-1);
- PyString_ConcatAndDel(&temp, s);
+ PyBytes_ConcatAndDel(&temp, s);
PyTuple_SET_ITEM(pieces, n-1, temp);
if (temp == NULL)
goto Done;
/* Paste them all together with ", " between. */
- s = PyString_FromString(", ");
+ s = PyBytes_FromString(", ");
if (s == NULL)
goto Done;
- result = _PyString_Join(s, pieces);
+ result = _PyBytes_Join(s, pieces);
Py_DECREF(s);
Done:
diff --git a/Objects/typeobject.c b/Objects/typeobject.c
index c3aa090..2ea3d29 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, \
- ((PyStringObject *)(name))->ob_shash)
+ ((PyBytesObject *)(name))->ob_shash)
#define MCACHE_CACHEABLE_NAME(name) \
- PyString_CheckExact(name) && \
- PyString_GET_SIZE(name) <= MCACHE_MAX_ATTR_SIZE
+ PyBytes_CheckExact(name) && \
+ PyBytes_GET_SIZE(name) <= MCACHE_MAX_ATTR_SIZE
struct method_cache_entry {
unsigned int version;
@@ -218,7 +218,7 @@
s = type->tp_name;
else
s++;
- return PyString_FromString(s);
+ return PyBytes_FromString(s);
}
}
@@ -237,14 +237,14 @@
"can't delete %s.__name__", type->tp_name);
return -1;
}
- if (!PyString_Check(value)) {
+ if (!PyBytes_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(PyString_AS_STRING(value))
- != (size_t)PyString_GET_SIZE(value)) {
+ if (strlen(PyBytes_AS_STRING(value))
+ != (size_t)PyBytes_GET_SIZE(value)) {
PyErr_Format(PyExc_ValueError,
"__name__ must not contain null bytes");
return -1;
@@ -257,7 +257,7 @@
Py_DECREF(et->ht_name);
et->ht_name = value;
- type->tp_name = PyString_AS_STRING(value);
+ type->tp_name = PyBytes_AS_STRING(value);
return 0;
}
@@ -280,9 +280,9 @@
else {
s = strrchr(type->tp_name, '.');
if (s != NULL)
- return PyString_FromStringAndSize(
+ return PyBytes_FromStringAndSize(
type->tp_name, (Py_ssize_t)(s - type->tp_name));
- return PyString_FromString("__builtin__");
+ return PyBytes_FromString("__builtin__");
}
}
@@ -556,7 +556,7 @@
{
PyObject *result;
if (!(type->tp_flags & Py_TPFLAGS_HEAPTYPE) && type->tp_doc != NULL)
- return PyString_FromString(type->tp_doc);
+ return PyBytes_FromString(type->tp_doc);
result = PyDict_GetItemString(type->tp_dict, "__doc__");
if (result == NULL) {
result = Py_None;
@@ -645,7 +645,7 @@
mod = type_module(type, NULL);
if (mod == NULL)
PyErr_Clear();
- else if (!PyString_Check(mod)) {
+ else if (!PyBytes_Check(mod)) {
Py_DECREF(mod);
mod = NULL;
}
@@ -658,14 +658,14 @@
else
kind = "type";
- if (mod != NULL && strcmp(PyString_AS_STRING(mod), "__builtin__")) {
- rtn = PyString_FromFormat("<%s '%s.%s'>",
+ if (mod != NULL && strcmp(PyBytes_AS_STRING(mod), "__builtin__")) {
+ rtn = PyBytes_FromFormat("<%s '%s.%s'>",
kind,
- PyString_AS_STRING(mod),
- PyString_AS_STRING(name));
+ PyBytes_AS_STRING(mod),
+ PyBytes_AS_STRING(name));
}
else
- rtn = PyString_FromFormat("<%s '%s'>", kind, type->tp_name);
+ rtn = PyBytes_FromFormat("<%s '%s'>", kind, type->tp_name);
Py_XDECREF(mod);
Py_DECREF(name);
@@ -1137,7 +1137,7 @@
PyObject *res;
if (*attrobj == NULL) {
- *attrobj = PyString_InternFromString(attrstr);
+ *attrobj = PyBytes_InternFromString(attrstr);
if (*attrobj == NULL)
return NULL;
}
@@ -1329,7 +1329,7 @@
}
if (name == NULL)
return NULL;
- if (!PyString_Check(name)) {
+ if (!PyBytes_Check(name)) {
Py_DECREF(name);
return NULL;
}
@@ -1351,7 +1351,7 @@
o = class_name(o);
PyErr_Format(PyExc_TypeError,
"duplicate base class %s",
- o ? PyString_AS_STRING(o) : "?");
+ o ? PyBytes_AS_STRING(o) : "?");
Py_XDECREF(o);
return -1;
}
@@ -1397,7 +1397,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 ? PyString_AS_STRING(name) : "?");
+ name ? PyBytes_AS_STRING(name) : "?");
Py_XDECREF(name);
if (--n && (size_t)(off+1) < sizeof(buf)) {
buf[off++] = ',';
@@ -1750,7 +1750,7 @@
PyObject *descr;
if (dict_str == NULL) {
- dict_str = PyString_InternFromString("__dict__");
+ dict_str = PyBytes_InternFromString("__dict__");
if (dict_str == NULL)
return NULL;
}
@@ -1899,14 +1899,14 @@
unsigned char *p;
Py_ssize_t i, n;
- if (!PyString_Check(s)) {
+ if (!PyBytes_Check(s)) {
PyErr_Format(PyExc_TypeError,
"__slots__ items must be strings, not '%.200s'",
Py_TYPE(s)->tp_name);
return 0;
}
- p = (unsigned char *) PyString_AS_STRING(s);
- n = PyString_GET_SIZE(s);
+ p = (unsigned char *) PyBytes_AS_STRING(s);
+ n = PyBytes_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)
@@ -2108,7 +2108,7 @@
/* Have slots */
/* Make it into a tuple */
- if (PyString_Check(slots) || PyUnicode_Check(slots))
+ if (PyBytes_Check(slots) || PyUnicode_Check(slots))
slots = PyTuple_Pack(1, slots);
else
slots = PySequence_Tuple(slots);
@@ -2146,8 +2146,8 @@
char *s;
if (!valid_identifier(tmp))
goto bad_slots;
- assert(PyString_Check(tmp));
- s = PyString_AS_STRING(tmp);
+ assert(PyBytes_Check(tmp));
+ s = PyBytes_AS_STRING(tmp);
if (strcmp(s, "__dict__") == 0) {
if (!may_add_dict || add_dict) {
PyErr_SetString(PyExc_TypeError,
@@ -2179,7 +2179,7 @@
for (i = j = 0; i < nslots; i++) {
char *s;
tmp = PyTuple_GET_ITEM(slots, i);
- s = PyString_AS_STRING(tmp);
+ s = PyBytes_AS_STRING(tmp);
if ((add_dict && strcmp(s, "__dict__") == 0) ||
(add_weak && strcmp(s, "__weakref__") == 0))
continue;
@@ -2272,7 +2272,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 = PyString_AS_STRING(name);
+ type->tp_name = PyBytes_AS_STRING(name);
/* Set tp_base and tp_bases */
type->tp_bases = bases;
@@ -2305,14 +2305,14 @@
*/
{
PyObject *doc = PyDict_GetItemString(dict, "__doc__");
- if (doc != NULL && PyString_Check(doc)) {
- const size_t n = (size_t)PyString_GET_SIZE(doc);
+ if (doc != NULL && PyBytes_Check(doc)) {
+ const size_t n = (size_t)PyBytes_GET_SIZE(doc);
char *tp_doc = (char *)PyObject_MALLOC(n+1);
if (tp_doc == NULL) {
Py_DECREF(type);
return NULL;
}
- memcpy(tp_doc, PyString_AS_STRING(doc), n+1);
+ memcpy(tp_doc, PyBytes_AS_STRING(doc), n+1);
type->tp_doc = tp_doc;
}
}
@@ -2335,7 +2335,7 @@
slotoffset = base->tp_basicsize;
if (slots != NULL) {
for (i = 0; i < nslots; i++, mp++) {
- mp->name = PyString_AS_STRING(
+ mp->name = PyBytes_AS_STRING(
PyTuple_GET_ITEM(slots, i));
mp->type = T_OBJECT_EX;
mp->offset = slotoffset;
@@ -2536,7 +2536,7 @@
/* Give up */
PyErr_Format(PyExc_AttributeError,
"type object '%.50s' has no attribute '%.400s'",
- type->tp_name, PyString_AS_STRING(name));
+ type->tp_name, PyBytes_AS_STRING(name));
return NULL;
}
@@ -2855,7 +2855,7 @@
if (sorted_methods == NULL)
goto error;
if (comma == NULL) {
- comma = PyString_InternFromString(", ");
+ comma = PyBytes_InternFromString(", ");
if (comma == NULL)
goto error;
}
@@ -2863,7 +2863,7 @@
"O", sorted_methods);
if (joined == NULL)
goto error;
- joined_str = PyString_AsString(joined);
+ joined_str = PyBytes_AsString(joined);
if (joined_str == NULL)
goto error;
@@ -2897,20 +2897,20 @@
mod = type_module(type, NULL);
if (mod == NULL)
PyErr_Clear();
- else if (!PyString_Check(mod)) {
+ else if (!PyBytes_Check(mod)) {
Py_DECREF(mod);
mod = NULL;
}
name = type_name(type, NULL);
if (name == NULL)
return NULL;
- 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),
+ 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),
self);
else
- rtn = PyString_FromFormat("<%s object at %p>",
+ rtn = PyBytes_FromFormat("<%s object at %p>",
type->tp_name, self);
Py_XDECREF(mod);
Py_DECREF(name);
@@ -3070,7 +3070,7 @@
static PyObject *copyreg_str;
if (!copyreg_str) {
- copyreg_str = PyString_InternFromString("copy_reg");
+ copyreg_str = PyBytes_InternFromString("copy_reg");
if (copyreg_str == NULL)
return NULL;
}
@@ -3376,7 +3376,7 @@
return NULL;
if (PyUnicode_Check(format_spec)) {
self_as_str = PyObject_Unicode(self);
- } else if (PyString_Check(format_spec)) {
+ } else if (PyBytes_Check(format_spec)) {
self_as_str = PyObject_Str(self);
} else {
PyErr_SetString(PyExc_TypeError, "argument to __format__ must be unicode or str");
@@ -3619,7 +3619,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, &PyString_Type))
+ else if (PyType_IsSubtype(base, &PyBytes_Type))
type->tp_flags |= Py_TPFLAGS_STRING_SUBCLASS;
#ifdef Py_USING_UNICODE
else if (PyType_IsSubtype(base, &PyUnicode_Type))
@@ -3958,7 +3958,7 @@
*/
if (PyDict_GetItemString(type->tp_dict, "__doc__") == NULL) {
if (type->tp_doc != NULL) {
- PyObject *doc = PyString_FromString(type->tp_doc);
+ PyObject *doc = PyBytes_FromString(type->tp_doc);
if (doc == NULL)
goto error;
PyDict_SetItemString(type->tp_dict, "__doc__", doc);
@@ -4846,7 +4846,7 @@
descrgetfunc f;
if (getitem_str == NULL) {
- getitem_str = PyString_InternFromString("__getitem__");
+ getitem_str = PyBytes_InternFromString("__getitem__");
if (getitem_str == NULL)
return NULL;
}
@@ -5214,7 +5214,7 @@
return res;
}
PyErr_Clear();
- return PyString_FromFormat("<%s object at %p>",
+ return PyBytes_FromFormat("<%s object at %p>",
Py_TYPE(self)->tp_name, self);
}
@@ -5322,13 +5322,13 @@
static PyObject *getattr_str = NULL;
if (getattr_str == NULL) {
- getattr_str = PyString_InternFromString("__getattr__");
+ getattr_str = PyBytes_InternFromString("__getattr__");
if (getattr_str == NULL)
return NULL;
}
if (getattribute_str == NULL) {
getattribute_str =
- PyString_InternFromString("__getattribute__");
+ PyBytes_InternFromString("__getattribute__");
if (getattribute_str == NULL)
return NULL;
}
@@ -5469,7 +5469,7 @@
static PyObject *get_str = NULL;
if (get_str == NULL) {
- get_str = PyString_InternFromString("__get__");
+ get_str = PyBytes_InternFromString("__get__");
if (get_str == NULL)
return NULL;
}
@@ -5539,7 +5539,7 @@
Py_ssize_t i, n;
if (new_str == NULL) {
- new_str = PyString_InternFromString("__new__");
+ new_str = PyBytes_InternFromString("__new__");
if (new_str == NULL)
return NULL;
}
@@ -6069,7 +6069,7 @@
if (initialized)
return;
for (p = slotdefs; p->name; p++) {
- p->name_strobj = PyString_InternFromString(p->name);
+ p->name_strobj = PyBytes_InternFromString(p->name);
if (!p->name_strobj)
Py_FatalError("Out of memory interning slotdef names");
}
@@ -6284,12 +6284,12 @@
superobject *su = (superobject *)self;
if (su->obj_type)
- return PyString_FromFormat(
+ return PyBytes_FromFormat(
"<super: <class '%s'>, <%s object>>",
su->type ? su->type->tp_name : "NULL",
su->obj_type->tp_name);
else
- return PyString_FromFormat(
+ return PyBytes_FromFormat(
"<super: <class '%s'>, NULL>",
su->type ? su->type->tp_name : "NULL");
}
@@ -6303,9 +6303,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 = (PyString_Check(name) &&
- PyString_GET_SIZE(name) == 9 &&
- strcmp(PyString_AS_STRING(name), "__class__") == 0);
+ skip = (PyBytes_Check(name) &&
+ PyBytes_GET_SIZE(name) == 9 &&
+ strcmp(PyBytes_AS_STRING(name), "__class__") == 0);
}
if (!skip) {
@@ -6397,7 +6397,7 @@
PyObject *class_attr;
if (class_str == NULL) {
- class_str = PyString_FromString("__class__");
+ class_str = PyBytes_FromString("__class__");
if (class_str == NULL)
return NULL;
}
diff --git a/Objects/unicodeobject.c b/Objects/unicodeobject.c
index c008bd6..7af560c 100644
--- a/Objects/unicodeobject.c
+++ b/Objects/unicodeobject.c
@@ -1080,9 +1080,9 @@
#endif
/* Coerce object */
- if (PyString_Check(obj)) {
- s = PyString_AS_STRING(obj);
- len = PyString_GET_SIZE(obj);
+ if (PyBytes_Check(obj)) {
+ s = PyBytes_AS_STRING(obj);
+ len = PyBytes_GET_SIZE(obj);
}
else if (PyByteArray_Check(obj)) {
/* Python 2.x specific */
@@ -1254,7 +1254,7 @@
v = PyCodec_Encode(unicode, encoding, errors);
if (v == NULL)
goto onError;
- if (!PyString_Check(v)) {
+ if (!PyBytes_Check(v)) {
PyErr_Format(PyExc_TypeError,
"encoder did not return a string object (type=%.400s)",
Py_TYPE(v)->tp_name);
@@ -1654,13 +1654,13 @@
char * start;
if (size == 0)
- return PyString_FromStringAndSize(NULL, 0);
+ return PyBytes_FromStringAndSize(NULL, 0);
- v = PyString_FromStringAndSize(NULL, cbAllocated);
+ v = PyBytes_FromStringAndSize(NULL, cbAllocated);
if (v == NULL)
return NULL;
- start = out = PyString_AS_STRING(v);
+ start = out = PyBytes_AS_STRING(v);
for (;i < size; ++i) {
Py_UNICODE ch = s[i];
@@ -1726,7 +1726,7 @@
*out++ = '-';
}
- _PyString_Resize(&v, out - start);
+ _PyBytes_Resize(&v, out - start);
return v;
}
@@ -1991,10 +1991,10 @@
nallocated = size * 4;
if (nallocated / 4 != size) /* overflow! */
return PyErr_NoMemory();
- v = PyString_FromStringAndSize(NULL, nallocated);
+ v = PyBytes_FromStringAndSize(NULL, nallocated);
if (v == NULL)
return NULL;
- p = PyString_AS_STRING(v);
+ p = PyBytes_AS_STRING(v);
}
for (i = 0; i < size;) {
@@ -2042,13 +2042,13 @@
/* This was stack allocated. */
nneeded = p - stackbuf;
assert(nneeded <= nallocated);
- v = PyString_FromStringAndSize(stackbuf, nneeded);
+ v = PyBytes_FromStringAndSize(stackbuf, nneeded);
}
else {
/* Cut back to size actually needed. */
- nneeded = p - PyString_AS_STRING(v);
+ nneeded = p - PyBytes_AS_STRING(v);
assert(nneeded <= nallocated);
- _PyString_Resize(&v, nneeded);
+ _PyBytes_Resize(&v, nneeded);
}
return v;
@@ -2276,12 +2276,12 @@
0xDC00 <= s[i+1] && s[i+1] <= 0xDFFF)
pairs++;
#endif
- v = PyString_FromStringAndSize(NULL,
+ v = PyBytes_FromStringAndSize(NULL,
4 * (size - pairs + (byteorder == 0)));
if (v == NULL)
return NULL;
- p = (unsigned char *)PyString_AS_STRING(v);
+ p = (unsigned char *)PyBytes_AS_STRING(v);
if (byteorder == 0)
STORECHAR(0xFEFF);
if (size == 0)
@@ -2541,12 +2541,12 @@
if (s[i] >= 0x10000)
pairs++;
#endif
- v = PyString_FromStringAndSize(NULL,
+ v = PyBytes_FromStringAndSize(NULL,
2 * (size + pairs + (byteorder == 0)));
if (v == NULL)
return NULL;
- p = (unsigned char *)PyString_AS_STRING(v);
+ p = (unsigned char *)PyBytes_AS_STRING(v);
if (byteorder == 0)
STORECHAR(0xFEFF);
if (size == 0)
@@ -2889,7 +2889,7 @@
escape.
*/
- repr = PyString_FromStringAndSize(NULL,
+ repr = PyBytes_FromStringAndSize(NULL,
2
#ifdef Py_UNICODE_WIDE
+ 10*size
@@ -2900,7 +2900,7 @@
if (repr == NULL)
return NULL;
- p = PyString_AS_STRING(repr);
+ p = PyBytes_AS_STRING(repr);
if (quotes) {
*p++ = 'u';
@@ -2912,7 +2912,7 @@
/* Escape quotes and backslashes */
if ((quotes &&
- ch == (Py_UNICODE) PyString_AS_STRING(repr)[1]) || ch == '\\') {
+ ch == (Py_UNICODE) PyBytes_AS_STRING(repr)[1]) || ch == '\\') {
*p++ = '\\';
*p++ = (char) ch;
continue;
@@ -2998,10 +2998,10 @@
*p++ = (char) ch;
}
if (quotes)
- *p++ = PyString_AS_STRING(repr)[1];
+ *p++ = PyBytes_AS_STRING(repr)[1];
*p = '\0';
- _PyString_Resize(&repr, p - PyString_AS_STRING(repr));
+ _PyBytes_Resize(&repr, p - PyBytes_AS_STRING(repr));
return repr;
}
@@ -3150,16 +3150,16 @@
static const char *hexdigit = "0123456789abcdef";
#ifdef Py_UNICODE_WIDE
- repr = PyString_FromStringAndSize(NULL, 10 * size);
+ repr = PyBytes_FromStringAndSize(NULL, 10 * size);
#else
- repr = PyString_FromStringAndSize(NULL, 6 * size);
+ repr = PyBytes_FromStringAndSize(NULL, 6 * size);
#endif
if (repr == NULL)
return NULL;
if (size == 0)
return repr;
- p = q = PyString_AS_STRING(repr);
+ p = q = PyBytes_AS_STRING(repr);
while (size-- > 0) {
Py_UNICODE ch = *s++;
#ifdef Py_UNICODE_WIDE
@@ -3218,7 +3218,7 @@
*p++ = (char) ch;
}
*p = '\0';
- _PyString_Resize(&repr, p - q);
+ _PyBytes_Resize(&repr, p - q);
return repr;
}
@@ -3458,12 +3458,12 @@
/* allocate enough for a simple encoding without
replacements, if we need more, we'll resize */
- res = PyString_FromStringAndSize(NULL, size);
+ res = PyBytes_FromStringAndSize(NULL, size);
if (res == NULL)
goto onError;
if (size == 0)
return res;
- str = PyString_AS_STRING(res);
+ str = PyBytes_AS_STRING(res);
ressize = size;
while (p<endp) {
@@ -3513,7 +3513,7 @@
p = collend;
break;
case 4: /* xmlcharrefreplace */
- respos = str-PyString_AS_STRING(res);
+ respos = str-PyBytes_AS_STRING(res);
/* determine replacement size (temporarily (mis)uses p) */
for (p = collstart, repsize = 0; p < collend; ++p) {
if (*p<10)
@@ -3540,9 +3540,9 @@
if (requiredsize > ressize) {
if (requiredsize<2*ressize)
requiredsize = 2*ressize;
- if (_PyString_Resize(&res, requiredsize))
+ if (_PyBytes_Resize(&res, requiredsize))
goto onError;
- str = PyString_AS_STRING(res) + respos;
+ str = PyBytes_AS_STRING(res) + respos;
ressize = requiredsize;
}
/* generate replacement (temporarily (mis)uses p) */
@@ -3560,17 +3560,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-PyString_AS_STRING(res);
+ respos = str-PyBytes_AS_STRING(res);
repsize = PyUnicode_GET_SIZE(repunicode);
requiredsize = respos+repsize+(endp-collend);
if (requiredsize > ressize) {
if (requiredsize<2*ressize)
requiredsize = 2*ressize;
- if (_PyString_Resize(&res, requiredsize)) {
+ if (_PyBytes_Resize(&res, requiredsize)) {
Py_DECREF(repunicode);
goto onError;
}
- str = PyString_AS_STRING(res) + respos;
+ str = PyBytes_AS_STRING(res) + respos;
ressize = requiredsize;
}
/* check if there is anything unencodable in the replacement
@@ -3591,10 +3591,10 @@
}
}
/* Resize if we allocated to much */
- respos = str-PyString_AS_STRING(res);
+ respos = str-PyBytes_AS_STRING(res);
if (respos<ressize)
/* If this falls res will be NULL */
- _PyString_Resize(&res, respos);
+ _PyBytes_Resize(&res, respos);
Py_XDECREF(errorHandler);
Py_XDECREF(exc);
return res;
@@ -3671,7 +3671,7 @@
goto onError;
}
}
- if (p - PyUnicode_AS_UNICODE(v) < PyString_GET_SIZE(v))
+ if (p - PyUnicode_AS_UNICODE(v) < PyBytes_GET_SIZE(v))
if (_PyUnicode_Resize(&v, p - PyUnicode_AS_UNICODE(v)) < 0)
goto onError;
Py_XDECREF(errorHandler);
@@ -3849,20 +3849,20 @@
if (*repr == NULL) {
/* Create string object */
- *repr = PyString_FromStringAndSize(NULL, mbcssize);
+ *repr = PyBytes_FromStringAndSize(NULL, mbcssize);
if (*repr == NULL)
return -1;
}
else {
/* Extend string object */
- n = PyString_Size(*repr);
- if (_PyString_Resize(repr, n + mbcssize) < 0)
+ n = PyBytes_Size(*repr);
+ if (_PyBytes_Resize(repr, n + mbcssize) < 0)
return -1;
}
/* Do the conversion */
if (size > 0) {
- char *s = PyString_AS_STRING(*repr) + n;
+ char *s = PyBytes_AS_STRING(*repr) + n;
if (0 == WideCharToMultiByte(CP_ACP, 0, p, size, s, mbcssize, NULL, NULL)) {
PyErr_SetFromWindowsErrWithFilename(0, NULL);
return -1;
@@ -4329,7 +4329,7 @@
}
return x;
}
- else if (PyString_Check(x))
+ else if (PyBytes_Check(x))
return x;
else {
/* wrong return value */
@@ -4343,11 +4343,11 @@
static int
charmapencode_resize(PyObject **outobj, Py_ssize_t *outpos, Py_ssize_t requiredsize)
{
- Py_ssize_t outsize = PyString_GET_SIZE(*outobj);
+ Py_ssize_t outsize = PyBytes_GET_SIZE(*outobj);
/* exponentially overallocate to minimize reallocations */
if (requiredsize < 2*outsize)
requiredsize = 2*outsize;
- if (_PyString_Resize(outobj, requiredsize)) {
+ if (_PyBytes_Resize(outobj, requiredsize)) {
return 0;
}
return 1;
@@ -4368,7 +4368,7 @@
{
PyObject *rep;
char *outstart;
- Py_ssize_t outsize = PyString_GET_SIZE(*outobj);
+ Py_ssize_t outsize = PyBytes_GET_SIZE(*outobj);
if (Py_TYPE(mapping) == &EncodingMapType) {
int res = encoding_map_lookup(c, mapping);
@@ -4378,7 +4378,7 @@
if (outsize<requiredsize)
if (!charmapencode_resize(outobj, outpos, requiredsize))
return enc_EXCEPTION;
- outstart = PyString_AS_STRING(*outobj);
+ outstart = PyBytes_AS_STRING(*outobj);
outstart[(*outpos)++] = (char)res;
return enc_SUCCESS;
}
@@ -4397,19 +4397,19 @@
Py_DECREF(rep);
return enc_EXCEPTION;
}
- outstart = PyString_AS_STRING(*outobj);
+ outstart = PyBytes_AS_STRING(*outobj);
outstart[(*outpos)++] = (char)PyInt_AS_LONG(rep);
}
else {
- const char *repchars = PyString_AS_STRING(rep);
- Py_ssize_t repsize = PyString_GET_SIZE(rep);
+ const char *repchars = PyBytes_AS_STRING(rep);
+ Py_ssize_t repsize = PyBytes_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 = PyString_AS_STRING(*outobj);
+ outstart = PyBytes_AS_STRING(*outobj);
memcpy(outstart + *outpos, repchars, repsize);
*outpos += repsize;
}
@@ -4560,7 +4560,7 @@
/* allocate enough for a simple encoding without
replacements, if we need more, we'll resize */
- res = PyString_FromStringAndSize(NULL, size);
+ res = PyBytes_FromStringAndSize(NULL, size);
if (res == NULL)
goto onError;
if (size == 0)
@@ -4585,8 +4585,8 @@
}
/* Resize if we allocated to much */
- if (respos<PyString_GET_SIZE(res)) {
- if (_PyString_Resize(&res, respos))
+ if (respos<PyBytes_GET_SIZE(res)) {
+ if (_PyBytes_Resize(&res, respos))
goto onError;
}
Py_XDECREF(exc);
@@ -5484,7 +5484,7 @@
item = PySequence_Fast_GET_ITEM(fseq, i);
/* Convert item to Unicode. */
- if (! PyUnicode_Check(item) && ! PyString_Check(item)) {
+ if (! PyUnicode_Check(item) && ! PyBytes_Check(item)) {
PyErr_Format(PyExc_TypeError,
"sequence item %zd: expected string or Unicode,"
" %.80s found",
@@ -6488,7 +6488,7 @@
v = PyUnicode_AsEncodedObject((PyObject *)self, encoding, errors);
if (v == NULL)
goto onError;
- if (!PyString_Check(v) && !PyUnicode_Check(v)) {
+ if (!PyBytes_Check(v) && !PyUnicode_Check(v)) {
PyErr_Format(PyExc_TypeError,
"encoder did not return a string/unicode object "
"(type=%.400s)",
@@ -6524,7 +6524,7 @@
v = PyUnicode_AsDecodedObject((PyObject *)self, encoding, errors);
if (v == NULL)
goto onError;
- if (!PyString_Check(v) && !PyUnicode_Check(v)) {
+ if (!PyBytes_Check(v) && !PyUnicode_Check(v)) {
PyErr_Format(PyExc_TypeError,
"decoder did not return a string/unicode object "
"(type=%.400s)",
@@ -7154,7 +7154,7 @@
if (sep != NULL && sep != Py_None) {
if (PyUnicode_Check(sep))
return _PyUnicode_XStrip(self, striptype, sep);
- else if (PyString_Check(sep)) {
+ else if (PyBytes_Check(sep)) {
PyObject *res;
sep = PyUnicode_FromObject(sep);
if (sep==NULL)
@@ -8071,8 +8071,8 @@
str = _PyUnicode_AsDefaultEncodedString((PyObject *)self, NULL);
if (str == NULL)
return -1;
- *ptr = (void *) PyString_AS_STRING(str);
- return PyString_GET_SIZE(str);
+ *ptr = (void *) PyBytes_AS_STRING(str);
+ return PyBytes_GET_SIZE(str);
}
/* Helpers for PyUnicode_Format() */
@@ -8191,7 +8191,7 @@
PyObject *str; /* temporary string object. */
PyUnicodeObject *result;
- str = _PyString_FormatLong(val, flags, prec, type, &buf, &len);
+ str = _PyBytes_FormatLong(val, flags, prec, type, &buf, &len);
if (!str)
return NULL;
result = _PyUnicode_New(len);
@@ -8293,10 +8293,10 @@
buf[0] = PyUnicode_AS_UNICODE(v)[0];
}
- else if (PyString_Check(v)) {
- if (PyString_GET_SIZE(v) != 1)
+ else if (PyBytes_Check(v)) {
+ if (PyBytes_GET_SIZE(v) != 1)
goto onError;
- buf[0] = (Py_UNICODE)PyString_AS_STRING(v)[0];
+ buf[0] = (Py_UNICODE)PyBytes_AS_STRING(v)[0];
}
else {
@@ -8579,10 +8579,10 @@
goto onError;
if (PyUnicode_Check(temp))
/* nothing to do */;
- else if (PyString_Check(temp)) {
+ else if (PyBytes_Check(temp)) {
/* convert to string to Unicode */
- unicode = PyUnicode_Decode(PyString_AS_STRING(temp),
- PyString_GET_SIZE(temp),
+ unicode = PyUnicode_Decode(PyBytes_AS_STRING(temp),
+ PyBytes_GET_SIZE(temp),
NULL,
"strict");
Py_DECREF(temp);
diff --git a/Objects/weakrefobject.c b/Objects/weakrefobject.c
index 1aee5a5..2899bc7 100644
--- a/Objects/weakrefobject.c
+++ b/Objects/weakrefobject.c
@@ -166,8 +166,8 @@
"__name__");
if (nameobj == NULL)
PyErr_Clear();
- else if (PyString_Check(nameobj))
- name = PyString_AS_STRING(nameobj);
+ else if (PyBytes_Check(nameobj))
+ name = PyBytes_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 PyString_FromString(buffer);
+ return PyBytes_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 PyString_FromString(buf);
+ return PyBytes_FromString(buf);
}