self = (Noddy *)type->tp_alloc(type, 0);
if (self != NULL) {
- self->first = PyBytes_FromString("");
+ self->first = PyString_FromString("");
if (self->first == NULL)
{
Py_DECREF(self);
return NULL;
}
- self->last = PyBytes_FromString("");
+ self->last = PyString_FromString("");
if (self->last == NULL)
{
Py_DECREF(self);
PyObject *args, *result;
if (format == NULL) {
- format = PyBytes_FromString("%s %s");
+ format = PyString_FromString("%s %s");
if (format == NULL)
return NULL;
}
if (args == NULL)
return NULL;
- result = PyBytes_Format(format, args);
+ result = PyString_Format(format, args);
Py_DECREF(args);
return result;
self = (Noddy *)type->tp_alloc(type, 0);
if (self != NULL) {
- self->first = PyBytes_FromString("");
+ self->first = PyString_FromString("");
if (self->first == NULL)
{
Py_DECREF(self);
return NULL;
}
- self->last = PyBytes_FromString("");
+ self->last = PyString_FromString("");
if (self->last == NULL)
{
Py_DECREF(self);
return -1;
}
- if (! PyBytes_Check(value)) {
+ if (! PyString_Check(value)) {
PyErr_SetString(PyExc_TypeError,
"The first attribute value must be a string");
return -1;
return -1;
}
- if (! PyBytes_Check(value)) {
+ if (! PyString_Check(value)) {
PyErr_SetString(PyExc_TypeError,
"The last attribute value must be a string");
return -1;
PyObject *args, *result;
if (format == NULL) {
- format = PyBytes_FromString("%s %s");
+ format = PyString_FromString("%s %s");
if (format == NULL)
return NULL;
}
if (args == NULL)
return NULL;
- result = PyBytes_Format(format, args);
+ result = PyString_Format(format, args);
Py_DECREF(args);
return result;
self = (Noddy *)type->tp_alloc(type, 0);
if (self != NULL) {
- self->first = PyBytes_FromString("");
+ self->first = PyString_FromString("");
if (self->first == NULL)
{
Py_DECREF(self);
return NULL;
}
- self->last = PyBytes_FromString("");
+ self->last = PyString_FromString("");
if (self->last == NULL)
{
Py_DECREF(self);
PyObject *args, *result;
if (format == NULL) {
- format = PyBytes_FromString("%s %s");
+ format = PyString_FromString("%s %s");
if (format == NULL)
return NULL;
}
if (args == NULL)
return NULL;
- result = PyBytes_Format(format, args);
+ result = PyString_Format(format, args);
Py_DECREF(args);
return result;
}
Py_Initialize();
- pName = PyBytes_FromString(argv[1]);
+ pName = PyString_FromString(argv[1]);
/* Error checking of pName left out */
pModule = PyImport_Import(pName);
-/* Bytes (String) object interface */
+/* String (Bytes) object interface */
#ifndef Py_BYTESOBJECT_H
#define Py_BYTESOBJECT_H
#include <stdarg.h>
/*
-Type PyBytesObject represents a character string. An extra zero byte is
+Type PyStringObject represents a character string. An extra zero byte is
reserved at the end to ensure it is zero-terminated, but a size is
present so strings with null bytes in them can be represented. This
is an immutable object type.
* 'interned' dictionary; in this case the two references
* from 'interned' to this object are *not counted* in ob_refcnt.
*/
-} PyBytesObject;
+} PyStringObject;
#define SSTATE_NOT_INTERNED 0
#define SSTATE_INTERNED_MORTAL 1
#define SSTATE_INTERNED_IMMORTAL 2
PyAPI_DATA(PyTypeObject) PyBaseString_Type;
-PyAPI_DATA(PyTypeObject) PyBytes_Type;
+PyAPI_DATA(PyTypeObject) PyString_Type;
-#define PyBytes_Check(op) \
+#define PyString_Check(op) \
PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_STRING_SUBCLASS)
-#define PyBytes_CheckExact(op) (Py_TYPE(op) == &PyBytes_Type)
+#define PyString_CheckExact(op) (Py_TYPE(op) == &PyString_Type)
-PyAPI_FUNC(PyObject *) PyBytes_FromStringAndSize(const char *, Py_ssize_t);
-PyAPI_FUNC(PyObject *) PyBytes_FromString(const char *);
-PyAPI_FUNC(PyObject *) PyBytes_FromFormatV(const char*, va_list)
+PyAPI_FUNC(PyObject *) PyString_FromStringAndSize(const char *, Py_ssize_t);
+PyAPI_FUNC(PyObject *) PyString_FromString(const char *);
+PyAPI_FUNC(PyObject *) PyString_FromFormatV(const char*, va_list)
Py_GCC_ATTRIBUTE((format(printf, 1, 0)));
-PyAPI_FUNC(PyObject *) PyBytes_FromFormat(const char*, ...)
+PyAPI_FUNC(PyObject *) PyString_FromFormat(const char*, ...)
Py_GCC_ATTRIBUTE((format(printf, 1, 2)));
-PyAPI_FUNC(Py_ssize_t) PyBytes_Size(PyObject *);
-PyAPI_FUNC(char *) PyBytes_AsString(PyObject *);
-PyAPI_FUNC(PyObject *) PyBytes_Repr(PyObject *, int);
-PyAPI_FUNC(void) PyBytes_Concat(PyObject **, PyObject *);
-PyAPI_FUNC(void) PyBytes_ConcatAndDel(PyObject **, PyObject *);
-PyAPI_FUNC(int) _PyBytes_Resize(PyObject **, Py_ssize_t);
-PyAPI_FUNC(int) _PyBytes_Eq(PyObject *, PyObject*);
-PyAPI_FUNC(PyObject *) PyBytes_Format(PyObject *, PyObject *);
-PyAPI_FUNC(PyObject *) _PyBytes_FormatLong(PyObject*, int, int,
+PyAPI_FUNC(Py_ssize_t) PyString_Size(PyObject *);
+PyAPI_FUNC(char *) PyString_AsString(PyObject *);
+PyAPI_FUNC(PyObject *) PyString_Repr(PyObject *, int);
+PyAPI_FUNC(void) PyString_Concat(PyObject **, PyObject *);
+PyAPI_FUNC(void) PyString_ConcatAndDel(PyObject **, PyObject *);
+PyAPI_FUNC(int) _PyString_Resize(PyObject **, Py_ssize_t);
+PyAPI_FUNC(int) _PyString_Eq(PyObject *, PyObject*);
+PyAPI_FUNC(PyObject *) PyString_Format(PyObject *, PyObject *);
+PyAPI_FUNC(PyObject *) _PyString_FormatLong(PyObject*, int, int,
int, char**, int*);
-PyAPI_FUNC(PyObject *) PyBytes_DecodeEscape(const char *, Py_ssize_t,
+PyAPI_FUNC(PyObject *) PyString_DecodeEscape(const char *, Py_ssize_t,
const char *, Py_ssize_t,
const char *);
-PyAPI_FUNC(void) PyBytes_InternInPlace(PyObject **);
-PyAPI_FUNC(void) PyBytes_InternImmortal(PyObject **);
-PyAPI_FUNC(PyObject *) PyBytes_InternFromString(const char *);
+PyAPI_FUNC(void) PyString_InternInPlace(PyObject **);
+PyAPI_FUNC(void) PyString_InternImmortal(PyObject **);
+PyAPI_FUNC(PyObject *) PyString_InternFromString(const char *);
PyAPI_FUNC(void) _Py_ReleaseInternedStrings(void);
/* Use only if you know it's a string */
-#define PyBytes_CHECK_INTERNED(op) (((PyBytesObject *)(op))->ob_sstate)
+#define PyString_CHECK_INTERNED(op) (((PyStringObject *)(op))->ob_sstate)
/* Macro, trading safety for speed */
-#define PyBytes_AS_STRING(op) (((PyBytesObject *)(op))->ob_sval)
-#define PyBytes_GET_SIZE(op) Py_SIZE(op)
+#define PyString_AS_STRING(op) (((PyStringObject *)(op))->ob_sval)
+#define PyString_GET_SIZE(op) Py_SIZE(op)
-/* _PyBytes_Join(sep, x) is like sep.join(x). sep must be PyBytesObject*,
+/* _PyString_Join(sep, x) is like sep.join(x). sep must be PyStringObject*,
x must be an iterable object. */
-PyAPI_FUNC(PyObject *) _PyBytes_Join(PyObject *sep, PyObject *x);
+PyAPI_FUNC(PyObject *) _PyString_Join(PyObject *sep, PyObject *x);
/* --- Generic Codecs ----------------------------------------------------- */
/* Create an object by decoding the encoded string s of the
given size. */
-PyAPI_FUNC(PyObject*) PyBytes_Decode(
+PyAPI_FUNC(PyObject*) PyString_Decode(
const char *s, /* encoded string */
Py_ssize_t size, /* size of buffer */
const char *encoding, /* encoding */
/* Encodes a char buffer of the given size and returns a
Python object. */
-PyAPI_FUNC(PyObject*) PyBytes_Encode(
+PyAPI_FUNC(PyObject*) PyString_Encode(
const char *s, /* string char buffer */
Py_ssize_t size, /* number of chars to encode */
const char *encoding, /* encoding */
/* Encodes a string object and returns the result as Python
object. */
-PyAPI_FUNC(PyObject*) PyBytes_AsEncodedObject(
+PyAPI_FUNC(PyObject*) PyString_AsEncodedObject(
PyObject *str, /* string object */
const char *encoding, /* encoding */
const char *errors /* error handling */
If the codec returns an Unicode object, the object is converted
back to a string using the default encoding.
- DEPRECATED - use PyBytes_AsEncodedObject() instead. */
+ DEPRECATED - use PyString_AsEncodedObject() instead. */
-PyAPI_FUNC(PyObject*) PyBytes_AsEncodedString(
+PyAPI_FUNC(PyObject*) PyString_AsEncodedString(
PyObject *str, /* string object */
const char *encoding, /* encoding */
const char *errors /* error handling */
/* Decodes a string object and returns the result as Python
object. */
-PyAPI_FUNC(PyObject*) PyBytes_AsDecodedObject(
+PyAPI_FUNC(PyObject*) PyString_AsDecodedObject(
PyObject *str, /* string object */
const char *encoding, /* encoding */
const char *errors /* error handling */
If the codec returns an Unicode object, the object is converted
back to a string using the default encoding.
- DEPRECATED - use PyBytes_AsDecodedObject() instead. */
+ DEPRECATED - use PyString_AsDecodedObject() instead. */
-PyAPI_FUNC(PyObject*) PyBytes_AsDecodedString(
+PyAPI_FUNC(PyObject*) PyString_AsDecodedString(
PyObject *str, /* string object */
const char *encoding, /* encoding */
const char *errors /* error handling */
0-terminated (passing a string with embedded NULL characters will
cause an exception). */
-PyAPI_FUNC(int) PyBytes_AsStringAndSize(
+PyAPI_FUNC(int) PyString_AsStringAndSize(
register PyObject *obj, /* string or Unicode object */
register char **s, /* pointer to buffer variable */
register Py_ssize_t *len /* pointer to length variable or NULL
into the string pointed to by buffer. For the argument descriptions,
see Objects/stringlib/localeutil.h */
-PyAPI_FUNC(int) _PyBytes_InsertThousandsGrouping(char *buffer,
+PyAPI_FUNC(int) _PyString_InsertThousandsGrouping(char *buffer,
Py_ssize_t len,
char *plast,
Py_ssize_t buf_size,
PyAPI_FUNC(long) _Py_HashPointer(void*);
/* Helper for passing objects to printf and the like */
-#define PyObject_REPR(obj) PyBytes_AS_STRING(PyObject_Repr(obj))
+#define PyObject_REPR(obj) PyString_AS_STRING(PyObject_Repr(obj))
/* Flag bits for printing: */
#define Py_PRINT_RAW 1 /* No string quotes etc. */
#define Py_TPFLAGS_LONG_SUBCLASS (1L<<24)
#define Py_TPFLAGS_LIST_SUBCLASS (1L<<25)
#define Py_TPFLAGS_TUPLE_SUBCLASS (1L<<26)
-#define Py_TPFLAGS_BYTES_SUBCLASS (1L<<27)
+#define Py_TPFLAGS_STRING_SUBCLASS (1L<<27)
#define Py_TPFLAGS_UNICODE_SUBCLASS (1L<<28)
#define Py_TPFLAGS_DICT_SUBCLASS (1L<<29)
#define Py_TPFLAGS_BASE_EXC_SUBCLASS (1L<<30)
static PyObject *PyCurses_ ## X (PyObject *self) \
{ \
PyCursesInitialised \
- return PyBytes_FromString(X()); }
+ return PyString_FromString(X()); }
#define NoArgTrueFalseFunction(X) \
static PyObject *PyCurses_ ## X (PyObject *self) \
#define PyExceptionClass_Name(x) \
(PyClass_Check((x)) \
- ? PyBytes_AS_STRING(((PyClassObject*)(x))->cl_name) \
+ ? PyString_AS_STRING(((PyClassObject*)(x))->cl_name) \
: (char *)(((PyTypeObject*)(x))->tp_name))
#define PyExceptionInstance_Class(x) \
* all platforms (Python interprets the format string itself, and does whatever
* the platform C requires to convert a size_t/Py_ssize_t argument):
*
- * PyBytes_FromFormat
+ * PyString_FromFormat
* PyErr_Format
- * PyBytes_FromFormatV
+ * PyString_FromFormatV
*
* Lower-level uses require that you interpolate the correct format modifier
* yourself (e.g., calling printf, fprintf, sprintf, PyOS_snprintf); for
PyAPI_FUNC(void) PyTuple_Fini(void);
PyAPI_FUNC(void) PyList_Fini(void);
PyAPI_FUNC(void) PySet_Fini(void);
-PyAPI_FUNC(void) PyBytes_Fini(void);
+PyAPI_FUNC(void) PyString_Fini(void);
PyAPI_FUNC(void) PyInt_Fini(void);
PyAPI_FUNC(void) PyFloat_Fini(void);
PyAPI_FUNC(void) PyOS_FiniInterrupts(void);
#define PyBytesObject PyStringObject
#define PyBytes_Type PyString_Type
-#define PyString_Check PyBytes_Check
-#define PyString_CheckExact PyBytes_CheckExact
-#define PyString_CHECK_INTERNED PyBytes_CHECK_INTERNED
-#define PyString_AS_STRING PyBytes_AS_STRING
-#define PyString_GET_SIZE PyBytes_GET_SIZE
-
-#define Py_TPFLAGS_STRING_SUBCLASS Py_TPFLAGS_BYTES_SUBCLASS
+#define PyBytes_Check PyString_Check
+#define PyBytes_CheckExact PyString_CheckExact
+#define PyBytes_CHECK_INTERNED PyString_CHECK_INTERNED
+#define PyBytes_AS_STRING PyString_AS_STRING
+#define PyBytes_GET_SIZE PyString_GET_SIZE
+#define Py_TPFLAGS_BYTES_SUBCLASS Py_TPFLAGS_STRING_SUBCLASS
#define PyBytes_FromStringAndSize PyString_FromStringAndSize
#define PyBytes_FromString PyString_FromString
#define PyBytes_Format PyString_Format
#define _PyBytes_FormatLong _PyString_FormatLong
#define PyBytes_DecodeEscape PyString_DecodeEscape
-#define PyBytes_InternInPlace PyString_InternInPlace
-#define PyBytes_InternImmortal PyString_InternImmortal
-#define PyBytes_InternFromString PyString_InternFromString
#define _PyBytes_Join _PyString_Join
#define PyBytes_Decode PyString_Decode
#define PyBytes_Encode PyString_Encode
** some of the image and sound processing interfaces on the mac:-(
*/
{
- PyBytesObject *p = 0;
+ PyStringObject *p = 0;
long off = (long)&(p->ob_sval[0]);
if( PyDict_SetItemString(d, "string_id_to_buffer", Py_BuildValue("i", off)) != 0)
NavGetDefaultDialogOptions(opt);
while ( PyDict_Next(d, &pos, &key, &value) ) {
- if ( !key || !value || !PyBytes_Check(key) ) {
+ if ( !key || !value || !PyString_Check(key) ) {
PyErr_SetString(ErrorObject, "DialogOption has non-string key");
return 0;
}
- keystr = PyBytes_AsString(key);
+ keystr = PyString_AsString(key);
if( strcmp(keystr, "defaultLocation") == 0 ) {
if ( (defaultLocation_storage = PyMem_NEW(AEDesc, 1)) == NULL ) {
PyErr_NoMemory();
/* Add some symbolic constants to the module */
d = PyModule_GetDict(m);
- ErrorObject = PyBytes_FromString("Nav.error");
+ ErrorObject = PyString_FromString("Nav.error");
PyDict_SetItemString(d, "error", ErrorObject);
/* XXXX Add constants here */
OSErr err;
size = AEGetDescDataSize(&self->ob_itself);
- if ( (res = PyBytes_FromStringAndSize(NULL, size)) == NULL )
+ if ( (res = PyString_FromStringAndSize(NULL, size)) == NULL )
return NULL;
- if ( (ptr = PyBytes_AsString(res)) == NULL )
+ if ( (ptr = PyString_AsString(res)) == NULL )
return NULL;
if ( (err=AEGetDescData(&self->ob_itself, ptr, size)) < 0 )
return PyMac_Error(err);
{
char buf[100];
sprintf(buf, "<CFTypeRef type-%d object at 0x%8.8x for 0x%8.8x>", (int)CFGetTypeID(self->ob_itself), (unsigned)self, (unsigned)self->ob_itself);
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
static int CFTypeRefObj_hash(CFTypeRefObject *self)
{
char buf[100];
sprintf(buf, "<CFArrayRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
static int CFArrayRefObj_hash(CFArrayRefObject *self)
{
char buf[100];
sprintf(buf, "<CFMutableArrayRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
static int CFMutableArrayRefObj_hash(CFMutableArrayRefObject *self)
{
char buf[100];
sprintf(buf, "<CFDictionaryRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
static int CFDictionaryRefObj_hash(CFDictionaryRefObject *self)
{
char buf[100];
sprintf(buf, "<CFMutableDictionaryRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
static int CFMutableDictionaryRefObj_hash(CFMutableDictionaryRefObject *self)
{
if (v == Py_None) { *p_itself = NULL; return 1; }
- if (PyBytes_Check(v)) {
+ if (PyString_Check(v)) {
char *cStr;
Py_ssize_t cLen;
- if( PyBytes_AsStringAndSize(v, &cStr, &cLen) < 0 ) return 0;
+ if( PyString_AsStringAndSize(v, &cStr, &cLen) < 0 ) return 0;
*p_itself = CFDataCreate((CFAllocatorRef)NULL, (unsigned char *)cStr, cLen);
return 1;
}
int size = CFDataGetLength(_self->ob_itself);
char *data = (char *)CFDataGetBytePtr(_self->ob_itself);
- _res = (PyObject *)PyBytes_FromStringAndSize(data, size);
+ _res = (PyObject *)PyString_FromStringAndSize(data, size);
return _res;
}
{
char buf[100];
sprintf(buf, "<CFDataRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
static int CFDataRefObj_hash(CFDataRefObject *self)
{
char buf[100];
sprintf(buf, "<CFMutableDataRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
static int CFMutableDataRefObj_hash(CFMutableDataRefObject *self)
{
if (v == Py_None) { *p_itself = NULL; return 1; }
- if (PyBytes_Check(v)) {
+ if (PyString_Check(v)) {
char *cStr;
if (!PyArg_Parse(v, "es", "ascii", &cStr))
return 0;
if( data == NULL ) return PyErr_NoMemory();
if ( CFStringGetCString(_self->ob_itself, data, size, 0) ) {
- _res = (PyObject *)PyBytes_FromString(data);
+ _res = (PyObject *)PyString_FromString(data);
} else {
PyErr_SetString(PyExc_RuntimeError, "CFStringGetCString could not fit the string");
_res = NULL;
{
char buf[100];
sprintf(buf, "<CFStringRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
static int CFStringRefObj_hash(CFStringRefObject *self)
{
char buf[100];
sprintf(buf, "<CFMutableStringRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
static int CFMutableStringRefObj_hash(CFMutableStringRefObject *self)
{
char buf[100];
sprintf(buf, "<CFURL object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
static int CFURLRefObj_hash(CFURLRefObject *self)
int
PyCF_Python2CF(PyObject *src, CFTypeRef *dst) {
- if (PyBytes_Check(src) || PyUnicode_Check(src))
+ if (PyString_Check(src) || PyUnicode_Check(src))
return PyCF_Python2CF_simple(src, dst);
if (PySequence_Check(src))
return PyCF_Python2CF_sequence(src, (CFArrayRef *)dst);
return (*dst != NULL);
}
#endif
- if (PyBytes_Check(src) || PyUnicode_Check(src))
+ if (PyString_Check(src) || PyUnicode_Check(src))
return PyCF_Python2CF_string(src, (CFStringRef *)dst);
if (PyBool_Check(src)) {
if (src == Py_True)
CFIndex size;
UniChar *unichars;
- if (PyBytes_Check(src)) {
+ if (PyString_Check(src)) {
if (!PyArg_Parse(src, "es", "ascii", &chars))
return 0; /* This error is more descriptive than the general one below */
*dst = CFStringCreateWithCString((CFAllocatorRef)NULL, chars, kCFStringEncodingASCII);
size = GetHandleSize((Handle)self->ob_itself);
HLock((Handle)self->ob_itself);
- rv = PyBytes_FromStringAndSize(*(Handle)self->ob_itself, size);
+ rv = PyString_FromStringAndSize(*(Handle)self->ob_itself, size);
HUnlock((Handle)self->ob_itself);
return rv;
PyMac_Error(err);
return NULL;
}
- _res = PyBytes_FromString(strbuf);
+ _res = PyString_FromString(strbuf);
return _res;
}
static PyObject *FSSpec_get_data(FSSpecObject *self, void *closure)
{
- return PyBytes_FromStringAndSize((char *)&self->ob_itself, sizeof(self->ob_itself));
+ return PyString_FromStringAndSize((char *)&self->ob_itself, sizeof(self->ob_itself));
}
#define FSSpec_set_data NULL
self->ob_itself.vRefNum,
self->ob_itself.parID,
self->ob_itself.name[0], self->ob_itself.name+1);
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
#define FSSpec_hash NULL
static PyObject *FSRef_get_data(FSRefObject *self, void *closure)
{
- return PyBytes_FromStringAndSize((char *)&self->ob_itself, sizeof(self->ob_itself));
+ return PyString_FromStringAndSize((char *)&self->ob_itself, sizeof(self->ob_itself));
}
#define FSRef_set_data NULL
if (!PyArg_ParseTuple(_args, "O", &obj))
return NULL;
- if (PyBytes_Check(obj)) {
+ if (PyString_Check(obj)) {
Py_INCREF(obj);
return obj;
}
}
/* On OSX we now try a pathname */
- if ( PyBytes_Check(v) || PyUnicode_Check(v)) {
+ if ( PyString_Check(v) || PyUnicode_Check(v)) {
char *path = NULL;
if (!PyArg_Parse(v, "et", Py_FileSystemDefaultEncoding, &path))
return 0;
if ( !PyArg_ParseTuple(_args, "ii", &from, &length) )
return NULL;
cp = _self->ob_itself->baseAddr+from;
- _res = PyBytes_FromStringAndSize(cp, length);
+ _res = PyString_FromStringAndSize(cp, length);
return _res;
}
static PyObject *BMObj_get_bitmap_data(BitMapObject *self, void *closure)
{
- return PyBytes_FromStringAndSize((char *)self->ob_itself, sizeof(BitMap));
+ return PyString_FromStringAndSize((char *)self->ob_itself, sizeof(BitMap));
}
#define BMObj_set_bitmap_data NULL
static PyObject *BMObj_get_pixmap_data(BitMapObject *self, void *closure)
{
- return PyBytes_FromStringAndSize((char *)self->ob_itself, sizeof(PixMap));
+ return PyString_FromStringAndSize((char *)self->ob_itself, sizeof(PixMap));
}
#define BMObj_set_pixmap_data NULL
int rowbytes;
char *data;
- if ( !PyArg_ParseTuple(_args, "O!iO&", &PyBytes_Type, &source, &rowbytes, PyMac_GetRect,
+ if ( !PyArg_ParseTuple(_args, "O!iO&", &PyString_Type, &source, &rowbytes, PyMac_GetRect,
&bounds) )
return NULL;
- data = PyBytes_AsString(source);
+ data = PyString_AsString(source);
if ((ptr=(BitMap *)malloc(sizeof(BitMap))) == NULL )
return PyErr_NoMemory();
ptr->baseAddr = (Ptr)data;
BitMap *ptr;
PyObject *source;
- if ( !PyArg_ParseTuple(_args, "O!", &PyBytes_Type, &source) )
+ if ( !PyArg_ParseTuple(_args, "O!", &PyString_Type, &source) )
return NULL;
- if ( PyBytes_Size(source) != sizeof(BitMap) && PyBytes_Size(source) != sizeof(PixMap) ) {
+ if ( PyString_Size(source) != sizeof(BitMap) && PyString_Size(source) != sizeof(PixMap) ) {
PyErr_Format(PyExc_TypeError,
"Argument size was %ld, should be %lu (sizeof BitMap) or %lu (sizeof PixMap)",
- PyBytes_Size(source), sizeof(BitMap), sizeof(PixMap));
+ PyString_Size(source), sizeof(BitMap), sizeof(PixMap));
return NULL;
}
- ptr = (BitMapPtr)PyBytes_AsString(source);
+ ptr = (BitMapPtr)PyString_AsString(source);
if ( (_res = BMObj_New(ptr)) == NULL ) {
return NULL;
}
if ( !PyArg_ParseTuple(_args, "O&ii", ResObj_Convert, &pm, &from, &length) )
return NULL;
cp = GetPixBaseAddr(pm)+from;
- _res = PyBytes_FromStringAndSize(cp, length);
+ _res = PyString_FromStringAndSize(cp, length);
return _res;
}
state = HGetState(self->ob_itself);
HLock(self->ob_itself);
- res = PyBytes_FromStringAndSize(
+ res = PyString_FromStringAndSize(
*self->ob_itself,
GetHandleSize(self->ob_itself));
HUnlock(self->ob_itself);
if ( v == NULL )
return -1;
- if ( !PyBytes_Check(v) )
+ if ( !PyString_Check(v) )
return -1;
- size = PyBytes_Size(v);
- data = PyBytes_AsString(v);
+ size = PyString_Size(v);
+ data = PyString_AsString(v);
/* XXXX Do I need the GetState/SetState calls? */
SetHandleSize(self->ob_itself, size);
if ( MemError())
flavorType,
&byteCount);
if (_err != noErr) return PyMac_Error(_err);
- _res = PyBytes_FromStringAndSize(NULL, (int)byteCount);
+ _res = PyString_FromStringAndSize(NULL, (int)byteCount);
if ( _res == NULL ) return NULL;
_err = GetScrapFlavorData(_self->ob_itself,
flavorType,
&byteCount,
- PyBytes_AS_STRING(_res));
+ PyString_AS_STRING(_res));
if (_err != noErr) {
Py_XDECREF(_res);
return PyMac_Error(_err);
/* Add some symbolic constants to the module */
d = PyModule_GetDict(m);
- ErrorObject = PyBytes_FromString("Sndihooks.error");
+ ErrorObject = PyString_FromString("Sndihooks.error");
PyDict_SetItemString(d, "error", ErrorObject);
/* XXXX Add constants here */
{
char buf[100];
sprintf(buf, "<Window object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
static int WinObj_hash(WindowObject *self)
Include/bitset.h \
Include/boolobject.h \
Include/bytes_methods.h \
- Include/bytearrayobject.h \
Include/bytesobject.h \
Include/bufferobject.h \
Include/cellobject.h \
bytesio_getvalue(BytesIOObject *self)
{
CHECK_CLOSED(self);
- return PyBytes_FromStringAndSize(self->buf, self->string_size);
+ return PyString_FromStringAndSize(self->buf, self->string_size);
}
PyDoc_STRVAR(isatty_doc,
output = self->buf + self->pos;
self->pos += size;
- return PyBytes_FromStringAndSize(output, size);
+ return PyString_FromStringAndSize(output, size);
}
self->pos -= size;
}
- return PyBytes_FromStringAndSize(output, n);
+ return PyString_FromStringAndSize(output, n);
}
PyDoc_STRVAR(readlines_doc,
return NULL;
while ((n = get_line(self, &output)) != 0) {
- line = PyBytes_FromStringAndSize(output, n);
+ line = PyString_FromStringAndSize(output, n);
if (!line)
goto on_error;
if (PyList_Append(result, line) == -1) {
if (!next || n == 0)
return NULL;
- return PyBytes_FromStringAndSize(next, n);
+ return PyString_FromStringAndSize(next, n);
}
PyDoc_STRVAR(seek_doc,
if (!PyArg_ParseTuple(args, "s#|z:escape_decode",
&data, &size, &errors))
return NULL;
- return codec_tuple(PyBytes_DecodeEscape(data, size, errors, 0, NULL),
+ return codec_tuple(PyString_DecodeEscape(data, size, errors, 0, NULL),
size);
}
Py_ssize_t len;
if (!PyArg_ParseTuple(args, "O!|z:escape_encode",
- &PyBytes_Type, &str, &errors))
+ &PyString_Type, &str, &errors))
return NULL;
- str = PyBytes_Repr(str, 0);
+ str = PyString_Repr(str, 0);
if (!str)
return NULL;
/* The string will be quoted. Unquote, similar to unicode-escape. */
- buf = PyBytes_AS_STRING (str);
- len = PyBytes_GET_SIZE (str);
+ buf = PyString_AS_STRING (str);
+ len = PyString_GET_SIZE (str);
memmove(buf, buf+1, len-2);
- if (_PyBytes_Resize(&str, len-2) < 0)
+ if (_PyString_Resize(&str, len-2) < 0)
return NULL;
- return codec_tuple(str, PyBytes_Size(str));
+ return codec_tuple(str, PyString_Size(str));
}
#ifdef Py_USING_UNICODE
&data, &size, &errors))
return NULL;
- return codec_tuple(PyBytes_FromStringAndSize(data, size),
+ return codec_tuple(PyString_FromStringAndSize(data, size),
size);
}
&data, &size, &errors))
return NULL;
- return codec_tuple(PyBytes_FromStringAndSize(data, size),
+ return codec_tuple(PyString_FromStringAndSize(data, size),
size);
}
if (PyUnicode_Check(obj)) {
data = PyUnicode_AS_DATA(obj);
size = PyUnicode_GET_DATA_SIZE(obj);
- return codec_tuple(PyBytes_FromStringAndSize(data, size),
+ return codec_tuple(PyString_FromStringAndSize(data, size),
size);
}
else {
if (PyObject_AsReadBuffer(obj, (const void **)&data, &size))
return NULL;
- return codec_tuple(PyBytes_FromStringAndSize(data, size),
+ return codec_tuple(PyString_FromStringAndSize(data, size),
size);
}
}
if (i != 0) {
if (i < 0)
return NULL;
- return PyBytes_FromString("[...]");
+ return PyString_FromString("[...]");
}
aslist = PySequence_List(deque);
return NULL;
}
if (((dequeobject *)deque)->maxlen != -1)
- fmt = PyBytes_FromFormat("deque(%%r, maxlen=%i)",
+ fmt = PyString_FromFormat("deque(%%r, maxlen=%i)",
((dequeobject *)deque)->maxlen);
else
- fmt = PyBytes_FromString("deque(%r)");
+ fmt = PyString_FromString("deque(%r)");
if (fmt == NULL) {
Py_DECREF(aslist);
Py_ReprLeave(deque);
return NULL;
}
- result = PyBytes_Format(fmt, aslist);
+ result = PyString_Format(fmt, aslist);
Py_DECREF(fmt);
Py_DECREF(aslist);
Py_ReprLeave(deque);
if (baserepr == NULL)
return NULL;
if (dd->default_factory == NULL)
- defrepr = PyBytes_FromString("None");
+ defrepr = PyString_FromString("None");
else
{
int status = Py_ReprEnter(dd->default_factory);
if (status != 0) {
if (status < 0)
return NULL;
- defrepr = PyBytes_FromString("...");
+ defrepr = PyString_FromString("...");
}
else
defrepr = PyObject_Repr(dd->default_factory);
Py_DECREF(baserepr);
return NULL;
}
- result = PyBytes_FromFormat("defaultdict(%s, %s)",
- PyBytes_AS_STRING(defrepr),
- PyBytes_AS_STRING(baserepr));
+ result = PyString_FromFormat("defaultdict(%s, %s)",
+ PyString_AS_STRING(defrepr),
+ PyString_AS_STRING(baserepr));
Py_DECREF(defrepr);
Py_DECREF(baserepr);
return result;
return Py_None;
}
else
- return PyBytes_FromStringAndSize((char*)&c, 1);
+ return PyString_FromStringAndSize((char*)&c, 1);
}
static PyObject *
if (src == NULL)
*target = dflt;
else {
- if (src == Py_None || PyBytes_Size(src) == 0)
+ if (src == Py_None || PyString_Size(src) == 0)
*target = '\0';
- else if (!PyBytes_Check(src) || PyBytes_Size(src) != 1) {
+ else if (!PyString_Check(src) || PyString_Size(src) != 1) {
PyErr_Format(PyExc_TypeError,
"\"%s\" must be an 1-character string",
name);
return -1;
}
else {
- char *s = PyBytes_AsString(src);
+ char *s = PyString_AsString(src);
if (s == NULL)
return -1;
*target = s[0];
_set_str(const char *name, PyObject **target, PyObject *src, const char *dflt)
{
if (src == NULL)
- *target = PyBytes_FromString(dflt);
+ *target = PyString_FromString(dflt);
else {
if (src == Py_None)
*target = NULL;
{
PyObject *field;
- field = PyBytes_FromStringAndSize(self->field, self->field_len);
+ field = PyString_FromStringAndSize(self->field, self->field_len);
if (field == NULL)
return -1;
self->field_len = 0;
}
++self->line_num;
- line = PyBytes_AsString(lineobj);
- linelen = PyBytes_Size(lineobj);
+ line = PyString_AsString(lineobj);
+ linelen = PyString_Size(lineobj);
if (line == NULL || linelen < 0) {
Py_DECREF(lineobj);
rec_len++;\
} while(0)
- lineterm = PyBytes_AsString(dialect->lineterminator);
+ lineterm = PyString_AsString(dialect->lineterminator);
if (lineterm == NULL)
return -1;
int terminator_len;
char *terminator;
- terminator_len = PyBytes_Size(self->dialect->lineterminator);
+ terminator_len = PyString_Size(self->dialect->lineterminator);
if (terminator_len == -1)
return 0;
if (!join_check_rec_size(self, self->rec_len + terminator_len))
return 0;
- terminator = PyBytes_AsString(self->dialect->lineterminator);
+ terminator = PyString_AsString(self->dialect->lineterminator);
if (terminator == NULL)
return 0;
memmove(self->rec + self->rec_len, terminator, terminator_len);
break;
}
- if (PyBytes_Check(field)) {
+ if (PyString_Check(field)) {
append_ok = join_append(self,
- PyBytes_AS_STRING(field),
+ PyString_AS_STRING(field),
"ed, len == 1);
Py_DECREF(field);
}
if (str == NULL)
return NULL;
- append_ok = join_append(self, PyBytes_AS_STRING(str),
+ append_ok = join_append(self, PyString_AS_STRING(str),
"ed, len == 1);
Py_DECREF(str);
}
if (-1 == PyType_Type.tp_setattro(self, key, value))
return -1;
- if (value && PyBytes_Check(key) &&
- 0 == strcmp(PyBytes_AS_STRING(key), "_fields_"))
+ if (value && PyString_Check(key) &&
+ 0 == strcmp(PyString_AS_STRING(key), "_fields_"))
return StructUnionType_update_stgdict(self, value, 1);
return 0;
}
if (-1 == PyObject_GenericSetAttr(self, key, value))
return -1;
- if (PyBytes_Check(key) &&
- 0 == strcmp(PyBytes_AS_STRING(key), "_fields_"))
+ if (PyString_Check(key) &&
+ 0 == strcmp(PyString_AS_STRING(key), "_fields_"))
return StructUnionType_update_stgdict(self, value, 0);
return 0;
}
size = Py_TYPE(value)->tp_as_buffer->bf_getreadbuffer(value, 0, (void *)&ptr);
if (size < 0)
return -1;
- } else if (-1 == PyBytes_AsStringAndSize(value, &ptr, &size)) {
+ } else if (-1 == PyString_AsStringAndSize(value, &ptr, &size)) {
return -1;
}
if (size > self->b_size) {
static PyObject *
CharArray_get_raw(CDataObject *self)
{
- return PyBytes_FromStringAndSize(self->b_ptr, self->b_size);
+ return PyString_FromStringAndSize(self->b_ptr, self->b_size);
}
static PyObject *
for (i = 0; i < self->b_size; ++i)
if (*ptr++ == '\0')
break;
- return PyBytes_FromStringAndSize(self->b_ptr, i);
+ return PyString_FromStringAndSize(self->b_ptr, i);
}
static int
conversion_mode_errors);
if (!value)
return -1;
- } else if (!PyBytes_Check(value)) {
+ } else if (!PyString_Check(value)) {
PyErr_Format(PyExc_TypeError,
"string expected instead of %s instance",
Py_TYPE(value)->tp_name);
return -1;
} else
Py_INCREF(value);
- size = PyBytes_GET_SIZE(value);
+ size = PyString_GET_SIZE(value);
if (size > self->b_size) {
PyErr_SetString(PyExc_ValueError,
"string too long");
return -1;
}
- ptr = PyBytes_AS_STRING(value);
+ ptr = PyString_AS_STRING(value);
memcpy(self->b_ptr, ptr, size);
if (size < self->b_size)
self->b_ptr[size] = '\0';
"can't delete attribute");
return -1;
}
- if (PyBytes_Check(value)) {
+ if (PyString_Check(value)) {
value = PyUnicode_FromEncodedObject(value,
conversion_mode_encoding,
conversion_mode_errors);
Py_INCREF(Py_None);
return Py_None;
}
- if (PyUnicode_Check(value) || PyBytes_Check(value)) {
+ if (PyUnicode_Check(value) || PyString_Check(value)) {
PyCArgObject *parg;
struct fielddesc *fd = getentry("Z");
Py_INCREF(Py_None);
return Py_None;
}
- if (PyBytes_Check(value) || PyUnicode_Check(value)) {
+ if (PyString_Check(value) || PyUnicode_Check(value)) {
PyCArgObject *parg;
struct fielddesc *fd = getentry("z");
return (PyObject *)parg;
}
/* string */
- if (PyBytes_Check(value)) {
+ if (PyString_Check(value)) {
PyCArgObject *parg;
struct fielddesc *fd = getentry("z");
}
/* c_char_p, c_wchar_p */
stgd = PyObject_stgdict(value);
- if (stgd && CDataObject_Check(value) && stgd->proto && PyBytes_Check(stgd->proto)) {
+ if (stgd && CDataObject_Check(value) && stgd->proto && PyString_Check(stgd->proto)) {
PyCArgObject *parg;
- switch (PyBytes_AS_STRING(stgd->proto)[0]) {
+ switch (PyString_AS_STRING(stgd->proto)[0]) {
case 'z': /* c_char_p */
case 'Z': /* c_wchar_p */
parg = new_CArgObject();
if (suffix == NULL)
#ifdef WORDS_BIGENDIAN
- suffix = PyBytes_InternFromString("_le");
+ suffix = PyString_InternFromString("_le");
#else
- suffix = PyBytes_InternFromString("_be");
+ suffix = PyString_InternFromString("_be");
#endif
Py_INCREF(name);
- PyBytes_Concat(&name, suffix);
+ PyString_Concat(&name, suffix);
if (name == NULL)
return NULL;
dict = PyObject_stgdict((PyObject *)self);
assert(dict); /* Cannot be NULL for CDataObject instances */
- fmt = PyBytes_AsString(dict->proto);
+ fmt = PyString_AsString(dict->proto);
assert(fmt);
fd = getentry(fmt);
SIMPLE_TYPE_CHARS);
goto error;
}
- fmt = getentry(PyBytes_AS_STRING(proto));
+ fmt = getentry(PyString_AS_STRING(proto));
if (fmt == NULL) {
Py_DECREF(result);
PyErr_Format(PyExc_ValueError,
"_type_ '%s' not supported",
- PyBytes_AS_STRING(proto));
+ PyString_AS_STRING(proto));
return NULL;
}
Overrides the SimpleType_from_param generic method.
*/
if (result->tp_base == &Simple_Type) {
- switch (PyBytes_AS_STRING(proto)[0]) {
+ switch (PyString_AS_STRING(proto)[0]) {
case 'z': /* c_char_p */
ml = &c_char_p_method;
stgdict->flags |= TYPEFLAG_ISPOINTER;
assert(dict);
/* I think we can rely on this being a one-character string */
- fmt = PyBytes_AsString(dict->proto);
+ fmt = PyString_AsString(dict->proto);
assert(fmt);
fd = getentry(fmt);
#endif
target = target->b_base;
}
- return PyBytes_FromStringAndSize(string, cp-string);
+ return PyString_FromStringAndSize(string, cp-string);
}
/*
_unpickle,
Py_TYPE(_self),
PyObject_GetAttrString(_self, "__dict__"),
- PyBytes_FromStringAndSize(self->b_ptr, self->b_size));
+ PyString_FromStringAndSize(self->b_ptr, self->b_size));
}
static PyObject *
dict = PyType_stgdict(arg);
if (dict
/* simple pointer types, c_void_p, c_wchar_p, BSTR, ... */
- && PyBytes_Check(dict->proto)
+ && PyString_Check(dict->proto)
/* We only allow c_void_p, c_char_p and c_wchar_p as a simple output parameter type */
- && (strchr("PzZ", PyBytes_AS_STRING(dict->proto)[0]))) {
+ && (strchr("PzZ", PyString_AS_STRING(dict->proto)[0]))) {
return 1;
}
return 1;
}
#endif
- if (PyBytes_Check(obj) || PyUnicode_Check(obj)) {
- *pname = PyBytes_AsString(obj);
+ if (PyString_Check(obj) || PyUnicode_Check(obj)) {
+ *pname = PyString_AsString(obj);
return *pname ? 1 : 0;
}
PyErr_SetString(PyExc_TypeError,
/* We HAVE already checked that the tuple can be parsed with "i|zO", so... */
Py_ssize_t tsize = PyTuple_GET_SIZE(item);
flag = PyInt_AS_LONG(PyTuple_GET_ITEM(item, 0));
- name = tsize > 1 ? PyBytes_AS_STRING(PyTuple_GET_ITEM(item, 1)) : NULL;
+ name = tsize > 1 ? PyString_AS_STRING(PyTuple_GET_ITEM(item, 1)) : NULL;
defval = tsize > 2 ? PyTuple_GET_ITEM(item, 2) : NULL;
switch (flag & (PARAMFLAG_FIN | PARAMFLAG_FOUT | PARAMFLAG_FLCID)) {
"NULL stgdict unexpected");
goto error;
}
- if (PyBytes_Check(dict->proto)) {
+ if (PyString_Check(dict->proto)) {
PyErr_Format(
PyExc_TypeError,
"%s 'out' parameter must be passed as default value",
{
#ifdef MS_WIN32
if (self->index)
- return PyBytes_FromFormat("<COM method offset %d: %s at %p>",
+ return PyString_FromFormat("<COM method offset %d: %s at %p>",
self->index - 0x1000,
Py_TYPE(self)->tp_name,
self);
#endif
- return PyBytes_FromFormat("<%s object at %p>",
+ return PyString_FromFormat("<%s object at %p>",
Py_TYPE(self)->tp_name,
self);
}
}
if (kwds && PyDict_GetItem(kwds, name)) {
- char *field = PyBytes_AsString(name);
+ char *field = PyString_AsString(name);
if (field == NULL) {
PyErr_Clear();
field = "???";
type, so this cannot be NULL */
if (itemdict->getfunc == getentry("c")->getfunc) {
char *ptr = (char *)self->b_ptr;
- return PyBytes_FromStringAndSize(ptr + ilow, len);
+ return PyString_FromStringAndSize(ptr + ilow, len);
#ifdef CTYPES_UNICODE
} else if (itemdict->getfunc == getentry("u")->getfunc) {
wchar_t *ptr = (wchar_t *)self->b_ptr;
char *dest;
if (slicelen <= 0)
- return PyBytes_FromString("");
+ return PyString_FromString("");
if (step == 1) {
- return PyBytes_FromStringAndSize(ptr + start,
+ return PyString_FromStringAndSize(ptr + start,
slicelen);
}
dest = (char *)PyMem_Malloc(slicelen);
dest[i] = ptr[cur];
}
- np = PyBytes_FromStringAndSize(dest, slicelen);
+ np = PyString_FromStringAndSize(dest, slicelen);
PyMem_Free(dest);
return np;
}
static PyObject *format;
if (Py_TYPE(self)->tp_base != &Simple_Type) {
- return PyBytes_FromFormat("<%s object at %p>",
+ return PyString_FromFormat("<%s object at %p>",
Py_TYPE(self)->tp_name, self);
}
if (format == NULL) {
- format = PyBytes_InternFromString("%s(%r)");
+ format = PyString_InternFromString("%s(%r)");
if (format == NULL)
return NULL;
}
if (val == NULL)
return NULL;
- name = PyBytes_FromString(Py_TYPE(self)->tp_name);
+ name = PyString_FromString(Py_TYPE(self)->tp_name);
if (name == NULL) {
Py_DECREF(val);
return NULL;
if (args == NULL)
return NULL;
- result = PyBytes_Format(format, args);
+ result = PyString_Format(format, args);
Py_DECREF(args);
return result;
}
assert(itemdict);
if (itemdict->getfunc == getentry("c")->getfunc) {
char *ptr = *(char **)self->b_ptr;
- return PyBytes_FromStringAndSize(ptr + ilow, len);
+ return PyString_FromStringAndSize(ptr + ilow, len);
#ifdef CTYPES_UNICODE
} else if (itemdict->getfunc == getentry("u")->getfunc) {
wchar_t *ptr = *(wchar_t **)self->b_ptr;
char *dest;
if (len <= 0)
- return PyBytes_FromString("");
+ return PyString_FromString("");
if (step == 1) {
- return PyBytes_FromStringAndSize(ptr + start,
+ return PyString_FromStringAndSize(ptr + start,
len);
}
dest = (char *)PyMem_Malloc(len);
for (cur = start, i = 0; i < len; cur += step, i++) {
dest[i] = ptr[cur];
}
- np = PyBytes_FromStringAndSize(dest, len);
+ np = PyString_FromStringAndSize(dest, len);
PyMem_Free(dest);
return np;
}
++methods;
}
- s = PyBytes_FromString(comerror_doc);
+ s = PyString_FromString(comerror_doc);
if (s == NULL)
goto error;
status = PyDict_SetItemString(dict, "__doc__", s);
string_at(const char *ptr, int size)
{
if (size == -1)
- return PyBytes_FromString(ptr);
- return PyBytes_FromStringAndSize(ptr, size);
+ return PyString_FromString(ptr);
+ return PyString_FromStringAndSize(ptr, size);
}
static int
return 1;
dict = PyType_stgdict(arg);
if (dict) {
- if (PyBytes_Check(dict->proto)
- && (strchr("sPzUZXO", PyBytes_AS_STRING(dict->proto)[0]))) {
+ if (PyString_Check(dict->proto)
+ && (strchr("sPzUZXO", PyString_AS_STRING(dict->proto)[0]))) {
/* simple pointer types, c_void_p, c_wchar_p, BSTR, ... */
return 1;
}
PyCodeObject *py_code = 0;
PyFrameObject *py_frame = 0;
- py_srcfile = PyBytes_FromString(filename);
+ py_srcfile = PyString_FromString(filename);
if (!py_srcfile) goto bad;
- py_funcname = PyBytes_FromString(funcname);
+ py_funcname = PyString_FromString(funcname);
if (!py_funcname) goto bad;
py_globals = PyDict_New();
if (!py_globals) goto bad;
empty_tuple = PyTuple_New(0);
if (!empty_tuple) goto bad;
- empty_string = PyBytes_FromString("");
+ empty_string = PyString_FromString("");
if (!empty_string) goto bad;
py_code = PyCode_New(
0, /*int argcount,*/
static PyObject *context;
if (context == NULL)
- context = PyBytes_InternFromString("_ctypes.DllGetClassObject");
+ context = PyString_InternFromString("_ctypes.DllGetClassObject");
mod = PyImport_ImportModuleNoBlock("ctypes");
if (!mod) {
static PyObject *context;
if (context == NULL)
- context = PyBytes_InternFromString("_ctypes.DllCanUnloadNow");
+ context = PyString_InternFromString("_ctypes.DllCanUnloadNow");
mod = PyImport_ImportModuleNoBlock("ctypes");
if (!mod) {
self->tag, self);
break;
}
- return PyBytes_FromString(buffer);
+ return PyString_FromString(buffer);
}
static PyMemberDef PyCArgType_members[] = {
return 0;
}
- if (PyBytes_Check(obj)) {
+ if (PyString_Check(obj)) {
pa->ffi_type = &ffi_type_pointer;
- pa->value.p = PyBytes_AS_STRING(obj);
+ pa->value.p = PyString_AS_STRING(obj);
Py_INCREF(obj);
pa->keep = obj;
return 0;
PyObject *tp, *v, *tb, *s, *cls_str, *msg_str;
va_start(vargs, fmt);
- s = PyBytes_FromFormatV(fmt, vargs);
+ s = PyString_FromFormatV(fmt, vargs);
va_end(vargs);
if (!s)
return;
PyErr_NormalizeException(&tp, &v, &tb);
cls_str = PyObject_Str(tp);
if (cls_str) {
- PyBytes_ConcatAndDel(&s, cls_str);
- PyBytes_ConcatAndDel(&s, PyBytes_FromString(": "));
+ PyString_ConcatAndDel(&s, cls_str);
+ PyString_ConcatAndDel(&s, PyString_FromString(": "));
if (s == NULL)
goto error;
} else
PyErr_Clear();
msg_str = PyObject_Str(v);
if (msg_str)
- PyBytes_ConcatAndDel(&s, msg_str);
+ PyString_ConcatAndDel(&s, msg_str);
else {
PyErr_Clear();
- PyBytes_ConcatAndDel(&s, PyBytes_FromString("???"));
+ PyString_ConcatAndDel(&s, PyString_FromString("???"));
if (s == NULL)
goto error;
}
if (!PyArg_ParseTuple(args, "O|O:LoadLibrary", &nameobj, &ignored))
return NULL;
#ifdef _UNICODE
- name = alloca((PyBytes_Size(nameobj) + 1) * sizeof(WCHAR));
+ name = alloca((PyString_Size(nameobj) + 1) * sizeof(WCHAR));
if (!name) {
PyErr_NoMemory();
return NULL;
{
int r;
- char *aname = PyBytes_AsString(nameobj);
+ char *aname = PyString_AsString(nameobj);
if(!aname)
return NULL;
- r = MultiByteToWideChar(CP_ACP, 0, aname, -1, name, PyBytes_Size(nameobj) + 1);
+ r = MultiByteToWideChar(CP_ACP, 0, aname, -1, name, PyString_Size(nameobj) + 1);
name[r] = 0;
}
#else
- name = PyBytes_AsString(nameobj);
+ name = PyString_AsString(nameobj);
if(!name)
return NULL;
#endif
Py_INCREF(result);
return result;
}
- if (PyBytes_CheckExact(cls)) {
- buf = alloca(strlen(PyBytes_AS_STRING(cls)) + 3 + 1);
- sprintf(buf, "LP_%s", PyBytes_AS_STRING(cls));
+ if (PyString_CheckExact(cls)) {
+ buf = alloca(strlen(PyString_AS_STRING(cls)) + 3 + 1);
+ sprintf(buf, "LP_%s", PyString_AS_STRING(cls));
result = PyObject_CallFunction((PyObject *)Py_TYPE(&Pointer_Type),
"s(O){}",
buf,
name = ((PyTypeObject *)self->proto)->tp_name;
if (bits)
- result = PyBytes_FromFormat(
+ result = PyString_FromFormat(
#if (PY_VERSION_HEX < 0x02050000)
"<Field type=%s, ofs=%d:%d, bits=%d>",
#else
#endif
name, self->offset, size, bits);
else
- result = PyBytes_FromFormat(
+ result = PyString_FromFormat(
#if (PY_VERSION_HEX < 0x02050000)
"<Field type=%s, ofs=%d, size=%d>",
#else
static PyObject *
c_set(void *ptr, PyObject *value, Py_ssize_t size)
{
- if (!PyBytes_Check(value) || (1 != PyBytes_Size(value))) {
+ if (!PyString_Check(value) || (1 != PyString_Size(value))) {
PyErr_Format(PyExc_TypeError,
"one character string expected");
return NULL;
}
- *(char *)ptr = PyBytes_AS_STRING(value)[0];
+ *(char *)ptr = PyString_AS_STRING(value)[0];
_RET(value);
}
static PyObject *
c_get(void *ptr, Py_ssize_t size)
{
- return PyBytes_FromStringAndSize((char *)ptr, 1);
+ return PyString_FromStringAndSize((char *)ptr, 1);
}
#ifdef CTYPES_UNICODE
{
Py_ssize_t len;
- if (PyBytes_Check(value)) {
+ if (PyString_Check(value)) {
value = PyUnicode_FromEncodedObject(value,
conversion_mode_encoding,
conversion_mode_errors);
/* It's easier to calculate in characters than in bytes */
length /= sizeof(wchar_t);
- if (PyBytes_Check(value)) {
+ if (PyString_Check(value)) {
value = PyUnicode_FromEncodedObject(value,
conversion_mode_encoding,
conversion_mode_errors);
PyObject *result;
size_t slen;
- result = PyBytes_FromString((char *)ptr);
+ result = PyString_FromString((char *)ptr);
if (!result)
return NULL;
/* chop off at the first NUL character, if any.
* On error, result will be deallocated and set to NULL.
*/
- slen = strlen(PyBytes_AS_STRING(result));
+ slen = strlen(PyString_AS_STRING(result));
size = min(size, (Py_ssize_t)slen);
if (result->ob_refcnt == 1) {
/* shorten the result */
- _PyBytes_Resize(&result, size);
+ _PyString_Resize(&result, size);
return result;
} else
/* cannot shorten the result */
- return PyBytes_FromStringAndSize(ptr, size);
+ return PyString_FromStringAndSize(ptr, size);
}
static PyObject *
char *data;
Py_ssize_t size;
- data = PyBytes_AsString(value);
+ data = PyString_AsString(value);
if (!data)
return NULL;
size = strlen(data);
Py_INCREF(value);
return value;
}
- if (PyBytes_Check(value)) {
- *(char **)ptr = PyBytes_AS_STRING(value);
+ if (PyString_Check(value)) {
+ *(char **)ptr = PyString_AS_STRING(value);
Py_INCREF(value);
return value;
} else if (PyUnicode_Check(value)) {
conversion_mode_errors);
if (str == NULL)
return NULL;
- *(char **)ptr = PyBytes_AS_STRING(str);
+ *(char **)ptr = PyString_AS_STRING(str);
return str;
} else if (PyInt_Check(value) || PyLong_Check(value)) {
#if SIZEOF_VOID_P == SIZEOF_LONG_LONG
return NULL;
}
#endif
- return PyBytes_FromString(*(char **)ptr);
+ return PyString_FromString(*(char **)ptr);
} else {
Py_INCREF(Py_None);
return Py_None;
Py_INCREF(value);
return value;
}
- if (PyBytes_Check(value)) {
+ if (PyString_Check(value)) {
value = PyUnicode_FromEncodedObject(value,
conversion_mode_encoding,
conversion_mode_errors);
/* convert value into a PyUnicodeObject or NULL */
if (Py_None == value) {
value = NULL;
- } else if (PyBytes_Check(value)) {
+ } else if (PyString_Check(value)) {
value = PyUnicode_FromEncodedObject(value,
conversion_mode_encoding,
conversion_mode_errors);
PyDict_SetItemString(d, "error", PyCursesError);
/* Make the version available */
- v = PyBytes_FromString(PyCursesVersion);
+ v = PyString_FromString(PyCursesVersion);
PyDict_SetItemString(d, "version", v);
PyDict_SetItemString(d, "__version__", v);
Py_DECREF(v);
{
if (PyInt_Check(obj)) {
*ch = (chtype) PyInt_AsLong(obj);
- } else if(PyBytes_Check(obj)
- && (PyBytes_Size(obj) == 1)) {
- *ch = (chtype) *PyBytes_AsString(obj);
+ } else if(PyString_Check(obj)
+ && (PyString_Size(obj) == 1)) {
+ *ch = (chtype) *PyString_AsString(obj);
} else {
return 0;
}
return Py_BuildValue("c", rtn);
else
#if defined(__NetBSD__)
- return PyBytes_FromString(unctrl(rtn));
+ return PyString_FromString(unctrl(rtn));
#else
- return PyBytes_FromString((char *)keyname(rtn));
+ return PyString_FromString((char *)keyname(rtn));
#endif
}
}
if (rtn2 == ERR)
rtn[0] = 0;
- return PyBytes_FromString(rtn);
+ return PyString_FromString(rtn);
}
static PyObject *
}
if (rtn2 == ERR)
rtn[0] = 0;
- return PyBytes_FromString(rtn);
+ return PyString_FromString(rtn);
}
static PyObject *
ch = erasechar();
- return PyBytes_FromStringAndSize(&ch, 1);
+ return PyString_FromStringAndSize(&ch, 1);
}
static PyObject *
}
knp = keyname(ch);
- return PyBytes_FromString((knp == NULL) ? "" : (char *)knp);
+ return PyString_FromString((knp == NULL) ? "" : (char *)knp);
}
#endif
ch = killchar();
- return PyBytes_FromStringAndSize(&ch, 1);
+ return PyString_FromStringAndSize(&ch, 1);
}
static PyObject *
Py_INCREF(Py_None);
return Py_None;
}
- return PyBytes_FromString( capname );
+ return PyString_FromString( capname );
}
static PyObject *
return NULL;
}
- return PyBytes_FromString(result);
+ return PyString_FromString(result);
}
static PyObject *
if (PyInt_Check(temp))
ch = (chtype) PyInt_AsLong(temp);
- else if (PyBytes_Check(temp))
- ch = (chtype) *PyBytes_AsString(temp);
+ else if (PyString_Check(temp))
+ ch = (chtype) *PyString_AsString(temp);
else {
PyErr_SetString(PyExc_TypeError, "argument must be a ch or an int");
return NULL;
}
- return PyBytes_FromString(unctrl(ch));
+ return PyString_FromString(unctrl(ch));
}
static PyObject *
if (PyInt_Check(temp))
ch = (int) PyInt_AsLong(temp);
- else if (PyBytes_Check(temp))
- ch = (int) *PyBytes_AsString(temp);
+ else if (PyString_Check(temp))
+ ch = (int) *PyString_AsString(temp);
else {
PyErr_SetString(PyExc_TypeError, "argument must be a ch or an int");
return NULL;
PyDict_SetItemString(d, "error", PyCursesError);
/* Make the version available */
- v = PyBytes_FromString(PyCursesVersion);
+ v = PyString_FromString(PyCursesVersion);
PyDict_SetItemString(d, "version", v);
PyDict_SetItemString(d, "__version__", v);
Py_DECREF(v);
#define PyDict_CheckExact PyDict_Check
#if (PY_VERSION_HEX < 0x02020000)
#define PyList_CheckExact PyList_Check
-#define PyBytes_CheckExact PyBytes_Check
+#define PyString_CheckExact PyString_Check
#if (PY_VERSION_HEX >= 0x01060000)
#define Py_USING_UNICODE /* always enabled for 2.0 and 2.1 */
#endif
switch (PyList_GET_SIZE(list)) {
case 0:
Py_DECREF(list);
- return PyBytes_FromString("");
+ return PyString_FromString("");
case 1:
result = PyList_GET_ITEM(list, 0);
Py_INCREF(result);
return 0;
}
#endif
- if (PyBytes_Check(tag)) {
- char *p = PyBytes_AS_STRING(tag);
- for (i = 0; i < PyBytes_GET_SIZE(tag); i++) {
+ if (PyString_Check(tag)) {
+ char *p = PyString_AS_STRING(tag);
+ for (i = 0; i < PyString_GET_SIZE(tag); i++) {
if (p[i] == '{')
check = 0;
else if (p[i] == '}')
if (Element_CheckExact(item) && !PyObject_Compare(item->tag, tag)) {
PyObject* text = element_get_text(item);
if (text == Py_None)
- return PyBytes_FromString("");
+ return PyString_FromString("");
Py_XINCREF(text);
return text;
}
PyObject* repr;
char buffer[100];
- repr = PyBytes_FromString("<Element ");
+ repr = PyString_FromString("<Element ");
- PyBytes_ConcatAndDel(&repr, PyObject_Repr(self->tag));
+ PyString_ConcatAndDel(&repr, PyObject_Repr(self->tag));
sprintf(buffer, " at %p>", self);
- PyBytes_ConcatAndDel(&repr, PyBytes_FromString(buffer));
+ PyString_ConcatAndDel(&repr, PyString_FromString(buffer));
return repr;
}
Py_INCREF(data); self->data = data;
} else {
/* more than one item; use a list to collect items */
- if (PyBytes_CheckExact(self->data) && Py_REFCNT(self->data) == 1 &&
- PyBytes_CheckExact(data) && PyBytes_GET_SIZE(data) == 1) {
+ if (PyString_CheckExact(self->data) && Py_REFCNT(self->data) == 1 &&
+ PyString_CheckExact(data) && PyString_GET_SIZE(data) == 1) {
/* expat often generates single character data sections; handle
the most common case by resizing the existing string... */
- Py_ssize_t size = PyBytes_GET_SIZE(self->data);
- if (_PyBytes_Resize(&self->data, size + 1) < 0)
+ Py_ssize_t size = PyString_GET_SIZE(self->data);
+ if (_PyString_Resize(&self->data, size + 1) < 0)
return NULL;
- PyBytes_AS_STRING(self->data)[size] = PyBytes_AS_STRING(data)[0];
+ PyString_AS_STRING(self->data)[size] = PyString_AS_STRING(data)[0];
} else if (PyList_CheckExact(self->data)) {
if (PyList_Append(self->data, data) < 0)
return NULL;
return PyUnicode_DecodeUTF8(string, size, "strict");
#endif
- return PyBytes_FromStringAndSize(string, size);
+ return PyString_FromStringAndSize(string, size);
}
LOCAL(PyObject*)
PyObject* value;
/* look the 'raw' name up in the names dictionary */
- key = PyBytes_FromStringAndSize(string, size);
+ key = PyString_FromStringAndSize(string, size);
if (!key)
return NULL;
break;
if (i != size) {
/* convert to universal name */
- tag = PyBytes_FromStringAndSize(NULL, size+1);
- p = PyBytes_AS_STRING(tag);
+ tag = PyString_FromStringAndSize(NULL, size+1);
+ p = PyString_AS_STRING(tag);
p[0] = '{';
memcpy(p+1, string, size);
size++;
#if defined(Py_USING_UNICODE)
/* inline makestring, to avoid duplicating the source string if
it's not an utf-8 string */
- p = PyBytes_AS_STRING(tag);
+ p = PyString_AS_STRING(tag);
if (checkstring(p, size)) {
value = PyUnicode_DecodeUTF8(p, size, "strict");
Py_DECREF(tag);
} else {
PyErr_Format(
PyExc_SyntaxError, "undefined entity &%s;: line %ld, column %ld",
- PyBytes_AS_STRING(key),
+ PyString_AS_STRING(key),
EXPAT(GetErrorLineNumber)(self->parser),
EXPAT(GetErrorColumnNumber)(self->parser)
);
return NULL;
}
- if (!PyBytes_CheckExact(buffer) || PyBytes_GET_SIZE(buffer) == 0) {
+ if (!PyString_CheckExact(buffer) || PyString_GET_SIZE(buffer) == 0) {
Py_DECREF(buffer);
break;
}
res = expat_parse(
- self, PyBytes_AS_STRING(buffer), PyBytes_GET_SIZE(buffer), 0
+ self, PyString_AS_STRING(buffer), PyString_GET_SIZE(buffer), 0
);
Py_DECREF(buffer);
if (event_set == Py_None) {
/* default is "end" only */
- target->end_event_obj = PyBytes_FromString("end");
+ target->end_event_obj = PyString_FromString("end");
Py_RETURN_NONE;
}
for (i = 0; i < PyTuple_GET_SIZE(event_set); i++) {
PyObject* item = PyTuple_GET_ITEM(event_set, i);
char* event;
- if (!PyBytes_Check(item))
+ if (!PyString_Check(item))
goto error;
- event = PyBytes_AS_STRING(item);
+ event = PyString_AS_STRING(item);
if (strcmp(event, "start") == 0) {
Py_INCREF(item);
target->start_event_obj = item;
char buffer[100];
sprintf(buffer, "Expat %d.%d.%d", XML_MAJOR_VERSION,
XML_MINOR_VERSION, XML_MICRO_VERSION);
- return PyBytes_FromString(buffer);
+ return PyString_FromString(buffer);
} else {
PyErr_SetString(PyExc_AttributeError, name);
return NULL;
Py_ssize_t total = 0;
int n;
- result = PyBytes_FromStringAndSize(NULL, DEFAULT_BUFFER_SIZE);
+ result = PyString_FromStringAndSize(NULL, DEFAULT_BUFFER_SIZE);
if (result == NULL)
return NULL;
while (1) {
Py_ssize_t newsize = total + DEFAULT_BUFFER_SIZE;
- if (PyBytes_GET_SIZE(result) < newsize) {
- if (_PyBytes_Resize(&result, newsize) < 0) {
+ if (PyString_GET_SIZE(result) < newsize) {
+ if (_PyString_Resize(&result, newsize) < 0) {
if (total == 0) {
Py_DECREF(result);
return NULL;
Py_BEGIN_ALLOW_THREADS
errno = 0;
n = read(self->fd,
- PyBytes_AS_STRING(result) + total,
+ PyString_AS_STRING(result) + total,
newsize - total);
Py_END_ALLOW_THREADS
if (n == 0)
total += n;
}
- if (PyBytes_GET_SIZE(result) > total) {
- if (_PyBytes_Resize(&result, total) < 0) {
+ if (PyString_GET_SIZE(result) > total) {
+ if (_PyString_Resize(&result, total) < 0) {
/* This should never happen, but just in case */
Py_DECREF(result);
return NULL;
return fileio_readall(self);
}
- bytes = PyBytes_FromStringAndSize(NULL, size);
+ bytes = PyString_FromStringAndSize(NULL, size);
if (bytes == NULL)
return NULL;
- ptr = PyBytes_AS_STRING(bytes);
+ ptr = PyString_AS_STRING(bytes);
Py_BEGIN_ALLOW_THREADS
errno = 0;
}
if (n != size) {
- if (_PyBytes_Resize(&bytes, n) < 0) {
+ if (_PyString_Resize(&bytes, n) < 0) {
Py_DECREF(bytes);
return NULL;
}
fileio_repr(PyFileIOObject *self)
{
if (self->fd < 0)
- return PyBytes_FromFormat("_fileio._FileIO(-1)");
+ return PyString_FromFormat("_fileio._FileIO(-1)");
- return PyBytes_FromFormat("_fileio._FileIO(%d, '%s')",
+ return PyString_FromFormat("_fileio._FileIO(%d, '%s')",
self->fd, mode_string(self));
}
static PyObject *
get_mode(PyFileIOObject *self, void *closure)
{
- return PyBytes_FromString(mode_string(self));
+ return PyString_FromString(mode_string(self));
}
static PyGetSetDef fileio_getsetlist[] = {
digest_size = EVP_MD_CTX_size(&temp_ctx);
EVP_DigestFinal(&temp_ctx, digest, NULL);
- retval = PyBytes_FromStringAndSize((const char *)digest, digest_size);
+ retval = PyString_FromStringAndSize((const char *)digest, digest_size);
EVP_MD_CTX_cleanup(&temp_ctx);
return retval;
}
/* Create a new string */
/* NOTE: not thread safe! modifying an already created string object */
/* (not a problem because we hold the GIL by default) */
- retval = PyBytes_FromStringAndSize(NULL, digest_size * 2);
+ retval = PyString_FromStringAndSize(NULL, digest_size * 2);
if (!retval)
return NULL;
- hex_digest = PyBytes_AsString(retval);
+ hex_digest = PyString_AsString(retval);
if (!hex_digest) {
Py_DECREF(retval);
return NULL;
{
char buf[100];
PyOS_snprintf(buf, sizeof(buf), "<%s HASH object @ %p>",
- PyBytes_AsString(((EVPobject *)self)->name), self);
- return PyBytes_FromString(buf);
+ PyString_AsString(((EVPobject *)self)->name), self);
+ return PyString_FromString(buf);
}
#if HASH_OBJ_CONSTRUCTOR
/* used in the init function to setup a constructor */
#define INIT_CONSTRUCTOR_CONSTANTS(NAME) do { \
- CONST_ ## NAME ## _name_obj = PyBytes_FromString(#NAME); \
+ CONST_ ## NAME ## _name_obj = PyString_FromString(#NAME); \
if (EVP_get_digestbyname(#NAME)) { \
CONST_new_ ## NAME ## _ctx_p = &CONST_new_ ## NAME ## _ctx; \
EVP_DigestInit(CONST_new_ ## NAME ## _ctx_p, EVP_get_digestbyname(#NAME)); \
m = Py_InitModule3("_heapq", heapq_methods, module_doc);
if (m == NULL)
return;
- PyModule_AddObject(m, "__about__", PyBytes_FromString(__about__));
+ PyModule_AddObject(m, "__about__", PyString_FromString(__about__));
}
return ERR_EOF;
}
}
- *pvalue = PyBytes_FromStringAndSize(buf, len);
+ *pvalue = PyString_FromStringAndSize(buf, len);
free(buf);
if (*pvalue == NULL) {
return ERR_EXCEPTION;
self->index - written);
self->index -= written;
if (written == 0) {
- char *s = PyBytes_AsString(self->logfilename);
+ char *s = PyString_AsString(self->logfilename);
PyErr_SetFromErrnoWithFilename(PyExc_IOError, s);
do_stop(self);
return -1;
}
if (written > 0) {
if (fflush(self->logfp)) {
- char *s = PyBytes_AsString(self->logfilename);
+ char *s = PyString_AsString(self->logfilename);
PyErr_SetFromErrnoWithFilename(PyExc_IOError, s);
do_stop(self);
return -1;
self->next_fileno++;
Py_DECREF(obj);
if (pack_define_file(self, fileno,
- PyBytes_AS_STRING(fcode->co_filename)) < 0)
+ PyString_AS_STRING(fcode->co_filename)) < 0)
return -1;
}
else {
PyObject *name = PyDict_GetItem(dict, obj);
if (name == NULL) {
if (pack_define_func(self, fileno, fcode->co_firstlineno,
- PyBytes_AS_STRING(fcode->co_name)) < 0) {
+ PyString_AS_STRING(fcode->co_name)) < 0) {
Py_DECREF(obj);
return -1;
}
len = PyList_GET_SIZE(temp);
for (i = 0; i < len; ++i) {
PyObject *item = PyList_GET_ITEM(temp, i);
- buffer = PyBytes_AsString(item);
+ buffer = PyString_AsString(item);
if (buffer == NULL) {
pack_add_info(self, "sys-path-entry", "<non-string-path-entry>");
PyErr_Clear();
input_unicode = PyUnicode_AS_UNICODE(pystr);
/* One char input can be up to 6 chars output, estimate 4 of these */
output_size = 2 + (MIN_EXPANSION * 4) + input_chars;
- rval = PyBytes_FromStringAndSize(NULL, output_size);
+ rval = PyString_FromStringAndSize(NULL, output_size);
if (rval == NULL) {
return NULL;
}
- output = PyBytes_AS_STRING(rval);
+ output = PyString_AS_STRING(rval);
chars = 0;
output[chars++] = '"';
for (i = 0; i < input_chars; i++) {
if (output_size > 2 + (input_chars * MAX_EXPANSION)) {
output_size = 2 + (input_chars * MAX_EXPANSION);
}
- if (_PyBytes_Resize(&rval, output_size) == -1) {
+ if (_PyString_Resize(&rval, output_size) == -1) {
return NULL;
}
- output = PyBytes_AS_STRING(rval);
+ output = PyString_AS_STRING(rval);
}
}
output[chars++] = '"';
- if (_PyBytes_Resize(&rval, chars) == -1) {
+ if (_PyString_Resize(&rval, chars) == -1) {
return NULL;
}
return rval;
char *output;
char *input_str;
- input_chars = PyBytes_GET_SIZE(pystr);
- input_str = PyBytes_AS_STRING(pystr);
+ input_chars = PyString_GET_SIZE(pystr);
+ input_str = PyString_AS_STRING(pystr);
/* One char input can be up to 6 chars output, estimate 4 of these */
output_size = 2 + (MIN_EXPANSION * 4) + input_chars;
- rval = PyBytes_FromStringAndSize(NULL, output_size);
+ rval = PyString_FromStringAndSize(NULL, output_size);
if (rval == NULL) {
return NULL;
}
- output = PyBytes_AS_STRING(rval);
+ output = PyString_AS_STRING(rval);
chars = 0;
output[chars++] = '"';
for (i = 0; i < input_chars; i++) {
if (output_size > 2 + (input_chars * MIN_EXPANSION)) {
output_size = 2 + (input_chars * MIN_EXPANSION);
}
- if (_PyBytes_Resize(&rval, output_size) == -1) {
+ if (_PyString_Resize(&rval, output_size) == -1) {
return NULL;
}
- output = PyBytes_AS_STRING(rval);
+ output = PyString_AS_STRING(rval);
}
}
output[chars++] = '"';
- if (_PyBytes_Resize(&rval, chars) == -1) {
+ if (_PyString_Resize(&rval, chars) == -1) {
return NULL;
}
return rval;
ustr = PyUnicode_FromUnicode(&c, 0);
}
if (joinstr == NULL) {
- joinstr = PyBytes_InternFromString("join");
+ joinstr = PyString_InternFromString("join");
}
if (joinstr == NULL || ustr == NULL) {
return NULL;
scanstring_str(PyObject *pystr, Py_ssize_t end, char *encoding, int strict)
{
PyObject *rval;
- Py_ssize_t len = PyBytes_GET_SIZE(pystr);
+ Py_ssize_t len = PyString_GET_SIZE(pystr);
Py_ssize_t begin = end - 1;
Py_ssize_t next = begin;
- char *buf = PyBytes_AS_STRING(pystr);
+ char *buf = PyString_AS_STRING(pystr);
PyObject *chunks = PyList_New(0);
if (chunks == NULL) {
goto bail;
if (encoding == NULL) {
encoding = DEFAULT_ENCODING;
}
- if (PyBytes_Check(pystr)) {
+ if (PyString_Check(pystr)) {
return scanstring_str(pystr, end, encoding, strict);
}
else if (PyUnicode_Check(pystr)) {
py_encode_basestring_ascii(PyObject* self, PyObject *pystr)
{
/* METH_O */
- if (PyBytes_Check(pystr)) {
+ if (PyString_Check(pystr)) {
return ascii_escape_str(pystr);
}
else if (PyUnicode_Check(pystr)) {
if (isupper(c))
ul[n++] = c;
}
- ulo = PyBytes_FromStringAndSize((const char *)ul, n);
+ ulo = PyString_FromStringAndSize((const char *)ul, n);
if (!ulo)
return;
if (string)
if (islower(c))
ul[n++] = c;
}
- ulo = PyBytes_FromStringAndSize((const char *)ul, n);
+ ulo = PyString_FromStringAndSize((const char *)ul, n);
if (!ulo)
return;
if (string)
if (isalpha(c))
ul[n++] = c;
}
- ulo = PyBytes_FromStringAndSize((const char *)ul, n);
+ ulo = PyString_FromStringAndSize((const char *)ul, n);
if (!ulo)
return;
if (string)
PyErr_SetString(Error, "unsupported locale setting");
return NULL;
}
- result_object = PyBytes_FromString(result);
+ result_object = PyString_FromString(result);
if (!result_object)
return NULL;
/* record changes to LC_CTYPE */
PyErr_SetString(Error, "locale query failed");
return NULL;
}
- result_object = PyBytes_FromString(result);
+ result_object = PyString_FromString(result);
}
return result_object;
}
involved herein */
#define RESULT_STRING(s)\
- x = PyBytes_FromString(l->s);\
+ x = PyString_FromString(l->s);\
if (!x) goto failed;\
PyDict_SetItemString(result, #s, x);\
Py_XDECREF(x)
if (!PyArg_UnpackTuple(args, "strcoll", 2, 2, &os1, &os2))
return NULL;
/* If both arguments are byte strings, use strcoll. */
- if (PyBytes_Check(os1) && PyBytes_Check(os2))
- return PyInt_FromLong(strcoll(PyBytes_AS_STRING(os1),
- PyBytes_AS_STRING(os2)));
+ if (PyString_Check(os1) && PyString_Check(os2))
+ return PyInt_FromLong(strcoll(PyString_AS_STRING(os1),
+ PyString_AS_STRING(os2)));
/* If neither argument is unicode, it's an error. */
if (!PyUnicode_Check(os1) && !PyUnicode_Check(os2)) {
PyErr_SetString(PyExc_ValueError, "strcoll arguments must be strings");
return PyErr_NoMemory();
strxfrm(buf, s, n2);
}
- result = PyBytes_FromString(buf);
+ result = PyString_FromString(buf);
PyMem_Free(buf);
return result;
}
return NULL;
/* Check whether this is a supported constant. GNU libc sometimes
returns numeric values in the char* return value, which would
- crash PyBytes_FromString. */
+ crash PyString_FromString. */
for (i = 0; langinfo_constants[i].name; i++)
if (langinfo_constants[i].value == item) {
/* Check NULL as a workaround for GNU libc's returning NULL
instead of an empty string for nl_langinfo(ERA). */
const char *result = nl_langinfo(item);
- return PyBytes_FromString(result != NULL ? result : "");
+ return PyString_FromString(result != NULL ? result : "");
}
PyErr_SetString(PyExc_ValueError, "unsupported langinfo constant");
return NULL;
char *in;
if (!PyArg_ParseTuple(args, "z", &in))
return 0;
- return PyBytes_FromString(gettext(in));
+ return PyString_FromString(gettext(in));
}
PyDoc_STRVAR(dgettext__doc__,
char *domain, *in;
if (!PyArg_ParseTuple(args, "zz", &domain, &in))
return 0;
- return PyBytes_FromString(dgettext(domain, in));
+ return PyString_FromString(dgettext(domain, in));
}
PyDoc_STRVAR(dcgettext__doc__,
int category;
if (!PyArg_ParseTuple(args, "zzi", &domain, &msgid, &category))
return 0;
- return PyBytes_FromString(dcgettext(domain,msgid,category));
+ return PyString_FromString(dcgettext(domain,msgid,category));
}
PyDoc_STRVAR(textdomain__doc__,
PyErr_SetFromErrno(PyExc_OSError);
return NULL;
}
- return PyBytes_FromString(domain);
+ return PyString_FromString(domain);
}
PyDoc_STRVAR(bindtextdomain__doc__,
PyErr_SetFromErrno(PyExc_OSError);
return NULL;
}
- return PyBytes_FromString(dirname);
+ return PyString_FromString(dirname);
}
#ifdef HAVE_BIND_TEXTDOMAIN_CODESET
return NULL;
codeset = bind_textdomain_codeset(domain, codeset);
if (codeset)
- return PyBytes_FromString(codeset);
+ return PyString_FromString(codeset);
Py_RETURN_NONE;
}
#endif
Error = PyErr_NewException("locale.Error", NULL, NULL);
PyDict_SetItemString(d, "Error", Error);
- x = PyBytes_FromString(locale__doc__);
+ x = PyString_FromString(locale__doc__);
PyDict_SetItemString(d, "__doc__", x);
Py_XDECREF(x);
/* built-in function: look up the module name */
PyObject *mod = fn->m_module;
char *modname;
- if (mod && PyBytes_Check(mod)) {
- modname = PyBytes_AS_STRING(mod);
+ if (mod && PyString_Check(mod)) {
+ modname = PyString_AS_STRING(mod);
}
else if (mod && PyModule_Check(mod)) {
modname = PyModule_GetName(mod);
modname = "__builtin__";
}
if (strcmp(modname, "__builtin__") != 0)
- return PyBytes_FromFormat("<%s.%s>",
+ return PyString_FromFormat("<%s.%s>",
modname,
fn->m_ml->ml_name);
else
- return PyBytes_FromFormat("<%s>",
+ return PyString_FromFormat("<%s>",
fn->m_ml->ml_name);
}
else {
repr(getattr(type(__self__), __name__))
*/
PyObject *self = fn->m_self;
- PyObject *name = PyBytes_FromString(fn->m_ml->ml_name);
+ PyObject *name = PyString_FromString(fn->m_ml->ml_name);
if (name != NULL) {
PyObject *mo = _PyType_Lookup(Py_TYPE(self), name);
Py_XINCREF(mo);
}
}
PyErr_Clear();
- return PyBytes_FromFormat("<built-in method %s>",
+ return PyString_FromFormat("<built-in method %s>",
fn->m_ml->ml_name);
}
}
if (!fmt_args) {
return NULL;
}
- template = PyBytes_FromString("%s <- %s ->%s\n");
+ template = PyString_FromString("%s <- %s ->%s\n");
if (!template) {
Py_DECREF(fmt_args);
return NULL;
}
- display_str = PyBytes_Format(template, fmt_args);
+ display_str = PyString_Format(template, fmt_args);
Py_DECREF(template);
Py_DECREF(fmt_args);
if (!display_str) {
Py_INCREF(&PyUnicode_Type);
self->text_factory = (PyObject*)&PyUnicode_Type;
- if (PyBytes_Check(database) || PyUnicode_Check(database)) {
- if (PyBytes_Check(database)) {
+ if (PyString_Check(database) || PyUnicode_Check(database)) {
+ if (PyString_Check(database)) {
database_utf8 = database;
Py_INCREF(database_utf8);
} else {
}
Py_BEGIN_ALLOW_THREADS
- rc = sqlite3_open(PyBytes_AsString(database_utf8), &self->db);
+ rc = sqlite3_open(PyString_AsString(database_utf8), &self->db);
Py_END_ALLOW_THREADS
Py_DECREF(database_utf8);
if (class_attr) {
class_attr_str = PyObject_Str(class_attr);
if (class_attr_str) {
- if (strcmp(PyBytes_AsString(class_attr_str), "<type 'apsw.Connection'>") == 0) {
+ if (strcmp(PyString_AsString(class_attr_str), "<type 'apsw.Connection'>") == 0) {
/* In the APSW Connection object, the first entry after
* PyObject_HEAD is the sqlite3* we want to get hold of.
* Luckily, this is the same layout as we have in our
}
if (!isolation_level) {
- isolation_level = PyBytes_FromString("");
+ isolation_level = PyString_FromString("");
if (!isolation_level) {
return -1;
}
} else {
sqlite3_result_blob(context, buffer, buflen, SQLITE_TRANSIENT);
}
- } else if (PyBytes_Check(py_val)) {
- sqlite3_result_text(context, PyBytes_AsString(py_val), -1, SQLITE_TRANSIENT);
+ } else if (PyString_Check(py_val)) {
+ sqlite3_result_text(context, PyString_AsString(py_val), -1, SQLITE_TRANSIENT);
} else if (PyUnicode_Check(py_val)) {
stringval = PyUnicode_AsUTF8String(py_val);
if (stringval) {
- sqlite3_result_text(context, PyBytes_AsString(stringval), -1, SQLITE_TRANSIENT);
+ sqlite3_result_text(context, PyString_AsString(stringval), -1, SQLITE_TRANSIENT);
Py_DECREF(stringval);
}
} else {
Py_INCREF(isolation_level);
self->isolation_level = isolation_level;
- begin_statement = PyBytes_FromString("BEGIN ");
+ begin_statement = PyString_FromString("BEGIN ");
if (!begin_statement) {
return -1;
}
- PyBytes_Concat(&begin_statement, isolation_level);
+ PyString_Concat(&begin_statement, isolation_level);
if (!begin_statement) {
return -1;
}
- self->begin_statement = PyMem_Malloc(PyBytes_Size(begin_statement) + 2);
+ self->begin_statement = PyMem_Malloc(PyString_Size(begin_statement) + 2);
if (!self->begin_statement) {
return -1;
}
- strcpy(self->begin_statement, PyBytes_AsString(begin_statement));
+ strcpy(self->begin_statement, PyString_AsString(begin_statement));
Py_DECREF(begin_statement);
}
goto finally;
}
- string1 = PyBytes_FromStringAndSize((const char*)text1_data, text1_length);
- string2 = PyBytes_FromStringAndSize((const char*)text2_data, text2_length);
+ string1 = PyString_FromStringAndSize((const char*)text1_data, text1_length);
+ string2 = PyString_FromStringAndSize((const char*)text2_data, text2_length);
if (!string1 || !string2) {
goto finally; /* failed to allocate strings */
goto finally;
}
- if (!PyArg_ParseTuple(args, "O!O:create_collation(name, callback)", &PyBytes_Type, &name, &callable)) {
+ if (!PyArg_ParseTuple(args, "O!O:create_collation(name, callback)", &PyString_Type, &name, &callable)) {
goto finally;
}
goto finally;
}
- chk = PyBytes_AsString(uppercase_name);
+ chk = PyString_AsString(uppercase_name);
while (*chk) {
if ((*chk >= '0' && *chk <= '9')
|| (*chk >= 'A' && *chk <= 'Z')
}
rc = sqlite3_create_collation(self->db,
- PyBytes_AsString(uppercase_name),
+ PyString_AsString(uppercase_name),
SQLITE_UTF8,
(callable != Py_None) ? callable : NULL,
(callable != Py_None) ? pysqlite_collation_callback : NULL);
/* Determines how bytestrings from SQLite are converted to Python objects:
* - PyUnicode_Type: Python Unicode objects are constructed from UTF-8 bytestrings
* - OptimizedUnicode: Like before, but for ASCII data, only PyStrings are created.
- * - PyBytes_Type: PyStrings are created as-is.
+ * - PyString_Type: PyStrings are created as-is.
* - Any custom callable: Any object returned from the callable called with the bytestring
* as single parameter.
*/
if (*pos == '[') {
type_start = pos + 1;
} else if (*pos == ']' && type_start != (const char*)-1) {
- key = PyBytes_FromStringAndSize(type_start, pos - type_start);
+ key = PyString_FromStringAndSize(type_start, pos - type_start);
if (!key) {
/* creating a string failed, but it is too complicated
* to propagate the error here, we just assume there is
* 'NUMBER(10)' to be treated as 'NUMBER', for example.
* In other words, it will work as people expect it to work.*/
if (*pos == ' ' || *pos == '(' || *pos == 0) {
- py_decltype = PyBytes_FromStringAndSize(decltype, pos - decltype);
+ py_decltype = PyString_FromStringAndSize(decltype, pos - decltype);
if (!py_decltype) {
return -1;
}
if ((*pos == '[') && (pos > colname) && (*(pos-1) == ' ')) {
pos--;
}
- return PyBytes_FromStringAndSize(colname, pos - colname);
+ return PyString_FromStringAndSize(colname, pos - colname);
}
}
}
}
if (is_ascii) {
- return PyBytes_FromString(val_str);
+ return PyString_FromString(val_str);
} else {
return PyUnicode_DecodeUTF8(val_str, strlen(val_str), NULL);
}
Py_INCREF(Py_None);
converted = Py_None;
} else {
- item = PyBytes_FromStringAndSize(val_str, nbytes);
+ item = PyString_FromStringAndSize(val_str, nbytes);
if (!item) {
return NULL;
}
colname , val_str);
PyErr_SetString(pysqlite_OperationalError, buf);
}
- } else if (self->connection->text_factory == (PyObject*)&PyBytes_Type) {
- converted = PyBytes_FromString(val_str);
+ } else if (self->connection->text_factory == (PyObject*)&PyString_Type) {
+ converted = PyString_FromString(val_str);
} else {
converted = PyObject_CallFunction(self->connection->text_factory, "s", val_str);
}
return NULL;
}
- if (!PyBytes_Check(operation) && !PyUnicode_Check(operation)) {
+ if (!PyString_Check(operation) && !PyUnicode_Check(operation)) {
PyErr_SetString(PyExc_ValueError, "operation parameter must be str or unicode");
return NULL;
}
return NULL;
}
- if (!PyBytes_Check(operation) && !PyUnicode_Check(operation)) {
+ if (!PyString_Check(operation) && !PyUnicode_Check(operation)) {
PyErr_SetString(PyExc_ValueError, "operation parameter must be str or unicode");
return NULL;
}
rc = pysqlite_statement_reset(self->statement);
}
- if (PyBytes_Check(operation)) {
- operation_cstr = PyBytes_AsString(operation);
+ if (PyString_Check(operation)) {
+ operation_cstr = PyString_AsString(operation);
} else {
operation_bytestr = PyUnicode_AsUTF8String(operation);
if (!operation_bytestr) {
goto error;
}
- operation_cstr = PyBytes_AsString(operation_bytestr);
+ operation_cstr = PyString_AsString(operation_bytestr);
}
/* reset description and rowcount */
return NULL;
}
- if (PyBytes_Check(script_obj)) {
- script_cstr = PyBytes_AsString(script_obj);
+ if (PyString_Check(script_obj)) {
+ script_cstr = PyString_AsString(script_obj);
} else if (PyUnicode_Check(script_obj)) {
script_str = PyUnicode_AsUTF8String(script_obj);
if (!script_str) {
return NULL;
}
- script_cstr = PyBytes_AsString(script_str);
+ script_cstr = PyString_AsString(script_str);
} else {
PyErr_SetString(PyExc_ValueError, "script argument must be unicode or string.");
return NULL;
/* a basic type is adapted; there's a performance optimization if that's not the case
* (99 % of all usages) */
if (type == &PyInt_Type || type == &PyLong_Type || type == &PyFloat_Type
- || type == &PyBytes_Type || type == &PyUnicode_Type || type == &PyBuffer_Type) {
+ || type == &PyString_Type || type == &PyUnicode_Type || type == &PyBuffer_Type) {
pysqlite_BaseTypeAdapted = 1;
}
Py_DECREF(tmp_obj);
}
- if (!(tmp_obj = PyBytes_FromString(PYSQLITE_VERSION))) {
+ if (!(tmp_obj = PyString_FromString(PYSQLITE_VERSION))) {
goto error;
}
PyDict_SetItemString(dict, "version", tmp_obj);
Py_DECREF(tmp_obj);
- if (!(tmp_obj = PyBytes_FromString(sqlite3_libversion()))) {
+ if (!(tmp_obj = PyString_FromString(sqlite3_libversion()))) {
goto error;
}
PyDict_SetItemString(dict, "sqlite_version", tmp_obj);
item = PyTuple_GetItem(self->data, _idx);
Py_XINCREF(item);
return item;
- } else if (PyBytes_Check(idx)) {
- key = PyBytes_AsString(idx);
+ } else if (PyString_Check(idx)) {
+ key = PyString_AsString(idx);
nitems = PyTuple_Size(self->description);
for (i = 0; i < nitems; i++) {
- compare_key = PyBytes_AsString(PyTuple_GET_ITEM(PyTuple_GET_ITEM(self->description, i), 0));
+ compare_key = PyString_AsString(PyTuple_GET_ITEM(PyTuple_GET_ITEM(self->description, i), 0));
if (!compare_key) {
return NULL;
}
self->st = NULL;
self->in_use = 0;
- if (PyBytes_Check(sql)) {
+ if (PyString_Check(sql)) {
sql_str = sql;
Py_INCREF(sql_str);
} else if (PyUnicode_Check(sql)) {
self->in_weakreflist = NULL;
self->sql = sql_str;
- sql_cstr = PyBytes_AsString(sql_str);
+ sql_cstr = PyString_AsString(sql_str);
rc = sqlite3_prepare(connection->db,
sql_cstr,
paramtype = TYPE_LONG;
} else if (PyFloat_CheckExact(parameter)) {
paramtype = TYPE_FLOAT;
- } else if (PyBytes_CheckExact(parameter)) {
+ } else if (PyString_CheckExact(parameter)) {
paramtype = TYPE_STRING;
} else if (PyUnicode_CheckExact(parameter)) {
paramtype = TYPE_UNICODE;
paramtype = TYPE_LONG;
} else if (PyFloat_Check(parameter)) {
paramtype = TYPE_FLOAT;
- } else if (PyBytes_Check(parameter)) {
+ } else if (PyString_Check(parameter)) {
paramtype = TYPE_STRING;
} else if (PyUnicode_Check(parameter)) {
paramtype = TYPE_UNICODE;
}
if (paramtype == TYPE_STRING && !allow_8bit_chars) {
- string = PyBytes_AS_STRING(parameter);
+ string = PyString_AS_STRING(parameter);
for (c = string; *c != 0; c++) {
if (*c & 0x80) {
PyErr_SetString(pysqlite_ProgrammingError, "You must not use 8-bit bytestrings unless you use a text_factory that can interpret 8-bit bytestrings (like text_factory = str). It is highly recommended that you instead just switch your application to Unicode strings.");
rc = sqlite3_bind_double(self->st, pos, PyFloat_AsDouble(parameter));
break;
case TYPE_STRING:
- string = PyBytes_AS_STRING(parameter);
+ string = PyString_AS_STRING(parameter);
rc = sqlite3_bind_text(self->st, pos, string, -1, SQLITE_TRANSIENT);
break;
case TYPE_UNICODE:
stringval = PyUnicode_AsUTF8String(parameter);
- string = PyBytes_AsString(stringval);
+ string = PyString_AsString(stringval);
rc = sqlite3_bind_text(self->st, pos, string, -1, SQLITE_TRANSIENT);
Py_DECREF(stringval);
break;
}
if (PyInt_CheckExact(obj) || PyLong_CheckExact(obj)
- || PyFloat_CheckExact(obj) || PyBytes_CheckExact(obj)
+ || PyFloat_CheckExact(obj) || PyString_CheckExact(obj)
|| PyUnicode_CheckExact(obj) || PyBuffer_Check(obj)) {
return 0;
} else {
char* sql_cstr;
sqlite3_stmt* new_st;
- sql_cstr = PyBytes_AsString(self->sql);
+ sql_cstr = PyString_AsString(self->sql);
rc = sqlite3_prepare(self->db,
sql_cstr,
size = PyObject_Length(string);
#endif
- if (PyBytes_Check(string) || bytes == size)
+ if (PyString_Check(string) || bytes == size)
charsize = 1;
#if defined(HAVE_UNICODE)
else if (bytes == (Py_ssize_t) (size * sizeof(Py_UNICODE)))
if (!args)
return NULL;
- name = PyBytes_FromString(module);
+ name = PyString_FromString(module);
if (!name)
return NULL;
mod = PyImport_Import(name);
Py_DECREF(x);
}
- x = PyBytes_FromString(copyright);
+ x = PyString_FromString(copyright);
if (x) {
PyDict_SetItemString(d, "copyright", x);
Py_DECREF(x);
static PyObject *
PySSL_server(PySSLObject *self)
{
- return PyBytes_FromString(self->server);
+ return PyString_FromString(self->server);
}
static PyObject *
PySSL_issuer(PySSLObject *self)
{
- return PyBytes_FromString(self->issuer);
+ return PyString_FromString(self->issuer);
}
static PyObject *
_setSSLError(NULL, 0, __FILE__, __LINE__);
goto fail;
}
- name_obj = PyBytes_FromStringAndSize(namebuf, buflen);
+ name_obj = PyString_FromStringAndSize(namebuf, buflen);
if (name_obj == NULL)
goto fail;
/*
fprintf(stderr, "RDN level %d, attribute %s: %s\n",
entry->set,
- PyBytes_AS_STRING(PyTuple_GET_ITEM(attr, 0)),
- PyBytes_AS_STRING(PyTuple_GET_ITEM(attr, 1)));
+ PyString_AS_STRING(PyTuple_GET_ITEM(attr, 0)),
+ PyString_AS_STRING(PyTuple_GET_ITEM(attr, 1)));
*/
if (attr == NULL)
goto fail1;
goto fail;
}
- v = PyBytes_FromString("DirName");
+ v = PyString_FromString("DirName");
if (v == NULL) {
Py_DECREF(t);
goto fail;
t = PyTuple_New(2);
if (t == NULL)
goto fail;
- v = PyBytes_FromStringAndSize(buf, (vptr - buf));
+ v = PyString_FromStringAndSize(buf, (vptr - buf));
if (v == NULL) {
Py_DECREF(t);
goto fail;
}
PyTuple_SET_ITEM(t, 0, v);
- v = PyBytes_FromStringAndSize((vptr + 1), (len - (vptr - buf + 1)));
+ v = PyString_FromStringAndSize((vptr + 1), (len - (vptr - buf + 1)));
if (v == NULL) {
Py_DECREF(t);
goto fail;
_setSSLError(NULL, 0, __FILE__, __LINE__);
goto fail1;
}
- sn_obj = PyBytes_FromStringAndSize(buf, len);
+ sn_obj = PyString_FromStringAndSize(buf, len);
if (sn_obj == NULL)
goto fail1;
if (PyDict_SetItemString(retval, "serialNumber", sn_obj) < 0) {
_setSSLError(NULL, 0, __FILE__, __LINE__);
goto fail1;
}
- pnotBefore = PyBytes_FromStringAndSize(buf, len);
+ pnotBefore = PyString_FromStringAndSize(buf, len);
if (pnotBefore == NULL)
goto fail1;
if (PyDict_SetItemString(retval, "notBefore", pnotBefore) < 0) {
_setSSLError(NULL, 0, __FILE__, __LINE__);
goto fail1;
}
- pnotAfter = PyBytes_FromStringAndSize(buf, len);
+ pnotAfter = PyString_FromStringAndSize(buf, len);
if (pnotAfter == NULL)
goto fail1;
if (PyDict_SetItemString(retval, "notAfter", pnotAfter) < 0) {
PySSL_SetError(self, len, __FILE__, __LINE__);
return NULL;
}
- retval = PyBytes_FromStringAndSize((const char *) bytes_buf, len);
+ retval = PyString_FromStringAndSize((const char *) bytes_buf, len);
OPENSSL_free(bytes_buf);
return retval;
if (cipher_name == NULL) {
PyTuple_SET_ITEM(retval, 0, Py_None);
} else {
- v = PyBytes_FromString(cipher_name);
+ v = PyString_FromString(cipher_name);
if (v == NULL)
goto fail0;
PyTuple_SET_ITEM(retval, 0, v);
if (cipher_protocol == NULL) {
PyTuple_SET_ITEM(retval, 1, Py_None);
} else {
- v = PyBytes_FromString(cipher_protocol);
+ v = PyString_FromString(cipher_protocol);
if (v == NULL)
goto fail0;
PyTuple_SET_ITEM(retval, 1, v);
if (!PyArg_ParseTuple(args, "|i:read", &len))
return NULL;
- if (!(buf = PyBytes_FromStringAndSize((char *) 0, len)))
+ if (!(buf = PyString_FromStringAndSize((char *) 0, len)))
return NULL;
/* first check if there are bytes ready to be read */
return NULL;
} else if (sockstate == SOCKET_HAS_BEEN_CLOSED) {
/* should contain a zero-length string */
- _PyBytes_Resize(&buf, 0);
+ _PyString_Resize(&buf, 0);
return buf;
}
}
do {
err = 0;
PySSL_BEGIN_ALLOW_THREADS
- count = SSL_read(self->ssl, PyBytes_AsString(buf), len);
+ count = SSL_read(self->ssl, PyString_AsString(buf), len);
err = SSL_get_error(self->ssl, count);
PySSL_END_ALLOW_THREADS
if(PyErr_CheckSignals()) {
(SSL_get_shutdown(self->ssl) ==
SSL_RECEIVED_SHUTDOWN))
{
- _PyBytes_Resize(&buf, 0);
+ _PyString_Resize(&buf, 0);
return buf;
} else {
sockstate = SOCKET_OPERATION_OK;
return PySSL_SetError(self, count, __FILE__, __LINE__);
}
if (count != len)
- _PyBytes_Resize(&buf, count);
+ _PyString_Resize(&buf, count);
return buf;
}
{
int bytes;
- if (!PyBytes_Check(arg))
+ if (!PyString_Check(arg))
return PyErr_Format(PyExc_TypeError,
"RAND_egd() expected string, found %s",
Py_TYPE(arg)->tp_name);
- bytes = RAND_egd(PyBytes_AS_STRING(arg));
+ bytes = RAND_egd(PyString_AS_STRING(arg));
if (bytes == -1) {
PyErr_SetString(PySSLErrorObject,
"EGD connection failed or EGD did not return "
if (msg == NULL)
return -1;
rval = PyErr_WarnEx(PyExc_DeprecationWarning,
- PyBytes_AS_STRING(msg), 2);
+ PyString_AS_STRING(msg), 2);
Py_DECREF(msg);
if (rval == 0)
return 0;
static PyObject *
nu_char(const char *p, const formatdef *f)
{
- return PyBytes_FromStringAndSize(p, 1);
+ return PyString_FromStringAndSize(p, 1);
}
static PyObject *
static int
np_char(char *p, PyObject *v, const formatdef *f)
{
- if (!PyBytes_Check(v) || PyBytes_Size(v) != 1) {
+ if (!PyString_Check(v) || PyString_Size(v) != 1) {
PyErr_SetString(StructError,
"char format require string of length 1");
return -1;
}
- *p = *PyBytes_AsString(v);
+ *p = *PyString_AsString(v);
return 0;
}
char c;
Py_ssize_t size, len, num, itemsize, x;
- fmt = PyBytes_AS_STRING(self->s_format);
+ fmt = PyString_AS_STRING(self->s_format);
f = whichtable((char **)&fmt);
const formatdef *e = code->fmtdef;
const char *res = startfrom + code->offset;
if (e->format == 's') {
- v = PyBytes_FromStringAndSize(res, code->size);
+ v = PyString_FromStringAndSize(res, code->size);
} else if (e->format == 'p') {
Py_ssize_t n = *(unsigned char*)res;
if (n >= code->size)
n = code->size - 1;
- v = PyBytes_FromStringAndSize(res + 1, n);
+ v = PyString_FromStringAndSize(res + 1, n);
} else {
v = e->unpack(res, e);
}
assert(soself->s_codes != NULL);
if (inputstr == NULL)
goto fail;
- if (PyBytes_Check(inputstr) &&
- PyBytes_GET_SIZE(inputstr) == soself->s_size) {
- return s_unpack_internal(soself, PyBytes_AS_STRING(inputstr));
+ if (PyString_Check(inputstr) &&
+ PyString_GET_SIZE(inputstr) == soself->s_size) {
+ return s_unpack_internal(soself, PyString_AS_STRING(inputstr));
}
args = PyTuple_Pack(1, inputstr);
if (args == NULL)
const formatdef *e = code->fmtdef;
char *res = buf + code->offset;
if (e->format == 's') {
- if (!PyBytes_Check(v)) {
+ if (!PyString_Check(v)) {
PyErr_SetString(StructError,
"argument for 's' must be a string");
return -1;
}
- n = PyBytes_GET_SIZE(v);
+ n = PyString_GET_SIZE(v);
if (n > code->size)
n = code->size;
if (n > 0)
- memcpy(res, PyBytes_AS_STRING(v), n);
+ memcpy(res, PyString_AS_STRING(v), n);
} else if (e->format == 'p') {
- if (!PyBytes_Check(v)) {
+ if (!PyString_Check(v)) {
PyErr_SetString(StructError,
"argument for 'p' must be a string");
return -1;
}
- n = PyBytes_GET_SIZE(v);
+ n = PyString_GET_SIZE(v);
if (n > (code->size - 1))
n = code->size - 1;
if (n > 0)
- memcpy(res + 1, PyBytes_AS_STRING(v), n);
+ memcpy(res + 1, PyString_AS_STRING(v), n);
if (n > 255)
n = 255;
*res = Py_SAFE_DOWNCAST(n, Py_ssize_t, unsigned char);
}
/* Allocate a new string */
- result = PyBytes_FromStringAndSize((char *)NULL, soself->s_size);
+ result = PyString_FromStringAndSize((char *)NULL, soself->s_size);
if (result == NULL)
return NULL;
/* Call the guts */
- if ( s_pack_internal(soself, args, 0, PyBytes_AS_STRING(result)) != 0 ) {
+ if ( s_pack_internal(soself, args, 0, PyString_AS_STRING(result)) != 0 ) {
Py_DECREF(result);
return NULL;
}
{
PyObject *ver, *m;
- ver = PyBytes_FromString("0.2");
+ ver = PyString_FromString("0.2");
if (ver == NULL)
return;
}
#endif
-/* Some tests of PyBytes_FromFormat(). This needs more tests. */
+/* Some tests of PyString_FromFormat(). This needs more tests. */
static PyObject *
test_string_from_format(PyObject *self, PyObject *args)
{
char *msg;
#define CHECK_1_FORMAT(FORMAT, TYPE) \
- result = PyBytes_FromFormat(FORMAT, (TYPE)1); \
+ result = PyString_FromFormat(FORMAT, (TYPE)1); \
if (result == NULL) \
return NULL; \
- if (strcmp(PyBytes_AsString(result), "1")) { \
+ if (strcmp(PyString_AsString(result), "1")) { \
msg = FORMAT " failed at 1"; \
goto Fail; \
} \
static char *
AsString(PyObject *value, PyObject *tmp)
{
- if (PyBytes_Check(value))
- return PyBytes_AsString(value);
+ if (PyString_Check(value))
+ return PyString_AsString(value);
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(value)) {
PyObject *v = PyUnicode_AsUTF8String(value);
return NULL;
}
Py_DECREF(v);
- return PyBytes_AsString(v);
+ return PyString_AsString(v);
}
#endif
else {
return NULL;
}
Py_DECREF(v);
- return PyBytes_AsString(v);
+ return PyString_AsString(v);
}
}
* Could be a quoted string containing funnies, e.g. {"}.
* Return the string itself.
*/
- return PyBytes_FromString(list);
+ return PyString_FromString(list);
}
if (argc == 0)
- v = PyBytes_FromString("");
+ v = PyString_FromString("");
else if (argc == 1)
- v = PyBytes_FromString(argv[0]);
+ v = PyString_FromString(argv[0]);
else if ((v = PyTuple_New(argc)) != NULL) {
int i;
PyObject *w;
return result;
/* Fall through, returning arg. */
}
- else if (PyBytes_Check(arg)) {
+ else if (PyString_Check(arg)) {
int argc;
char **argv;
- char *list = PyBytes_AsString(arg);
+ char *list = PyString_AsString(arg);
if (Tcl_SplitList((Tcl_Interp *)NULL, list, &argc, &argv) != TCL_OK) {
Py_INCREF(arg);
}
Tcl_Free(FREECAST argv);
if (argc > 1)
- return Split(PyBytes_AsString(arg));
+ return Split(PyString_AsString(arg));
/* Fall through, returning arg. */
}
Py_INCREF(arg);
static PyObject *
PyTclObject_str(PyTclObject *self)
{
- if (self->string && PyBytes_Check(self->string)) {
+ if (self->string && PyString_Check(self->string)) {
Py_INCREF(self->string);
return self->string;
}
/* XXX Could cache value if it is an ASCII string. */
- return PyBytes_FromString(Tcl_GetString(self->value));
+ return PyString_FromString(Tcl_GetString(self->value));
}
static char*
#ifdef Py_USING_UNICODE
if (i == len)
/* It is an ASCII string. */
- self->string = PyBytes_FromStringAndSize(s, len);
+ self->string = PyString_FromStringAndSize(s, len);
else {
self->string = PyUnicode_DecodeUTF8(s, len, "strict");
if (!self->string) {
PyErr_Clear();
- self->string = PyBytes_FromStringAndSize(s, len);
+ self->string = PyString_FromStringAndSize(s, len);
}
}
#else
- self->string = PyBytes_FromStringAndSize(s, len);
+ self->string = PyString_FromStringAndSize(s, len);
#endif
if (!self->string)
return NULL;
char buf[50];
PyOS_snprintf(buf, 50, "<%s object at %p>",
self->value->typePtr->name, self->value);
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
static int
static PyObject*
get_typename(PyTclObject* obj, void* ignored)
{
- return PyBytes_FromString(obj->value->typePtr->name);
+ return PyString_FromString(obj->value->typePtr->name);
}
{
Tcl_Obj *result;
- if (PyBytes_Check(value))
- return Tcl_NewStringObj(PyBytes_AS_STRING(value),
- PyBytes_GET_SIZE(value));
+ if (PyString_Check(value))
+ return Tcl_NewStringObj(PyString_AS_STRING(value),
+ PyString_GET_SIZE(value));
else if (PyBool_Check(value))
return Tcl_NewBooleanObj(PyObject_IsTrue(value));
else if (PyInt_Check(value))
}
if (i == value->length)
- result = PyBytes_FromStringAndSize(s, len);
+ result = PyString_FromStringAndSize(s, len);
else {
/* Convert UTF-8 to Unicode string */
result = PyUnicode_DecodeUTF8(s, len, "strict");
if (result == NULL) {
PyErr_Clear();
- result = PyBytes_FromStringAndSize(s, len);
+ result = PyString_FromStringAndSize(s, len);
}
}
#else
- result = PyBytes_FromStringAndSize(value->bytes, value->length);
+ result = PyString_FromStringAndSize(value->bytes, value->length);
#endif
return result;
}
if (value->typePtr == app->ByteArrayType) {
int size;
char *data = (char*)Tcl_GetByteArrayFromObj(value, &size);
- return PyBytes_FromStringAndSize(data, size);
+ return PyString_FromStringAndSize(data, size);
}
if (value->typePtr == app->DoubleType) {
int size;
char *c;
c = Tcl_GetStringFromObj(value, &size);
- return PyBytes_FromStringAndSize(c, size);
+ return PyString_FromStringAndSize(c, size);
#endif
}
}
if (*p == '\0')
- res = PyBytes_FromStringAndSize(s, (int)(p-s));
+ res = PyString_FromStringAndSize(s, (int)(p-s));
else {
/* Convert UTF-8 to Unicode string */
p = strchr(p, '\0');
res = PyUnicode_DecodeUTF8(s, (int)(p-s), "strict");
if (res == NULL) {
PyErr_Clear();
- res = PyBytes_FromStringAndSize(s, (int)(p-s));
+ res = PyString_FromStringAndSize(s, (int)(p-s));
}
}
#else
p = strchr(p, '\0');
- res = PyBytes_FromStringAndSize(s, (int)(p-s));
+ res = PyString_FromStringAndSize(s, (int)(p-s));
#endif
}
return res;
if (err == TCL_ERROR)
res = Tkinter_Error(self);
else
- res = PyBytes_FromString(Tkapp_Result(self));
+ res = PyString_FromString(Tkapp_Result(self));
LEAVE_OVERLAP_TCL
ckfree(cmd);
}
if (err == TCL_ERROR)
res = Tkinter_Error(self);
else
- res = PyBytes_FromString(Tkapp_Result(self));
+ res = PyString_FromString(Tkapp_Result(self));
LEAVE_OVERLAP_TCL
return res;
}
if (err == TCL_ERROR)
res = Tkinter_Error(self);
else
- res = PyBytes_FromString(Tkapp_Result(self));
+ res = PyString_FromString(Tkapp_Result(self));
LEAVE_OVERLAP_TCL
return res;
}
res = Tkinter_Error(self);
else
- res = PyBytes_FromString(Tkapp_Result(self));
+ res = PyString_FromString(Tkapp_Result(self));
LEAVE_OVERLAP_TCL
return res;
}
if (err == TCL_ERROR)
res = Tkinter_Error(self);
else
- res = PyBytes_FromString(Tkapp_Result(self));
+ res = PyString_FromString(Tkapp_Result(self));
LEAVE_OVERLAP_TCL
return res;
}
varname_converter(PyObject *in, void *_out)
{
char **out = (char**)_out;
- if (PyBytes_Check(in)) {
- *out = PyBytes_AsString(in);
+ if (PyString_Check(in)) {
+ *out = PyString_AsString(in);
return 1;
}
if (PyTclObject_Check(in)) {
res = FromObj(self, tres);
}
else {
- res = PyBytes_FromString(Tcl_GetString(tres));
+ res = PyString_FromString(Tcl_GetString(tres));
}
}
LEAVE_OVERLAP_TCL
goto finally;
for (i = 0; i < argc; i++) {
- PyObject *s = PyBytes_FromString(argv[i]);
+ PyObject *s = PyString_FromString(argv[i]);
if (!s || PyTuple_SetItem(v, i, s)) {
Py_DECREF(v);
v = NULL;
PyObject *res = NULL;
if (s) {
- res = PyBytes_FromString(s);
+ res = PyString_FromString(s);
ckfree(s);
}
return PythonCmd_Error(interp);
for (i = 0; i < (argc - 1); i++) {
- PyObject *s = PyBytes_FromString(argv[i + 1]);
+ PyObject *s = PyString_FromString(argv[i + 1]);
if (!s || PyTuple_SetItem(arg, i, s)) {
Py_DECREF(arg);
return PythonCmd_Error(interp);
PyOS_snprintf(buf, sizeof(buf), "<tktimertoken at %p%s>", v,
v->func == NULL ? ", handler deleted" : "");
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
static PyObject *
static void
ins_string(PyObject *d, char *name, char *val)
{
- PyObject *v = PyBytes_FromString(val);
+ PyObject *v = PyString_FromString(val);
if (v) {
PyDict_SetItemString(d, name, v);
Py_DECREF(v);
Py_INCREF(Py_None);
return Py_None;
}
- return PyBytes_FromString((char *) value.ptr);
+ return PyString_FromString((char *) value.ptr);
default:
PyErr_SetString(ErrorObject, "unknown element type");
return NULL;
PyErr_SetString(ErrorObject, "unknown element type");
return -1;
}
- if (!PyBytes_Check(value)) {
+ if (!PyString_Check(value)) {
PyErr_BadArgument();
return -1;
}
- param->value.ptr = PyBytes_AS_STRING(value);
- param->sizeIn = PyBytes_GET_SIZE(value)+1; /*account for NUL*/
+ param->value.ptr = PyString_AS_STRING(value);
+ param->sizeIn = PyString_GET_SIZE(value)+1; /*account for NUL*/
break;
case AL_SET_VAL:
case AL_VECTOR_VAL:
return NULL;
}
size *= ch;
- v = PyBytes_FromStringAndSize((char *) NULL, size * framecount);
+ v = PyString_FromStringAndSize((char *) NULL, size * framecount);
if (v == NULL)
return NULL;
Py_BEGIN_ALLOW_THREADS
- alReadFrames(self->port, (void *) PyBytes_AS_STRING(v), framecount);
+ alReadFrames(self->port, (void *) PyString_AS_STRING(v), framecount);
Py_END_ALLOW_THREADS
return v;
width = ALgetwidth(c);
#endif /* AL_405 */
ALfreeconfig(c);
- v = PyBytes_FromStringAndSize((char *)NULL, width * count);
+ v = PyString_FromStringAndSize((char *)NULL, width * count);
if (v == NULL)
return NULL;
Py_BEGIN_ALLOW_THREADS
- ret = ALreadsamps(self->port, (void *) PyBytes_AsString(v), count);
+ ret = ALreadsamps(self->port, (void *) PyString_AsString(v), count);
Py_END_ALLOW_THREADS
if (ret == -1) {
Py_DECREF(v);
Py_INCREF(item);
break;
case AL_STRING_VAL:
- item = PyBytes_FromString(pvs[i].value.ptr);
+ item = PyString_FromString(pvs[i].value.ptr);
PyMem_DEL(pvs[i].value.ptr);
break;
case AL_MATRIX_VAL:
PyDict_SetItemString(v, "elementType", item);
Py_DECREF(item);
- item = PyBytes_FromString(pinfo.name);
+ item = PyString_FromString(pinfo.name);
PyDict_SetItemString(v, "name", item);
Py_DECREF(item);
return NULL;
if ((name = ALgetname(device, descriptor)) == NULL)
return NULL;
- return PyBytes_FromString(name);
+ return PyString_FromString(name);
}
static PyObject *
static PyObject *
c_getitem(arrayobject *ap, Py_ssize_t i)
{
- return PyBytes_FromStringAndSize(&((char *)ap->ob_item)[i], 1);
+ return PyString_FromStringAndSize(&((char *)ap->ob_item)[i], 1);
}
static int
static PyObject *
array_tostring(arrayobject *self, PyObject *unused)
{
- return PyBytes_FromStringAndSize(self->ob_item,
+ return PyString_FromStringAndSize(self->ob_item,
Py_SIZE(self) * self->ob_descr->itemsize);
}
array_get_typecode(arrayobject *a, void *closure)
{
char tc = a->ob_descr->typecode;
- return PyBytes_FromStringAndSize(&tc, 1);
+ return PyString_FromStringAndSize(&tc, 1);
}
static PyObject *
typecode = a->ob_descr->typecode;
if (len == 0) {
PyOS_snprintf(buf, sizeof(buf), "array('%c')", typecode);
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
if (typecode == 'c')
Py_XDECREF(v);
PyOS_snprintf(buf, sizeof(buf), "array('%c', ", typecode);
- s = PyBytes_FromString(buf);
- PyBytes_ConcatAndDel(&s, t);
- PyBytes_ConcatAndDel(&s, PyBytes_FromString(")"));
+ s = PyString_FromString(buf);
+ PyString_ConcatAndDel(&s, t);
+ PyString_ConcatAndDel(&s, PyString_FromString(")"));
return s;
}
return NULL;
if (!(initial == NULL || PyList_Check(initial)
- || PyBytes_Check(initial) || PyTuple_Check(initial)
+ || PyString_Check(initial) || PyTuple_Check(initial)
|| (c == 'u' && PyUnicode_Check(initial)))) {
it = PyObject_GetIter(initial);
if (it == NULL)
}
Py_DECREF(v);
}
- } else if (initial != NULL && PyBytes_Check(initial)) {
+ } else if (initial != NULL && PyString_Check(initial)) {
PyObject *t_initial, *v;
t_initial = PyTuple_Pack(1, initial);
if (t_initial == NULL) {
/* Passing a short** for an 's' argument is correct only
if the string contents is aligned for interpretation
- as short[]. Due to the definition of PyBytesObject,
+ as short[]. Due to the definition of PyStringObject,
this is currently (Python 2.6) the case. */
if ( !PyArg_ParseTuple(args, "s#s#:findfit",
(char**)&cp1, &len1, (char**)&cp2, &len2) )
return 0;
}
- rv = PyBytes_FromStringAndSize(NULL, len);
+ rv = PyString_FromStringAndSize(NULL, len);
if ( rv == 0 )
return 0;
- ncp = (signed char *)PyBytes_AsString(rv);
+ ncp = (signed char *)PyString_AsString(rv);
for ( i=0; i < len; i += size ) {
return 0;
}
- rv = PyBytes_FromStringAndSize(NULL, len/2);
+ rv = PyString_FromStringAndSize(NULL, len/2);
if ( rv == 0 )
return 0;
- ncp = (signed char *)PyBytes_AsString(rv);
+ ncp = (signed char *)PyString_AsString(rv);
for ( i=0; i < len; i += size*2 ) {
return 0;
}
- rv = PyBytes_FromStringAndSize(NULL, len*2);
+ rv = PyString_FromStringAndSize(NULL, len*2);
if ( rv == 0 )
return 0;
- ncp = (signed char *)PyBytes_AsString(rv);
+ ncp = (signed char *)PyString_AsString(rv);
for ( i=0; i < len; i += size ) {
return 0;
}
- rv = PyBytes_FromStringAndSize(NULL, len1);
+ rv = PyString_FromStringAndSize(NULL, len1);
if ( rv == 0 )
return 0;
- ncp = (signed char *)PyBytes_AsString(rv);
+ ncp = (signed char *)PyString_AsString(rv);
for ( i=0; i < len1; i += size ) {
if ( size == 1 ) val1 = (int)*CHARP(cp1, i);
return 0;
}
- rv = PyBytes_FromStringAndSize(NULL, len);
+ rv = PyString_FromStringAndSize(NULL, len);
if ( rv == 0 )
return 0;
- ncp = (signed char *)PyBytes_AsString(rv);
+ ncp = (signed char *)PyString_AsString(rv);
for ( i=0; i < len; i += size ) {
return 0;
}
- rv = PyBytes_FromStringAndSize(NULL, len);
+ rv = PyString_FromStringAndSize(NULL, len);
if ( rv == 0 )
return 0;
- ncp = (unsigned char *)PyBytes_AsString(rv);
+ ncp = (unsigned char *)PyString_AsString(rv);
for ( i=0; i < len; i += size ) {
if ( size == 1 ) val = ((int)*CHARP(cp, i)) << 8;
return 0;
}
- rv = PyBytes_FromStringAndSize(NULL, (len/size)*size2);
+ rv = PyString_FromStringAndSize(NULL, (len/size)*size2);
if ( rv == 0 )
return 0;
- ncp = (unsigned char *)PyBytes_AsString(rv);
+ ncp = (unsigned char *)PyString_AsString(rv);
for ( i=0, j=0; i < len; i += size, j += size2 ) {
if ( size == 1 ) val = ((int)*CHARP(cp, i)) << 8;
nbytes / bytes_per_frame != ceiling)
str = NULL;
else
- str = PyBytes_FromStringAndSize(NULL, nbytes);
+ str = PyString_FromStringAndSize(NULL, nbytes);
if (str == NULL) {
PyErr_SetString(PyExc_MemoryError,
goto exit;
}
}
- ncp = PyBytes_AsString(str);
+ ncp = PyString_AsString(str);
for (;;) {
while (d < 0) {
goto exit;
/* We have checked before that the length
* of the string fits into int. */
- len = (int)(ncp - PyBytes_AsString(str));
+ len = (int)(ncp - PyString_AsString(str));
if (len == 0) {
/*don't want to resize to zero length*/
- rv = PyBytes_FromStringAndSize("", 0);
+ rv = PyString_FromStringAndSize("", 0);
Py_DECREF(str);
str = rv;
- } else if (_PyBytes_Resize(&str, len) < 0)
+ } else if (_PyString_Resize(&str, len) < 0)
goto exit;
rv = Py_BuildValue("(O(iO))", str, d, samps);
Py_DECREF(samps);
return 0;
}
- rv = PyBytes_FromStringAndSize(NULL, len/size);
+ rv = PyString_FromStringAndSize(NULL, len/size);
if ( rv == 0 )
return 0;
- ncp = (unsigned char *)PyBytes_AsString(rv);
+ ncp = (unsigned char *)PyString_AsString(rv);
for ( i=0; i < len; i += size ) {
if ( size == 1 ) val = ((int)*CHARP(cp, i)) << 8;
return 0;
}
- rv = PyBytes_FromStringAndSize(NULL, len*size);
+ rv = PyString_FromStringAndSize(NULL, len*size);
if ( rv == 0 )
return 0;
- ncp = (signed char *)PyBytes_AsString(rv);
+ ncp = (signed char *)PyString_AsString(rv);
for ( i=0; i < len*size; i += size ) {
cval = *cp++;
return 0;
}
- rv = PyBytes_FromStringAndSize(NULL, len/size);
+ rv = PyString_FromStringAndSize(NULL, len/size);
if ( rv == 0 )
return 0;
- ncp = (unsigned char *)PyBytes_AsString(rv);
+ ncp = (unsigned char *)PyString_AsString(rv);
for ( i=0; i < len; i += size ) {
if ( size == 1 ) val = ((int)*CHARP(cp, i)) << 8;
return 0;
}
- rv = PyBytes_FromStringAndSize(NULL, len*size);
+ rv = PyString_FromStringAndSize(NULL, len*size);
if ( rv == 0 )
return 0;
- ncp = (signed char *)PyBytes_AsString(rv);
+ ncp = (signed char *)PyString_AsString(rv);
for ( i=0; i < len*size; i += size ) {
cval = *cp++;
return 0;
}
- str = PyBytes_FromStringAndSize(NULL, len/(size*2));
+ str = PyString_FromStringAndSize(NULL, len/(size*2));
if ( str == 0 )
return 0;
- ncp = (signed char *)PyBytes_AsString(str);
+ ncp = (signed char *)PyString_AsString(str);
/* Decode state, should have (value, step) */
if ( state == Py_None ) {
} else if ( !PyArg_ParseTuple(state, "ii", &valpred, &index) )
return 0;
- str = PyBytes_FromStringAndSize(NULL, len*size*2);
+ str = PyString_FromStringAndSize(NULL, len*size*2);
if ( str == 0 )
return 0;
- ncp = (signed char *)PyBytes_AsString(str);
+ ncp = (signed char *)PyString_AsString(str);
step = stepsizeTable[index];
bufferstep = 0;
#define BASE64_PAD '='
/* Max binary chunk size; limited only by available memory */
-#define BASE64_MAXBIN (INT_MAX/2 - sizeof(PyBytesObject) - 3)
+#define BASE64_MAXBIN (INT_MAX/2 - sizeof(PyStringObject) - 3)
static unsigned char table_b2a_base64[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
ascii_len--;
/* Allocate the buffer */
- if ( (rv=PyBytes_FromStringAndSize(NULL, bin_len)) == NULL )
+ if ( (rv=PyString_FromStringAndSize(NULL, bin_len)) == NULL )
return NULL;
- bin_data = (unsigned char *)PyBytes_AsString(rv);
+ bin_data = (unsigned char *)PyString_AsString(rv);
for( ; bin_len > 0 ; ascii_len--, ascii_data++ ) {
/* XXX is it really best to add NULs if there's no more data */
}
/* We're lazy and allocate to much (fixed up later) */
- if ( (rv=PyBytes_FromStringAndSize(NULL, bin_len*2+2)) == NULL )
+ if ( (rv=PyString_FromStringAndSize(NULL, bin_len*2+2)) == NULL )
return NULL;
- ascii_data = (unsigned char *)PyBytes_AsString(rv);
+ ascii_data = (unsigned char *)PyString_AsString(rv);
/* Store the length */
*ascii_data++ = ' ' + (bin_len & 077);
}
*ascii_data++ = '\n'; /* Append a courtesy newline */
- _PyBytes_Resize(&rv, (ascii_data -
- (unsigned char *)PyBytes_AsString(rv)));
+ _PyString_Resize(&rv, (ascii_data -
+ (unsigned char *)PyString_AsString(rv)));
return rv;
}
bin_len = ((ascii_len+3)/4)*3; /* Upper bound, corrected later */
/* Allocate the buffer */
- if ( (rv=PyBytes_FromStringAndSize(NULL, bin_len)) == NULL )
+ if ( (rv=PyString_FromStringAndSize(NULL, bin_len)) == NULL )
return NULL;
- bin_data = (unsigned char *)PyBytes_AsString(rv);
+ bin_data = (unsigned char *)PyString_AsString(rv);
bin_len = 0;
for( ; ascii_len > 0; ascii_len--, ascii_data++) {
/* And set string size correctly. If the result string is empty
** (because the input was all invalid) return the shared empty
- ** string instead; _PyBytes_Resize() won't do this for us.
+ ** string instead; _PyString_Resize() won't do this for us.
*/
if (bin_len > 0)
- _PyBytes_Resize(&rv, bin_len);
+ _PyString_Resize(&rv, bin_len);
else {
Py_DECREF(rv);
- rv = PyBytes_FromString("");
+ rv = PyString_FromString("");
}
return rv;
}
/* We're lazy and allocate too much (fixed up later).
"+3" leaves room for up to two pad characters and a trailing
newline. Note that 'b' gets encoded as 'Yg==\n' (1 in, 5 out). */
- if ( (rv=PyBytes_FromStringAndSize(NULL, bin_len*2 + 3)) == NULL )
+ if ( (rv=PyString_FromStringAndSize(NULL, bin_len*2 + 3)) == NULL )
return NULL;
- ascii_data = (unsigned char *)PyBytes_AsString(rv);
+ ascii_data = (unsigned char *)PyString_AsString(rv);
for( ; bin_len > 0 ; bin_len--, bin_data++ ) {
/* Shift the data into our buffer */
}
*ascii_data++ = '\n'; /* Append a courtesy newline */
- _PyBytes_Resize(&rv, (ascii_data -
- (unsigned char *)PyBytes_AsString(rv)));
+ _PyString_Resize(&rv, (ascii_data -
+ (unsigned char *)PyString_AsString(rv)));
return rv;
}
/* Allocate a string that is too big (fixed later)
Add two to the initial length to prevent interning which
would preclude subsequent resizing. */
- if ( (rv=PyBytes_FromStringAndSize(NULL, len+2)) == NULL )
+ if ( (rv=PyString_FromStringAndSize(NULL, len+2)) == NULL )
return NULL;
- bin_data = (unsigned char *)PyBytes_AsString(rv);
+ bin_data = (unsigned char *)PyString_AsString(rv);
for( ; len > 0 ; len--, ascii_data++ ) {
/* Get the byte and look it up */
Py_DECREF(rv);
return NULL;
}
- _PyBytes_Resize(
- &rv, (bin_data - (unsigned char *)PyBytes_AsString(rv)));
+ _PyString_Resize(
+ &rv, (bin_data - (unsigned char *)PyString_AsString(rv)));
if (rv) {
PyObject *rrv = Py_BuildValue("Oi", rv, done);
Py_DECREF(rv);
return NULL;
/* Worst case: output is twice as big as input (fixed later) */
- if ( (rv=PyBytes_FromStringAndSize(NULL, len*2+2)) == NULL )
+ if ( (rv=PyString_FromStringAndSize(NULL, len*2+2)) == NULL )
return NULL;
- out_data = (unsigned char *)PyBytes_AsString(rv);
+ out_data = (unsigned char *)PyString_AsString(rv);
for( in=0; in<len; in++) {
ch = in_data[in];
}
}
}
- _PyBytes_Resize(&rv, (out_data -
- (unsigned char *)PyBytes_AsString(rv)));
+ _PyString_Resize(&rv, (out_data -
+ (unsigned char *)PyString_AsString(rv)));
return rv;
}
return NULL;
/* Allocate a buffer that is at least large enough */
- if ( (rv=PyBytes_FromStringAndSize(NULL, len*2+2)) == NULL )
+ if ( (rv=PyString_FromStringAndSize(NULL, len*2+2)) == NULL )
return NULL;
- ascii_data = (unsigned char *)PyBytes_AsString(rv);
+ ascii_data = (unsigned char *)PyString_AsString(rv);
for( ; len > 0 ; len--, bin_data++ ) {
/* Shift into our buffer, and output any 6bits ready */
leftchar <<= (6-leftbits);
*ascii_data++ = table_b2a_hqx[leftchar & 0x3f];
}
- _PyBytes_Resize(&rv, (ascii_data -
- (unsigned char *)PyBytes_AsString(rv)));
+ _PyString_Resize(&rv, (ascii_data -
+ (unsigned char *)PyString_AsString(rv)));
return rv;
}
/* Empty string is a special case */
if ( in_len == 0 )
- return PyBytes_FromString("");
+ return PyString_FromString("");
/* Allocate a buffer of reasonable size. Resized when needed */
out_len = in_len*2;
- if ( (rv=PyBytes_FromStringAndSize(NULL, out_len)) == NULL )
+ if ( (rv=PyString_FromStringAndSize(NULL, out_len)) == NULL )
return NULL;
out_len_left = out_len;
- out_data = (unsigned char *)PyBytes_AsString(rv);
+ out_data = (unsigned char *)PyString_AsString(rv);
/*
** We need two macros here to get/put bytes and handle
#define OUTBYTE(b) \
do { \
if ( --out_len_left < 0 ) { \
- _PyBytes_Resize(&rv, 2*out_len); \
+ _PyString_Resize(&rv, 2*out_len); \
if ( rv == NULL ) return NULL; \
- out_data = (unsigned char *)PyBytes_AsString(rv) \
+ out_data = (unsigned char *)PyString_AsString(rv) \
+ out_len; \
out_len_left = out_len-1; \
out_len = out_len * 2; \
OUTBYTE(in_byte);
}
}
- _PyBytes_Resize(&rv, (out_data -
- (unsigned char *)PyBytes_AsString(rv)));
+ _PyString_Resize(&rv, (out_data -
+ (unsigned char *)PyString_AsString(rv)));
return rv;
}
if (!PyArg_ParseTuple(args, "s#:b2a_hex", &argbuf, &arglen))
return NULL;
- retval = PyBytes_FromStringAndSize(NULL, arglen*2);
+ retval = PyString_FromStringAndSize(NULL, arglen*2);
if (!retval)
return NULL;
- retbuf = PyBytes_AsString(retval);
+ retbuf = PyString_AsString(retval);
if (!retbuf)
goto finally;
return NULL;
}
- retval = PyBytes_FromStringAndSize(NULL, (arglen/2));
+ retval = PyString_FromStringAndSize(NULL, (arglen/2));
if (!retval)
return NULL;
- retbuf = PyBytes_AsString(retval);
+ retbuf = PyString_AsString(retval);
if (!retbuf)
goto finally;
out++;
}
}
- if ((rv = PyBytes_FromStringAndSize((char *)odata, out)) == NULL) {
+ if ((rv = PyString_FromStringAndSize((char *)odata, out)) == NULL) {
PyMem_Free(odata);
return NULL;
}
}
}
}
- if ((rv = PyBytes_FromStringAndSize((char *)odata, out)) == NULL) {
+ if ((rv = PyString_FromStringAndSize((char *)odata, out)) == NULL) {
PyMem_Free(odata);
return NULL;
}
return;
d = PyModule_GetDict(m);
- x = PyBytes_FromString(doc_binascii);
+ x = PyString_FromString(doc_binascii);
PyDict_SetItemString(d, "__doc__", x);
Py_XDECREF(x);
return NULL;
}
- result = PyBytes_FromStringAndSize(data, (int)drec.size);
+ result = PyString_FromStringAndSize(data, (int)drec.size);
if (data != buf) free(data);
return result;
}
if (dp->di_type == DB_RECNO)
item = PyInt_FromLong(*((int*)data));
else
- item = PyBytes_FromStringAndSize(data,
+ item = PyString_FromStringAndSize(data,
(int)krec.size);
if (data != buf) free(data);
if (item == NULL) {
#error "Large file support, but neither off_t nor fpos_t is large enough."
#endif
-#define BUF(v) PyBytes_AS_STRING((PyBytesObject *)v)
+#define BUF(v) PyString_AS_STRING((PyStringObject *)v)
#define MODE_CLOSED 0
#define MODE_READ 1
int univ_newline = f->f_univ_newline;
total_v_size = n > 0 ? n : 100;
- v = PyBytes_FromStringAndSize((char *)NULL, total_v_size);
+ v = PyString_FromStringAndSize((char *)NULL, total_v_size);
if (v == NULL)
return NULL;
Py_DECREF(v);
return NULL;
}
- if (_PyBytes_Resize(&v, total_v_size) < 0)
+ if (_PyString_Resize(&v, total_v_size) < 0)
return NULL;
buf = BUF(v) + used_v_size;
end = BUF(v) + total_v_size;
used_v_size = buf - BUF(v);
if (used_v_size != total_v_size)
- _PyBytes_Resize(&v, used_v_size);
+ _PyString_Resize(&v, used_v_size);
return v;
}
/* This is a hacked version of Python's
* fileobject.c:readahead_get_line_skip(). */
-static PyBytesObject *
+static PyStringObject *
Util_ReadAheadGetLineSkip(BZ2FileObject *f, int skip, int bufsize)
{
- PyBytesObject* s;
+ PyStringObject* s;
char *bufptr;
char *buf;
int len;
len = f->f_bufend - f->f_bufptr;
if (len == 0)
- return (PyBytesObject *)
- PyBytes_FromStringAndSize(NULL, skip);
+ return (PyStringObject *)
+ PyString_FromStringAndSize(NULL, skip);
bufptr = memchr(f->f_bufptr, '\n', len);
if (bufptr != NULL) {
bufptr++; /* Count the '\n' */
len = bufptr - f->f_bufptr;
- s = (PyBytesObject *)
- PyBytes_FromStringAndSize(NULL, skip+len);
+ s = (PyStringObject *)
+ PyString_FromStringAndSize(NULL, skip+len);
if (s == NULL)
return NULL;
- memcpy(PyBytes_AS_STRING(s)+skip, f->f_bufptr, len);
+ memcpy(PyString_AS_STRING(s)+skip, f->f_bufptr, len);
f->f_bufptr = bufptr;
if (bufptr == f->f_bufend)
Util_DropReadAhead(f);
PyMem_Free(buf);
return NULL;
}
- memcpy(PyBytes_AS_STRING(s)+skip, bufptr, len);
+ memcpy(PyString_AS_STRING(s)+skip, bufptr, len);
PyMem_Free(buf);
}
return s;
case MODE_READ:
break;
case MODE_READ_EOF:
- ret = PyBytes_FromString("");
+ ret = PyString_FromString("");
goto cleanup;
case MODE_CLOSED:
PyErr_SetString(PyExc_ValueError,
"more than a Python string can hold");
goto cleanup;
}
- ret = PyBytes_FromStringAndSize((char *)NULL, buffersize);
+ ret = PyString_FromStringAndSize((char *)NULL, buffersize);
if (ret == NULL)
goto cleanup;
bytesread = 0;
}
if (bytesrequested < 0) {
buffersize = Util_NewBufferSize(buffersize);
- if (_PyBytes_Resize(&ret, buffersize) < 0)
+ if (_PyString_Resize(&ret, buffersize) < 0)
goto cleanup;
} else {
break;
}
}
if (bytesread != buffersize)
- _PyBytes_Resize(&ret, bytesread);
+ _PyString_Resize(&ret, bytesread);
cleanup:
RELEASE_LOCK(self);
case MODE_READ:
break;
case MODE_READ_EOF:
- ret = PyBytes_FromString("");
+ ret = PyString_FromString("");
goto cleanup;
case MODE_CLOSED:
PyErr_SetString(PyExc_ValueError,
}
if (sizehint == 0)
- ret = PyBytes_FromString("");
+ ret = PyString_FromString("");
else
ret = Util_GetLine(self, (sizehint < 0) ? 0 : sizehint);
}
if (big_buffer == NULL) {
/* Create the big buffer */
- big_buffer = PyBytes_FromStringAndSize(
+ big_buffer = PyString_FromStringAndSize(
NULL, buffersize);
if (big_buffer == NULL)
goto error;
- buffer = PyBytes_AS_STRING(big_buffer);
+ buffer = PyString_AS_STRING(big_buffer);
memcpy(buffer, small_buffer, nfilled);
}
else {
/* Grow the big buffer */
- _PyBytes_Resize(&big_buffer, buffersize);
- buffer = PyBytes_AS_STRING(big_buffer);
+ _PyString_Resize(&big_buffer, buffersize);
+ buffer = PyString_AS_STRING(big_buffer);
}
continue;
}
while (p != NULL) {
/* Process complete lines */
p++;
- line = PyBytes_FromStringAndSize(q, p-q);
+ line = PyString_FromStringAndSize(q, p-q);
if (line == NULL)
goto error;
err = PyList_Append(list, line);
}
if (nfilled != 0) {
/* Partial last line */
- line = PyBytes_FromStringAndSize(buffer, nfilled);
+ line = PyString_FromStringAndSize(buffer, nfilled);
if (line == NULL)
goto error;
if (sizehint > 0) {
Py_DECREF(line);
goto error;
}
- PyBytes_Concat(&line, rest);
+ PyString_Concat(&line, rest);
Py_DECREF(rest);
if (line == NULL)
goto error;
could potentially execute Python code. */
for (i = 0; i < j; i++) {
PyObject *v = PyList_GET_ITEM(list, i);
- if (!PyBytes_Check(v)) {
+ if (!PyString_Check(v)) {
const char *buffer;
Py_ssize_t len;
if (PyObject_AsCharBuffer(v, &buffer, &len)) {
"strings");
goto error;
}
- line = PyBytes_FromStringAndSize(buffer,
+ line = PyString_FromStringAndSize(buffer,
len);
if (line == NULL)
goto error;
Py_BEGIN_ALLOW_THREADS
for (i = 0; i < j; i++) {
line = PyList_GET_ITEM(list, i);
- len = PyBytes_GET_SIZE(line);
+ len = PyString_GET_SIZE(line);
BZ2_bzWrite (&bzerror, self->fp,
- PyBytes_AS_STRING(line), len);
+ PyString_AS_STRING(line), len);
if (bzerror != BZ_OK) {
Py_BLOCK_THREADS
Util_CatchBZ2Error(bzerror);
Py_INCREF(Py_None);
return Py_None;
case NEWLINE_CR:
- return PyBytes_FromString("\r");
+ return PyString_FromString("\r");
case NEWLINE_LF:
- return PyBytes_FromString("\n");
+ return PyString_FromString("\n");
case NEWLINE_CR|NEWLINE_LF:
return Py_BuildValue("(ss)", "\r", "\n");
case NEWLINE_CRLF:
- return PyBytes_FromString("\r\n");
+ return PyString_FromString("\r\n");
case NEWLINE_CR|NEWLINE_CRLF:
return Py_BuildValue("(ss)", "\r", "\r\n");
case NEWLINE_LF|NEWLINE_CRLF:
static PyObject *
BZ2File_iternext(BZ2FileObject *self)
{
- PyBytesObject* ret;
+ PyStringObject* ret;
ACQUIRE_LOCK(self);
if (self->mode == MODE_CLOSED) {
PyErr_SetString(PyExc_ValueError,
}
ret = Util_ReadAheadGetLineSkip(self, 0, READAHEAD_BUFSIZE);
RELEASE_LOCK(self);
- if (ret == NULL || PyBytes_GET_SIZE(ret) == 0) {
+ if (ret == NULL || PyString_GET_SIZE(ret) == 0) {
Py_XDECREF(ret);
return NULL;
}
return NULL;
if (datasize == 0)
- return PyBytes_FromString("");
+ return PyString_FromString("");
ACQUIRE_LOCK(self);
if (!self->running) {
goto error;
}
- ret = PyBytes_FromStringAndSize(NULL, bufsize);
+ ret = PyString_FromStringAndSize(NULL, bufsize);
if (!ret)
goto error;
break; /* no more input data */
if (bzs->avail_out == 0) {
bufsize = Util_NewBufferSize(bufsize);
- if (_PyBytes_Resize(&ret, bufsize) < 0) {
+ if (_PyString_Resize(&ret, bufsize) < 0) {
BZ2_bzCompressEnd(bzs);
goto error;
}
}
}
- _PyBytes_Resize(&ret, (Py_ssize_t)(BZS_TOTAL_OUT(bzs) - totalout));
+ _PyString_Resize(&ret, (Py_ssize_t)(BZS_TOTAL_OUT(bzs) - totalout));
RELEASE_LOCK(self);
return ret;
}
self->running = 0;
- ret = PyBytes_FromStringAndSize(NULL, bufsize);
+ ret = PyString_FromStringAndSize(NULL, bufsize);
if (!ret)
goto error;
}
if (bzs->avail_out == 0) {
bufsize = Util_NewBufferSize(bufsize);
- if (_PyBytes_Resize(&ret, bufsize) < 0)
+ if (_PyString_Resize(&ret, bufsize) < 0)
goto error;
bzs->next_out = BUF(ret);
bzs->next_out = BUF(ret) + (BZS_TOTAL_OUT(bzs)
}
if (bzs->avail_out != 0)
- _PyBytes_Resize(&ret, (Py_ssize_t)(BZS_TOTAL_OUT(bzs) - totalout));
+ _PyString_Resize(&ret, (Py_ssize_t)(BZS_TOTAL_OUT(bzs) - totalout));
RELEASE_LOCK(self);
return ret;
goto error;
}
- ret = PyBytes_FromStringAndSize(NULL, bufsize);
+ ret = PyString_FromStringAndSize(NULL, bufsize);
if (!ret)
goto error;
if (bzs->avail_in != 0) {
Py_DECREF(self->unused_data);
self->unused_data =
- PyBytes_FromStringAndSize(bzs->next_in,
+ PyString_FromStringAndSize(bzs->next_in,
bzs->avail_in);
}
self->running = 0;
break; /* no more input data */
if (bzs->avail_out == 0) {
bufsize = Util_NewBufferSize(bufsize);
- if (_PyBytes_Resize(&ret, bufsize) < 0) {
+ if (_PyString_Resize(&ret, bufsize) < 0) {
BZ2_bzDecompressEnd(bzs);
goto error;
}
}
if (bzs->avail_out != 0)
- _PyBytes_Resize(&ret, (Py_ssize_t)(BZS_TOTAL_OUT(bzs) - totalout));
+ _PyString_Resize(&ret, (Py_ssize_t)(BZS_TOTAL_OUT(bzs) - totalout));
RELEASE_LOCK(self);
return ret;
}
#endif
- self->unused_data = PyBytes_FromString("");
+ self->unused_data = PyString_FromString("");
if (!self->unused_data)
goto error;
* data in one shot. We will check it later anyway. */
bufsize = datasize + (datasize/100+1) + 600;
- ret = PyBytes_FromStringAndSize(NULL, bufsize);
+ ret = PyString_FromStringAndSize(NULL, bufsize);
if (!ret)
return NULL;
}
if (bzs->avail_out == 0) {
bufsize = Util_NewBufferSize(bufsize);
- if (_PyBytes_Resize(&ret, bufsize) < 0) {
+ if (_PyString_Resize(&ret, bufsize) < 0) {
BZ2_bzCompressEnd(bzs);
Py_DECREF(ret);
return NULL;
}
if (bzs->avail_out != 0)
- _PyBytes_Resize(&ret, (Py_ssize_t)BZS_TOTAL_OUT(bzs));
+ _PyString_Resize(&ret, (Py_ssize_t)BZS_TOTAL_OUT(bzs));
BZ2_bzCompressEnd(bzs);
return ret;
return NULL;
if (datasize == 0)
- return PyBytes_FromString("");
+ return PyString_FromString("");
- ret = PyBytes_FromStringAndSize(NULL, bufsize);
+ ret = PyString_FromStringAndSize(NULL, bufsize);
if (!ret)
return NULL;
}
if (bzs->avail_out == 0) {
bufsize = Util_NewBufferSize(bufsize);
- if (_PyBytes_Resize(&ret, bufsize) < 0) {
+ if (_PyString_Resize(&ret, bufsize) < 0) {
BZ2_bzDecompressEnd(bzs);
Py_DECREF(ret);
return NULL;
}
if (bzs->avail_out != 0)
- _PyBytes_Resize(&ret, (Py_ssize_t)BZS_TOTAL_OUT(bzs));
+ _PyString_Resize(&ret, (Py_ssize_t)BZS_TOTAL_OUT(bzs));
BZ2_bzDecompressEnd(bzs);
return ret;
if (m == NULL)
return;
- PyModule_AddObject(m, "__author__", PyBytes_FromString(__author__));
+ PyModule_AddObject(m, "__author__", PyString_FromString(__author__));
Py_INCREF(&BZ2File_Type);
PyModule_AddObject(m, "BZ2File", (PyObject *)&BZ2File_Type);
if (format) args = Py_VaBuildValue(format, va);
va_end(va);
if (format && ! args) return NULL;
- if (stringformat && !(retval=PyBytes_FromString(stringformat)))
+ if (stringformat && !(retval=PyString_FromString(stringformat)))
return NULL;
if (retval) {
if (args) {
PyObject *v;
- v=PyBytes_Format(retval, args);
+ v=PyString_Format(retval, args);
Py_DECREF(retval);
Py_DECREF(args);
if (! v) return NULL;
n = (int)_n;
if (s == NULL) {
if (!( self->buf_size )) return 0;
- py_str = PyBytes_FromStringAndSize(self->write_buf,
+ py_str = PyString_FromStringAndSize(self->write_buf,
self->buf_size);
if (!py_str)
return -1;
if (n > WRITE_BUF_SIZE) {
if (!( py_str =
- PyBytes_FromStringAndSize(s, n)))
+ PyString_FromStringAndSize(s, n)))
return -1;
}
else {
Py_XDECREF(self->last_string);
self->last_string = str;
- if (! (*s = PyBytes_AsString(str))) return -1;
+ if (! (*s = PyString_AsString(str))) return -1;
return n;
}
return -1;
}
- if ((str_size = PyBytes_Size(str)) < 0)
+ if ((str_size = PyString_Size(str)) < 0)
return -1;
Py_XDECREF(self->last_string);
self->last_string = str;
- if (! (*s = PyBytes_AsString(str)))
+ if (! (*s = PyString_AsString(str)))
return -1;
return str_size;
"to pickle");
goto finally;
}
- repr = PyBytes_FromStringAndSize(NULL, (int)nbytes);
+ repr = PyString_FromStringAndSize(NULL, (int)nbytes);
if (repr == NULL) goto finally;
- pdata = (unsigned char *)PyBytes_AS_STRING(repr);
+ pdata = (unsigned char *)PyString_AS_STRING(repr);
i = _PyLong_AsByteArray((PyLongObject *)args,
pdata, nbytes,
1 /* little endian */, 1 /* signed */);
if (!( repr = PyObject_Repr(args)))
goto finally;
- if ((size = PyBytes_Size(repr)) < 0)
+ if ((size = PyString_Size(repr)) < 0)
goto finally;
if (self->write_func(self, &l, 1) < 0)
goto finally;
if (self->write_func(self,
- PyBytes_AS_STRING((PyBytesObject *)repr),
+ PyString_AS_STRING((PyStringObject *)repr),
size) < 0)
goto finally;
int size, len;
PyObject *repr=0;
- if ((size = PyBytes_Size(args)) < 0)
+ if ((size = PyString_Size(args)) < 0)
return -1;
if (!self->bin) {
if (!( repr = PyObject_Repr(args)))
return -1;
- if ((len = PyBytes_Size(repr)) < 0)
+ if ((len = PyString_Size(repr)) < 0)
goto err;
- repr_str = PyBytes_AS_STRING((PyBytesObject *)repr);
+ repr_str = PyString_AS_STRING((PyStringObject *)repr);
if (self->write_func(self, &string, 1) < 0)
goto err;
int i;
char c_str[5];
- if ((size = PyBytes_Size(args)) < 0)
+ if ((size = PyString_Size(args)) < 0)
return -1;
if (size < 256) {
}
else {
if (self->write_func(self,
- PyBytes_AS_STRING(
- (PyBytesObject *)args),
+ PyString_AS_STRING(
+ (PyStringObject *)args),
size) < 0)
return -1;
}
static const char *hexdigit = "0123456789ABCDEF";
- repr = PyBytes_FromStringAndSize(NULL, 6 * size);
+ repr = PyString_FromStringAndSize(NULL, 6 * size);
if (repr == NULL)
return NULL;
if (size == 0)
return repr;
- p = q = PyBytes_AS_STRING(repr);
+ p = q = PyString_AS_STRING(repr);
while (size-- > 0) {
Py_UNICODE ch = *s++;
/* Map 16-bit characters to '\uxxxx' */
*p++ = (char) ch;
}
*p = '\0';
- _PyBytes_Resize(&repr, p - q);
+ _PyString_Resize(&repr, p - q);
return repr;
}
if (!repr)
return -1;
- if ((len = PyBytes_Size(repr)) < 0)
+ if ((len = PyString_Size(repr)) < 0)
goto err;
- repr_str = PyBytes_AS_STRING((PyBytesObject *)repr);
+ repr_str = PyString_AS_STRING((PyStringObject *)repr);
if (self->write_func(self, &string, 1) < 0)
goto err;
if (!( repr = PyUnicode_AsUTF8String(args)))
return -1;
- if ((size = PyBytes_Size(repr)) < 0)
+ if ((size = PyString_Size(repr)) < 0)
goto err;
if (size > INT_MAX)
return -1; /* string too large */
PDATA_APPEND(self->file, repr, -1);
}
else {
- if (self->write_func(self, PyBytes_AS_STRING(repr),
+ if (self->write_func(self, PyString_AS_STRING(repr),
size) < 0)
goto err;
}
goto finally;
- if ((module_size = PyBytes_Size(module)) < 0 ||
- (name_size = PyBytes_Size(name)) < 0)
+ if ((module_size = PyString_Size(module)) < 0 ||
+ (name_size = PyString_Size(name)) < 0)
goto finally;
- module_str = PyBytes_AS_STRING((PyBytesObject *)module);
- name_str = PyBytes_AS_STRING((PyBytesObject *)name);
+ module_str = PyString_AS_STRING((PyStringObject *)module);
+ name_str = PyString_AS_STRING((PyStringObject *)name);
if (self->write_func(self, &inst, 1) < 0)
goto finally;
if (!( module = whichmodule(args, global_name)))
goto finally;
- if ((module_size = PyBytes_Size(module)) < 0 ||
- (name_size = PyBytes_Size(global_name)) < 0)
+ if ((module_size = PyString_Size(module)) < 0 ||
+ (name_size = PyString_Size(global_name)) < 0)
goto finally;
- module_str = PyBytes_AS_STRING((PyBytesObject *)module);
- name_str = PyBytes_AS_STRING((PyBytesObject *)global_name);
+ module_str = PyString_AS_STRING((PyStringObject *)module);
+ name_str = PyString_AS_STRING((PyStringObject *)global_name);
/* XXX This can be doing a relative import. Clearly it shouldn't,
but I don't know how to stop it. :-( */
if (pid != Py_None) {
if (!self->bin) {
- if (!PyBytes_Check(pid)) {
+ if (!PyString_Check(pid)) {
PyErr_SetString(PicklingError,
"persistent id must be string");
goto finally;
if (self->write_func(self, &persid, 1) < 0)
goto finally;
- if ((size = PyBytes_Size(pid)) < 0)
+ if ((size = PyString_Size(pid)) < 0)
goto finally;
if (self->write_func(self,
- PyBytes_AS_STRING(
- (PyBytesObject *)pid),
+ PyString_AS_STRING(
+ (PyStringObject *)pid),
size) < 0)
goto finally;
use_newobj = 0;
}
else {
- use_newobj = PyBytes_Check(temp) &&
- strcmp(PyBytes_AS_STRING(temp),
+ use_newobj = PyString_Check(temp) &&
+ strcmp(PyString_AS_STRING(temp),
"__newobj__") == 0;
Py_DECREF(temp);
}
break;
case 's':
- if ((type == &PyBytes_Type) && (PyBytes_GET_SIZE(args) < 2)) {
+ if ((type == &PyString_Type) && (PyString_GET_SIZE(args) < 2)) {
res = save_string(self, args, 0);
goto finally;
}
#ifdef Py_USING_UNICODE
case 'u':
- if ((type == &PyUnicode_Type) && (PyBytes_GET_SIZE(args) < 2)) {
+ if ((type == &PyUnicode_Type) && (PyString_GET_SIZE(args) < 2)) {
res = save_unicode(self, args, 0);
goto finally;
}
switch (type->tp_name[0]) {
case 's':
- if (type == &PyBytes_Type) {
+ if (type == &PyString_Type) {
res = save_string(self, args, 1);
goto finally;
}
if (t == NULL)
goto finally;
- if (PyBytes_Check(t)) {
+ if (PyString_Check(t)) {
res = save_global(self, args, t);
goto finally;
}
for (rsize = 0, i = l; --i >= 0; ) {
k = data->data[i];
- if (PyBytes_Check(k))
- rsize += PyBytes_GET_SIZE(k);
+ if (PyString_Check(k))
+ rsize += PyString_GET_SIZE(k);
else if (PyInt_Check(k)) { /* put */
ik = PyInt_AS_LONG((PyIntObject*)k);
}
/* Now generate the result */
- r = PyBytes_FromStringAndSize(NULL, rsize);
+ r = PyString_FromStringAndSize(NULL, rsize);
if (r == NULL) goto err;
- s = PyBytes_AS_STRING((PyBytesObject *)r);
+ s = PyString_AS_STRING((PyStringObject *)r);
for (i = 0; i < l; i++) {
k = data->data[i];
- if (PyBytes_Check(k)) {
- ssize = PyBytes_GET_SIZE(k);
+ if (PyString_Check(k)) {
+ ssize = PyString_GET_SIZE(k);
if (ssize) {
- p=PyBytes_AS_STRING((PyBytesObject *)k);
+ p=PyString_AS_STRING((PyStringObject *)k);
while (--ssize >= 0)
*s++ = *p++;
}
goto insecure;
/********************************************/
- str = PyBytes_DecodeEscape(p, len, NULL, 0, NULL);
+ str = PyString_DecodeEscape(p, len, NULL, 0, NULL);
free(s);
if (str) {
PDATA_PUSH(self->stack, str, -1);
if (self->read_func(self, &s, l) < 0)
return -1;
- if (!( py_string = PyBytes_FromStringAndSize(s, l)))
+ if (!( py_string = PyString_FromStringAndSize(s, l)))
return -1;
PDATA_PUSH(self->stack, py_string, -1);
if (self->read_func(self, &s, l) < 0) return -1;
- if (!( py_string = PyBytes_FromStringAndSize(s, l))) return -1;
+ if (!( py_string = PyString_FromStringAndSize(s, l))) return -1;
PDATA_PUSH(self->stack, py_string, -1);
return 0;
if ((len = self->readline_func(self, &s)) < 0) return -1;
if (len < 2) return bad_readline();
- module_name = PyBytes_FromStringAndSize(s, len - 1);
+ module_name = PyString_FromStringAndSize(s, len - 1);
if (!module_name) return -1;
if ((len = self->readline_func(self, &s)) >= 0) {
if (len < 2) return bad_readline();
- if ((class_name = PyBytes_FromStringAndSize(s, len - 1))) {
+ if ((class_name = PyString_FromStringAndSize(s, len - 1))) {
class = find_class(module_name, class_name,
self->find_class);
Py_DECREF(class_name);
if ((len = self->readline_func(self, &s)) < 0) return -1;
if (len < 2) return bad_readline();
- module_name = PyBytes_FromStringAndSize(s, len - 1);
+ module_name = PyString_FromStringAndSize(s, len - 1);
if (!module_name) return -1;
if ((len = self->readline_func(self, &s)) >= 0) {
Py_DECREF(module_name);
return bad_readline();
}
- if ((class_name = PyBytes_FromStringAndSize(s, len - 1))) {
+ if ((class_name = PyString_FromStringAndSize(s, len - 1))) {
class = find_class(module_name, class_name,
self->find_class);
Py_DECREF(class_name);
if ((len = self->readline_func(self, &s)) < 0) return -1;
if (len < 2) return bad_readline();
- pid = PyBytes_FromStringAndSize(s, len - 1);
+ pid = PyString_FromStringAndSize(s, len - 1);
if (!pid) return -1;
if (PyList_Check(self->pers_func)) {
if ((len = self->readline_func(self, &s)) < 0) return -1;
if (len < 2) return bad_readline();
- if (!( py_str = PyBytes_FromStringAndSize(s, len - 1))) return -1;
+ if (!( py_str = PyString_FromStringAndSize(s, len - 1))) return -1;
value = PyDict_GetItem(self->memo, py_str);
if (! value) {
* confirm that pair is really a 2-tuple of strings.
*/
if (!PyTuple_Check(pair) || PyTuple_Size(pair) != 2 ||
- !PyBytes_Check(module_name = PyTuple_GET_ITEM(pair, 0)) ||
- !PyBytes_Check(class_name = PyTuple_GET_ITEM(pair, 1))) {
+ !PyString_Check(module_name = PyTuple_GET_ITEM(pair, 0)) ||
+ !PyString_Check(class_name = PyTuple_GET_ITEM(pair, 1))) {
Py_DECREF(py_code);
PyErr_Format(PyExc_ValueError, "_inverted_registry[%ld] "
"isn't a 2-tuple of strings", code);
if ((l = self->readline_func(self, &s)) < 0) return -1;
if (l < 2) return bad_readline();
if (!( len=self->stack->length )) return stackUnderflow();
- if (!( py_str = PyBytes_FromStringAndSize(s, l - 1))) return -1;
+ if (!( py_str = PyString_FromStringAndSize(s, l - 1))) return -1;
value=self->stack->data[len-1];
l=PyDict_SetItem(self->memo, py_str, value);
Py_DECREF(py_str);
{
PyObject *copyreg, *t, *r;
-#define INIT_STR(S) if (!( S ## _str=PyBytes_InternFromString(#S))) return -1;
+#define INIT_STR(S) if (!( S ## _str=PyString_InternFromString(#S))) return -1;
if (PyType_Ready(&Unpicklertype) < 0)
return -1;
/* Add some symbolic constants to the module */
d = PyModule_GetDict(m);
- v = PyBytes_FromString(rev);
+ v = PyString_FromString(rev);
PyDict_SetItemString(d, "__version__", v);
Py_XDECREF(v);
/* These are purely informational; no code uses them. */
/* File format version we write. */
- format_version = PyBytes_FromString("2.0");
+ format_version = PyString_FromString("2.0");
/* Format versions we can read. */
compatible_formats = Py_BuildValue("[sssss]",
"1.0", /* Original protocol 0 */
static PyObject *
IO_cgetval(PyObject *self) {
if (!IO__opencheck(IOOOBJECT(self))) return NULL;
- return PyBytes_FromStringAndSize(((IOobject*)self)->buf,
+ return PyString_FromStringAndSize(((IOobject*)self)->buf,
((IOobject*)self)->pos);
}
}
else
s=self->string_size;
- return PyBytes_FromStringAndSize(self->buf, s);
+ return PyString_FromStringAndSize(self->buf, s);
}
PyDoc_STRVAR(IO_isatty__doc__, "isatty(): always returns 0");
if ( (n=IO_cread((PyObject*)self,&output,n)) < 0) return NULL;
- return PyBytes_FromStringAndSize(output, n);
+ return PyString_FromStringAndSize(output, n);
}
PyDoc_STRVAR(IO_readline__doc__, "readline() -- Read one line");
n -= m;
self->pos -= m;
}
- return PyBytes_FromStringAndSize(output, n);
+ return PyString_FromStringAndSize(output, n);
}
PyDoc_STRVAR(IO_readlines__doc__, "readlines() -- Read all lines");
goto err;
if (n == 0)
break;
- line = PyBytes_FromStringAndSize (output, n);
+ line = PyString_FromStringAndSize (output, n);
if (!line)
goto err;
if (PyList_Append (result, line) == -1) {
next = IO_readline((IOobject *)self, NULL);
if (!next)
return NULL;
- if (!PyBytes_GET_SIZE(next)) {
+ if (!PyString_GET_SIZE(next)) {
Py_DECREF(next);
PyErr_SetNone(PyExc_StopIteration);
return NULL;
while ((s = PyIter_Next(it)) != NULL) {
Py_ssize_t n;
char *c;
- if (PyBytes_AsStringAndSize(s, &c, &n) == -1) {
+ if (PyString_AsStringAndSize(s, &c, &n) == -1) {
Py_DECREF(it);
Py_DECREF(s);
return NULL;
if (!PyArg_ParseTuple(args, "i:readda", &numframes))
return NULL;
- result = PyBytes_FromStringAndSize(NULL, numframes * sizeof(CDFRAME));
+ result = PyString_FromStringAndSize(NULL, numframes * sizeof(CDFRAME));
if (result == NULL)
return NULL;
n = CDreadda(self->ob_cdplayer,
- (CDFRAME *) PyBytes_AsString(result), numframes);
+ (CDFRAME *) PyString_AsString(result), numframes);
if (n == -1) {
Py_DECREF(result);
PyErr_SetFromErrno(CdError);
return NULL;
}
if (n < numframes)
- _PyBytes_Resize(&result, n * sizeof(CDFRAME));
+ _PyString_Resize(&result, n * sizeof(CDFRAME));
return result;
}
PyTuple_SetItem(args, 1, PyInt_FromLong((long) type));
switch (type) {
case cd_audio:
- v = PyBytes_FromStringAndSize(data, CDDA_DATASIZE);
+ v = PyString_FromStringAndSize(data, CDDA_DATASIZE);
break;
case cd_pnum:
case cd_index:
#undef ptr
break;
case cd_catalog:
- v = PyBytes_FromStringAndSize(NULL, 13);
- p = PyBytes_AsString(v);
+ v = PyString_FromStringAndSize(NULL, 13);
+ p = PyString_AsString(v);
for (i = 0; i < 13; i++)
*p++ = ((char *) data)[i] + '0';
break;
case cd_ident:
#define ptr ((struct cdident *) data)
- v = PyBytes_FromStringAndSize(NULL, 12);
- p = PyBytes_AsString(v);
+ v = PyString_FromStringAndSize(NULL, 12);
+ p = PyString_AsString(v);
CDsbtoa(p, ptr->country, 2);
p += 2;
CDsbtoa(p, ptr->owner, 3);
PyObject *v;
if (!PyArg_GetObject(args, nargs, i, &v))
return 0;
- if (!PyBytes_Check(v)) {
+ if (!PyString_Check(v)) {
return PyErr_BadArgument();
}
- *p_arg = PyBytes_AsString(v);
+ *p_arg = PyString_AsString(v);
return 1;
}
const MultibyteCodec *codec;
const char *enc;
- if (!PyBytes_Check(encoding)) {
+ if (!PyString_Check(encoding)) {
PyErr_SetString(PyExc_TypeError,
"encoding name must be a string.");
return NULL;
if (cofunc == NULL)
return NULL;
- enc = PyBytes_AS_STRING(encoding);
+ enc = PyString_AS_STRING(encoding);
for (codec = codec_list; codec->encoding[0]; codec++)
if (strcmp(codec->encoding, enc) == 0)
break;
else if (strcmp(errors, "replace") == 0)
return ERROR_REPLACE;
else
- return PyBytes_FromString(errors);
+ return PyString_FromString(errors);
}
static PyObject *
{
PyObject *args, *cb, *r;
- assert(PyBytes_Check(errors));
- cb = PyCodec_LookupError(PyBytes_AS_STRING(errors));
+ assert(PyString_Check(errors));
+ cb = PyCodec_LookupError(PyString_AS_STRING(errors));
if (cb == NULL)
return NULL;
return self->errors;
}
- return PyBytes_FromString(errors);
+ return PyString_FromString(errors);
}
static int
{
PyObject *cb;
- if (!PyBytes_Check(value)) {
+ if (!PyString_Check(value)) {
PyErr_SetString(PyExc_TypeError, "errors must be a string");
return -1;
}
- cb = internal_error_callback(PyBytes_AS_STRING(value));
+ cb = internal_error_callback(PyString_AS_STRING(value));
if (cb == NULL)
return -1;
Py_ssize_t orgpos, orgsize;
orgpos = (Py_ssize_t)((char *)buf->outbuf -
- PyBytes_AS_STRING(buf->outobj));
- orgsize = PyBytes_GET_SIZE(buf->outobj);
- if (_PyBytes_Resize(&buf->outobj, orgsize + (
+ PyString_AS_STRING(buf->outobj));
+ orgsize = PyString_GET_SIZE(buf->outobj);
+ if (_PyString_Resize(&buf->outobj, orgsize + (
esize < (orgsize >> 1) ? (orgsize >> 1) | 1 : esize)) == -1)
return -1;
- buf->outbuf = (unsigned char *)PyBytes_AS_STRING(buf->outobj) +orgpos;
- buf->outbuf_end = (unsigned char *)PyBytes_AS_STRING(buf->outobj)
- + PyBytes_GET_SIZE(buf->outobj);
+ buf->outbuf = (unsigned char *)PyString_AS_STRING(buf->outobj) +orgpos;
+ buf->outbuf_end = (unsigned char *)PyString_AS_STRING(buf->outobj)
+ + PyString_GET_SIZE(buf->outobj);
return 0;
}
goto errorexit;
}
- retstrsize = PyBytes_GET_SIZE(retstr);
+ retstrsize = PyString_GET_SIZE(retstr);
REQUIRE_ENCODEBUFFER(buf, retstrsize);
- memcpy(buf->outbuf, PyBytes_AS_STRING(retstr), retstrsize);
+ memcpy(buf->outbuf, PyString_AS_STRING(retstr), retstrsize);
buf->outbuf += retstrsize;
newpos = PyInt_AsSsize_t(PyTuple_GET_ITEM(retobj, 1));
Py_ssize_t finalsize, r = 0;
if (datalen == 0)
- return PyBytes_FromString("");
+ return PyString_FromString("");
buf.excobj = NULL;
buf.inbuf = buf.inbuf_top = *data;
buf.inbuf_end = buf.inbuf_top + datalen;
- buf.outobj = PyBytes_FromStringAndSize(NULL, datalen * 2 + 16);
+ buf.outobj = PyString_FromStringAndSize(NULL, datalen * 2 + 16);
if (buf.outobj == NULL)
goto errorexit;
- buf.outbuf = (unsigned char *)PyBytes_AS_STRING(buf.outobj);
- buf.outbuf_end = buf.outbuf + PyBytes_GET_SIZE(buf.outobj);
+ buf.outbuf = (unsigned char *)PyString_AS_STRING(buf.outobj);
+ buf.outbuf_end = buf.outbuf + PyString_GET_SIZE(buf.outobj);
while (buf.inbuf < buf.inbuf_end) {
Py_ssize_t inleft, outleft;
}
finalsize = (Py_ssize_t)((char *)buf.outbuf -
- PyBytes_AS_STRING(buf.outobj));
+ PyString_AS_STRING(buf.outobj));
- if (finalsize != PyBytes_GET_SIZE(buf.outobj))
- if (_PyBytes_Resize(&buf.outobj, finalsize) == -1)
+ if (finalsize != PyString_GET_SIZE(buf.outobj))
+ if (_PyString_Resize(&buf.outobj, finalsize) == -1)
goto errorexit;
Py_XDECREF(buf.excobj);
if (cres == NULL)
goto errorexit;
- if (!PyBytes_Check(cres)) {
+ if (!PyString_Check(cres)) {
PyErr_SetString(PyExc_TypeError,
"stream function returned a "
"non-string object");
goto errorexit;
}
- endoffile = (PyBytes_GET_SIZE(cres) == 0);
+ endoffile = (PyString_GET_SIZE(cres) == 0);
if (self->pendingsize > 0) {
PyObject *ctr;
char *ctrdata;
- rsize = PyBytes_GET_SIZE(cres) + self->pendingsize;
- ctr = PyBytes_FromStringAndSize(NULL, rsize);
+ rsize = PyString_GET_SIZE(cres) + self->pendingsize;
+ ctr = PyString_FromStringAndSize(NULL, rsize);
if (ctr == NULL)
goto errorexit;
- ctrdata = PyBytes_AS_STRING(ctr);
+ ctrdata = PyString_AS_STRING(ctr);
memcpy(ctrdata, self->pending, self->pendingsize);
memcpy(ctrdata + self->pendingsize,
- PyBytes_AS_STRING(cres),
- PyBytes_GET_SIZE(cres));
+ PyString_AS_STRING(cres),
+ PyString_GET_SIZE(cres));
Py_DECREF(cres);
cres = ctr;
self->pendingsize = 0;
}
- rsize = PyBytes_GET_SIZE(cres);
- if (decoder_prepare_buffer(&buf, PyBytes_AS_STRING(cres),
+ rsize = PyString_GET_SIZE(cres);
+ if (decoder_prepare_buffer(&buf, PyString_AS_STRING(cres),
rsize) != 0)
goto errorexit;
if (pwrt == NULL)
return NULL;
- if (PyBytes_Size(pwrt) > 0) {
+ if (PyString_Size(pwrt) > 0) {
PyObject *wr;
wr = PyObject_CallMethod(self->stream, "write", "O", pwrt);
if (wr == NULL) {
return NULL;
retry:
- compressedBuffer = PyBytes_FromStringAndSize(NULL, frameBufferSize);
+ compressedBuffer = PyString_FromStringAndSize(NULL, frameBufferSize);
if (compressedBuffer == NULL)
return NULL;
if (clCompressImage(compressionScheme, width, height, originalFormat,
compressionRatio, (void *) frameBuffer,
&compressedBufferSize,
- (void *) PyBytes_AsString(compressedBuffer))
+ (void *) PyString_AsString(compressedBuffer))
== FAILURE || error_handler_called) {
Py_DECREF(compressedBuffer);
if (!error_handler_called)
}
if (compressedBufferSize < frameBufferSize)
- _PyBytes_Resize(&compressedBuffer, compressedBufferSize);
+ _PyString_Resize(&compressedBuffer, compressedBufferSize);
return compressedBuffer;
}
frameBufferSize = width * height * CL_BytesPerPixel(originalFormat);
- frameBuffer = PyBytes_FromStringAndSize(NULL, frameBufferSize);
+ frameBuffer = PyString_FromStringAndSize(NULL, frameBufferSize);
if (frameBuffer == NULL)
return NULL;
error_handler_called = 0;
if (clDecompressImage(compressionScheme, width, height, originalFormat,
compressedBufferSize, compressedBuffer,
- (void *) PyBytes_AsString(frameBuffer))
+ (void *) PyString_AsString(frameBuffer))
== FAILURE || error_handler_called) {
Py_DECREF(frameBuffer);
if (!error_handler_called)
if (error_handler_called)
return NULL;
- data = PyBytes_FromStringAndSize(NULL, size);
+ data = PyString_FromStringAndSize(NULL, size);
if (data == NULL)
return NULL;
error_handler_called = 0;
if (clCompress(SELF->ob_compressorHdl, numberOfFrames,
(void *) frameBuffer, &compressedBufferSize,
- (void *) PyBytes_AsString(data)) == FAILURE ||
+ (void *) PyString_AsString(data)) == FAILURE ||
error_handler_called) {
Py_DECREF(data);
if (!error_handler_called)
}
if (compressedBufferSize < size)
- if (_PyBytes_Resize(&data, compressedBufferSize))
+ if (_PyString_Resize(&data, compressedBufferSize))
return NULL;
if (compressedBufferSize > size) {
if (error_handler_called)
return NULL;
- data = PyBytes_FromStringAndSize(NULL, dataSize);
+ data = PyString_FromStringAndSize(NULL, dataSize);
if (data == NULL)
return NULL;
error_handler_called = 0;
if (clDecompress(SELF->ob_compressorHdl, numberOfFrames,
compressedDataSize, (void *) compressedData,
- (void *) PyBytes_AsString(data)) == FAILURE ||
+ (void *) PyString_AsString(data)) == FAILURE ||
error_handler_called) {
Py_DECREF(data);
if (!error_handler_called)
PyList_SetItem(list, i, Py_None);
} else
PyList_SetItem(list, i,
- PyBytes_FromString((char *) PVbuffer[i]));
+ PyString_FromString((char *) PVbuffer[i]));
}
PyMem_DEL(PVbuffer);
return NULL;
}
- return PyBytes_FromString(name);
+ return PyString_FromString(name);
}
static PyObject *
PyList_SetItem(list, i, Py_None);
} else
PyList_SetItem(list, i,
- PyBytes_FromString((char *) PVbuffer[i]));
+ PyString_FromString((char *) PVbuffer[i]));
}
PyMem_DEL(PVbuffer);
return NULL;
}
- return PyBytes_FromString(name);
+ return PyString_FromString(name);
}
static PyObject *
else
result = PyObject_CallMethod(tzinfo, "tzname", "O", tzinfoarg);
- if (result != NULL && result != Py_None && ! PyBytes_Check(result)) {
+ if (result != NULL && result != Py_None && ! PyString_Check(result)) {
PyErr_Format(PyExc_TypeError, "tzinfo.tzname() must "
"return None or a string, not '%s'",
Py_TYPE(result)->tp_name);
{
PyObject *temp;
- assert(PyBytes_Check(repr));
+ assert(PyString_Check(repr));
assert(tzinfo);
if (tzinfo == Py_None)
return repr;
/* Get rid of the trailing ')'. */
- assert(PyBytes_AsString(repr)[PyBytes_Size(repr)-1] == ')');
- temp = PyBytes_FromStringAndSize(PyBytes_AsString(repr),
- PyBytes_Size(repr) - 1);
+ assert(PyString_AsString(repr)[PyString_Size(repr)-1] == ')');
+ temp = PyString_FromStringAndSize(PyString_AsString(repr),
+ PyString_Size(repr) - 1);
Py_DECREF(repr);
if (temp == NULL)
return NULL;
repr = temp;
/* Append ", tzinfo=". */
- PyBytes_ConcatAndDel(&repr, PyBytes_FromString(", tzinfo="));
+ PyString_ConcatAndDel(&repr, PyString_FromString(", tzinfo="));
/* Append repr(tzinfo). */
- PyBytes_ConcatAndDel(&repr, PyObject_Repr(tzinfo));
+ PyString_ConcatAndDel(&repr, PyObject_Repr(tzinfo));
/* Add a closing paren. */
- PyBytes_ConcatAndDel(&repr, PyBytes_FromString(")"));
+ PyString_ConcatAndDel(&repr, PyString_FromString(")"));
return repr;
}
DayNames[wday], MonthNames[GET_MONTH(date) - 1],
GET_DAY(date), hours, minutes, seconds,
GET_YEAR(date));
- return PyBytes_FromString(buffer);
+ return PyString_FromString(buffer);
}
/* Add an hours & minutes UTC offset string to buf. buf has no more than
else
sprintf(freplacement, "%06d", 0);
- return PyBytes_FromStringAndSize(freplacement, strlen(freplacement));
+ return PyString_FromStringAndSize(freplacement, strlen(freplacement));
}
/* I sure don't want to reproduce the strftime code from the time module,
/* format utcoffset */
char buf[100];
PyObject *tzinfo = get_tzinfo_member(object);
- zreplacement = PyBytes_FromString("");
+ zreplacement = PyString_FromString("");
if (zreplacement == NULL) goto Done;
if (tzinfo != Py_None && tzinfo != NULL) {
assert(tzinfoarg != NULL);
tzinfoarg) < 0)
goto Done;
Py_DECREF(zreplacement);
- zreplacement = PyBytes_FromString(buf);
+ zreplacement = PyString_FromString(buf);
if (zreplacement == NULL) goto Done;
}
}
assert(zreplacement != NULL);
- ptoappend = PyBytes_AS_STRING(zreplacement);
- ntoappend = PyBytes_GET_SIZE(zreplacement);
+ ptoappend = PyString_AS_STRING(zreplacement);
+ ntoappend = PyString_GET_SIZE(zreplacement);
}
else if (ch == 'Z') {
/* format tzname */
if (Zreplacement == NULL) {
PyObject *tzinfo = get_tzinfo_member(object);
- Zreplacement = PyBytes_FromString("");
+ Zreplacement = PyString_FromString("");
if (Zreplacement == NULL) goto Done;
if (tzinfo != Py_None && tzinfo != NULL) {
PyObject *temp;
temp = call_tzname(tzinfo, tzinfoarg);
if (temp == NULL) goto Done;
if (temp != Py_None) {
- assert(PyBytes_Check(temp));
+ assert(PyString_Check(temp));
/* Since the tzname is getting
* stuffed into the format, we
* have to double any % signs
Py_DECREF(temp);
if (Zreplacement == NULL)
goto Done;
- if (!PyBytes_Check(Zreplacement)) {
+ if (!PyString_Check(Zreplacement)) {
PyErr_SetString(PyExc_TypeError, "tzname.replace() did not return a string");
goto Done;
}
}
}
assert(Zreplacement != NULL);
- ptoappend = PyBytes_AS_STRING(Zreplacement);
- ntoappend = PyBytes_GET_SIZE(Zreplacement);
+ ptoappend = PyString_AS_STRING(Zreplacement);
+ ntoappend = PyString_GET_SIZE(Zreplacement);
}
else if (ch == 'f') {
/* format microseconds */
goto Done;
}
assert(freplacement != NULL);
- assert(PyBytes_Check(freplacement));
- ptoappend = PyBytes_AS_STRING(freplacement);
- ntoappend = PyBytes_GET_SIZE(freplacement);
+ assert(PyString_Check(freplacement));
+ ptoappend = PyString_AS_STRING(freplacement);
+ ntoappend = PyString_GET_SIZE(freplacement);
}
else {
/* percent followed by neither z nor Z */
PyErr_NoMemory();
goto Done;
}
- if (_PyBytes_Resize(&newfmt, bigger) < 0)
+ if (_PyString_Resize(&newfmt, bigger) < 0)
goto Done;
totalnew = bigger;
- pnew = PyBytes_AsString(newfmt) + usednew;
+ pnew = PyString_AsString(newfmt) + usednew;
}
memcpy(pnew, ptoappend, ntoappend);
pnew += ntoappend;
assert(usednew <= totalnew);
} /* end while() */
- if (_PyBytes_Resize(&newfmt, usednew) < 0)
+ if (_PyString_Resize(&newfmt, usednew) < 0)
goto Done;
{
PyObject *time = PyImport_ImportModuleNoBlock("time");
delta_repr(PyDateTime_Delta *self)
{
if (GET_TD_MICROSECONDS(self) != 0)
- return PyBytes_FromFormat("%s(%d, %d, %d)",
+ return PyString_FromFormat("%s(%d, %d, %d)",
Py_TYPE(self)->tp_name,
GET_TD_DAYS(self),
GET_TD_SECONDS(self),
GET_TD_MICROSECONDS(self));
if (GET_TD_SECONDS(self) != 0)
- return PyBytes_FromFormat("%s(%d, %d)",
+ return PyString_FromFormat("%s(%d, %d)",
Py_TYPE(self)->tp_name,
GET_TD_DAYS(self),
GET_TD_SECONDS(self));
- return PyBytes_FromFormat("%s(%d)",
+ return PyString_FromFormat("%s(%d)",
Py_TYPE(self)->tp_name,
GET_TD_DAYS(self));
}
pbuf += n;
}
- return PyBytes_FromStringAndSize(buf, pbuf - buf);
+ return PyString_FromStringAndSize(buf, pbuf - buf);
Fail:
PyErr_SetString(PyExc_SystemError, "goofy result from PyOS_snprintf");
/* Check for invocation from pickle with __getstate__ state */
if (PyTuple_GET_SIZE(args) == 1 &&
- PyBytes_Check(state = PyTuple_GET_ITEM(args, 0)) &&
- PyBytes_GET_SIZE(state) == _PyDateTime_DATE_DATASIZE &&
- MONTH_IS_SANE(PyBytes_AS_STRING(state)[2]))
+ PyString_Check(state = PyTuple_GET_ITEM(args, 0)) &&
+ PyString_GET_SIZE(state) == _PyDateTime_DATE_DATASIZE &&
+ MONTH_IS_SANE(PyString_AS_STRING(state)[2]))
{
PyDateTime_Date *me;
me = (PyDateTime_Date *) (type->tp_alloc(type, 0));
if (me != NULL) {
- char *pdata = PyBytes_AS_STRING(state);
+ char *pdata = PyString_AS_STRING(state);
memcpy(me->data, pdata, _PyDateTime_DATE_DATASIZE);
me->hashcode = -1;
}
type_name,
GET_YEAR(self), GET_MONTH(self), GET_DAY(self));
- return PyBytes_FromString(buffer);
+ return PyString_FromString(buffer);
}
static PyObject *
char buffer[128];
isoformat_date(self, buffer, sizeof(buffer));
- return PyBytes_FromString(buffer);
+ return PyString_FromString(buffer);
}
/* str() calls the appropriate isoformat() method. */
return NULL;
/* Check for str or unicode */
- if (PyBytes_Check(format)) {
+ if (PyString_Check(format)) {
/* If format is zero length, return str(self) */
- if (PyBytes_GET_SIZE(format) == 0)
+ if (PyString_GET_SIZE(format) == 0)
return PyObject_Str((PyObject *)self);
} else if (PyUnicode_Check(format)) {
/* If format is zero length, return str(self) */
{
return Py_BuildValue(
"(N)",
- PyBytes_FromStringAndSize((char *)self->data,
+ PyString_FromStringAndSize((char *)self->data,
_PyDateTime_DATE_DATASIZE));
}
/* Check for invocation from pickle with __getstate__ state */
if (PyTuple_GET_SIZE(args) >= 1 &&
PyTuple_GET_SIZE(args) <= 2 &&
- PyBytes_Check(state = PyTuple_GET_ITEM(args, 0)) &&
- PyBytes_GET_SIZE(state) == _PyDateTime_TIME_DATASIZE &&
- ((unsigned char) (PyBytes_AS_STRING(state)[0])) < 24)
+ PyString_Check(state = PyTuple_GET_ITEM(args, 0)) &&
+ PyString_GET_SIZE(state) == _PyDateTime_TIME_DATASIZE &&
+ ((unsigned char) (PyString_AS_STRING(state)[0])) < 24)
{
PyDateTime_Time *me;
char aware;
aware = (char)(tzinfo != Py_None);
me = (PyDateTime_Time *) (type->tp_alloc(type, aware));
if (me != NULL) {
- char *pdata = PyBytes_AS_STRING(state);
+ char *pdata = PyString_AS_STRING(state);
memcpy(me->data, pdata, _PyDateTime_TIME_DATASIZE);
me->hashcode = -1;
else
PyOS_snprintf(buffer, sizeof(buffer),
"%s(%d, %d)", type_name, h, m);
- result = PyBytes_FromString(buffer);
+ result = PyString_FromString(buffer);
if (result != NULL && HASTZINFO(self))
result = append_keyword_tzinfo(result, self->tzinfo);
return result;
_PyDateTime_TIME_DATASIZE);
isoformat_time(pdatetime, buf, sizeof(buf));
- result = PyBytes_FromString(buf);
+ result = PyString_FromString(buf);
if (result == NULL || ! HASTZINFO(self) || self->tzinfo == Py_None)
return result;
Py_DECREF(result);
return NULL;
}
- PyBytes_ConcatAndDel(&result, PyBytes_FromString(buf));
+ PyString_ConcatAndDel(&result, PyString_FromString(buf));
return result;
}
/* Reduce this to a hash of another object. */
if (offset == 0)
- temp = PyBytes_FromStringAndSize((char *)self->data,
+ temp = PyString_FromStringAndSize((char *)self->data,
_PyDateTime_TIME_DATASIZE);
else {
int hour;
PyObject *basestate;
PyObject *result = NULL;
- basestate = PyBytes_FromStringAndSize((char *)self->data,
+ basestate = PyString_FromStringAndSize((char *)self->data,
_PyDateTime_TIME_DATASIZE);
if (basestate != NULL) {
if (! HASTZINFO(self) || self->tzinfo == Py_None)
/* Check for invocation from pickle with __getstate__ state */
if (PyTuple_GET_SIZE(args) >= 1 &&
PyTuple_GET_SIZE(args) <= 2 &&
- PyBytes_Check(state = PyTuple_GET_ITEM(args, 0)) &&
- PyBytes_GET_SIZE(state) == _PyDateTime_DATETIME_DATASIZE &&
- MONTH_IS_SANE(PyBytes_AS_STRING(state)[2]))
+ PyString_Check(state = PyTuple_GET_ITEM(args, 0)) &&
+ PyString_GET_SIZE(state) == _PyDateTime_DATETIME_DATASIZE &&
+ MONTH_IS_SANE(PyString_AS_STRING(state)[2]))
{
PyDateTime_DateTime *me;
char aware;
aware = (char)(tzinfo != Py_None);
me = (PyDateTime_DateTime *) (type->tp_alloc(type , aware));
if (me != NULL) {
- char *pdata = PyBytes_AS_STRING(state);
+ char *pdata = PyString_AS_STRING(state);
memcpy(me->data, pdata, _PyDateTime_DATETIME_DATASIZE);
me->hashcode = -1;
GET_YEAR(self), GET_MONTH(self), GET_DAY(self),
DATE_GET_HOUR(self), DATE_GET_MINUTE(self));
}
- baserepr = PyBytes_FromString(buffer);
+ baserepr = PyString_FromString(buffer);
if (baserepr == NULL || ! HASTZINFO(self))
return baserepr;
return append_keyword_tzinfo(baserepr, self->tzinfo);
assert(cp != NULL);
*cp++ = sep;
isoformat_time(self, cp, sizeof(buffer) - (cp - buffer));
- result = PyBytes_FromString(buffer);
+ result = PyString_FromString(buffer);
if (result == NULL || ! HASTZINFO(self))
return result;
Py_DECREF(result);
return NULL;
}
- PyBytes_ConcatAndDel(&result, PyBytes_FromString(buffer));
+ PyString_ConcatAndDel(&result, PyString_FromString(buffer));
return result;
}
/* Reduce this to a hash of another object. */
if (n == OFFSET_NAIVE)
- temp = PyBytes_FromStringAndSize(
+ temp = PyString_FromStringAndSize(
(char *)self->data,
_PyDateTime_DATETIME_DATASIZE);
else {
PyObject *basestate;
PyObject *result = NULL;
- basestate = PyBytes_FromStringAndSize((char *)self->data,
+ basestate = PyString_FromStringAndSize((char *)self->data,
_PyDateTime_DATETIME_DATASIZE);
if (basestate != NULL) {
if (! HASTZINFO(self) || self->tzinfo == Py_None)
drec = dbm_fetch(dp->di_dbm, krec);
if ( drec.dptr == 0 ) {
PyErr_SetString(PyExc_KeyError,
- PyBytes_AS_STRING((PyBytesObject *)key));
+ PyString_AS_STRING((PyStringObject *)key));
return NULL;
}
if ( dbm_error(dp->di_dbm) ) {
PyErr_SetString(DbmError, "");
return NULL;
}
- return PyBytes_FromStringAndSize(drec.dptr, drec.dsize);
+ return PyString_FromStringAndSize(drec.dptr, drec.dsize);
}
static int
if ( dbm_delete(dp->di_dbm, krec) < 0 ) {
dbm_clearerr(dp->di_dbm);
PyErr_SetString(PyExc_KeyError,
- PyBytes_AS_STRING((PyBytesObject *)v));
+ PyString_AS_STRING((PyStringObject *)v));
return -1;
}
} else {
{
datum key, val;
- if (PyBytes_AsStringAndSize(v, (char **)&key.dptr,
+ if (PyString_AsStringAndSize(v, (char **)&key.dptr,
(Py_ssize_t *)&key.dsize)) {
return -1;
}
return NULL;
for (key = dbm_firstkey(dp->di_dbm); key.dptr;
key = dbm_nextkey(dp->di_dbm)) {
- item = PyBytes_FromStringAndSize(key.dptr, key.dsize);
+ item = PyString_FromStringAndSize(key.dptr, key.dsize);
if (item == NULL) {
Py_DECREF(v);
return NULL;
check_dbmobject_open(dp);
val = dbm_fetch(dp->di_dbm, key);
if (val.dptr != NULL)
- return PyBytes_FromStringAndSize(val.dptr, val.dsize);
+ return PyString_FromStringAndSize(val.dptr, val.dsize);
else {
Py_INCREF(defvalue);
return defvalue;
check_dbmobject_open(dp);
val = dbm_fetch(dp->di_dbm, key);
if (val.dptr != NULL)
- return PyBytes_FromStringAndSize(val.dptr, val.dsize);
+ return PyString_FromStringAndSize(val.dptr, val.dsize);
if (defvalue == NULL) {
- defvalue = PyBytes_FromStringAndSize(NULL, 0);
+ defvalue = PyString_FromStringAndSize(NULL, 0);
if (defvalue == NULL)
return NULL;
}
else
Py_INCREF(defvalue);
- val.dptr = PyBytes_AS_STRING(defvalue);
- val.dsize = PyBytes_GET_SIZE(defvalue);
+ val.dptr = PyString_AS_STRING(defvalue);
+ val.dsize = PyString_GET_SIZE(defvalue);
if (dbm_store(dp->di_dbm, key, val, DBM_INSERT) < 0) {
dbm_clearerr(dp->di_dbm);
PyErr_SetString(DbmError, "cannot add item to database");
d = PyModule_GetDict(m);
if (DbmError == NULL)
DbmError = PyErr_NewException("dbm.error", NULL, NULL);
- s = PyBytes_FromString(which_dbm);
+ s = PyString_FromString(which_dbm);
if (s != NULL) {
PyDict_SetItemString(d, "library", s);
Py_DECREF(s);
{
char *name;
PyUnivPtr *func;
- if (PyBytes_Check(args)) {
- name = PyBytes_AS_STRING(args);
+ if (PyString_Check(args)) {
+ name = PyString_AS_STRING(args);
} else {
PyErr_Format(PyExc_TypeError, "expected string, found %.200s",
Py_TYPE(args)->tp_name);
return NULL;
}
name = PyTuple_GetItem(args, 0);
- if (!PyBytes_Check(name)) {
+ if (!PyString_Check(name)) {
PyErr_SetString(PyExc_TypeError,
"function name must be a string");
return NULL;
}
func = (long (*)(long, long, long, long, long,
long, long, long, long, long))
- dlsym(xp->dl_handle, PyBytes_AsString(name));
+ dlsym(xp->dl_handle, PyString_AsString(name));
if (func == NULL) {
PyErr_SetString(PyExc_ValueError, dlerror());
return NULL;
PyObject *v = PyTuple_GetItem(args, i);
if (PyInt_Check(v))
alist[i-1] = PyInt_AsLong(v);
- else if (PyBytes_Check(v))
- alist[i-1] = (long)PyBytes_AsString(v);
+ else if (PyString_Check(v))
+ alist[i-1] = (long)PyString_AsString(v);
else if (v == Py_None)
alist[i-1] = (long) ((char *)NULL);
else {
static void
_inscode(PyObject *d, PyObject *de, char *name, int code)
{
- PyObject *u = PyBytes_FromString(name);
+ PyObject *u = PyString_FromString(name);
PyObject *v = PyInt_FromLong((long) code);
/* Don't bother checking for errors; they'll be caught at the end
PyErr_SetFromErrno(PyExc_IOError);
return NULL;
}
- return PyBytes_FromStringAndSize(buf, len);
+ return PyString_FromStringAndSize(buf, len);
}
PyErr_Clear();
return PyInt_FromLong(ret);
}
else {
- return PyBytes_FromStringAndSize(buf, len);
+ return PyString_FromStringAndSize(buf, len);
}
}
PyErr_SetFromErrno(PyExc_IOError);
return NULL;
}
- return PyBytes_FromStringAndSize(buf, len);
+ return PyString_FromStringAndSize(buf, len);
}
PyErr_Clear();
/* "label" is an exception, getmember only works for char pointers,
not for char arrays */
if (strcmp(name, "label") == 0)
- return PyBytes_FromString(g->ob_generic->label);
+ return PyString_FromString(g->ob_generic->label);
return PyMember_Get((char *)g->ob_generic, generic_memberlist, name);
}
/* "label" is an exception: setmember doesn't set strings;
and FORMS wants you to call a function to set the label */
if (strcmp(name, "label") == 0) {
- if (!PyBytes_Check(v)) {
+ if (!PyString_Check(v)) {
PyErr_SetString(PyExc_TypeError,
"label attr must be string");
return -1;
}
- fl_set_object_label(g->ob_generic, PyBytes_AsString(v));
+ fl_set_object_label(g->ob_generic, PyString_AsString(v));
return 0;
}
char buf[100];
PyOS_snprintf(buf, sizeof(buf), "<FORMS_object at %p, objclass=%d>",
g, g->ob_generic->objclass);
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
static PyTypeObject GenericObjecttype = {
Py_INCREF(Py_None);
return Py_None;
}
- return PyBytes_FromString (str);
+ return PyString_FromString (str);
}
/* int func (object) */
Py_INCREF(Py_None);
return Py_None;
}
- return PyBytes_FromString (str);
+ return PyString_FromString (str);
}
static PyObject *
char buf[100];
PyOS_snprintf(buf, sizeof(buf), "<FORMS_form at %p, window=%ld>",
f, f->ob_form->window);
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
static PyTypeObject Formtype = {
Py_INCREF(Py_None);
return Py_None;
}
- return PyBytes_FromString(str);
+ return PyString_FromString(str);
}
static PyObject *
Py_INCREF(Py_None);
return Py_None;
}
- return PyBytes_FromString(str);
+ return PyString_FromString(str);
}
Py_INCREF(Py_None);
return Py_None;
}
- return PyBytes_FromString(str);
+ return PyString_FromString(str);
}
static PyObject *
PyErr_SetString(PyExc_RuntimeError, "error in fmgetfontname");
return NULL;
}
- return PyBytes_FromStringAndSize(fontname, len);
+ return PyString_FromStringAndSize(fontname, len);
}
static PyObject *
PyErr_SetString(PyExc_RuntimeError, "error in fmgetcomment");
return NULL;
}
- return PyBytes_FromStringAndSize(comment, len);
+ return PyString_FromStringAndSize(comment, len);
}
static PyObject *
PyObject *v;
if (fontlist == NULL)
return;
- v = PyBytes_FromString(fontname);
+ v = PyString_FromString(fontname);
if (v == NULL)
err = -1;
else {
static PyObject *
fm_fontpath(PyObject *self)
{
- return PyBytes_FromString(fmfontpath());
+ return PyString_FromString(fmfontpath());
}
static PyMethodDef fm_methods[] = {
char *cname;
/* simple version of instance_repr */
PyObject *classname = inst->in_class->cl_name;
- if (classname != NULL && PyBytes_Check(classname))
- cname = PyBytes_AsString(classname);
+ if (classname != NULL && PyString_Check(classname))
+ cname = PyString_AsString(classname);
else
cname = "?";
PySys_WriteStderr("gc: %.100s <%.100s instance at %p>\n",
double t1 = 0.0;
if (delstr == NULL) {
- delstr = PyBytes_InternFromString("__del__");
+ delstr = PyString_InternFromString("__del__");
if (delstr == NULL)
Py_FatalError("gc couldn't allocate \"__del__\"");
}
if (PyErr_Occurred()) {
if (gc_str == NULL)
- gc_str = PyBytes_FromString("garbage collection");
+ gc_str = PyString_FromString("garbage collection");
PyErr_WriteUnraisable(gc_str);
Py_FatalError("unexpected exception during garbage collection");
}
drec = gdbm_fetch(dp->di_dbm, krec);
if (drec.dptr == 0) {
PyErr_SetString(PyExc_KeyError,
- PyBytes_AS_STRING((PyBytesObject *)key));
+ PyString_AS_STRING((PyStringObject *)key));
return NULL;
}
- v = PyBytes_FromStringAndSize(drec.dptr, drec.dsize);
+ v = PyString_FromStringAndSize(drec.dptr, drec.dsize);
free(drec.dptr);
return v;
}
if (w == NULL) {
if (gdbm_delete(dp->di_dbm, krec) < 0) {
PyErr_SetString(PyExc_KeyError,
- PyBytes_AS_STRING((PyBytesObject *)v));
+ PyString_AS_STRING((PyStringObject *)v));
return -1;
}
}
"GDBM object has already been closed");
return -1;
}
- if (!PyBytes_Check(arg)) {
+ if (!PyString_Check(arg)) {
PyErr_Format(PyExc_TypeError,
"gdbm key must be string, not %.100s",
arg->ob_type->tp_name);
return -1;
}
- key.dptr = PyBytes_AS_STRING(arg);
- key.dsize = PyBytes_GET_SIZE(arg);
+ key.dptr = PyString_AS_STRING(arg);
+ key.dsize = PyString_GET_SIZE(arg);
return gdbm_exists(dp->di_dbm, key);
}
key = gdbm_firstkey(dp->di_dbm);
while (key.dptr) {
- item = PyBytes_FromStringAndSize(key.dptr, key.dsize);
+ item = PyString_FromStringAndSize(key.dptr, key.dsize);
if (item == NULL) {
free(key.dptr);
Py_DECREF(v);
check_dbmobject_open(dp);
key = gdbm_firstkey(dp->di_dbm);
if (key.dptr) {
- v = PyBytes_FromStringAndSize(key.dptr, key.dsize);
+ v = PyString_FromStringAndSize(key.dptr, key.dsize);
free(key.dptr);
return v;
}
check_dbmobject_open(dp);
nextkey = gdbm_nextkey(dp->di_dbm, key);
if (nextkey.dptr) {
- v = PyBytes_FromStringAndSize(nextkey.dptr, nextkey.dsize);
+ v = PyString_FromStringAndSize(nextkey.dptr, nextkey.dsize);
free(nextkey.dptr);
return v;
}
DbmError = PyErr_NewException("gdbm.error", NULL, NULL);
if (DbmError != NULL) {
PyDict_SetItemString(d, "error", DbmError);
- s = PyBytes_FromString(dbmmodule_open_flags);
+ s = PyString_FromString(dbmmodule_open_flags);
PyDict_SetItemString(d, "open_flags", s);
Py_DECREF(s);
}
#if 0
/* Don't check this, it breaks experiments with pixmode(PM_SIZE, ...) */
pixcount = (long)(x2+1-x1) * (long)(y2+1-y1);
- if (!PyBytes_Check(s) || PyBytes_Size(s) != pixcount*sizeof(long)) {
+ if (!PyString_Check(s) || PyString_Size(s) != pixcount*sizeof(long)) {
PyErr_SetString(PyExc_RuntimeError,
"string arg to lrectwrite has wrong size");
return NULL;
if (!PyArg_GetShort(args, 4, 3, &y2))
return NULL;
pixcount = (long)(x2+1-x1) * (long)(y2+1-y1);
- parray = PyBytes_FromStringAndSize((char *)NULL, pixcount*sizeof(long));
+ parray = PyString_FromStringAndSize((char *)NULL, pixcount*sizeof(long));
if (parray == NULL)
return NULL; /* No memory */
- lrectread(x1, y1, x2, y2, (unsigned long *) PyBytes_AsString(parray));
+ lrectread(x1, y1, x2, y2, (unsigned long *) PyString_AsString(parray));
return parray;
}
if ( !PyArg_Parse(args, "hhhhl", &x1, &y1, &x2, &y2, &hints) )
return 0;
size = (long)(x2+1-x1) * (long)(y2+1-y1);
- rv = PyBytes_FromStringAndSize((char *)NULL, size*sizeof(long));
+ rv = PyString_FromStringAndSize((char *)NULL, size*sizeof(long));
if ( rv == NULL )
return NULL;
- parray = (unsigned long *)PyBytes_AsString(rv);
+ parray = (unsigned long *)PyString_AsString(rv);
size_ret = readdisplay(x1, y1, x2, y2, parray, hints);
if ( size_ret != size ) {
printf("gl_readdisplay: got %ld pixels, expected %ld\n",
pixcount = width*height;
packedcount = ((width+packfactor-1)/packfactor) *
((height+packfactor-1)/packfactor);
- if (PyBytes_Size(unpacked) != pixcount*sizeof(long)) {
+ if (PyString_Size(unpacked) != pixcount*sizeof(long)) {
PyErr_SetString(PyExc_RuntimeError,
"string arg to packrect has wrong size");
return NULL;
}
- packed = PyBytes_FromStringAndSize((char *)NULL, packedcount);
+ packed = PyString_FromStringAndSize((char *)NULL, packedcount);
if (packed == NULL)
return NULL;
- parray = (unsigned long *) PyBytes_AsString(unpacked);
- p = (unsigned char *) PyBytes_AsString(packed);
+ parray = (unsigned long *) PyString_AsString(unpacked);
+ p = (unsigned char *) PyString_AsString(packed);
for (y = 0; y < height; y += packfactor, parray += packfactor*width) {
for (x = 0; x < width; x += packfactor) {
pixel = parray[x];
pixcount = width*height;
packedcount = ((width+packfactor-1)/packfactor) *
((height+packfactor-1)/packfactor);
- if (PyBytes_Size(packed) != packedcount) {
+ if (PyString_Size(packed) != packedcount) {
PyErr_SetString(PyExc_RuntimeError,
"string arg to unpackrect has wrong size");
return NULL;
}
- unpacked = PyBytes_FromStringAndSize((char *)NULL, pixcount*sizeof(long));
+ unpacked = PyString_FromStringAndSize((char *)NULL, pixcount*sizeof(long));
if (unpacked == NULL)
return NULL;
- parray = (unsigned long *) PyBytes_AsString(unpacked);
- p = (unsigned char *) PyBytes_AsString(packed);
+ parray = (unsigned long *) PyString_AsString(unpacked);
+ p = (unsigned char *) PyString_AsString(packed);
if (packfactor == 1 && width*height > 0) {
/* Just expand bytes to longs */
register int x = width * height;
{
char buf[20];
gversion(buf);
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
return NULL;
}
for (member = p->gr_mem; *member != NULL; member++) {
- PyObject *x = PyBytes_FromString(*member);
+ PyObject *x = PyString_FromString(*member);
if (x == NULL || PyList_Append(w, x) != 0) {
Py_XDECREF(x);
Py_DECREF(w);
}
#define SET(i,val) PyStructSequence_SET_ITEM(v, i, val)
- SET(setIndex++, PyBytes_FromString(p->gr_name));
+ SET(setIndex++, PyString_FromString(p->gr_name));
#ifdef __VMS
SET(setIndex++, Py_None);
Py_INCREF(Py_None);
#else
if (p->gr_passwd)
- SET(setIndex++, PyBytes_FromString(p->gr_passwd));
+ SET(setIndex++, PyString_FromString(p->gr_passwd));
else {
SET(setIndex++, Py_None);
Py_INCREF(Py_None);
py_str_name = PyObject_Str(pyo_name);
if (!py_str_name)
return NULL;
- name = PyBytes_AS_STRING(py_str_name);
+ name = PyString_AS_STRING(py_str_name);
if ((p = getgrnam(name)) == NULL) {
PyErr_Format(PyExc_KeyError, "getgrnam(): name not found: %s", name);
return 1;
if (bcos == NULL) {
/* cache string object for future use */
- bcos = PyBytes_FromString("backward_compatible");
+ bcos = PyString_FromString("backward_compatible");
if (bcos == NULL)
return 1;
}
xstep = (newx1 < newx2)? 1 : -1;
ystep = (newy1 < newy2)? 1 : -1;
- rv = PyBytes_FromStringAndSize(NULL,
+ rv = PyString_FromStringAndSize(NULL,
(abs(newx2-newx1)+1)*(abs(newy2-newy1)+1)*size);
if ( rv == 0 )
return 0;
- ncp = (char *)PyBytes_AsString(rv);
+ ncp = (char *)PyString_AsString(rv);
nsp = (short *)ncp;
nlp = (Py_Int32 *)ncp;
newy2 += ystep;
return 0;
}
- rv = PyBytes_FromStringAndSize(NULL, newx*newy*size);
+ rv = PyString_FromStringAndSize(NULL, newx*newy*size);
if ( rv == 0 )
return 0;
- ncp = (char *)PyBytes_AsString(rv);
+ ncp = (char *)PyString_AsString(rv);
nsp = (short *)ncp;
nlp = (Py_Int32 *)ncp;
for( iy = 0; iy < newy; iy++ ) {
return 0;
}
- rv = PyBytes_FromStringAndSize(NULL, len);
+ rv = PyString_FromStringAndSize(NULL, len);
if ( rv == 0 )
return 0;
- ncp = (unsigned char *)PyBytes_AsString(rv);
+ ncp = (unsigned char *)PyString_AsString(rv);
if ( width == 1 ) {
memcpy(ncp, cp, maxx); /* Copy first line */
return 0;
}
- rv = PyBytes_FromStringAndSize(NULL, (len+7)/8);
+ rv = PyString_FromStringAndSize(NULL, (len+7)/8);
if ( rv == 0 )
return 0;
- ncp = (unsigned char *)PyBytes_AsString(rv);
+ ncp = (unsigned char *)PyString_AsString(rv);
bit = 0x80;
ovalue = 0;
return 0;
}
- rv = PyBytes_FromStringAndSize(NULL, (len+1)/2);
+ rv = PyString_FromStringAndSize(NULL, (len+1)/2);
if ( rv == 0 )
return 0;
- ncp = (unsigned char *)PyBytes_AsString(rv);
+ ncp = (unsigned char *)PyString_AsString(rv);
pos = 0;
ovalue = 0;
for ( i=0; i < len; i++ ) {
return 0;
}
- rv = PyBytes_FromStringAndSize(NULL, (len+3)/4);
+ rv = PyString_FromStringAndSize(NULL, (len+3)/4);
if ( rv == 0 )
return 0;
- ncp = (unsigned char *)PyBytes_AsString(rv);
+ ncp = (unsigned char *)PyString_AsString(rv);
pos = 0;
ovalue = 0;
for ( i=0; i < len; i++ ) {
return 0;
}
- rv = PyBytes_FromStringAndSize(NULL, (len+7)/8);
+ rv = PyString_FromStringAndSize(NULL, (len+7)/8);
if ( rv == 0 )
return 0;
- ncp = (unsigned char *)PyBytes_AsString(rv);
+ ncp = (unsigned char *)PyString_AsString(rv);
bit = 0x80;
ovalue = 0;
return 0;
}
- rv = PyBytes_FromStringAndSize(NULL, (len+3)/4);
+ rv = PyString_FromStringAndSize(NULL, (len+3)/4);
if ( rv == 0 )
return 0;
- ncp = (unsigned char *)PyBytes_AsString(rv);
+ ncp = (unsigned char *)PyString_AsString(rv);
pos = 1;
ovalue = 0;
for ( i=0; i < len; i++ ) {
return 0;
}
- rv = PyBytes_FromStringAndSize(NULL, nlen);
+ rv = PyString_FromStringAndSize(NULL, nlen);
if ( rv == 0 )
return 0;
- ncp = (unsigned char *)PyBytes_AsString(rv);
+ ncp = (unsigned char *)PyString_AsString(rv);
bit = 0x80;
for ( i=0; i < nlen; i++ ) {
return 0;
}
- rv = PyBytes_FromStringAndSize(NULL, nlen);
+ rv = PyString_FromStringAndSize(NULL, nlen);
if ( rv == 0 )
return 0;
- ncp = (unsigned char *)PyBytes_AsString(rv);
+ ncp = (unsigned char *)PyString_AsString(rv);
pos = 0;
for ( i=0; i < nlen; i++ ) {
return 0;
}
- rv = PyBytes_FromStringAndSize(NULL, nlen);
+ rv = PyString_FromStringAndSize(NULL, nlen);
if ( rv == 0 )
return 0;
- ncp = (unsigned char *)PyBytes_AsString(rv);
+ ncp = (unsigned char *)PyString_AsString(rv);
pos = 0;
for ( i=0; i < nlen; i++ ) {
return 0;
}
- rv = PyBytes_FromStringAndSize(NULL, nlen);
+ rv = PyString_FromStringAndSize(NULL, nlen);
if ( rv == 0 )
return 0;
- ncp = (unsigned char *)PyBytes_AsString(rv);
+ ncp = (unsigned char *)PyString_AsString(rv);
for ( i=0; i < nlen; i++ ) {
/* Bits in source: aaaaaaaa BBbbbbbb GGGggggg RRRrrrrr */
return 0;
}
- rv = PyBytes_FromStringAndSize(NULL, nlen*4);
+ rv = PyString_FromStringAndSize(NULL, nlen*4);
if ( rv == 0 )
return 0;
- ncp = (unsigned char *)PyBytes_AsString(rv);
+ ncp = (unsigned char *)PyString_AsString(rv);
for ( i=0; i < nlen; i++ ) {
/* Bits in source: RRRBBGGG
return 0;
}
- rv = PyBytes_FromStringAndSize(NULL, nlen);
+ rv = PyString_FromStringAndSize(NULL, nlen);
if ( rv == 0 )
return 0;
- ncp = (unsigned char *)PyBytes_AsString(rv);
+ ncp = (unsigned char *)PyString_AsString(rv);
for ( i=0; i < nlen; i++ ) {
if (backward_compatible) {
return 0;
}
- rv = PyBytes_FromStringAndSize(NULL, nlen*4);
+ rv = PyString_FromStringAndSize(NULL, nlen*4);
if ( rv == 0 )
return 0;
- ncp = (unsigned char *)PyBytes_AsString(rv);
+ ncp = (unsigned char *)PyString_AsString(rv);
for ( i=0; i < nlen; i++ ) {
value = *cp++;
}
if ( zsize == 3 ) zsize = 4;
- rv = PyBytes_FromStringAndSize((char *)NULL, xsize*ysize*zsize);
+ rv = PyString_FromStringAndSize((char *)NULL, xsize*ysize*zsize);
if ( rv == NULL ) {
iclose(image);
return NULL;
}
- cdatap = PyBytes_AsString(rv);
+ cdatap = PyString_AsString(rv);
idatap = (long *)cdatap;
if (top_to_bottom) {
}
if ( zsize == 3 ) zsize = 4;
- rv = PyBytes_FromStringAndSize(NULL, xwtd*ywtd*zsize);
+ rv = PyString_FromStringAndSize(NULL, xwtd*ywtd*zsize);
if ( rv == NULL ) {
iclose(image);
return NULL;
xfac = (float)xsize/(float)xwtd;
yfac = (float)ysize/(float)ywtd;
PyFPE_END_PROTECT(yfac)
- cdatap = PyBytes_AsString(rv);
+ cdatap = PyString_AsString(rv);
idatap = (long *)cdatap;
if ( extended ) {
PyObject *result;
if (lz->cnt != PY_SSIZE_T_MAX)
- return PyBytes_FromFormat("count(%zd)", lz->cnt);
+ return PyString_FromFormat("count(%zd)", lz->cnt);
cnt_repr = PyObject_Repr(lz->long_cnt);
if (cnt_repr == NULL)
return NULL;
- result = PyBytes_FromFormat("count(%s)", PyBytes_AS_STRING(cnt_repr));
+ result = PyString_FromFormat("count(%s)", PyString_AS_STRING(cnt_repr));
Py_DECREF(cnt_repr);
return result;
}
return NULL;
if (ro->cnt == -1)
- result = PyBytes_FromFormat("repeat(%s)",
- PyBytes_AS_STRING(objrepr));
+ result = PyString_FromFormat("repeat(%s)",
+ PyString_AS_STRING(objrepr));
else
- result = PyBytes_FromFormat("repeat(%s, %zd)",
- PyBytes_AS_STRING(objrepr), ro->cnt);
+ result = PyString_FromFormat("repeat(%s, %zd)",
+ PyString_AS_STRING(objrepr), ro->cnt);
Py_DECREF(objrepr);
return result;
}
if (!PyArg_ParseTuple(args, "i:read", &size))
return NULL;
- rv = PyBytes_FromStringAndSize(NULL, size);
+ rv = PyString_FromStringAndSize(NULL, size);
if (rv == NULL)
return NULL;
- cp = PyBytes_AS_STRING(rv);
+ cp = PyString_AS_STRING(rv);
if ((count = read(self->x_fd, cp, size)) < 0) {
PyErr_SetFromErrno(LinuxAudioError);
Py_DECREF(rv);
return NULL;
}
self->x_icount += count;
- _PyBytes_Resize(&rv, count);
+ _PyString_Resize(&rv, count);
return rv;
}
{
PyObject *argv0 = NULL, *importer = NULL;
- if ((argv0 = PyBytes_FromString(filename)) &&
+ if ((argv0 = PyString_FromString(filename)) &&
(importer = PyImport_GetImporter(argv0)) &&
(importer->ob_type != &PyNullImporter_Type))
{
mdContext = self->md5;
md5_finish(&mdContext, aDigest);
- return PyBytes_FromStringAndSize((char *)aDigest, 16);
+ return PyString_FromStringAndSize((char *)aDigest, 16);
}
PyDoc_STRVAR(digest_doc,
c = (c>9) ? c+'a'-10 : c + '0';
hexdigest[j++] = c;
}
- return PyBytes_FromStringAndSize((char*)hexdigest, 32);
+ return PyString_FromStringAndSize((char*)hexdigest, 32);
}
static PyObject *
md5_get_name(PyObject *self, void *closure)
{
- return PyBytes_FromStringAndSize("MD5", 3);
+ return PyString_FromStringAndSize("MD5", 3);
}
static PyGetSetDef md5_getseters[] = {
else
++eol; /* we're interested in the position after the
newline. */
- result = PyBytes_FromStringAndSize(start, (eol - start));
+ result = PyString_FromStringAndSize(start, (eol - start));
self->pos += (eol - start);
return result;
}
PyErr_SetString(PyExc_IndexError, "mmap index out of range");
return NULL;
}
- return PyBytes_FromStringAndSize(self->data + i, 1);
+ return PyString_FromStringAndSize(self->data + i, 1);
}
static PyObject *
else if ((size_t)ihigh > self->size)
ihigh = self->size;
- return PyBytes_FromStringAndSize(self->data + ilow, ihigh-ilow);
+ return PyString_FromStringAndSize(self->data + ilow, ihigh-ilow);
}
static PyObject *
"mmap index out of range");
return NULL;
}
- return PyBytes_FromStringAndSize(self->data + i, 1);
+ return PyString_FromStringAndSize(self->data + i, 1);
}
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelen;
}
if (slicelen <= 0)
- return PyBytes_FromStringAndSize("", 0);
+ return PyString_FromStringAndSize("", 0);
else if (step == 1)
- return PyBytes_FromStringAndSize(self->data + start,
+ return PyString_FromStringAndSize(self->data + start,
slicelen);
else {
char *result_buf = (char *)PyMem_Malloc(slicelen);
cur += step, i++) {
result_buf[i] = self->data[cur];
}
- result = PyBytes_FromStringAndSize(result_buf,
+ result = PyString_FromStringAndSize(result_buf,
slicelen);
PyMem_Free(result_buf);
return result;
"mmap object doesn't support slice deletion");
return -1;
}
- if (! (PyBytes_Check(v)) ) {
+ if (! (PyString_Check(v)) ) {
PyErr_SetString(PyExc_IndexError,
"mmap slice assignment must be a string");
return -1;
}
- if (PyBytes_Size(v) != (ihigh - ilow)) {
+ if (PyString_Size(v) != (ihigh - ilow)) {
PyErr_SetString(PyExc_IndexError,
"mmap slice assignment is wrong size");
return -1;
}
if (!is_writeable(self))
return -1;
- buf = PyBytes_AsString(v);
+ buf = PyString_AsString(v);
memcpy(self->data + ilow, buf, ihigh-ilow);
return 0;
}
"mmap object doesn't support item deletion");
return -1;
}
- if (! (PyBytes_Check(v) && PyBytes_Size(v)==1) ) {
+ if (! (PyString_Check(v) && PyString_Size(v)==1) ) {
PyErr_SetString(PyExc_IndexError,
"mmap assignment must be single-character string");
return -1;
}
if (!is_writeable(self))
return -1;
- buf = PyBytes_AsString(v);
+ buf = PyString_AsString(v);
self->data[i] = buf[0];
return 0;
}
"mmap object doesn't support item deletion");
return -1;
}
- if (!PyBytes_Check(value) || PyBytes_Size(value) != 1) {
+ if (!PyString_Check(value) || PyString_Size(value) != 1) {
PyErr_SetString(PyExc_IndexError,
"mmap assignment must be single-character string");
return -1;
}
if (!is_writeable(self))
return -1;
- buf = PyBytes_AsString(value);
+ buf = PyString_AsString(value);
self->data[i] = buf[0];
return 0;
}
"mmap object doesn't support slice deletion");
return -1;
}
- if (!PyBytes_Check(value)) {
+ if (!PyString_Check(value)) {
PyErr_SetString(PyExc_IndexError,
"mmap slice assignment must be a string");
return -1;
}
- if (PyBytes_Size(value) != slicelen) {
+ if (PyString_Size(value) != slicelen) {
PyErr_SetString(PyExc_IndexError,
"mmap slice assignment is wrong size");
return -1;
if (slicelen == 0)
return 0;
else if (step == 1) {
- const char *buf = PyBytes_AsString(value);
+ const char *buf = PyString_AsString(value);
if (buf == NULL)
return -1;
}
else {
Py_ssize_t cur, i;
- const char *buf = PyBytes_AsString(value);
+ const char *buf = PyString_AsString(value);
if (buf == NULL)
return -1;
if (invallen > 0 && inval[invallen-1] == '\0')
invallen--;
}
- key = PyBytes_FromStringAndSize(inkey, inkeylen);
- val = PyBytes_FromStringAndSize(inval, invallen);
+ key = PyString_FromStringAndSize(inkey, inkeylen);
+ val = PyString_FromStringAndSize(inval, invallen);
if (key == NULL || val == NULL) {
/* XXX error -- don't know how to handle */
PyErr_Clear();
if ((err = yp_get_default_domain(&domain)) != 0)
return nis_error(err);
- res = PyBytes_FromStringAndSize (domain, strlen(domain));
+ res = PyString_FromStringAndSize (domain, strlen(domain));
return res;
}
len--;
if (err != 0)
return nis_error(err);
- res = PyBytes_FromStringAndSize (match, len);
+ res = PyString_FromStringAndSize (match, len);
free (match);
return res;
}
if ((list = PyList_New(0)) == NULL)
return NULL;
for (maps = maps; maps; maps = maps->next) {
- PyObject *str = PyBytes_FromString(maps->map);
+ PyObject *str = PyString_FromString(maps->map);
if (!str || PyList_Append(list, str) < 0)
{
Py_DECREF(list);
}
#endif
- if (!PyBytes_Check(attr)) {
+ if (!PyString_Check(attr)) {
PyErr_SetString(PyExc_TypeError,
"attribute name must be a string");
return NULL;
}
- s = PyBytes_AS_STRING(attr);
+ s = PyString_AS_STRING(attr);
Py_INCREF(obj);
for (;;) {
PyObject *newobj, *str;
p = strchr(s, '.');
- str = p ? PyBytes_FromStringAndSize(s, (p-s)) :
- PyBytes_FromString(s);
+ str = p ? PyString_FromStringAndSize(s, (p-s)) :
+ PyString_FromString(s);
if (str == NULL) {
Py_DECREF(obj);
return NULL;
if (!PyArg_ParseTuple(args, "i:read", &size))
return NULL;
- rv = PyBytes_FromStringAndSize(NULL, size);
+ rv = PyString_FromStringAndSize(NULL, size);
if (rv == NULL)
return NULL;
- cp = PyBytes_AS_STRING(rv);
+ cp = PyString_AS_STRING(rv);
Py_BEGIN_ALLOW_THREADS
count = read(self->fd, cp, size);
return NULL;
}
self->icount += count;
- _PyBytes_Resize(&rv, count);
+ _PyString_Resize(&rv, count);
return rv;
}
Py_INCREF(rval);
}
else if (strcmp(name, "name") == 0) {
- rval = PyBytes_FromString(self->devicename);
+ rval = PyString_FromString(self->devicename);
}
else if (strcmp(name, "mode") == 0) {
/* No need for a "default" in this switch: from newossobject(),
self->mode can only be one of these three values. */
switch(self->mode) {
case O_RDONLY:
- rval = PyBytes_FromString("r");
+ rval = PyString_FromString("r");
break;
case O_RDWR:
- rval = PyBytes_FromString("rw");
+ rval = PyString_FromString("rw");
break;
case O_WRONLY:
- rval = PyBytes_FromString("w");
+ rval = PyString_FromString("w");
break;
}
}
if (labels == NULL || names == NULL)
goto error2;
for (i = 0; i < num_controls; i++) {
- s = PyBytes_FromString(control_labels[i]);
+ s = PyString_FromString(control_labels[i]);
if (s == NULL)
goto error2;
PyList_SET_ITEM(labels, i, s);
- s = PyBytes_FromString(control_names[i]);
+ s = PyString_FromString(control_names[i]);
if (s == NULL)
goto error2;
PyList_SET_ITEM(names, i, s);
}
if (TYPE(n) == encoding_decl)
- (void) addelem(v, i+1, PyBytes_FromString(STR(n)));
+ (void) addelem(v, i+1, PyString_FromString(STR(n)));
return (v);
}
else if (ISTERMINAL(TYPE(n))) {
PyObject *result = mkseq(2 + lineno + col_offset);
if (result != NULL) {
(void) addelem(result, 0, PyInt_FromLong(TYPE(n)));
- (void) addelem(result, 1, PyBytes_FromString(STR(n)));
+ (void) addelem(result, 1, PyString_FromString(STR(n)));
if (lineno == 1)
(void) addelem(result, 2, PyInt_FromLong(n->n_lineno));
if (col_offset == 1)
temp = PySequence_GetItem(elem, 1);
if (temp == NULL)
return 0;
- if (!PyBytes_Check(temp)) {
+ if (!PyString_Check(temp)) {
PyErr_Format(parser_error,
"second item in terminal node must be a string,"
" found %s",
Py_DECREF(o);
}
}
- len = PyBytes_GET_SIZE(temp) + 1;
+ len = PyString_GET_SIZE(temp) + 1;
strn = (char *)PyObject_MALLOC(len);
if (strn != NULL)
- (void) memcpy(strn, PyBytes_AS_STRING(temp), len);
+ (void) memcpy(strn, PyString_AS_STRING(temp), len);
Py_DECREF(temp);
}
else if (!ISNONTERMINAL(type)) {
}
if (res && encoding) {
Py_ssize_t len;
- len = PyBytes_GET_SIZE(encoding) + 1;
+ len = PyString_GET_SIZE(encoding) + 1;
res->n_str = (char *)PyObject_MALLOC(len);
if (res->n_str != NULL)
- (void) memcpy(res->n_str, PyBytes_AS_STRING(encoding), len);
+ (void) memcpy(res->n_str, PyString_AS_STRING(encoding), len);
Py_DECREF(encoding);
Py_DECREF(tuple);
}
char *p = strchr(*e, '=');
if (p == NULL)
continue;
- k = PyBytes_FromStringAndSize(*e, (int)(p-*e));
+ k = PyString_FromStringAndSize(*e, (int)(p-*e));
if (k == NULL) {
PyErr_Clear();
continue;
}
- v = PyBytes_FromString(p+1);
+ v = PyString_FromString(p+1);
if (v == NULL) {
PyErr_Clear();
Py_DECREF(k);
rc = DosQueryExtLIBPATH(buffer, BEGIN_LIBPATH);
if (rc == NO_ERROR) { /* (not a type, envname is NOT 'BEGIN_LIBPATH') */
- PyObject *v = PyBytes_FromString(buffer);
+ PyObject *v = PyString_FromString(buffer);
PyDict_SetItemString(d, "BEGINLIBPATH", v);
Py_DECREF(v);
}
rc = DosQueryExtLIBPATH(buffer, END_LIBPATH);
if (rc == NO_ERROR) { /* (not a typo, envname is NOT 'END_LIBPATH') */
- PyObject *v = PyBytes_FromString(buffer);
+ PyObject *v = PyString_FromString(buffer);
PyDict_SetItemString(d, "ENDLIBPATH", v);
Py_DECREF(v);
}
#endif
if (ret == NULL)
return posix_error();
- return PyBytes_FromString(ret);
+ return PyString_FromString(ret);
}
#endif
#endif
if (ret == NULL)
return posix_error();
- return PyBytes_FromString(buffer);
+ return PyString_FromString(buffer);
}
#endif
Py_END_ALLOW_THREADS
if (res == NULL)
return posix_error();
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
#ifdef Py_USING_UNICODE
/* Skip over . and .. */
if (strcmp(FileData.cFileName, ".") != 0 &&
strcmp(FileData.cFileName, "..") != 0) {
- v = PyBytes_FromString(FileData.cFileName);
+ v = PyString_FromString(FileData.cFileName);
if (v == NULL) {
Py_DECREF(d);
d = NULL;
/* Leave Case of Name Alone -- In Native Form */
/* (Removed Forced Lowercasing Code) */
- v = PyBytes_FromString(namebuf);
+ v = PyString_FromString(namebuf);
if (v == NULL) {
Py_DECREF(d);
d = NULL;
(NAMLEN(ep) == 1 ||
(ep->d_name[1] == '.' && NAMLEN(ep) == 2)))
continue;
- v = PyBytes_FromStringAndSize(ep->d_name, NAMLEN(ep));
+ v = PyString_FromStringAndSize(ep->d_name, NAMLEN(ep));
if (v == NULL) {
Py_DECREF(d);
d = NULL;
return PyUnicode_Decode(outbuf, strlen(outbuf),
Py_FileSystemDefaultEncoding, NULL);
}
- return PyBytes_FromString(outbuf);
+ return PyString_FromString(outbuf);
} /* end of posix__getfullpathname */
#endif /* MS_WINDOWS */
/* Omit Pseudo-Env Vars that Would Confuse Programs if Passed On */
if (stricmp(k, "BEGINLIBPATH") != 0 && stricmp(k, "ENDLIBPATH") != 0) {
#endif
- len = PyBytes_Size(key) + PyBytes_Size(val) + 2;
+ len = PyString_Size(key) + PyString_Size(val) + 2;
p = PyMem_NEW(char, len);
if (p == NULL) {
PyErr_NoMemory();
{
goto fail_2;
}
- len = PyBytes_Size(key) + PyBytes_Size(val) + 2;
+ len = PyString_Size(key) + PyString_Size(val) + 2;
p = PyMem_NEW(char, len);
if (p == NULL) {
PyErr_NoMemory();
{
goto fail_2;
}
- len = PyBytes_Size(key) + PyBytes_Size(val) + 2;
+ len = PyString_Size(key) + PyString_Size(val) + 2;
p = PyMem_NEW(char, len);
if (p == NULL) {
PyErr_NoMemory();
"unable to determine login name");
}
else
- result = PyBytes_FromString(name);
+ result = PyString_FromString(name);
errno = old_errno;
return result;
return posix_error_with_allocated_filename(path);
PyMem_Free(path);
- v = PyBytes_FromStringAndSize(buf, n);
+ v = PyString_FromStringAndSize(buf, n);
#ifdef Py_USING_UNICODE
if (arg_is_unicode) {
PyObject *w;
errno = EINVAL;
return posix_error();
}
- buffer = PyBytes_FromStringAndSize((char *)NULL, size);
+ buffer = PyString_FromStringAndSize((char *)NULL, size);
if (buffer == NULL)
return NULL;
Py_BEGIN_ALLOW_THREADS
- n = read(fd, PyBytes_AsString(buffer), size);
+ n = read(fd, PyString_AsString(buffer), size);
Py_END_ALLOW_THREADS
if (n < 0) {
Py_DECREF(buffer);
return posix_error();
}
if (n != size)
- _PyBytes_Resize(&buffer, n);
+ _PyString_Resize(&buffer, n);
return buffer;
}
/* XXX This can leak memory -- not easy to fix :-( */
len = strlen(s1) + strlen(s2) + 2;
/* len includes space for a trailing \0; the size arg to
- PyBytes_FromStringAndSize does not count that */
- newstr = PyBytes_FromStringAndSize(NULL, (int)len - 1);
+ PyString_FromStringAndSize does not count that */
+ newstr = PyString_FromStringAndSize(NULL, (int)len - 1);
if (newstr == NULL)
return PyErr_NoMemory();
- newenv = PyBytes_AS_STRING(newstr);
+ newenv = PyString_AS_STRING(newstr);
PyOS_snprintf(newenv, len, "%s=%s", s1, s2);
if (putenv(newenv)) {
Py_DECREF(newstr);
"strerror() argument out of range");
return NULL;
}
- return PyBytes_FromString(message);
+ return PyString_FromString(message);
}
#endif
if (name == NULL)
return PyErr_NoMemory();
- result = PyBytes_FromString(name);
+ result = PyString_FromString(name);
free(name);
return result;
}
Py_XDECREF(err);
return NULL;
}
- return PyBytes_FromString(buffer);
+ return PyString_FromString(buffer);
}
#endif
*valuep = PyInt_AS_LONG(arg);
return 1;
}
- if (PyBytes_Check(arg)) {
+ if (PyString_Check(arg)) {
/* look up the value in the table using a binary search */
size_t lo = 0;
size_t mid;
size_t hi = tablesize;
int cmp;
- char *confname = PyBytes_AS_STRING(arg);
+ char *confname = PyString_AS_STRING(arg);
while (lo < hi) {
mid = (lo + hi) / 2;
cmp = strcmp(confname, table[mid].name);
}
else {
if ((unsigned int)len >= sizeof(buffer)) {
- result = PyBytes_FromStringAndSize(NULL, len-1);
+ result = PyString_FromStringAndSize(NULL, len-1);
if (result != NULL)
- confstr(name, PyBytes_AS_STRING(result), len);
+ confstr(name, PyString_AS_STRING(result), len);
}
else
- result = PyBytes_FromStringAndSize(buffer, len-1);
+ result = PyString_FromStringAndSize(buffer, len-1);
}
}
return result;
}
/* Allocate bytes */
- result = PyBytes_FromStringAndSize(NULL, howMany);
+ result = PyString_FromStringAndSize(NULL, howMany);
if (result != NULL) {
/* Get random data */
if (! pCryptGenRandom(hCryptProv, howMany, (unsigned char*)
- PyBytes_AS_STRING(result))) {
+ PyString_AS_STRING(result))) {
Py_DECREF(result);
return win32_error("CryptGenRandom", NULL);
}
"negative argument not allowed");
/* Allocate bytes */
- result = PyBytes_FromStringAndSize(NULL, howMany);
+ result = PyString_FromStringAndSize(NULL, howMany);
if (result != NULL) {
/* Get random data */
if (RAND_pseudo_bytes((unsigned char*)
- PyBytes_AS_STRING(result),
+ PyString_AS_STRING(result),
howMany) < 0) {
Py_DECREF(result);
return PyErr_Format(PyExc_ValueError,
sets(PyObject *v, int i, char* val)
{
if (val)
- PyStructSequence_SET_ITEM(v, i, PyBytes_FromString(val));
+ PyStructSequence_SET_ITEM(v, i, PyString_FromString(val));
else {
PyStructSequence_SET_ITEM(v, i, Py_None);
Py_INCREF(Py_None);
{
PyObject *name = hinfo->nameobj;
if (name == NULL) {
- name = PyBytes_FromString(hinfo->name);
+ name = PyString_FromString(hinfo->name);
hinfo->nameobj = name;
}
Py_XINCREF(name);
Py_INCREF(Py_None);
return Py_None;
}
- return PyBytes_FromString(str);
+ return PyString_FromString(str);
}
static PyObject *
Py_INCREF(Py_None);
return Py_None;
}
- return PyBytes_FromStringAndSize((const char *)str, len);
+ return PyString_FromStringAndSize((const char *)str, len);
}
/* Callback routines */
PyObject *filename = NULL;
if (handler_info[slot].tb_code == NULL) {
- code = PyBytes_FromString("");
+ code = PyString_FromString("");
if (code == NULL)
goto failed;
- name = PyBytes_FromString(func_name);
+ name = PyString_FromString(func_name);
if (name == NULL)
goto failed;
nulltuple = PyTuple_New(0);
if (nulltuple == NULL)
goto failed;
- filename = PyBytes_FromString(__FILE__);
+ filename = PyString_FromString(__FILE__);
handler_info[slot].tb_code =
PyCode_New(0, /* argcount */
0, /* nlocals */
goto finally;
/* XXX what to do if it returns a Unicode string? */
- if (!PyBytes_Check(str)) {
+ if (!PyString_Check(str)) {
PyErr_Format(PyExc_TypeError,
"read() did not return a string object (type=%.400s)",
Py_TYPE(str)->tp_name);
goto finally;
}
- len = PyBytes_GET_SIZE(str);
+ len = PyString_GET_SIZE(str);
if (len > buf_size) {
PyErr_Format(PyExc_ValueError,
"read() returned too much data: "
buf_size, len);
goto finally;
}
- memcpy(buf, PyBytes_AsString(str), len);
+ memcpy(buf, PyString_AsString(str), len);
finally:
Py_XDECREF(arg);
Py_XDECREF(str);
= XML_GetInputContext(self->itself, &offset, &size);
if (buffer != NULL)
- return PyBytes_FromStringAndSize(buffer + offset,
+ return PyString_FromStringAndSize(buffer + offset,
size - offset);
else
Py_RETURN_NONE;
#define APPEND(list, str) \
do { \
- PyObject *o = PyBytes_FromString(str); \
+ PyObject *o = PyString_FromString(str); \
if (o != NULL) \
PyList_Append(list, o); \
Py_XDECREF(o); \
while (rev[i] != ' ' && rev[i] != '\0')
++i;
- return PyBytes_FromStringAndSize(rev, i);
+ return PyString_FromStringAndSize(rev, i);
}
/* Initialization function for the module */
MODULE_INITFUNC(void)
{
PyObject *m, *d;
- PyObject *errmod_name = PyBytes_FromString(MODULE_NAME ".errors");
+ PyObject *errmod_name = PyString_FromString(MODULE_NAME ".errors");
PyObject *errors_module;
PyObject *modelmod_name;
PyObject *model_module;
if (errmod_name == NULL)
return;
- modelmod_name = PyBytes_FromString(MODULE_NAME ".model");
+ modelmod_name = PyString_FromString(MODULE_NAME ".model");
if (modelmod_name == NULL)
return;
static PyObject *
get_completer_delims(PyObject *self, PyObject *noarg)
{
- return PyBytes_FromString(rl_completer_word_break_characters);
+ return PyString_FromString(rl_completer_word_break_characters);
}
PyDoc_STRVAR(doc_get_completer_delims,
if (!PyArg_ParseTuple(args, "i:index", &idx))
return NULL;
if ((hist_ent = history_get(idx)))
- return PyBytes_FromString(hist_ent->line);
+ return PyString_FromString(hist_ent->line);
else {
Py_RETURN_NONE;
}
static PyObject *
get_line_buffer(PyObject *self, PyObject *noarg)
{
- return PyBytes_FromString(rl_line_buffer);
+ return PyString_FromString(rl_line_buffer);
}
PyDoc_STRVAR(doc_get_line_buffer,
if (m == NULL)
goto error;
for (i = 0; i < num_matches; i++) {
- s = PyBytes_FromString(matches[i+1]);
+ s = PyString_FromString(matches[i+1]);
if (s == NULL)
goto error;
if (PyList_SetItem(m, i, s) == -1)
result = NULL;
}
else {
- char *s = PyBytes_AsString(r);
+ char *s = PyString_AsString(r);
if (s == NULL)
goto error;
result = strdup(s);
"data=0x%lx udata=%p>",
(unsigned long)(s->e.ident), s->e.filter, s->e.flags,
s->e.fflags, (long)(s->e.data), s->e.udata);
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
static int
SHAcopy(self, &temp);
sha_final(digest, &temp);
- return PyBytes_FromStringAndSize((const char *)digest, self->digestsize);
+ return PyString_FromStringAndSize((const char *)digest, self->digestsize);
}
PyDoc_STRVAR(SHA256_hexdigest__doc__,
sha_final(digest, &temp);
/* Create a new string */
- retval = PyBytes_FromStringAndSize(NULL, self->digestsize * 2);
+ retval = PyString_FromStringAndSize(NULL, self->digestsize * 2);
if (!retval)
return NULL;
- hex_digest = PyBytes_AsString(retval);
+ hex_digest = PyString_AsString(retval);
if (!hex_digest) {
Py_DECREF(retval);
return NULL;
SHA256_get_name(PyObject *self, void *closure)
{
if (((SHAobject *)self)->digestsize == 32)
- return PyBytes_FromStringAndSize("SHA256", 6);
+ return PyString_FromStringAndSize("SHA256", 6);
else
- return PyBytes_FromStringAndSize("SHA224", 6);
+ return PyString_FromStringAndSize("SHA224", 6);
}
static PyGetSetDef SHA_getseters[] = {
SHAcopy(self, &temp);
sha512_final(digest, &temp);
- return PyBytes_FromStringAndSize((const char *)digest, self->digestsize);
+ return PyString_FromStringAndSize((const char *)digest, self->digestsize);
}
PyDoc_STRVAR(SHA512_hexdigest__doc__,
sha512_final(digest, &temp);
/* Create a new string */
- retval = PyBytes_FromStringAndSize(NULL, self->digestsize * 2);
+ retval = PyString_FromStringAndSize(NULL, self->digestsize * 2);
if (!retval)
return NULL;
- hex_digest = PyBytes_AsString(retval);
+ hex_digest = PyString_AsString(retval);
if (!hex_digest) {
Py_DECREF(retval);
return NULL;
SHA512_get_name(PyObject *self, void *closure)
{
if (((SHAobject *)self)->digestsize == 64)
- return PyBytes_FromStringAndSize("SHA512", 6);
+ return PyString_FromStringAndSize("SHA512", 6);
else
- return PyBytes_FromStringAndSize("SHA384", 6);
+ return PyString_FromStringAndSize("SHA384", 6);
}
static PyGetSetDef SHA_getseters[] = {
SHAcopy(self, &temp);
sha_final(digest, &temp);
- return PyBytes_FromStringAndSize((const char *)digest, sizeof(digest));
+ return PyString_FromStringAndSize((const char *)digest, sizeof(digest));
}
PyDoc_STRVAR(SHA_hexdigest__doc__,
sha_final(digest, &temp);
/* Create a new string */
- retval = PyBytes_FromStringAndSize(NULL, sizeof(digest) * 2);
+ retval = PyString_FromStringAndSize(NULL, sizeof(digest) * 2);
if (!retval)
return NULL;
- hex_digest = PyBytes_AsString(retval);
+ hex_digest = PyString_AsString(retval);
if (!hex_digest) {
Py_DECREF(retval);
return NULL;
static PyObject *
SHA_get_name(PyObject *self, void *closure)
{
- return PyBytes_FromStringAndSize("SHA1", 4);
+ return PyString_FromStringAndSize("SHA1", 4);
}
static PyGetSetDef SHA_getseters[] = {
set_gaierror(error);
return NULL;
}
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X",
bdaddr->b[5], bdaddr->b[4], bdaddr->b[3],
bdaddr->b[2], bdaddr->b[1], bdaddr->b[0]);
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
#endif
#ifdef linux
if (a->sun_path[0] == 0) { /* Linux abstract namespace */
addrlen -= offsetof(struct sockaddr_un, sun_path);
- return PyBytes_FromStringAndSize(a->sun_path,
+ return PyString_FromStringAndSize(a->sun_path,
addrlen);
}
else
#endif /* linux */
{
/* regular NULL-terminated string */
- return PyBytes_FromString(a->sun_path);
+ return PyString_FromString(a->sun_path);
}
}
#endif /* AF_UNIX */
addr = (struct sockaddr_sco *)addr_ret;
_BT_SCO_MEMB(addr, family) = AF_BLUETOOTH;
- straddr = PyBytes_AsString(args);
+ straddr = PyString_AsString(args);
if (straddr == NULL) {
PyErr_SetString(socket_error, "getsockaddrarg: "
"wrong format");
"getsockopt buflen out of range");
return NULL;
}
- buf = PyBytes_FromStringAndSize((char *)NULL, buflen);
+ buf = PyString_FromStringAndSize((char *)NULL, buflen);
if (buf == NULL)
return NULL;
res = getsockopt(s->sock_fd, level, optname,
- (void *)PyBytes_AS_STRING(buf), &buflen);
+ (void *)PyString_AS_STRING(buf), &buflen);
if (res < 0) {
Py_DECREF(buf);
return s->errorhandler();
}
- _PyBytes_Resize(&buf, buflen);
+ _PyString_Resize(&buf, buflen);
return buf;
#endif /* __BEOS__ */
}
}
/* Allocate a new string. */
- buf = PyBytes_FromStringAndSize((char *) 0, recvlen);
+ buf = PyString_FromStringAndSize((char *) 0, recvlen);
if (buf == NULL)
return NULL;
/* Call the guts */
- outlen = sock_recv_guts(s, PyBytes_AS_STRING(buf), recvlen, flags);
+ outlen = sock_recv_guts(s, PyString_AS_STRING(buf), recvlen, flags);
if (outlen < 0) {
/* An error occurred, release the string and return an
error. */
if (outlen != recvlen) {
/* We did not read as many bytes as we anticipated, resize the
string if possible and be succesful. */
- if (_PyBytes_Resize(&buf, outlen) < 0)
+ if (_PyString_Resize(&buf, outlen) < 0)
/* Oopsy, not so succesful after all. */
return NULL;
}
return NULL;
}
- buf = PyBytes_FromStringAndSize((char *) 0, recvlen);
+ buf = PyString_FromStringAndSize((char *) 0, recvlen);
if (buf == NULL)
return NULL;
- outlen = sock_recvfrom_guts(s, PyBytes_AS_STRING(buf),
+ outlen = sock_recvfrom_guts(s, PyString_AS_STRING(buf),
recvlen, flags, &addr);
if (outlen < 0) {
goto finally;
if (outlen != recvlen) {
/* We did not read as many bytes as we anticipated, resize the
string if possible and be succesful. */
- if (_PyBytes_Resize(&buf, outlen) < 0)
+ if (_PyString_Resize(&buf, outlen) < 0)
/* Oopsy, not so succesful after all. */
goto finally;
}
(long)s->sock_fd, s->sock_family,
s->sock_type,
s->sock_proto);
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
if (res < 0)
return set_error();
buf[sizeof buf - 1] = '\0';
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
PyDoc_STRVAR(gethostname_doc,
if (h->h_aliases) {
for (pch = h->h_aliases; *pch != NULL; pch++) {
int status;
- tmp = PyBytes_FromString(*pch);
+ tmp = PyString_FromString(*pch);
if (tmp == NULL)
goto err;
PyErr_SetString(socket_error, "port/proto not found");
return NULL;
}
- return PyBytes_FromString(sp->s_name);
+ return PyString_FromString(sp->s_name);
}
PyDoc_STRVAR(getservbyport_doc,
if (inet_aton != NULL) {
#endif
if (inet_aton(ip_addr, &buf))
- return PyBytes_FromStringAndSize((char *)(&buf),
+ return PyString_FromStringAndSize((char *)(&buf),
sizeof(buf));
PyErr_SetString(socket_error,
return NULL;
}
}
- return PyBytes_FromStringAndSize((char *) &packed_addr,
+ return PyString_FromStringAndSize((char *) &packed_addr,
sizeof(packed_addr));
#ifdef USE_INET_ATON_WEAKLINK
memcpy(&packed_addr, packed_str, addr_len);
- return PyBytes_FromString(inet_ntoa(packed_addr));
+ return PyString_FromString(inet_ntoa(packed_addr));
}
#ifdef HAVE_INET_PTON
"illegal IP address string passed to inet_pton");
return NULL;
} else if (af == AF_INET) {
- return PyBytes_FromStringAndSize(packed,
+ return PyString_FromStringAndSize(packed,
sizeof(struct in_addr));
#ifdef ENABLE_IPV6
} else if (af == AF_INET6) {
- return PyBytes_FromStringAndSize(packed,
+ return PyString_FromStringAndSize(packed,
sizeof(struct in6_addr));
#endif
} else {
char ip[INET_ADDRSTRLEN + 1];
#endif
- /* Guarantee NUL-termination for PyBytes_FromString() below */
+ /* Guarantee NUL-termination for PyString_FromString() below */
memset((void *) &ip[0], '\0', sizeof(ip));
if (!PyArg_ParseTuple(args, "is#:inet_ntop", &af, &packed, &len)) {
PyErr_SetFromErrno(socket_error);
return NULL;
} else {
- return PyBytes_FromString(retval);
+ return PyString_FromString(retval);
}
/* NOTREACHED */
idna = PyObject_CallMethod(hobj, "encode", "s", "idna");
if (!idna)
return NULL;
- hptr = PyBytes_AsString(idna);
- } else if (PyBytes_Check(hobj)) {
- hptr = PyBytes_AsString(hobj);
+ hptr = PyString_AsString(idna);
+ } else if (PyString_Check(hobj)) {
+ hptr = PyString_AsString(hobj);
} else {
PyErr_SetString(PyExc_TypeError,
"getaddrinfo() argument 1 must be string or None");
if (PyInt_Check(pobj)) {
PyOS_snprintf(pbuf, sizeof(pbuf), "%ld", PyInt_AsLong(pobj));
pptr = pbuf;
- } else if (PyBytes_Check(pobj)) {
- pptr = PyBytes_AsString(pobj);
+ } else if (PyString_Check(pobj)) {
+ pptr = PyString_AsString(pobj);
} else if (pobj == Py_None) {
pptr = (char *)NULL;
} else {
sets(PyObject *v, int i, char* val)
{
if (val)
- PyStructSequence_SET_ITEM(v, i, PyBytes_FromString(val));
+ PyStructSequence_SET_ITEM(v, i, PyString_FromString(val));
else {
PyStructSequence_SET_ITEM(v, i, Py_None);
Py_INCREF(Py_None);
i = i+1;
}
if (j < i) {
- item = PyBytes_FromStringAndSize(s+j, i-j);
+ item = PyString_FromStringAndSize(s+j, i-j);
if (item == NULL)
goto finally;
i = i+1;
}
if (maxsplit && (countsplit >= maxsplit) && i < len) {
- item = PyBytes_FromStringAndSize(
+ item = PyString_FromStringAndSize(
s+i, len - i);
if (item == NULL)
goto finally;
i = j = 0;
while (i+n <= len) {
if (s[i] == sub[0] && (n == 1 || memcmp(s+i, sub, n) == 0)) {
- item = PyBytes_FromStringAndSize(s+j, i-j);
+ item = PyString_FromStringAndSize(s+j, i-j);
if (item == NULL)
goto fail;
err = PyList_Append(list, item);
else
i++;
}
- item = PyBytes_FromStringAndSize(s+j, len-j);
+ item = PyString_FromStringAndSize(s+j, len-j);
if (item == NULL)
goto fail;
err = PyList_Append(list, item);
if (seqlen == 1) {
/* Optimization if there's only one item */
PyObject *item = PySequence_GetItem(seq, 0);
- if (item && !PyBytes_Check(item)) {
+ if (item && !PyString_Check(item)) {
PyErr_SetString(PyExc_TypeError,
"first argument must be sequence of strings");
Py_DECREF(item);
return item;
}
- if (!(res = PyBytes_FromStringAndSize((char*)NULL, sz)))
+ if (!(res = PyString_FromStringAndSize((char*)NULL, sz)))
return NULL;
- p = PyBytes_AsString(res);
+ p = PyString_AsString(res);
/* optimize for lists, since it's the most common case. all others
* (tuples and arbitrary sequences) just use the sequence abstract
if (PyList_Check(seq)) {
for (i = 0; i < seqlen; i++) {
PyObject *item = PyList_GET_ITEM(seq, i);
- if (!PyBytes_Check(item)) {
+ if (!PyString_Check(item)) {
PyErr_SetString(PyExc_TypeError,
"first argument must be sequence of strings");
Py_DECREF(res);
return NULL;
}
- slen = PyBytes_GET_SIZE(item);
+ slen = PyString_GET_SIZE(item);
while (reslen + slen + seplen >= sz) {
- if (_PyBytes_Resize(&res, sz * 2) < 0)
+ if (_PyString_Resize(&res, sz * 2) < 0)
return NULL;
sz *= 2;
- p = PyBytes_AsString(res) + reslen;
+ p = PyString_AsString(res) + reslen;
}
if (i > 0) {
memcpy(p, sep, seplen);
p += seplen;
reslen += seplen;
}
- memcpy(p, PyBytes_AS_STRING(item), slen);
+ memcpy(p, PyString_AS_STRING(item), slen);
p += slen;
reslen += slen;
}
- _PyBytes_Resize(&res, reslen);
+ _PyString_Resize(&res, reslen);
return res;
}
/* This is now type safe */
for (i = 0; i < seqlen; i++) {
PyObject *item = getitemfunc(seq, i);
- if (!item || !PyBytes_Check(item)) {
+ if (!item || !PyString_Check(item)) {
PyErr_SetString(PyExc_TypeError,
"first argument must be sequence of strings");
Py_DECREF(res);
Py_XDECREF(item);
return NULL;
}
- slen = PyBytes_GET_SIZE(item);
+ slen = PyString_GET_SIZE(item);
while (reslen + slen + seplen >= sz) {
- if (_PyBytes_Resize(&res, sz * 2) < 0) {
+ if (_PyString_Resize(&res, sz * 2) < 0) {
Py_DECREF(item);
return NULL;
}
sz *= 2;
- p = PyBytes_AsString(res) + reslen;
+ p = PyString_AsString(res) + reslen;
}
if (i > 0) {
memcpy(p, sep, seplen);
p += seplen;
reslen += seplen;
}
- memcpy(p, PyBytes_AS_STRING(item), slen);
+ memcpy(p, PyString_AS_STRING(item), slen);
p += slen;
reslen += slen;
Py_DECREF(item);
}
- _PyBytes_Resize(&res, reslen);
+ _PyString_Resize(&res, reslen);
return res;
}
Py_ssize_t len, i, j;
- if (PyBytes_AsStringAndSize(args, &s, &len))
+ if (PyString_AsStringAndSize(args, &s, &len))
return NULL;
i = 0;
return args;
}
else
- return PyBytes_FromStringAndSize(s+i, j-i);
+ return PyString_FromStringAndSize(s+i, j-i);
}
int changed;
WARN;
- if (PyBytes_AsStringAndSize(args, &s, &n))
+ if (PyString_AsStringAndSize(args, &s, &n))
return NULL;
- newstr = PyBytes_FromStringAndSize(NULL, n);
+ newstr = PyString_FromStringAndSize(NULL, n);
if (newstr == NULL)
return NULL;
- s_new = PyBytes_AsString(newstr);
+ s_new = PyString_AsString(newstr);
changed = 0;
for (i = 0; i < n; i++) {
int c = Py_CHARMASK(*s++);
int changed;
WARN;
- if (PyBytes_AsStringAndSize(args, &s, &n))
+ if (PyString_AsStringAndSize(args, &s, &n))
return NULL;
- newstr = PyBytes_FromStringAndSize(NULL, n);
+ newstr = PyString_FromStringAndSize(NULL, n);
if (newstr == NULL)
return NULL;
- s_new = PyBytes_AsString(newstr);
+ s_new = PyString_AsString(newstr);
changed = 0;
for (i = 0; i < n; i++) {
int c = Py_CHARMASK(*s++);
int changed;
WARN;
- if (PyBytes_AsStringAndSize(args, &s, &n))
+ if (PyString_AsStringAndSize(args, &s, &n))
return NULL;
- newstr = PyBytes_FromStringAndSize(NULL, n);
+ newstr = PyString_FromStringAndSize(NULL, n);
if (newstr == NULL)
return NULL;
- s_new = PyBytes_AsString(newstr);
+ s_new = PyString_AsString(newstr);
changed = 0;
if (0 < n) {
int c = Py_CHARMASK(*s++);
}
/* Second pass: create output string and fill it */
- out = PyBytes_FromStringAndSize(NULL, i+j);
+ out = PyString_FromStringAndSize(NULL, i+j);
if (out == NULL)
return NULL;
i = 0;
- q = PyBytes_AS_STRING(out);
+ q = PyString_AS_STRING(out);
for (p = string; p < e; p++) {
if (*p == '\t') {
int changed;
WARN;
- if (PyBytes_AsStringAndSize(args, &s, &n))
+ if (PyString_AsStringAndSize(args, &s, &n))
return NULL;
- newstr = PyBytes_FromStringAndSize(NULL, n);
+ newstr = PyString_FromStringAndSize(NULL, n);
if (newstr == NULL)
return NULL;
- s_new = PyBytes_AsString(newstr);
+ s_new = PyString_AsString(newstr);
changed = 0;
for (i = 0; i < n; i++) {
int c = Py_CHARMASK(*s++);
return NULL;
}
- result = PyBytes_FromStringAndSize((char *)NULL, 256);
+ result = PyString_FromStringAndSize((char *)NULL, 256);
if (result == NULL)
return NULL;
- c = (unsigned char *) PyBytes_AS_STRING((PyBytesObject *)result);
+ c = (unsigned char *) PyString_AS_STRING((PyStringObject *)result);
for (i = 0; i < 256; i++)
c[i]=(unsigned char)i;
for (i = 0; i < fromlen; i++)
}
table = table1;
- inlen = PyBytes_GET_SIZE(input_obj);
- result = PyBytes_FromStringAndSize((char *)NULL, inlen);
+ inlen = PyString_GET_SIZE(input_obj);
+ result = PyString_FromStringAndSize((char *)NULL, inlen);
if (result == NULL)
return NULL;
- output_start = output = PyBytes_AsString(result);
- input = PyBytes_AsString(input_obj);
+ output_start = output = PyString_AsString(result);
+ input = PyString_AsString(input_obj);
if (dellen == 0) {
/* If no deletions are required, use faster code */
}
/* Fix the size of the resulting string */
if (inlen > 0)
- _PyBytes_Resize(&result, output - output_start);
+ _PyString_Resize(&result, output - output_start);
return result;
}
Py_XINCREF(newstr);
}
else {
- newstr = PyBytes_FromStringAndSize(new_s, out_len);
+ newstr = PyString_FromStringAndSize(new_s, out_len);
PyMem_FREE(new_s);
}
return newstr;
if (isspace(c))
buf[n++] = c;
}
- s = PyBytes_FromStringAndSize(buf, n);
+ s = PyString_FromStringAndSize(buf, n);
if (s)
PyModule_AddObject(m, "whitespace", s);
if (islower(c))
buf[n++] = c;
}
- s = PyBytes_FromStringAndSize(buf, n);
+ s = PyString_FromStringAndSize(buf, n);
if (s)
PyModule_AddObject(m, "lowercase", s);
if (isupper(c))
buf[n++] = c;
}
- s = PyBytes_FromStringAndSize(buf, n);
+ s = PyString_FromStringAndSize(buf, n);
if (s)
PyModule_AddObject(m, "uppercase", s);
}
if (!PyArg_ParseTuple(args, "i:read", &size))
return NULL;
- rv = PyBytes_FromStringAndSize(NULL, size);
+ rv = PyString_FromStringAndSize(NULL, size);
if (rv == NULL)
return NULL;
- if (!(cp = PyBytes_AsString(rv)))
+ if (!(cp = PyString_AsString(rv)))
goto finally;
count = read(self->x_fd, cp, size);
if (!PyArg_Parse(args, "i", &invert))
return NULL;
- if (!(output = PyBytes_FromStringAndSize(
+ if (!(output = PyString_FromStringAndSize(
NULL,
(int)(self->ob_info.width * self->ob_info.height * factor))))
{
return NULL;
}
- if (!(outstr = PyBytes_AsString(output))) {
+ if (!(outstr = PyString_AsString(output))) {
Py_DECREF(output);
return NULL;
}
fieldsize = self->ob_info.width * self->ob_info.height / 2;
obcapture = (char*)self->ob_capture;
- if (!(f1 = PyBytes_FromStringAndSize(obcapture, fieldsize)))
+ if (!(f1 = PyString_FromStringAndSize(obcapture, fieldsize)))
goto finally;
- if (!(f2 = PyBytes_FromStringAndSize(obcapture + fieldsize,
+ if (!(f2 = PyString_FromStringAndSize(obcapture + fieldsize,
fieldsize)))
goto finally;
ret = PyTuple_Pack(2, f1, f2);
goto finally;
}
- if (!(videodata = PyBytes_FromStringAndSize(NULL, bytes)))
+ if (!(videodata = PyString_FromStringAndSize(NULL, bytes)))
goto finally;
/* XXX -- need to do something about the bitvector */
{
- char* str = PyBytes_AsString(videodata);
+ char* str = PyString_AsString(videodata);
if (!str)
goto finally;
if (svQueryCaptureBufferSize(self->ob_svideo, &info, &bytes))
return sv_error();
- if (!(videodata = PyBytes_FromStringAndSize(NULL, bytes)))
+ if (!(videodata = PyString_FromStringAndSize(NULL, bytes)))
return NULL;
- str = PyBytes_AsString(videodata);
+ str = PyString_AsString(videodata);
if (!str)
goto finally;
return NULL;
}
- if (!(output = PyBytes_FromStringAndSize(NULL,
+ if (!(output = PyString_FromStringAndSize(NULL,
(int)(width * height * factor))))
return NULL;
- str = PyBytes_AsString(output);
+ str = PyString_AsString(output);
if (!str) {
Py_DECREF(output);
return NULL;
S_ident_o = new_S_ident_o;
Py_INCREF(S_ident_o);
- openlog(PyBytes_AsString(S_ident_o), logopt, facility);
+ openlog(PyString_AsString(S_ident_o), logopt, facility);
Py_INCREF(Py_None);
return Py_None;
return NULL;
for (i = 0; i < NCCS; i++) {
ch = (char)mode.c_cc[i];
- v = PyBytes_FromStringAndSize(&ch, 1);
+ v = PyString_FromStringAndSize(&ch, 1);
if (v == NULL)
goto err;
PyList_SetItem(cc, i, v);
for (i = 0; i < NCCS; i++) {
v = PyList_GetItem(cc, i);
- if (PyBytes_Check(v) && PyBytes_Size(v) == 1)
- mode.c_cc[i] = (cc_t) * PyBytes_AsString(v);
+ if (PyString_Check(v) && PyString_Size(v) == 1)
+ mode.c_cc[i] = (cc_t) * PyString_AsString(v);
else if (PyInt_Check(v))
mode.c_cc[i] = (cc_t) PyInt_AsLong(v);
else {
Py_XINCREF(kw);
self->kw = kw;
self->dict = NULL; /* making sure */
- self->key = PyBytes_FromFormat("thread.local.%p", self);
+ self->key = PyString_FromFormat("thread.local.%p", self);
if (self->key == NULL)
goto err;
e.g. an empty format, or %Z when the timezone
is unknown. */
PyObject *ret;
- ret = PyBytes_FromStringAndSize(outbuf, buflen);
+ ret = PyString_FromStringAndSize(outbuf, buflen);
free(outbuf);
return ret;
}
p = asctime(&buf);
if (p[24] == '\n')
p[24] = '\0';
- return PyBytes_FromString(p);
+ return PyString_FromString(p);
}
PyDoc_STRVAR(asctime_doc,
}
if (p[24] == '\n')
p[24] = '\0';
- return PyBytes_FromString(p);
+ return PyString_FromString(p);
}
PyDoc_STRVAR(ctime_doc,
if (old->category_changed != 0xFF)
index = old->category_changed;
}
- return PyBytes_FromString(_PyUnicode_CategoryNames[index]);
+ return PyString_FromString(_PyUnicode_CategoryNames[index]);
}
PyDoc_STRVAR(unicodedata_bidirectional__doc__,
else if (old->bidir_changed != 0xFF)
index = old->bidir_changed;
}
- return PyBytes_FromString(_PyUnicode_BidirectionalNames[index]);
+ return PyString_FromString(_PyUnicode_BidirectionalNames[index]);
}
PyDoc_STRVAR(unicodedata_combining__doc__,
if (old->category_changed == 0)
index = 0; /* unassigned */
}
- return PyBytes_FromString(_PyUnicode_EastAsianWidthNames[index]);
+ return PyString_FromString(_PyUnicode_EastAsianWidthNames[index]);
}
PyDoc_STRVAR(unicodedata_decomposition__doc__,
if (self) {
const change_record *old = get_old_record(self, c);
if (old->category_changed == 0)
- return PyBytes_FromString(""); /* unassigned */
+ return PyString_FromString(""); /* unassigned */
}
if (code < 0 || code >= 0x110000)
decomp[i] = '\0';
- return PyBytes_FromString(decomp);
+ return PyString_FromString(decomp);
}
static void
/* Hangul Decomposition adds three characters in
a single step, so we need atleast that much room. */
if (space < 3) {
- Py_ssize_t newsize = PyBytes_GET_SIZE(result) + 10;
+ Py_ssize_t newsize = PyString_GET_SIZE(result) + 10;
space += 10;
if (PyUnicode_Resize(&result, newsize) == -1)
return NULL;
}
}
- self->archive = PyBytes_FromString(buf);
+ self->archive = PyString_FromString(buf);
if (self->archive == NULL)
return -1;
- self->prefix = PyBytes_FromString(prefix);
+ self->prefix = PyString_FromString(prefix);
if (self->prefix == NULL)
return -1;
char *archive = "???";
char *prefix = "";
- if (self->archive != NULL && PyBytes_Check(self->archive))
- archive = PyBytes_AsString(self->archive);
- if (self->prefix != NULL && PyBytes_Check(self->prefix))
- prefix = PyBytes_AsString(self->prefix);
+ if (self->archive != NULL && PyString_Check(self->archive))
+ archive = PyString_AsString(self->archive);
+ if (self->prefix != NULL && PyString_Check(self->prefix))
+ prefix = PyString_AsString(self->prefix);
if (prefix != NULL && *prefix)
PyOS_snprintf(buf, sizeof(buf),
"<zipimporter object \"%.300s%c%.150s\">",
PyOS_snprintf(buf, sizeof(buf),
"<zipimporter object \"%.300s\">",
archive);
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
/* return fullname.split(".")[-1] */
subname = get_subname(fullname);
- len = make_filename(PyBytes_AsString(self->prefix), subname, path);
+ len = make_filename(PyString_AsString(self->prefix), subname, path);
if (len < 0)
return MI_ERROR;
/* add __path__ to the module *before* the code gets
executed */
PyObject *pkgpath, *fullpath;
- char *prefix = PyBytes_AsString(self->prefix);
+ char *prefix = PyString_AsString(self->prefix);
char *subname = get_subname(fullname);
int err;
- fullpath = PyBytes_FromFormat("%s%c%s%s",
- PyBytes_AsString(self->archive),
+ fullpath = PyString_FromFormat("%s%c%s%s",
+ PyString_AsString(self->archive),
SEP,
*prefix ? prefix : "",
subname);
}
path = buf;
#endif
- len = PyBytes_Size(self->archive);
+ len = PyString_Size(self->archive);
if ((size_t)len < strlen(path) &&
- strncmp(path, PyBytes_AsString(self->archive), len) == 0 &&
+ strncmp(path, PyString_AsString(self->archive), len) == 0 &&
path[len] == SEP) {
path = path + len + 1;
}
PyErr_SetFromErrnoWithFilename(PyExc_IOError, path);
return NULL;
}
- return get_data(PyBytes_AsString(self->archive), toc_entry);
+ return get_data(PyString_AsString(self->archive), toc_entry);
}
static PyObject *
}
subname = get_subname(fullname);
- len = make_filename(PyBytes_AsString(self->prefix), subname, path);
+ len = make_filename(PyString_AsString(self->prefix), subname, path);
if (len < 0)
return NULL;
toc_entry = PyDict_GetItemString(self->files, path);
if (toc_entry != NULL)
- return get_data(PyBytes_AsString(self->archive), toc_entry);
+ return get_data(PyString_AsString(self->archive), toc_entry);
/* we have the module, but no source */
Py_INCREF(Py_None);
PyMarshal_ReadShortFromFile(fp); /* local header size */
file_offset += l; /* Start of file data */
- raw_data = PyBytes_FromStringAndSize((char *)NULL, compress == 0 ?
+ raw_data = PyString_FromStringAndSize((char *)NULL, compress == 0 ?
data_size : data_size + 1);
if (raw_data == NULL) {
fclose(fp);
return NULL;
}
- buf = PyBytes_AsString(raw_data);
+ buf = PyString_AsString(raw_data);
err = fseek(fp, file_offset, 0);
if (err == 0)
unmarshal_code(char *pathname, PyObject *data, time_t mtime)
{
PyObject *code;
- char *buf = PyBytes_AsString(data);
- Py_ssize_t size = PyBytes_Size(data);
+ char *buf = PyString_AsString(data);
+ Py_ssize_t size = PyString_Size(data);
if (size <= 9) {
PyErr_SetString(ZipImportError,
static PyObject *
normalize_line_endings(PyObject *source)
{
- char *buf, *q, *p = PyBytes_AsString(source);
+ char *buf, *q, *p = PyString_AsString(source);
PyObject *fixed_source;
if (!p)
return NULL;
/* one char extra for trailing \n and one for terminating \0 */
- buf = (char *)PyMem_Malloc(PyBytes_Size(source) + 2);
+ buf = (char *)PyMem_Malloc(PyString_Size(source) + 2);
if (buf == NULL) {
PyErr_SetString(PyExc_MemoryError,
"zipimport: no memory to allocate "
}
*q++ = '\n'; /* add trailing \n */
*q = '\0';
- fixed_source = PyBytes_FromString(buf);
+ fixed_source = PyString_FromString(buf);
PyMem_Free(buf);
return fixed_source;
}
if (fixed_source == NULL)
return NULL;
- code = Py_CompileString(PyBytes_AsString(fixed_source), pathname,
+ code = Py_CompileString(PyString_AsString(fixed_source), pathname,
Py_file_input);
Py_DECREF(fixed_source);
return code;
{
PyObject *data, *code;
char *modpath;
- char *archive = PyBytes_AsString(self->archive);
+ char *archive = PyString_AsString(self->archive);
if (archive == NULL)
return NULL;
if (data == NULL)
return NULL;
- modpath = PyBytes_AsString(PyTuple_GetItem(toc_entry, 0));
+ modpath = PyString_AsString(PyTuple_GetItem(toc_entry, 0));
if (isbytecode) {
code = unmarshal_code(modpath, data, mtime);
subname = get_subname(fullname);
- len = make_filename(PyBytes_AsString(self->prefix), subname, path);
+ len = make_filename(PyString_AsString(self->prefix), subname, path);
if (len < 0)
return NULL;
strcpy(path + len, zso->suffix);
if (Py_VerboseFlag > 1)
PySys_WriteStderr("# trying %s%c%s\n",
- PyBytes_AsString(self->archive),
+ PyString_AsString(self->archive),
SEP, path);
toc_entry = PyDict_GetItemString(self->files, path);
if (toc_entry != NULL) {
continue;
}
if (code != NULL && p_modpath != NULL)
- *p_modpath = PyBytes_AsString(
+ *p_modpath = PyString_AsString(
PyTuple_GetItem(toc_entry, 0));
return code;
}
if (self == NULL)
return NULL;
self->is_initialised = 0;
- self->unused_data = PyBytes_FromString("");
+ self->unused_data = PyString_FromString("");
if (self->unused_data == NULL) {
Py_DECREF(self);
return NULL;
}
- self->unconsumed_tail = PyBytes_FromString("");
+ self->unconsumed_tail = PyString_FromString("");
if (self->unconsumed_tail == NULL) {
Py_DECREF(self);
return NULL;
err=deflateEnd(&zst);
if (err == Z_OK)
- ReturnVal = PyBytes_FromStringAndSize((char *)output,
+ ReturnVal = PyString_FromStringAndSize((char *)output,
zst.total_out);
else
zlib_error(zst, err, "while finishing compression");
zst.avail_in = length;
zst.avail_out = r_strlen;
- if (!(result_str = PyBytes_FromStringAndSize(NULL, r_strlen)))
+ if (!(result_str = PyString_FromStringAndSize(NULL, r_strlen)))
return NULL;
zst.zalloc = (alloc_func)NULL;
zst.zfree = (free_func)Z_NULL;
- zst.next_out = (Byte *)PyBytes_AS_STRING(result_str);
+ zst.next_out = (Byte *)PyString_AS_STRING(result_str);
zst.next_in = (Byte *)input;
err = inflateInit2(&zst, wsize);
/* fall through */
case(Z_OK):
/* need more memory */
- if (_PyBytes_Resize(&result_str, r_strlen << 1) < 0) {
+ if (_PyString_Resize(&result_str, r_strlen << 1) < 0) {
inflateEnd(&zst);
goto error;
}
- zst.next_out = (unsigned char *)PyBytes_AS_STRING(result_str) \
+ zst.next_out = (unsigned char *)PyString_AS_STRING(result_str) \
+ r_strlen;
zst.avail_out = r_strlen;
r_strlen = r_strlen << 1;
goto error;
}
- _PyBytes_Resize(&result_str, zst.total_out);
+ _PyString_Resize(&result_str, zst.total_out);
return result_str;
error:
if (!PyArg_ParseTuple(args, "s#:compress", &input, &inplen))
return NULL;
- if (!(RetVal = PyBytes_FromStringAndSize(NULL, length)))
+ if (!(RetVal = PyString_FromStringAndSize(NULL, length)))
return NULL;
ENTER_ZLIB
self->zst.avail_in = inplen;
self->zst.next_in = input;
self->zst.avail_out = length;
- self->zst.next_out = (unsigned char *)PyBytes_AS_STRING(RetVal);
+ self->zst.next_out = (unsigned char *)PyString_AS_STRING(RetVal);
Py_BEGIN_ALLOW_THREADS
err = deflate(&(self->zst), Z_NO_FLUSH);
/* while Z_OK and the output buffer is full, there might be more output,
so extend the output buffer and try again */
while (err == Z_OK && self->zst.avail_out == 0) {
- if (_PyBytes_Resize(&RetVal, length << 1) < 0)
+ if (_PyString_Resize(&RetVal, length << 1) < 0)
goto error;
- self->zst.next_out = (unsigned char *)PyBytes_AS_STRING(RetVal) \
+ self->zst.next_out = (unsigned char *)PyString_AS_STRING(RetVal) \
+ length;
self->zst.avail_out = length;
length = length << 1;
RetVal = NULL;
goto error;
}
- _PyBytes_Resize(&RetVal, self->zst.total_out - start_total_out);
+ _PyString_Resize(&RetVal, self->zst.total_out - start_total_out);
error:
LEAVE_ZLIB
/* limit amount of data allocated to max_length */
if (max_length && length > max_length)
length = max_length;
- if (!(RetVal = PyBytes_FromStringAndSize(NULL, length)))
+ if (!(RetVal = PyString_FromStringAndSize(NULL, length)))
return NULL;
ENTER_ZLIB
self->zst.avail_in = inplen;
self->zst.next_in = input;
self->zst.avail_out = length;
- self->zst.next_out = (unsigned char *)PyBytes_AS_STRING(RetVal);
+ self->zst.next_out = (unsigned char *)PyString_AS_STRING(RetVal);
Py_BEGIN_ALLOW_THREADS
err = inflate(&(self->zst), Z_SYNC_FLUSH);
if (max_length && length > max_length)
length = max_length;
- if (_PyBytes_Resize(&RetVal, length) < 0)
+ if (_PyString_Resize(&RetVal, length) < 0)
goto error;
- self->zst.next_out = (unsigned char *)PyBytes_AS_STRING(RetVal) \
+ self->zst.next_out = (unsigned char *)PyString_AS_STRING(RetVal) \
+ old_length;
self->zst.avail_out = length - old_length;
of specified size. Return the unconsumed tail in an attribute.*/
if(max_length) {
Py_DECREF(self->unconsumed_tail);
- self->unconsumed_tail = PyBytes_FromStringAndSize((char *)self->zst.next_in,
+ self->unconsumed_tail = PyString_FromStringAndSize((char *)self->zst.next_in,
self->zst.avail_in);
if(!self->unconsumed_tail) {
Py_DECREF(RetVal);
*/
if (err == Z_STREAM_END) {
Py_XDECREF(self->unused_data); /* Free original empty string */
- self->unused_data = PyBytes_FromStringAndSize(
+ self->unused_data = PyString_FromStringAndSize(
(char *)self->zst.next_in, self->zst.avail_in);
if (self->unused_data == NULL) {
Py_DECREF(RetVal);
goto error;
}
- _PyBytes_Resize(&RetVal, self->zst.total_out - start_total_out);
+ _PyString_Resize(&RetVal, self->zst.total_out - start_total_out);
error:
LEAVE_ZLIB
/* Flushing with Z_NO_FLUSH is a no-op, so there's no point in
doing any work at all; just return an empty string. */
if (flushmode == Z_NO_FLUSH) {
- return PyBytes_FromStringAndSize(NULL, 0);
+ return PyString_FromStringAndSize(NULL, 0);
}
- if (!(RetVal = PyBytes_FromStringAndSize(NULL, length)))
+ if (!(RetVal = PyString_FromStringAndSize(NULL, length)))
return NULL;
ENTER_ZLIB
start_total_out = self->zst.total_out;
self->zst.avail_in = 0;
self->zst.avail_out = length;
- self->zst.next_out = (unsigned char *)PyBytes_AS_STRING(RetVal);
+ self->zst.next_out = (unsigned char *)PyString_AS_STRING(RetVal);
Py_BEGIN_ALLOW_THREADS
err = deflate(&(self->zst), flushmode);
/* while Z_OK and the output buffer is full, there might be more output,
so extend the output buffer and try again */
while (err == Z_OK && self->zst.avail_out == 0) {
- if (_PyBytes_Resize(&RetVal, length << 1) < 0)
+ if (_PyString_Resize(&RetVal, length << 1) < 0)
goto error;
- self->zst.next_out = (unsigned char *)PyBytes_AS_STRING(RetVal) \
+ self->zst.next_out = (unsigned char *)PyString_AS_STRING(RetVal) \
+ length;
self->zst.avail_out = length;
length = length << 1;
goto error;
}
- _PyBytes_Resize(&RetVal, self->zst.total_out - start_total_out);
+ _PyString_Resize(&RetVal, self->zst.total_out - start_total_out);
error:
LEAVE_ZLIB
PyErr_SetString(PyExc_ValueError, "length must be greater than zero");
return NULL;
}
- if (!(retval = PyBytes_FromStringAndSize(NULL, length)))
+ if (!(retval = PyString_FromStringAndSize(NULL, length)))
return NULL;
start_total_out = self->zst.total_out;
self->zst.avail_out = length;
- self->zst.next_out = (Byte *)PyBytes_AS_STRING(retval);
+ self->zst.next_out = (Byte *)PyString_AS_STRING(retval);
Py_BEGIN_ALLOW_THREADS
err = inflate(&(self->zst), Z_FINISH);
/* while Z_OK and the output buffer is full, there might be more output,
so extend the output buffer and try again */
while ((err == Z_OK || err == Z_BUF_ERROR) && self->zst.avail_out == 0) {
- if (_PyBytes_Resize(&retval, length << 1) < 0)
+ if (_PyString_Resize(&retval, length << 1) < 0)
goto error;
- self->zst.next_out = (Byte *)PyBytes_AS_STRING(retval) + length;
+ self->zst.next_out = (Byte *)PyString_AS_STRING(retval) + length;
self->zst.avail_out = length;
length = length << 1;
goto error;
}
}
- _PyBytes_Resize(&retval, self->zst.total_out - start_total_out);
+ _PyString_Resize(&retval, self->zst.total_out - start_total_out);
error:
PyModule_AddIntConstant(m, "Z_SYNC_FLUSH", Z_SYNC_FLUSH);
PyModule_AddIntConstant(m, "Z_FULL_FLUSH", Z_FULL_FLUSH);
- ver = PyBytes_FromString(ZLIB_VERSION);
+ ver = PyString_FromString(ZLIB_VERSION);
if (ver != NULL)
PyModule_AddObject(m, "ZLIB_VERSION", ver);
/* cache a hashed version of the attribute string */
if (hintstrobj == NULL) {
- hintstrobj = PyBytes_InternFromString("__length_hint__");
+ hintstrobj = PyString_InternFromString("__length_hint__");
if (hintstrobj == NULL)
goto defaultcase;
}
null_error();
return -1;
}
- okey = PyBytes_FromString(key);
+ okey = PyString_FromString(key);
if (okey == NULL)
return -1;
ret = PyObject_DelItem(o, okey);
/* Initialize cached value */
if (str__format__ == NULL) {
/* Initialize static variable needed by _PyType_Lookup */
- str__format__ = PyBytes_InternFromString("__format__");
+ str__format__ = PyString_InternFromString("__format__");
if (str__format__ == NULL)
goto done;
}
/* If no format_spec is provided, use an empty string */
if (format_spec == NULL) {
- empty = PyBytes_FromStringAndSize(NULL, 0);
+ empty = PyString_FromStringAndSize(NULL, 0);
format_spec = empty;
}
/* Check the format_spec type, and make sure it's str or unicode */
if (PyUnicode_Check(format_spec))
spec_is_unicode = 1;
- else if (PyBytes_Check(format_spec))
+ else if (PyString_Check(format_spec))
spec_is_unicode = 0;
else {
PyErr_Format(PyExc_TypeError,
/* Check the result type, and make sure it's str or unicode */
if (PyUnicode_Check(result))
result_is_unicode = 1;
- else if (PyBytes_Check(result))
+ else if (PyString_Check(result))
result_is_unicode = 0;
else {
PyErr_Format(PyExc_TypeError,
const char *type_name;
static PyObject *int_name = NULL;
if (int_name == NULL) {
- int_name = PyBytes_InternFromString("__int__");
+ int_name = PyString_InternFromString("__int__");
if (int_name == NULL)
return NULL;
}
non_integral_error:
if (PyInstance_Check(integral)) {
- type_name = PyBytes_AS_STRING(((PyInstanceObject *)integral)
+ type_name = PyString_AS_STRING(((PyInstanceObject *)integral)
->in_class->cl_name);
}
else {
Py_ssize_t buffer_len;
if (trunc_name == NULL) {
- trunc_name = PyBytes_InternFromString("__trunc__");
+ trunc_name = PyString_InternFromString("__trunc__");
if (trunc_name == NULL)
return NULL;
}
}
PyErr_Clear(); /* It's not an error if o.__trunc__ doesn't exist. */
- if (PyBytes_Check(o))
- return int_from_string(PyBytes_AS_STRING(o),
- PyBytes_GET_SIZE(o));
+ if (PyString_Check(o))
+ return int_from_string(PyString_AS_STRING(o),
+ PyString_GET_SIZE(o));
#ifdef Py_USING_UNICODE
if (PyUnicode_Check(o))
return PyInt_FromUnicode(PyUnicode_AS_UNICODE(o),
Py_ssize_t buffer_len;
if (trunc_name == NULL) {
- trunc_name = PyBytes_InternFromString("__trunc__");
+ trunc_name = PyString_InternFromString("__trunc__");
if (trunc_name == NULL)
return NULL;
}
}
PyErr_Clear(); /* It's not an error if o.__trunc__ doesn't exist. */
- if (PyBytes_Check(o))
+ if (PyString_Check(o))
/* need to do extra error checking that PyLong_FromString()
* doesn't do. In particular long('9.5') must raise an
* exception, not truncate the float.
*/
- return long_from_string(PyBytes_AS_STRING(o),
- PyBytes_GET_SIZE(o));
+ return long_from_string(PyString_AS_STRING(o),
+ PyString_GET_SIZE(o));
#ifdef Py_USING_UNICODE
if (PyUnicode_Check(o))
/* The above check is done in PyLong_FromUnicode(). */
if (key == NULL)
return null_error();
- okey = PyBytes_FromString(key);
+ okey = PyString_FromString(key);
if (okey == NULL)
return NULL;
r = PyObject_GetItem(o, okey);
return -1;
}
- okey = PyBytes_FromString(key);
+ okey = PyString_FromString(key);
if (okey == NULL)
return -1;
r = PyObject_SetItem(o, okey, value);
PyObject *bases;
if (__bases__ == NULL) {
- __bases__ = PyBytes_InternFromString("__bases__");
+ __bases__ = PyString_InternFromString("__bases__");
if (__bases__ == NULL)
return NULL;
}
int retval = 0;
if (__class__ == NULL) {
- __class__ = PyBytes_InternFromString("__class__");
+ __class__ = PyString_InternFromString("__class__");
if (__class__ == NULL)
return -1;
}
return 1;
if (name == NULL) {
- name = PyBytes_InternFromString("__instancecheck__");
+ name = PyString_InternFromString("__instancecheck__");
if (name == NULL)
return -1;
}
PyErr_Fetch(&t, &v, &tb);
if (name == NULL) {
- name = PyBytes_InternFromString("__subclasscheck__");
+ name = PyString_InternFromString("__subclasscheck__");
if (name == NULL)
return -1;
}
if (self->ob_ival)
s = true_str ? true_str :
- (true_str = PyBytes_InternFromString("True"));
+ (true_str = PyString_InternFromString("True"));
else
s = false_str ? false_str :
- (false_str = PyBytes_InternFromString("False"));
+ (false_str = PyString_InternFromString("False"));
Py_XINCREF(s);
return s;
}
const char *status = self->b_readonly ? "read-only" : "read-write";
if ( self->b_base == NULL )
- return PyBytes_FromFormat("<%s buffer ptr %p, size %zd at %p>",
+ return PyString_FromFormat("<%s buffer ptr %p, size %zd at %p>",
status,
self->b_ptr,
self->b_size,
self);
else
- return PyBytes_FromFormat(
+ return PyString_FromFormat(
"<%s buffer for %p, size %zd, offset %zd at %p>",
status,
self->b_base,
* underlying memory is immutable. b_readonly is a necessary but not
* sufficient condition for a buffer to be hashable. Perhaps it would
* be better to only allow hashing if the underlying object is known to
- * be immutable (e.g. PyBytes_Check() is true). Another idea would
+ * be immutable (e.g. PyString_Check() is true). Another idea would
* be to call tp_hash on the underlying object and see if it raises
* an error. */
if ( !self->b_readonly )
Py_ssize_t size;
if (!get_buf(self, &ptr, &size, ANY_BUFFER))
return NULL;
- return PyBytes_FromStringAndSize((const char *)ptr, size);
+ return PyString_FromStringAndSize((const char *)ptr, size);
}
/* Sequence methods */
if ( (count = (*pb->bf_getreadbuffer)(other, 0, &ptr2)) < 0 )
return NULL;
- ob = PyBytes_FromStringAndSize(NULL, size + count);
+ ob = PyString_FromStringAndSize(NULL, size + count);
if ( ob == NULL )
return NULL;
- p = PyBytes_AS_STRING(ob);
+ p = PyString_AS_STRING(ob);
memcpy(p, ptr1, size);
memcpy(p + size, ptr2, count);
count = 0;
if (!get_buf(self, &ptr, &size, ANY_BUFFER))
return NULL;
- ob = PyBytes_FromStringAndSize(NULL, size * count);
+ ob = PyString_FromStringAndSize(NULL, size * count);
if ( ob == NULL )
return NULL;
- p = PyBytes_AS_STRING(ob);
+ p = PyString_AS_STRING(ob);
while ( count-- )
{
memcpy(p, ptr, size);
PyErr_SetString(PyExc_IndexError, "buffer index out of range");
return NULL;
}
- return PyBytes_FromStringAndSize((char *)ptr + idx, 1);
+ return PyString_FromStringAndSize((char *)ptr + idx, 1);
}
static PyObject *
right = size;
if ( right < left )
right = left;
- return PyBytes_FromStringAndSize((char *)ptr + left,
+ return PyString_FromStringAndSize((char *)ptr + left,
right - left);
}
}
if (slicelength <= 0)
- return PyBytes_FromStringAndSize("", 0);
+ return PyString_FromStringAndSize("", 0);
else if (step == 1)
- return PyBytes_FromStringAndSize((char *)p + start,
+ return PyString_FromStringAndSize((char *)p + start,
stop - start);
else {
PyObject *result;
result_buf[i] = source_buf[cur];
}
- result = PyBytes_FromStringAndSize(result_buf,
+ result = PyString_FromStringAndSize(result_buf,
slicelength);
PyMem_Free(result_buf);
return result;
Py_ssize_t i;
/*
- newobj = PyBytes_FromStringAndSize(NULL, len);
+ newobj = PyString_FromStringAndSize(NULL, len);
if (!newobj)
return NULL;
- s = PyBytes_AS_STRING(newobj);
+ s = PyString_AS_STRING(newobj);
*/
Py_MEMCPY(result, cptr, len);
Py_ssize_t i;
/*
- newobj = PyBytes_FromStringAndSize(NULL, len);
+ newobj = PyString_FromStringAndSize(NULL, len);
if (!newobj)
return NULL;
- s = PyBytes_AS_STRING(newobj);
+ s = PyString_AS_STRING(newobj);
*/
Py_MEMCPY(result, cptr, len);
int previous_is_cased = 0;
/*
- newobj = PyBytes_FromStringAndSize(NULL, len);
+ newobj = PyString_FromStringAndSize(NULL, len);
if (newobj == NULL)
return NULL;
- s_new = PyBytes_AsString(newobj);
+ s_new = PyString_AsString(newobj);
*/
for (i = 0; i < len; i++) {
int c = Py_CHARMASK(*s++);
Py_ssize_t i;
/*
- newobj = PyBytes_FromStringAndSize(NULL, len);
+ newobj = PyString_FromStringAndSize(NULL, len);
if (newobj == NULL)
return NULL;
- s_new = PyBytes_AsString(newobj);
+ s_new = PyString_AsString(newobj);
*/
if (0 < len) {
int c = Py_CHARMASK(*s++);
Py_ssize_t i;
/*
- newobj = PyBytes_FromStringAndSize(NULL, len);
+ newobj = PyString_FromStringAndSize(NULL, len);
if (newobj == NULL)
return NULL;
- s_new = PyBytes_AsString(newobj);
+ s_new = PyString_AsString(newobj);
*/
for (i = 0; i < len; i++) {
int c = Py_CHARMASK(*s++);
/* share short strings */
if (size == 0) {
PyObject *t = (PyObject *)op;
- PyBytes_InternInPlace(&t);
+ PyString_InternInPlace(&t);
op = (PyBytesObject *)t;
nullstring = op;
Py_INCREF(op);
} else if (size == 1 && str != NULL) {
PyObject *t = (PyObject *)op;
- PyBytes_InternInPlace(&t);
+ PyString_InternInPlace(&t);
op = (PyBytesObject *)t;
characters[*str & UCHAR_MAX] = op;
Py_INCREF(op);
/* share short strings */
if (size == 0) {
PyObject *t = (PyObject *)op;
- PyBytes_InternInPlace(&t);
+ PyString_InternInPlace(&t);
op = (PyBytesObject *)t;
nullstring = op;
Py_INCREF(op);
} else if (size == 1) {
PyObject *t = (PyObject *)op;
- PyBytes_InternInPlace(&t);
+ PyString_InternInPlace(&t);
op = (PyBytesObject *)t;
characters[*str & UCHAR_MAX] = op;
Py_INCREF(op);
}
void
-PyBytes_InternInPlace(PyObject **p)
+PyString_InternInPlace(PyObject **p)
{
register PyBytesObject *s = (PyBytesObject *)(*p);
PyObject *t;
if (s == NULL || !PyBytes_Check(s))
- Py_FatalError("PyBytes_InternInPlace: strings only please!");
+ Py_FatalError("PyString_InternInPlace: strings only please!");
/* If it's a string subclass, we don't really know what putting
it in the interned dict might do. */
if (!PyBytes_CheckExact(s))
}
void
-PyBytes_InternImmortal(PyObject **p)
+PyString_InternImmortal(PyObject **p)
{
- PyBytes_InternInPlace(p);
+ PyString_InternInPlace(p);
if (PyBytes_CHECK_INTERNED(*p) != SSTATE_INTERNED_IMMORTAL) {
PyBytes_CHECK_INTERNED(*p) = SSTATE_INTERNED_IMMORTAL;
Py_INCREF(*p);
PyObject *
-PyBytes_InternFromString(const char *cp)
+PyString_InternFromString(const char *cp)
{
PyObject *s = PyBytes_FromString(cp);
if (s == NULL)
return NULL;
- PyBytes_InternInPlace(&s);
+ PyString_InternInPlace(&s);
return s;
}
void
-PyBytes_Fini(void)
+PyString_Fini(void)
{
int i;
for (i = 0; i < UCHAR_MAX + 1; i++) {
cell_repr(PyCellObject *op)
{
if (op->ob_ref == NULL)
- return PyBytes_FromFormat("<cell at %p: empty>", op);
+ return PyString_FromFormat("<cell at %p: empty>", op);
- return PyBytes_FromFormat("<cell at %p: %.80s object at %p>",
+ return PyString_FromFormat("<cell at %p: %.80s object at %p>",
op, op->ob_ref->ob_type->tp_name,
op->ob_ref);
}
PyClassObject *op, *dummy;
static PyObject *docstr, *modstr, *namestr;
if (docstr == NULL) {
- docstr= PyBytes_InternFromString("__doc__");
+ docstr= PyString_InternFromString("__doc__");
if (docstr == NULL)
return NULL;
}
if (modstr == NULL) {
- modstr= PyBytes_InternFromString("__module__");
+ modstr= PyString_InternFromString("__module__");
if (modstr == NULL)
return NULL;
}
if (namestr == NULL) {
- namestr= PyBytes_InternFromString("__name__");
+ namestr= PyString_InternFromString("__name__");
if (namestr == NULL)
return NULL;
}
- if (name == NULL || !PyBytes_Check(name)) {
+ if (name == NULL || !PyString_Check(name)) {
PyErr_SetString(PyExc_TypeError,
"PyClass_New: name must be a string");
return NULL;
}
if (getattrstr == NULL) {
- getattrstr = PyBytes_InternFromString("__getattr__");
+ getattrstr = PyString_InternFromString("__getattr__");
if (getattrstr == NULL)
goto alloc_error;
- setattrstr = PyBytes_InternFromString("__setattr__");
+ setattrstr = PyString_InternFromString("__setattr__");
if (setattrstr == NULL)
goto alloc_error;
- delattrstr = PyBytes_InternFromString("__delattr__");
+ delattrstr = PyString_InternFromString("__delattr__");
if (delattrstr == NULL)
goto alloc_error;
}
class_getattr(register PyClassObject *op, PyObject *name)
{
register PyObject *v;
- register char *sname = PyBytes_AsString(name);
+ register char *sname = PyString_AsString(name);
PyClassObject *klass;
descrgetfunc f;
if (v == NULL) {
PyErr_Format(PyExc_AttributeError,
"class %.50s has no attribute '%.400s'",
- PyBytes_AS_STRING(op->cl_name), sname);
+ PyString_AS_STRING(op->cl_name), sname);
return NULL;
}
f = TP_DESCR_GET(v->ob_type);
static char *
set_name(PyClassObject *c, PyObject *v)
{
- if (v == NULL || !PyBytes_Check(v))
+ if (v == NULL || !PyString_Check(v))
return "__name__ must be a string object";
- if (strlen(PyBytes_AS_STRING(v)) != (size_t)PyBytes_GET_SIZE(v))
+ if (strlen(PyString_AS_STRING(v)) != (size_t)PyString_GET_SIZE(v))
return "__name__ must not contain null bytes";
set_slot(&c->cl_name, v);
return "";
"classes are read-only in restricted mode");
return -1;
}
- sname = PyBytes_AsString(name);
+ sname = PyString_AsString(name);
if (sname[0] == '_' && sname[1] == '_') {
- Py_ssize_t n = PyBytes_Size(name);
+ Py_ssize_t n = PyString_Size(name);
if (sname[n-1] == '_' && sname[n-2] == '_') {
char *err = NULL;
if (strcmp(sname, "__dict__") == 0)
if (rv < 0)
PyErr_Format(PyExc_AttributeError,
"class %.50s has no attribute '%.400s'",
- PyBytes_AS_STRING(op->cl_name), sname);
+ PyString_AS_STRING(op->cl_name), sname);
return rv;
}
else
{
PyObject *mod = PyDict_GetItemString(op->cl_dict, "__module__");
char *name;
- if (op->cl_name == NULL || !PyBytes_Check(op->cl_name))
+ if (op->cl_name == NULL || !PyString_Check(op->cl_name))
name = "?";
else
- name = PyBytes_AsString(op->cl_name);
- if (mod == NULL || !PyBytes_Check(mod))
- return PyBytes_FromFormat("<class ?.%s at %p>", name, op);
+ name = PyString_AsString(op->cl_name);
+ if (mod == NULL || !PyString_Check(mod))
+ return PyString_FromFormat("<class ?.%s at %p>", name, op);
else
- return PyBytes_FromFormat("<class %s.%s at %p>",
- PyBytes_AsString(mod),
+ return PyString_FromFormat("<class %s.%s at %p>",
+ PyString_AsString(mod),
name, op);
}
PyObject *res;
Py_ssize_t m, n;
- if (name == NULL || !PyBytes_Check(name))
+ if (name == NULL || !PyString_Check(name))
return class_repr(op);
- if (mod == NULL || !PyBytes_Check(mod)) {
+ if (mod == NULL || !PyString_Check(mod)) {
Py_INCREF(name);
return name;
}
- m = PyBytes_GET_SIZE(mod);
- n = PyBytes_GET_SIZE(name);
- res = PyBytes_FromStringAndSize((char *)NULL, m+1+n);
+ m = PyString_GET_SIZE(mod);
+ n = PyString_GET_SIZE(name);
+ res = PyString_FromStringAndSize((char *)NULL, m+1+n);
if (res != NULL) {
- char *s = PyBytes_AS_STRING(res);
- memcpy(s, PyBytes_AS_STRING(mod), m);
+ char *s = PyString_AS_STRING(res);
+ memcpy(s, PyString_AS_STRING(mod), m);
s += m;
*s++ = '.';
- memcpy(s, PyBytes_AS_STRING(name), n);
+ memcpy(s, PyString_AS_STRING(name), n);
}
return res;
}
static PyObject *initstr;
if (initstr == NULL) {
- initstr = PyBytes_InternFromString("__init__");
+ initstr = PyString_InternFromString("__init__");
if (initstr == NULL)
return NULL;
}
PyErr_Fetch(&error_type, &error_value, &error_traceback);
/* Execute __del__ method, if any. */
if (delstr == NULL) {
- delstr = PyBytes_InternFromString("__del__");
+ delstr = PyString_InternFromString("__del__");
if (delstr == NULL)
PyErr_WriteUnraisable((PyObject*)inst);
}
instance_getattr1(register PyInstanceObject *inst, PyObject *name)
{
register PyObject *v;
- register char *sname = PyBytes_AsString(name);
+ register char *sname = PyString_AsString(name);
if (sname[0] == '_' && sname[1] == '_') {
if (strcmp(sname, "__dict__") == 0) {
if (PyEval_GetRestricted()) {
if (v == NULL && !PyErr_Occurred()) {
PyErr_Format(PyExc_AttributeError,
"%.50s instance has no attribute '%.400s'",
- PyBytes_AS_STRING(inst->in_class->cl_name), sname);
+ PyString_AS_STRING(inst->in_class->cl_name), sname);
}
return v;
}
assert(PyInstance_Check(pinst));
inst = (PyInstanceObject *)pinst;
- assert(PyBytes_Check(name));
+ assert(PyString_Check(name));
v = PyDict_GetItem(inst->in_dict, name);
if (v == NULL)
if (rv < 0)
PyErr_Format(PyExc_AttributeError,
"%.50s instance has no attribute '%.400s'",
- PyBytes_AS_STRING(inst->in_class->cl_name),
- PyBytes_AS_STRING(name));
+ PyString_AS_STRING(inst->in_class->cl_name),
+ PyString_AS_STRING(name));
return rv;
}
else
instance_setattr(PyInstanceObject *inst, PyObject *name, PyObject *v)
{
PyObject *func, *args, *res, *tmp;
- char *sname = PyBytes_AsString(name);
+ char *sname = PyString_AsString(name);
if (sname[0] == '_' && sname[1] == '_') {
- Py_ssize_t n = PyBytes_Size(name);
+ Py_ssize_t n = PyString_Size(name);
if (sname[n-1] == '_' && sname[n-2] == '_') {
if (strcmp(sname, "__dict__") == 0) {
if (PyEval_GetRestricted()) {
static PyObject *reprstr;
if (reprstr == NULL) {
- reprstr = PyBytes_InternFromString("__repr__");
+ reprstr = PyString_InternFromString("__repr__");
if (reprstr == NULL)
return NULL;
}
classname = inst->in_class->cl_name;
mod = PyDict_GetItemString(inst->in_class->cl_dict,
"__module__");
- if (classname != NULL && PyBytes_Check(classname))
- cname = PyBytes_AsString(classname);
+ if (classname != NULL && PyString_Check(classname))
+ cname = PyString_AsString(classname);
else
cname = "?";
- if (mod == NULL || !PyBytes_Check(mod))
- return PyBytes_FromFormat("<?.%s instance at %p>",
+ if (mod == NULL || !PyString_Check(mod))
+ return PyString_FromFormat("<?.%s instance at %p>",
cname, inst);
else
- return PyBytes_FromFormat("<%s.%s instance at %p>",
- PyBytes_AsString(mod),
+ return PyString_FromFormat("<%s.%s instance at %p>",
+ PyString_AsString(mod),
cname, inst);
}
res = PyEval_CallObject(func, (PyObject *)NULL);
static PyObject *strstr;
if (strstr == NULL) {
- strstr = PyBytes_InternFromString("__str__");
+ strstr = PyString_InternFromString("__str__");
if (strstr == NULL)
return NULL;
}
static PyObject *hashstr, *eqstr, *cmpstr;
if (hashstr == NULL) {
- hashstr = PyBytes_InternFromString("__hash__");
+ hashstr = PyString_InternFromString("__hash__");
if (hashstr == NULL)
return -1;
}
address. If an __eq__ or __cmp__ method exists, there must
be a __hash__. */
if (eqstr == NULL) {
- eqstr = PyBytes_InternFromString("__eq__");
+ eqstr = PyString_InternFromString("__eq__");
if (eqstr == NULL)
return -1;
}
return -1;
PyErr_Clear();
if (cmpstr == NULL) {
- cmpstr = PyBytes_InternFromString("__cmp__");
+ cmpstr = PyString_InternFromString("__cmp__");
if (cmpstr == NULL)
return -1;
}
Py_ssize_t outcome;
if (lenstr == NULL) {
- lenstr = PyBytes_InternFromString("__len__");
+ lenstr = PyString_InternFromString("__len__");
if (lenstr == NULL)
return -1;
}
PyObject *res;
if (getitemstr == NULL) {
- getitemstr = PyBytes_InternFromString("__getitem__");
+ getitemstr = PyString_InternFromString("__getitem__");
if (getitemstr == NULL)
return NULL;
}
if (value == NULL) {
if (delitemstr == NULL) {
- delitemstr = PyBytes_InternFromString("__delitem__");
+ delitemstr = PyString_InternFromString("__delitem__");
if (delitemstr == NULL)
return -1;
}
}
else {
if (setitemstr == NULL) {
- setitemstr = PyBytes_InternFromString("__setitem__");
+ setitemstr = PyString_InternFromString("__setitem__");
if (setitemstr == NULL)
return -1;
}
PyObject *func, *res;
if (getitemstr == NULL) {
- getitemstr = PyBytes_InternFromString("__getitem__");
+ getitemstr = PyString_InternFromString("__getitem__");
if (getitemstr == NULL)
return NULL;
}
static PyObject *getslicestr;
if (getslicestr == NULL) {
- getslicestr = PyBytes_InternFromString("__getslice__");
+ getslicestr = PyString_InternFromString("__getslice__");
if (getslicestr == NULL)
return NULL;
}
PyErr_Clear();
if (getitemstr == NULL) {
- getitemstr = PyBytes_InternFromString("__getitem__");
+ getitemstr = PyString_InternFromString("__getitem__");
if (getitemstr == NULL)
return NULL;
}
if (item == NULL) {
if (delitemstr == NULL) {
- delitemstr = PyBytes_InternFromString("__delitem__");
+ delitemstr = PyString_InternFromString("__delitem__");
if (delitemstr == NULL)
return -1;
}
}
else {
if (setitemstr == NULL) {
- setitemstr = PyBytes_InternFromString("__setitem__");
+ setitemstr = PyString_InternFromString("__setitem__");
if (setitemstr == NULL)
return -1;
}
if (value == NULL) {
if (delslicestr == NULL) {
delslicestr =
- PyBytes_InternFromString("__delslice__");
+ PyString_InternFromString("__delslice__");
if (delslicestr == NULL)
return -1;
}
PyErr_Clear();
if (delitemstr == NULL) {
delitemstr =
- PyBytes_InternFromString("__delitem__");
+ PyString_InternFromString("__delitem__");
if (delitemstr == NULL)
return -1;
}
else {
if (setslicestr == NULL) {
setslicestr =
- PyBytes_InternFromString("__setslice__");
+ PyString_InternFromString("__setslice__");
if (setslicestr == NULL)
return -1;
}
PyErr_Clear();
if (setitemstr == NULL) {
setitemstr =
- PyBytes_InternFromString("__setitem__");
+ PyString_InternFromString("__setitem__");
if (setitemstr == NULL)
return -1;
}
*/
if(__contains__ == NULL) {
- __contains__ = PyBytes_InternFromString("__contains__");
+ __contains__ = PyString_InternFromString("__contains__");
if(__contains__ == NULL)
return -1;
}
}
if (coerce_obj == NULL) {
- coerce_obj = PyBytes_InternFromString("__coerce__");
+ coerce_obj = PyString_InternFromString("__coerce__");
if (coerce_obj == NULL)
return NULL;
}
PyObject *coerced;
if (coerce_obj == NULL) {
- coerce_obj = PyBytes_InternFromString("__coerce__");
+ coerce_obj = PyString_InternFromString("__coerce__");
if (coerce_obj == NULL)
return -1;
}
#define UNARY(funcname, methodname) \
static PyObject *funcname(PyInstanceObject *self) { \
static PyObject *o; \
- if (o == NULL) { o = PyBytes_InternFromString(methodname); \
+ if (o == NULL) { o = PyString_InternFromString(methodname); \
if (o == NULL) return NULL; } \
return generic_unary_op(self, o); \
}
#define UNARY_FB(funcname, methodname, funcname_fb) \
static PyObject *funcname(PyInstanceObject *self) { \
static PyObject *o; \
- if (o == NULL) { o = PyBytes_InternFromString(methodname); \
+ if (o == NULL) { o = PyString_InternFromString(methodname); \
if (o == NULL) return NULL; } \
if (PyObject_HasAttr((PyObject*)self, o)) \
return generic_unary_op(self, o); \
assert(PyInstance_Check(v));
if (cmp_obj == NULL) {
- cmp_obj = PyBytes_InternFromString("__cmp__");
+ cmp_obj = PyString_InternFromString("__cmp__");
if (cmp_obj == NULL)
return -2;
}
static PyObject *nonzerostr;
if (nonzerostr == NULL) {
- nonzerostr = PyBytes_InternFromString("__nonzero__");
+ nonzerostr = PyString_InternFromString("__nonzero__");
if (nonzerostr == NULL)
return -1;
}
return -1;
PyErr_Clear();
if (lenstr == NULL) {
- lenstr = PyBytes_InternFromString("__len__");
+ lenstr = PyString_InternFromString("__len__");
if (lenstr == NULL)
return -1;
}
static PyObject *indexstr = NULL;
if (indexstr == NULL) {
- indexstr = PyBytes_InternFromString("__index__");
+ indexstr = PyString_InternFromString("__index__");
if (indexstr == NULL)
return NULL;
}
PyObject *truncated;
static PyObject *int_name;
if (int_name == NULL) {
- int_name = PyBytes_InternFromString("__int__");
+ int_name = PyString_InternFromString("__int__");
if (int_name == NULL)
return NULL;
}
if (name_op == NULL)
return -1;
for (i = 0; i < NAME_OPS; ++i) {
- name_op[i] = PyBytes_InternFromString(_name_op[i]);
+ name_op[i] = PyString_InternFromString(_name_op[i]);
if (name_op[i] == NULL)
return -1;
}
PyObject *func;
if (iterstr == NULL) {
- iterstr = PyBytes_InternFromString("__iter__");
+ iterstr = PyString_InternFromString("__iter__");
if (iterstr == NULL)
return NULL;
}
if (getitemstr == NULL) {
- getitemstr = PyBytes_InternFromString("__getitem__");
+ getitemstr = PyString_InternFromString("__getitem__");
if (getitemstr == NULL)
return NULL;
}
PyObject *func;
if (nextstr == NULL) {
- nextstr = PyBytes_InternFromString("next");
+ nextstr = PyString_InternFromString("next");
if (nextstr == NULL)
return NULL;
}
PyErr_Clear();
PyErr_Format(PyExc_AttributeError,
"%.200s instance has no __call__ method",
- PyBytes_AsString(inst->in_class->cl_name));
+ PyString_AsString(inst->in_class->cl_name));
return NULL;
}
/* We must check and increment the recursion depth here. Scenario:
{
static PyObject *docstr;
if (docstr == NULL) {
- docstr= PyBytes_InternFromString("__doc__");
+ docstr= PyString_InternFromString("__doc__");
if (docstr == NULL)
return NULL;
}
return NULL;
PyErr_Clear();
}
- else if (!PyBytes_Check(funcname)) {
+ else if (!PyString_Check(funcname)) {
Py_DECREF(funcname);
funcname = NULL;
}
else
- sfuncname = PyBytes_AS_STRING(funcname);
+ sfuncname = PyString_AS_STRING(funcname);
if (klass == NULL)
klassname = NULL;
else {
return NULL;
PyErr_Clear();
}
- else if (!PyBytes_Check(klassname)) {
+ else if (!PyString_Check(klassname)) {
Py_DECREF(klassname);
klassname = NULL;
}
else
- sklassname = PyBytes_AS_STRING(klassname);
+ sklassname = PyString_AS_STRING(klassname);
}
if (self == NULL)
- result = PyBytes_FromFormat("<unbound method %s.%s>",
+ result = PyString_FromFormat("<unbound method %s.%s>",
sklassname, sfuncname);
else {
/* XXX Shouldn't use repr() here! */
PyObject *selfrepr = PyObject_Repr(self);
if (selfrepr == NULL)
goto fail;
- if (!PyBytes_Check(selfrepr)) {
+ if (!PyString_Check(selfrepr)) {
Py_DECREF(selfrepr);
goto fail;
}
- result = PyBytes_FromFormat("<bound method %s.%s of %s>",
+ result = PyString_FromFormat("<bound method %s.%s of %s>",
sklassname, sfuncname,
- PyBytes_AS_STRING(selfrepr));
+ PyString_AS_STRING(selfrepr));
Py_DECREF(selfrepr);
}
fail:
PyErr_Clear();
return;
}
- if (PyBytes_Check(name)) {
- strncpy(buf, PyBytes_AS_STRING(name), bufsize);
+ if (PyString_Check(name)) {
+ strncpy(buf, PyString_AS_STRING(name), bufsize);
buf[bufsize-1] = '\0';
}
Py_DECREF(name);
for (i = PyTuple_GET_SIZE(tuple); --i >= 0; ) {
PyObject *v = PyTuple_GET_ITEM(tuple, i);
- if (v == NULL || !PyBytes_CheckExact(v)) {
+ if (v == NULL || !PyString_CheckExact(v)) {
Py_FatalError("non-string found in code slot");
}
- PyBytes_InternInPlace(&PyTuple_GET_ITEM(tuple, i));
+ PyString_InternInPlace(&PyTuple_GET_ITEM(tuple, i));
}
}
varnames == NULL || !PyTuple_Check(varnames) ||
freevars == NULL || !PyTuple_Check(freevars) ||
cellvars == NULL || !PyTuple_Check(cellvars) ||
- name == NULL || !PyBytes_Check(name) ||
- filename == NULL || !PyBytes_Check(filename) ||
- lnotab == NULL || !PyBytes_Check(lnotab) ||
+ name == NULL || !PyString_Check(name) ||
+ filename == NULL || !PyString_Check(filename) ||
+ lnotab == NULL || !PyString_Check(lnotab) ||
!PyObject_CheckReadBuffer(code)) {
PyErr_BadInternalCall();
return NULL;
/* Intern selected string constants */
for (i = PyTuple_Size(consts); --i >= 0; ) {
PyObject *v = PyTuple_GetItem(consts, i);
- if (!PyBytes_Check(v))
+ if (!PyString_Check(v))
continue;
- if (!all_name_chars((unsigned char *)PyBytes_AS_STRING(v)))
+ if (!all_name_chars((unsigned char *)PyString_AS_STRING(v)))
continue;
- PyBytes_InternInPlace(&PyTuple_GET_ITEM(consts, i));
+ PyString_InternInPlace(&PyTuple_GET_ITEM(consts, i));
}
co = PyObject_NEW(PyCodeObject, &PyCode_Type);
if (co != NULL) {
for (i = 0; i < len; i++) {
item = PyTuple_GET_ITEM(tup, i);
- if (PyBytes_CheckExact(item)) {
+ if (PyString_CheckExact(item)) {
Py_INCREF(item);
}
- else if (!PyBytes_Check(item)) {
+ else if (!PyString_Check(item)) {
PyErr_Format(
PyExc_TypeError,
"name tuples must contain only "
return NULL;
}
else {
- item = PyBytes_FromStringAndSize(
- PyBytes_AS_STRING(item),
- PyBytes_GET_SIZE(item));
+ item = PyString_FromStringAndSize(
+ PyString_AS_STRING(item),
+ PyString_GET_SIZE(item));
if (item == NULL) {
Py_DECREF(newtuple);
return NULL;
if (co->co_firstlineno != 0)
lineno = co->co_firstlineno;
- if (co->co_filename && PyBytes_Check(co->co_filename))
- filename = PyBytes_AS_STRING(co->co_filename);
- if (co->co_name && PyBytes_Check(co->co_name))
- name = PyBytes_AS_STRING(co->co_name);
+ if (co->co_filename && PyString_Check(co->co_filename))
+ filename = PyString_AS_STRING(co->co_filename);
+ if (co->co_name && PyString_Check(co->co_name))
+ name = PyString_AS_STRING(co->co_name);
PyOS_snprintf(buf, sizeof(buf),
"<code object %.100s at %p, file \"%.300s\", line %d>",
name, co, filename, lineno);
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
static int
int
PyCode_Addr2Line(PyCodeObject *co, int addrq)
{
- int size = PyBytes_Size(co->co_lnotab) / 2;
- unsigned char *p = (unsigned char*)PyBytes_AsString(co->co_lnotab);
+ int size = PyString_Size(co->co_lnotab) / 2;
+ unsigned char *p = (unsigned char*)PyString_AsString(co->co_lnotab);
int line = co->co_firstlineno;
int addr = 0;
while (--size >= 0) {
int size, addr, line;
unsigned char* p;
- p = (unsigned char*)PyBytes_AS_STRING(co->co_lnotab);
- size = PyBytes_GET_SIZE(co->co_lnotab) / 2;
+ p = (unsigned char*)PyString_AS_STRING(co->co_lnotab);
+ size = PyString_GET_SIZE(co->co_lnotab) / 2;
addr = 0;
line = co->co_firstlineno;
cv.imag = 0.;
if (complex_str == NULL) {
- if (!(complex_str = PyBytes_InternFromString("__complex__")))
+ if (!(complex_str = PyString_InternFromString("__complex__")))
return cv;
}
{
char buf[100];
complex_to_buf(buf, sizeof(buf), v, PREC_REPR);
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
static PyObject *
{
char buf[100];
complex_to_buf(buf, sizeof(buf), v, PREC_STR);
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
static long
#endif
Py_ssize_t len;
- if (PyBytes_Check(v)) {
- s = PyBytes_AS_STRING(v);
- len = PyBytes_GET_SIZE(v);
+ if (PyString_Check(v)) {
+ s = PyString_AS_STRING(v);
+ len = PyString_GET_SIZE(v);
}
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(v)) {
Py_INCREF(r);
return r;
}
- if (PyBytes_Check(r) || PyUnicode_Check(r)) {
+ if (PyString_Check(r) || PyUnicode_Check(r)) {
if (i != NULL) {
PyErr_SetString(PyExc_TypeError,
"complex() can't take second arg"
}
return complex_subtype_from_string(type, r);
}
- if (i != NULL && (PyBytes_Check(i) || PyUnicode_Check(i))) {
+ if (i != NULL && (PyString_Check(i) || PyUnicode_Check(i))) {
PyErr_SetString(PyExc_TypeError,
"complex() second arg can't be a string");
return NULL;
/* XXX Hack to support classes with __complex__ method */
if (complexstr == NULL) {
- complexstr = PyBytes_InternFromString("__complex__");
+ complexstr = PyString_InternFromString("__complex__");
if (complexstr == NULL)
return NULL;
}
static char *
descr_name(PyDescrObject *descr)
{
- if (descr->d_name != NULL && PyBytes_Check(descr->d_name))
- return PyBytes_AS_STRING(descr->d_name);
+ if (descr->d_name != NULL && PyString_Check(descr->d_name))
+ return PyString_AS_STRING(descr->d_name);
else
return "?";
}
static PyObject *
descr_repr(PyDescrObject *descr, char *format)
{
- return PyBytes_FromFormat(format, descr_name(descr),
+ return PyString_FromFormat(format, descr_name(descr),
descr->d_type->tp_name);
}
Py_INCREF(Py_None);
return Py_None;
}
- return PyBytes_FromString(descr->d_method->ml_doc);
+ return PyString_FromString(descr->d_method->ml_doc);
}
static PyMemberDef descr_members[] = {
Py_INCREF(Py_None);
return Py_None;
}
- return PyBytes_FromString(descr->d_member->doc);
+ return PyString_FromString(descr->d_member->doc);
}
static PyGetSetDef member_getset[] = {
Py_INCREF(Py_None);
return Py_None;
}
- return PyBytes_FromString(descr->d_getset->doc);
+ return PyString_FromString(descr->d_getset->doc);
}
static PyGetSetDef getset_getset[] = {
Py_INCREF(Py_None);
return Py_None;
}
- return PyBytes_FromString(descr->d_base->doc);
+ return PyString_FromString(descr->d_base->doc);
}
static PyGetSetDef wrapperdescr_getset[] = {
if (descr != NULL) {
Py_XINCREF(type);
descr->d_type = type;
- descr->d_name = PyBytes_InternFromString(name);
+ descr->d_name = PyString_InternFromString(name);
if (descr->d_name == NULL) {
Py_DECREF(descr);
descr = NULL;
static PyObject *
wrapper_repr(wrapperobject *wp)
{
- return PyBytes_FromFormat("<method-wrapper '%s' of %s object at %p>",
+ return PyString_FromFormat("<method-wrapper '%s' of %s object at %p>",
wp->descr->d_base->name,
wp->self->ob_type->tp_name,
wp->self);
{
char *s = wp->descr->d_base->name;
- return PyBytes_FromString(s);
+ return PyString_FromString(s);
}
static PyObject *
return Py_None;
}
else {
- return PyBytes_FromString(s);
+ return PyString_FromString(s);
}
}
{
register PyDictObject *mp;
if (dummy == NULL) { /* Auto-initialize dummy */
- dummy = PyBytes_FromString("<dummy key>");
+ dummy = PyString_FromString("<dummy key>");
if (dummy == NULL)
return NULL;
#ifdef SHOW_CONVERSION_COUNTS
* this assumption allows testing for errors during PyObject_RichCompareBool()
* to be dropped; string-string comparisons never raise exceptions. This also
* means we don't need to go through PyObject_RichCompareBool(); we can always
- * use _PyBytes_Eq() directly.
+ * use _PyString_Eq() directly.
*
* This is valuable because dicts with only string keys are very common.
*/
including subclasses of str; e.g., one reason to subclass
strings is to override __eq__, and for speed we don't cater to
that here. */
- if (!PyBytes_CheckExact(key)) {
+ if (!PyString_CheckExact(key)) {
#ifdef SHOW_CONVERSION_COUNTS
++converted;
#endif
if (ep->me_key == dummy)
freeslot = ep;
else {
- if (ep->me_hash == hash && _PyBytes_Eq(ep->me_key, key))
+ if (ep->me_hash == hash && _PyString_Eq(ep->me_key, key))
return ep;
freeslot = NULL;
}
if (ep->me_key == key
|| (ep->me_hash == hash
&& ep->me_key != dummy
- && _PyBytes_Eq(ep->me_key, key)))
+ && _PyString_Eq(ep->me_key, key)))
return ep;
if (ep->me_key == dummy && freeslot == NULL)
freeslot = ep;
PyThreadState *tstate;
if (!PyDict_Check(op))
return NULL;
- if (!PyBytes_CheckExact(key) ||
- (hash = ((PyBytesObject *) key)->ob_shash) == -1)
+ if (!PyString_CheckExact(key) ||
+ (hash = ((PyStringObject *) key)->ob_shash) == -1)
{
hash = PyObject_Hash(key);
if (hash == -1) {
assert(key);
assert(value);
mp = (PyDictObject *)op;
- if (PyBytes_CheckExact(key)) {
- hash = ((PyBytesObject *)key)->ob_shash;
+ if (PyString_CheckExact(key)) {
+ hash = ((PyStringObject *)key)->ob_shash;
if (hash == -1)
hash = PyObject_Hash(key);
}
return -1;
}
assert(key);
- if (!PyBytes_CheckExact(key) ||
- (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
+ if (!PyString_CheckExact(key) ||
+ (hash = ((PyStringObject *) key)->ob_shash) == -1) {
hash = PyObject_Hash(key);
if (hash == -1)
return -1;
i = Py_ReprEnter((PyObject *)mp);
if (i != 0) {
- return i > 0 ? PyBytes_FromString("{...}") : NULL;
+ return i > 0 ? PyString_FromString("{...}") : NULL;
}
if (mp->ma_used == 0) {
- result = PyBytes_FromString("{}");
+ result = PyString_FromString("{}");
goto Done;
}
if (pieces == NULL)
goto Done;
- colon = PyBytes_FromString(": ");
+ colon = PyString_FromString(": ");
if (colon == NULL)
goto Done;
/* Prevent repr from deleting value during key format. */
Py_INCREF(value);
s = PyObject_Repr(key);
- PyBytes_Concat(&s, colon);
- PyBytes_ConcatAndDel(&s, PyObject_Repr(value));
+ PyString_Concat(&s, colon);
+ PyString_ConcatAndDel(&s, PyObject_Repr(value));
Py_DECREF(value);
if (s == NULL)
goto Done;
/* Add "{}" decorations to the first and last items. */
assert(PyList_GET_SIZE(pieces) > 0);
- s = PyBytes_FromString("{");
+ s = PyString_FromString("{");
if (s == NULL)
goto Done;
temp = PyList_GET_ITEM(pieces, 0);
- PyBytes_ConcatAndDel(&s, temp);
+ PyString_ConcatAndDel(&s, temp);
PyList_SET_ITEM(pieces, 0, s);
if (s == NULL)
goto Done;
- s = PyBytes_FromString("}");
+ s = PyString_FromString("}");
if (s == NULL)
goto Done;
temp = PyList_GET_ITEM(pieces, PyList_GET_SIZE(pieces) - 1);
- PyBytes_ConcatAndDel(&temp, s);
+ PyString_ConcatAndDel(&temp, s);
PyList_SET_ITEM(pieces, PyList_GET_SIZE(pieces) - 1, temp);
if (temp == NULL)
goto Done;
/* Paste them all together with ", " between. */
- s = PyBytes_FromString(", ");
+ s = PyString_FromString(", ");
if (s == NULL)
goto Done;
- result = _PyBytes_Join(s, pieces);
+ result = _PyString_Join(s, pieces);
Py_DECREF(s);
Done:
long hash;
PyDictEntry *ep;
assert(mp->ma_table != NULL);
- if (!PyBytes_CheckExact(key) ||
- (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
+ if (!PyString_CheckExact(key) ||
+ (hash = ((PyStringObject *) key)->ob_shash) == -1) {
hash = PyObject_Hash(key);
if (hash == -1)
return NULL;
static PyObject *missing_str = NULL;
if (missing_str == NULL)
missing_str =
- PyBytes_InternFromString("__missing__");
+ PyString_InternFromString("__missing__");
missing = _PyType_Lookup(Py_TYPE(mp), missing_str);
if (missing != NULL)
return PyObject_CallFunctionObjArgs(missing,
long hash;
PyDictEntry *ep;
- if (!PyBytes_CheckExact(key) ||
- (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
+ if (!PyString_CheckExact(key) ||
+ (hash = ((PyStringObject *) key)->ob_shash) == -1) {
hash = PyObject_Hash(key);
if (hash == -1)
return NULL;
if (!PyArg_UnpackTuple(args, "get", 1, 2, &key, &failobj))
return NULL;
- if (!PyBytes_CheckExact(key) ||
- (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
+ if (!PyString_CheckExact(key) ||
+ (hash = ((PyStringObject *) key)->ob_shash) == -1) {
hash = PyObject_Hash(key);
if (hash == -1)
return NULL;
if (!PyArg_UnpackTuple(args, "setdefault", 1, 2, &key, &failobj))
return NULL;
- if (!PyBytes_CheckExact(key) ||
- (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
+ if (!PyString_CheckExact(key) ||
+ (hash = ((PyStringObject *) key)->ob_shash) == -1) {
hash = PyObject_Hash(key);
if (hash == -1)
return NULL;
"pop(): dictionary is empty");
return NULL;
}
- if (!PyBytes_CheckExact(key) ||
- (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
+ if (!PyString_CheckExact(key) ||
+ (hash = ((PyStringObject *) key)->ob_shash) == -1) {
hash = PyObject_Hash(key);
if (hash == -1)
return NULL;
PyDictObject *mp = (PyDictObject *)op;
PyDictEntry *ep;
- if (!PyBytes_CheckExact(key) ||
- (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
+ if (!PyString_CheckExact(key) ||
+ (hash = ((PyStringObject *) key)->ob_shash) == -1) {
hash = PyObject_Hash(key);
if (hash == -1)
return -1;
PyDict_GetItemString(PyObject *v, const char *key)
{
PyObject *kv, *rv;
- kv = PyBytes_FromString(key);
+ kv = PyString_FromString(key);
if (kv == NULL)
return NULL;
rv = PyDict_GetItem(v, kv);
{
PyObject *kv;
int err;
- kv = PyBytes_FromString(key);
+ kv = PyString_FromString(key);
if (kv == NULL)
return -1;
- PyBytes_InternInPlace(&kv); /* XXX Should we really? */
+ PyString_InternInPlace(&kv); /* XXX Should we really? */
err = PyDict_SetItem(v, kv, item);
Py_DECREF(kv);
return err;
{
PyObject *kv;
int err;
- kv = PyBytes_FromString(key);
+ kv = PyString_FromString(key);
if (kv == NULL)
return -1;
err = PyDict_DelItem(v, kv);
return NULL;
}
- self->message = PyBytes_FromString("");
+ self->message = PyString_FromString("");
if (!self->message) {
Py_DECREF(self);
return NULL;
switch (PyTuple_GET_SIZE(self->args)) {
case 0:
- out = PyBytes_FromString("");
+ out = PyString_FromString("");
break;
case 1:
out = PyObject_Str(PyTuple_GET_ITEM(self->args, 0));
dot = strrchr(name, '.');
if (dot != NULL) name = dot+1;
- repr = PyBytes_FromString(name);
+ repr = PyString_FromString(name);
if (!repr) {
Py_DECREF(repr_suffix);
return NULL;
}
- PyBytes_ConcatAndDel(&repr, repr_suffix);
+ PyString_ConcatAndDel(&repr, repr_suffix);
return repr;
}
PyObject *repr;
PyObject *tuple;
- fmt = PyBytes_FromString("[Errno %s] %s: %s");
+ fmt = PyString_FromString("[Errno %s] %s: %s");
if (!fmt)
return NULL;
PyTuple_SET_ITEM(tuple, 2, repr);
- rtnval = PyBytes_Format(fmt, tuple);
+ rtnval = PyString_Format(fmt, tuple);
Py_DECREF(fmt);
Py_DECREF(tuple);
PyObject *fmt;
PyObject *tuple;
- fmt = PyBytes_FromString("[Errno %s] %s");
+ fmt = PyString_FromString("[Errno %s] %s");
if (!fmt)
return NULL;
PyTuple_SET_ITEM(tuple, 1, Py_None);
}
- rtnval = PyBytes_Format(fmt, tuple);
+ rtnval = PyString_Format(fmt, tuple);
Py_DECREF(fmt);
Py_DECREF(tuple);
PyObject *repr;
PyObject *tuple;
- fmt = PyBytes_FromString("[Error %s] %s: %s");
+ fmt = PyString_FromString("[Error %s] %s: %s");
if (!fmt)
return NULL;
PyTuple_SET_ITEM(tuple, 2, repr);
- rtnval = PyBytes_Format(fmt, tuple);
+ rtnval = PyString_Format(fmt, tuple);
Py_DECREF(fmt);
Py_DECREF(tuple);
PyObject *fmt;
PyObject *tuple;
- fmt = PyBytes_FromString("[Error %s] %s");
+ fmt = PyString_FromString("[Error %s] %s");
if (!fmt)
return NULL;
PyTuple_SET_ITEM(tuple, 1, Py_None);
}
- rtnval = PyBytes_Format(fmt, tuple);
+ rtnval = PyString_Format(fmt, tuple);
Py_DECREF(fmt);
Py_DECREF(tuple);
str = PyObject_Str(Py_None);
if (!str) return NULL;
/* Don't fiddle with non-string return (shouldn't happen anyway) */
- if (!PyBytes_Check(str)) return str;
+ if (!PyString_Check(str)) return str;
/* XXX -- do all the additional formatting with filename and
lineno here */
have_filename = (self->filename != NULL) &&
- PyBytes_Check(self->filename);
+ PyString_Check(self->filename);
have_lineno = (self->lineno != NULL) && PyInt_Check(self->lineno);
if (!have_filename && !have_lineno)
return str;
- bufsize = PyBytes_GET_SIZE(str) + 64;
+ bufsize = PyString_GET_SIZE(str) + 64;
if (have_filename)
- bufsize += PyBytes_GET_SIZE(self->filename);
+ bufsize += PyString_GET_SIZE(self->filename);
buffer = PyMem_MALLOC(bufsize);
if (buffer == NULL)
if (have_filename && have_lineno)
PyOS_snprintf(buffer, bufsize, "%s (%s, line %ld)",
- PyBytes_AS_STRING(str),
- my_basename(PyBytes_AS_STRING(self->filename)),
+ PyString_AS_STRING(str),
+ my_basename(PyString_AS_STRING(self->filename)),
PyInt_AsLong(self->lineno));
else if (have_filename)
PyOS_snprintf(buffer, bufsize, "%s (%s)",
- PyBytes_AS_STRING(str),
- my_basename(PyBytes_AS_STRING(self->filename)));
+ PyString_AS_STRING(str),
+ my_basename(PyString_AS_STRING(self->filename)));
else /* only have_lineno */
PyOS_snprintf(buffer, bufsize, "%s (line %ld)",
- PyBytes_AS_STRING(str),
+ PyString_AS_STRING(str),
PyInt_AsLong(self->lineno));
- result = PyBytes_FromString(buffer);
+ result = PyString_FromString(buffer);
PyMem_FREE(buffer);
if (result == NULL)
return NULL;
}
- if (!PyBytes_Check(attr)) {
+ if (!PyString_Check(attr)) {
PyErr_Format(PyExc_TypeError, "%.200s attribute must be str", name);
return NULL;
}
static int
set_string(PyObject **attr, const char *value)
{
- PyObject *obj = PyBytes_FromString(value);
+ PyObject *obj = PyString_FromString(value);
if (!obj)
return -1;
Py_CLEAR(*attr);
"object");
if (!obj)
return -1;
- size = PyBytes_GET_SIZE(obj);
+ size = PyString_GET_SIZE(obj);
*start = ((PyUnicodeErrorObject *)exc)->start;
if (*start<0)
*start = 0;
if (!obj)
return -1;
*end = ((PyUnicodeErrorObject *)exc)->end;
- size = PyBytes_GET_SIZE(obj);
+ size = PyString_GET_SIZE(obj);
if (*end<1)
*end = 1;
if (*end>size)
Py_CLEAR(self->reason);
if (!PyArg_ParseTuple(args, "O!O!nnO!",
- &PyBytes_Type, &self->encoding,
+ &PyString_Type, &self->encoding,
objecttype, &self->object,
&self->start,
&self->end,
- &PyBytes_Type, &self->reason)) {
+ &PyString_Type, &self->reason)) {
self->encoding = self->object = self->reason = NULL;
return -1;
}
PyOS_snprintf(badchar_str, sizeof(badchar_str), "u%04x", badchar);
else
PyOS_snprintf(badchar_str, sizeof(badchar_str), "U%08x", badchar);
- return PyBytes_FromFormat(
+ return PyString_FromFormat(
"'%.400s' codec can't encode character u'\\%s' in position %zd: %.400s",
- PyBytes_AS_STRING(uself->encoding),
+ PyString_AS_STRING(uself->encoding),
badchar_str,
uself->start,
- PyBytes_AS_STRING(uself->reason)
+ PyString_AS_STRING(uself->reason)
);
}
- return PyBytes_FromFormat(
+ return PyString_FromFormat(
"'%.400s' codec can't encode characters in position %zd-%zd: %.400s",
- PyBytes_AS_STRING(uself->encoding),
+ PyString_AS_STRING(uself->encoding),
uself->start,
uself->end-1,
- PyBytes_AS_STRING(uself->reason)
+ PyString_AS_STRING(uself->reason)
);
}
if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)
return -1;
return UnicodeError_init((PyUnicodeErrorObject *)self, args,
- kwds, &PyBytes_Type);
+ kwds, &PyString_Type);
}
static PyObject *
/* FromFormat does not support %02x, so format that separately */
char byte[4];
PyOS_snprintf(byte, sizeof(byte), "%02x",
- ((int)PyBytes_AS_STRING(uself->object)[uself->start])&0xff);
- return PyBytes_FromFormat(
+ ((int)PyString_AS_STRING(uself->object)[uself->start])&0xff);
+ return PyString_FromFormat(
"'%.400s' codec can't decode byte 0x%s in position %zd: %.400s",
- PyBytes_AS_STRING(uself->encoding),
+ PyString_AS_STRING(uself->encoding),
byte,
uself->start,
- PyBytes_AS_STRING(uself->reason)
+ PyString_AS_STRING(uself->reason)
);
}
- return PyBytes_FromFormat(
+ return PyString_FromFormat(
"'%.400s' codec can't decode bytes in position %zd-%zd: %.400s",
- PyBytes_AS_STRING(uself->encoding),
+ PyString_AS_STRING(uself->encoding),
uself->start,
uself->end-1,
- PyBytes_AS_STRING(uself->reason)
+ PyString_AS_STRING(uself->reason)
);
}
&PyUnicode_Type, &self->object,
&self->start,
&self->end,
- &PyBytes_Type, &self->reason)) {
+ &PyString_Type, &self->reason)) {
self->object = self->reason = NULL;
return -1;
}
PyOS_snprintf(badchar_str, sizeof(badchar_str), "u%04x", badchar);
else
PyOS_snprintf(badchar_str, sizeof(badchar_str), "U%08x", badchar);
- return PyBytes_FromFormat(
+ return PyString_FromFormat(
"can't translate character u'\\%s' in position %zd: %.400s",
badchar_str,
uself->start,
- PyBytes_AS_STRING(uself->reason)
+ PyString_AS_STRING(uself->reason)
);
}
- return PyBytes_FromFormat(
+ return PyString_FromFormat(
"can't translate characters in position %zd-%zd: %.400s",
uself->start,
uself->end-1,
- PyBytes_AS_STRING(uself->reason)
+ PyString_AS_STRING(uself->reason)
);
}
(PyBaseExceptionObject *)PyExc_RecursionErrorInst;
PyObject *args_tuple;
PyObject *exc_message;
- exc_message = PyBytes_FromString("maximum recursion depth exceeded");
+ exc_message = PyString_FromString("maximum recursion depth exceeded");
if (!exc_message)
Py_FatalError("cannot allocate argument for RuntimeError "
"pre-allocation");
#include <io.h>
#endif
-#define BUF(v) PyBytes_AS_STRING((PyBytesObject *)v)
+#define BUF(v) PyString_AS_STRING((PyStringObject *)v)
#ifndef DONT_HAVE_ERRNO_H
#include <errno.h>
Py_INCREF(name);
f->f_name = name;
- f->f_mode = PyBytes_FromString(mode);
+ f->f_mode = PyString_FromString(mode);
f->f_close = close;
f->f_softspace = 0;
PyFileObject *f = (PyFileObject *)PyFile_Type.tp_new(&PyFile_Type,
NULL, NULL);
if (f != NULL) {
- PyObject *o_name = PyBytes_FromString(name);
+ PyObject *o_name = PyString_FromString(name);
if (o_name == NULL)
return NULL;
if (fill_file_fields(f, fp, o_name, mode, close) == NULL) {
#ifdef Py_USING_UNICODE
PyObject *ret = NULL;
PyObject *name = PyUnicode_AsUnicodeEscapeString(f->f_name);
- const char *name_str = name ? PyBytes_AsString(name) : "?";
- ret = PyBytes_FromFormat("<%s file u'%s', mode '%s' at %p>",
+ const char *name_str = name ? PyString_AsString(name) : "?";
+ ret = PyString_FromFormat("<%s file u'%s', mode '%s' at %p>",
f->f_fp == NULL ? "closed" : "open",
name_str,
- PyBytes_AsString(f->f_mode),
+ PyString_AsString(f->f_mode),
f);
Py_XDECREF(name);
return ret;
#endif
} else {
- return PyBytes_FromFormat("<%s file '%s', mode '%s' at %p>",
+ return PyString_FromFormat("<%s file '%s', mode '%s' at %p>",
f->f_fp == NULL ? "closed" : "open",
- PyBytes_AsString(f->f_name),
- PyBytes_AsString(f->f_mode),
+ PyString_AsString(f->f_name),
+ PyString_AsString(f->f_mode),
f);
}
}
"requested number of bytes is more than a Python string can hold");
return NULL;
}
- v = PyBytes_FromStringAndSize((char *)NULL, buffersize);
+ v = PyString_FromStringAndSize((char *)NULL, buffersize);
if (v == NULL)
return NULL;
bytesread = 0;
}
if (bytesrequested < 0) {
buffersize = new_buffersize(f, buffersize);
- if (_PyBytes_Resize(&v, buffersize) < 0)
+ if (_PyString_Resize(&v, buffersize) < 0)
return NULL;
} else {
/* Got what was requested. */
}
}
if (bytesread != buffersize)
- _PyBytes_Resize(&v, bytesread);
+ _PyString_Resize(&v, bytesread);
return v;
}
size_t increment; /* amount to increment the buffer */
size_t prev_v_size;
- /* Optimize for normal case: avoid _PyBytes_Resize if at all
+ /* Optimize for normal case: avoid _PyString_Resize if at all
* possible via first reading into stack buffer "buf".
*/
total_v_size = INITBUFSIZE; /* start small and pray */
clearerr(fp);
if (PyErr_CheckSignals())
return NULL;
- v = PyBytes_FromStringAndSize(buf, pvfree - buf);
+ v = PyString_FromStringAndSize(buf, pvfree - buf);
return v;
}
/* fgets read *something* */
assert(p > pvfree && *(p-1) == '\0');
--p; /* don't include \0 from fgets */
}
- v = PyBytes_FromStringAndSize(buf, p - buf);
+ v = PyString_FromStringAndSize(buf, p - buf);
return v;
}
/* yuck: fgets overwrote all the newlines, i.e. the entire
* into its buffer.
*/
total_v_size = MAXBUFSIZE << 1;
- v = PyBytes_FromStringAndSize((char*)NULL, (int)total_v_size);
+ v = PyString_FromStringAndSize((char*)NULL, (int)total_v_size);
if (v == NULL)
return v;
/* copy over everything except the last null byte */
Py_DECREF(v);
return NULL;
}
- if (_PyBytes_Resize(&v, (int)total_v_size) < 0)
+ if (_PyString_Resize(&v, (int)total_v_size) < 0)
return NULL;
/* overwrite the trailing null byte */
pvfree = BUF(v) + (prev_v_size - 1);
}
if (BUF(v) + total_v_size != p)
- _PyBytes_Resize(&v, p - BUF(v));
+ _PyString_Resize(&v, p - BUF(v));
return v;
#undef INITBUFSIZE
#undef MAXBUFSIZE
return getline_via_fgets(f, fp);
#endif
total_v_size = n > 0 ? n : 100;
- v = PyBytes_FromStringAndSize((char *)NULL, total_v_size);
+ v = PyString_FromStringAndSize((char *)NULL, total_v_size);
if (v == NULL)
return NULL;
buf = BUF(v);
Py_DECREF(v);
return NULL;
}
- if (_PyBytes_Resize(&v, total_v_size) < 0)
+ if (_PyString_Resize(&v, total_v_size) < 0)
return NULL;
buf = BUF(v) + used_v_size;
end = BUF(v) + total_v_size;
used_v_size = buf - BUF(v);
if (used_v_size != total_v_size)
- _PyBytes_Resize(&v, used_v_size);
+ _PyString_Resize(&v, used_v_size);
return v;
}
result = PyEval_CallObject(reader, args);
Py_DECREF(reader);
Py_DECREF(args);
- if (result != NULL && !PyBytes_Check(result) &&
+ if (result != NULL && !PyString_Check(result) &&
!PyUnicode_Check(result)) {
Py_DECREF(result);
result = NULL;
}
}
- if (n < 0 && result != NULL && PyBytes_Check(result)) {
- char *s = PyBytes_AS_STRING(result);
- Py_ssize_t len = PyBytes_GET_SIZE(result);
+ if (n < 0 && result != NULL && PyString_Check(result)) {
+ char *s = PyString_AS_STRING(result);
+ Py_ssize_t len = PyString_GET_SIZE(result);
if (len == 0) {
Py_DECREF(result);
result = NULL;
}
else if (s[len-1] == '\n') {
if (result->ob_refcnt == 1)
- _PyBytes_Resize(&result, len-1);
+ _PyString_Resize(&result, len-1);
else {
PyObject *v;
- v = PyBytes_FromStringAndSize(s, len-1);
+ v = PyString_FromStringAndSize(s, len-1);
Py_DECREF(result);
result = v;
}
if (!PyArg_ParseTuple(args, "|i:readline", &n))
return NULL;
if (n == 0)
- return PyBytes_FromString("");
+ return PyString_FromString("");
if (n < 0)
n = 0;
return get_line(f, n);
}
if (big_buffer == NULL) {
/* Create the big buffer */
- big_buffer = PyBytes_FromStringAndSize(
+ big_buffer = PyString_FromStringAndSize(
NULL, buffersize);
if (big_buffer == NULL)
goto error;
- buffer = PyBytes_AS_STRING(big_buffer);
+ buffer = PyString_AS_STRING(big_buffer);
memcpy(buffer, small_buffer, nfilled);
}
else {
/* Grow the big buffer */
- if ( _PyBytes_Resize(&big_buffer, buffersize) < 0 )
+ if ( _PyString_Resize(&big_buffer, buffersize) < 0 )
goto error;
- buffer = PyBytes_AS_STRING(big_buffer);
+ buffer = PyString_AS_STRING(big_buffer);
}
continue;
}
do {
/* Process complete lines */
p++;
- line = PyBytes_FromStringAndSize(q, p-q);
+ line = PyString_FromStringAndSize(q, p-q);
if (line == NULL)
goto error;
err = PyList_Append(list, line);
}
if (nfilled != 0) {
/* Partial last line */
- line = PyBytes_FromStringAndSize(buffer, nfilled);
+ line = PyString_FromStringAndSize(buffer, nfilled);
if (line == NULL)
goto error;
if (sizehint > 0) {
Py_DECREF(line);
goto error;
}
- PyBytes_Concat(&line, rest);
+ PyString_Concat(&line, rest);
Py_DECREF(rest);
if (line == NULL)
goto error;
could potentially execute Python code. */
for (i = 0; i < j; i++) {
PyObject *v = PyList_GET_ITEM(list, i);
- if (!PyBytes_Check(v)) {
+ if (!PyString_Check(v)) {
const char *buffer;
if (((f->f_binary &&
PyObject_AsReadBuffer(v,
"writelines() argument must be a sequence of strings");
goto error;
}
- line = PyBytes_FromStringAndSize(buffer,
+ line = PyString_FromStringAndSize(buffer,
len);
if (line == NULL)
goto error;
errno = 0;
for (i = 0; i < j; i++) {
line = PyList_GET_ITEM(list, i);
- len = PyBytes_GET_SIZE(line);
- nwritten = fwrite(PyBytes_AS_STRING(line),
+ len = PyString_GET_SIZE(line);
+ nwritten = fwrite(PyString_AS_STRING(line),
1, len, f->f_fp);
if (nwritten != len) {
FILE_ABORT_ALLOW_THREADS(f)
Py_INCREF(Py_None);
return Py_None;
case NEWLINE_CR:
- return PyBytes_FromString("\r");
+ return PyString_FromString("\r");
case NEWLINE_LF:
- return PyBytes_FromString("\n");
+ return PyString_FromString("\n");
case NEWLINE_CR|NEWLINE_LF:
return Py_BuildValue("(ss)", "\r", "\n");
case NEWLINE_CRLF:
- return PyBytes_FromString("\r\n");
+ return PyString_FromString("\r\n");
case NEWLINE_CR|NEWLINE_CRLF:
return Py_BuildValue("(ss)", "\r", "\r\n");
case NEWLINE_LF|NEWLINE_CRLF:
horrified by the recursive call: maximum recursion depth is limited by
logarithmic buffer growth to about 50 even when reading a 1gb line. */
-static PyBytesObject *
+static PyStringObject *
readahead_get_line_skip(PyFileObject *f, int skip, int bufsize)
{
- PyBytesObject* s;
+ PyStringObject* s;
char *bufptr;
char *buf;
Py_ssize_t len;
len = f->f_bufend - f->f_bufptr;
if (len == 0)
- return (PyBytesObject *)
- PyBytes_FromStringAndSize(NULL, skip);
+ return (PyStringObject *)
+ PyString_FromStringAndSize(NULL, skip);
bufptr = (char *)memchr(f->f_bufptr, '\n', len);
if (bufptr != NULL) {
bufptr++; /* Count the '\n' */
len = bufptr - f->f_bufptr;
- s = (PyBytesObject *)
- PyBytes_FromStringAndSize(NULL, skip+len);
+ s = (PyStringObject *)
+ PyString_FromStringAndSize(NULL, skip+len);
if (s == NULL)
return NULL;
- memcpy(PyBytes_AS_STRING(s)+skip, f->f_bufptr, len);
+ memcpy(PyString_AS_STRING(s)+skip, f->f_bufptr, len);
f->f_bufptr = bufptr;
if (bufptr == f->f_bufend)
drop_readahead(f);
PyMem_Free(buf);
return NULL;
}
- memcpy(PyBytes_AS_STRING(s)+skip, bufptr, len);
+ memcpy(PyString_AS_STRING(s)+skip, bufptr, len);
PyMem_Free(buf);
}
return s;
static PyObject *
file_iternext(PyFileObject *f)
{
- PyBytesObject* l;
+ PyStringObject* l;
if (f->f_fp == NULL)
return err_closed();
l = readahead_get_line_skip(f, 0, READAHEAD_BUFSIZE);
- if (l == NULL || PyBytes_GET_SIZE(l) == 0) {
+ if (l == NULL || PyString_GET_SIZE(l) == 0) {
Py_XDECREF(l);
return NULL;
}
assert(type != NULL && type->tp_alloc != NULL);
if (not_yet_string == NULL) {
- not_yet_string = PyBytes_InternFromString("<uninitialized file>");
+ not_yet_string = PyString_InternFromString("<uninitialized file>");
if (not_yet_string == NULL)
return NULL;
}
return 0;
}
else if (!PyErr_Occurred()) {
- PyObject *v = PyBytes_FromString(s);
+ PyObject *v = PyString_FromString(s);
int err;
if (v == NULL)
return -1;
if (pend)
*pend = NULL;
- if (PyBytes_Check(v)) {
- s = PyBytes_AS_STRING(v);
- len = PyBytes_GET_SIZE(v);
+ if (PyString_Check(v)) {
+ s = PyString_AS_STRING(v);
+ len = PyString_GET_SIZE(v);
}
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(v)) {
char buf[100];
format_float(buf, sizeof(buf), v, PREC_REPR);
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
static PyObject *
{
char buf[100];
format_float(buf, sizeof(buf), v, PREC_STR);
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
/* Comparison is pretty much a nightmare. When comparing float to float,
return float_subtype_new(type, args, kwds); /* Wimp out */
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O:float", kwlist, &x))
return NULL;
- if (PyBytes_Check(x))
+ if (PyString_Check(x))
return PyFloat_FromString(x, NULL);
return PyNumber_Float(x);
}
char* s;
float_format_type r;
- if (!PyBytes_Check(arg)) {
+ if (!PyString_Check(arg)) {
PyErr_Format(PyExc_TypeError,
"__getformat__() argument must be string, not %.500s",
Py_TYPE(arg)->tp_name);
return NULL;
}
- s = PyBytes_AS_STRING(arg);
+ s = PyString_AS_STRING(arg);
if (strcmp(s, "double") == 0) {
r = double_format;
}
switch (r) {
case unknown_format:
- return PyBytes_FromString("unknown");
+ return PyString_FromString("unknown");
case ieee_little_endian_format:
- return PyBytes_FromString("IEEE, little-endian");
+ return PyString_FromString("IEEE, little-endian");
case ieee_big_endian_format:
- return PyBytes_FromString("IEEE, big-endian");
+ return PyString_FromString("IEEE, big-endian");
default:
Py_FatalError("insane float_format or double_format");
return NULL;
/* Find the bytecode offset for the start of the given line, or the
* first code-owning line after it. */
- PyBytes_AsStringAndSize(f->f_code->co_lnotab, &lnotab, &lnotab_len);
+ PyString_AsStringAndSize(f->f_code->co_lnotab, &lnotab, &lnotab_len);
addr = 0;
line = f->f_code->co_firstlineno;
new_lasti = -1;
}
/* We're now ready to look at the bytecode. */
- PyBytes_AsStringAndSize(f->f_code->co_code, (char **)&code, &code_len);
+ PyString_AsStringAndSize(f->f_code->co_code, (char **)&code, &code_len);
min_addr = MIN(new_lasti, f->f_lasti);
max_addr = MAX(new_lasti, f->f_lasti);
int _PyFrame_Init()
{
- builtin_object = PyBytes_InternFromString("__builtins__");
+ builtin_object = PyString_InternFromString("__builtins__");
return (builtin_object != NULL);
}
for (j = nmap; --j >= 0; ) {
PyObject *key = PyTuple_GET_ITEM(map, j);
PyObject *value = values[j];
- assert(PyBytes_Check(key));
+ assert(PyString_Check(key));
if (deref) {
assert(PyCell_Check(value));
value = PyCell_GET(value);
for (j = nmap; --j >= 0; ) {
PyObject *key = PyTuple_GET_ITEM(map, j);
PyObject *value = PyObject_GetItem(dict, key);
- assert(PyBytes_Check(key));
+ assert(PyString_Check(key));
/* We only care about NULLs if clear is true. */
if (value == NULL) {
PyErr_Clear();
consts = ((PyCodeObject *)code)->co_consts;
if (PyTuple_Size(consts) >= 1) {
doc = PyTuple_GetItem(consts, 0);
- if (!PyBytes_Check(doc) && !PyUnicode_Check(doc))
+ if (!PyString_Check(doc) && !PyUnicode_Check(doc))
doc = Py_None;
}
else
Otherwise, use None.
*/
if (!__name__) {
- __name__ = PyBytes_InternFromString("__name__");
+ __name__ = PyString_InternFromString("__name__");
if (!__name__) {
Py_DECREF(op);
return NULL;
PyErr_Format(PyExc_ValueError,
"%s() requires a code object with %zd free vars,"
" not %zd",
- PyBytes_AsString(op->func_name),
+ PyString_AsString(op->func_name),
nclosure, nfree);
return -1;
}
return -1;
/* Not legal to del f.func_name or to set it to anything
* other than a string object. */
- if (value == NULL || !PyBytes_Check(value)) {
+ if (value == NULL || !PyString_Check(value)) {
PyErr_SetString(PyExc_TypeError,
"__name__ must be set to a string object");
return -1;
&PyDict_Type, &globals,
&name, &defaults, &closure))
return NULL;
- if (name != Py_None && !PyBytes_Check(name)) {
+ if (name != Py_None && !PyString_Check(name)) {
PyErr_SetString(PyExc_TypeError,
"arg 3 (name) must be None or string");
return NULL;
if (nfree != nclosure)
return PyErr_Format(PyExc_ValueError,
"%s requires closure of length %zd, not %zd",
- PyBytes_AS_STRING(code->co_name),
+ PyString_AS_STRING(code->co_name),
nfree, nclosure);
if (nclosure) {
Py_ssize_t i;
static PyObject*
func_repr(PyFunctionObject *op)
{
- return PyBytes_FromFormat("<function %s at %p>",
- PyBytes_AsString(op->func_name),
+ return PyString_FromFormat("<function %s at %p>",
+ PyString_AsString(op->func_name),
op);
}
gen_repr(PyGenObject *gen)
{
char *code_name;
- code_name = PyBytes_AsString(((PyCodeObject *)gen->gi_code)->co_name);
+ code_name = PyString_AsString(((PyCodeObject *)gen->gi_code)->co_name);
if (code_name == NULL)
return NULL;
- return PyBytes_FromFormat("<generator object %.200s at %p>",
+ return PyString_FromFormat("<generator object %.200s at %p>",
code_name, gen);
}
if (*end != '\0') {
bad:
slen = strlen(s) < 200 ? strlen(s) : 200;
- sobj = PyBytes_FromStringAndSize(s, slen);
+ sobj = PyString_FromStringAndSize(s, slen);
if (sobj == NULL)
return NULL;
srepr = PyObject_Repr(sobj);
return NULL;
PyErr_Format(PyExc_ValueError,
"invalid literal for int() with base %d: %s",
- base, PyBytes_AS_STRING(srepr));
+ base, PyString_AS_STRING(srepr));
Py_DECREF(srepr);
return NULL;
}
return PyInt_FromLong(0L);
if (base == -909)
return PyNumber_Int(x);
- if (PyBytes_Check(x)) {
+ if (PyString_Check(x)) {
/* Since PyInt_FromString doesn't have a length parameter,
* check here for possible NULs in the string. */
- char *string = PyBytes_AS_STRING(x);
- if (strlen(string) != PyBytes_Size(x)) {
+ char *string = PyString_AS_STRING(x);
+ if (strlen(string) != PyString_Size(x)) {
/* create a repr() of the input string,
* just like PyInt_FromString does */
PyObject *srepr;
return NULL;
PyErr_Format(PyExc_ValueError,
"invalid literal for int() with base %d: %s",
- base, PyBytes_AS_STRING(srepr));
+ base, PyString_AS_STRING(srepr));
Py_DECREF(srepr);
return NULL;
}
if (negative)
*--p = '-';
- return PyBytes_FromStringAndSize(p, &buf[sizeof(buf)] - p);
+ return PyString_FromStringAndSize(p, &buf[sizeof(buf)] - p);
}
static PyObject *
}
if (i < 0 || i >= Py_SIZE(op)) {
if (indexerr == NULL)
- indexerr = PyBytes_FromString(
+ indexerr = PyString_FromString(
"list index out of range");
PyErr_SetObject(PyExc_IndexError, indexerr);
return NULL;
i = Py_ReprEnter((PyObject*)v);
if (i != 0) {
- return i > 0 ? PyBytes_FromString("[...]") : NULL;
+ return i > 0 ? PyString_FromString("[...]") : NULL;
}
if (Py_SIZE(v) == 0) {
- result = PyBytes_FromString("[]");
+ result = PyString_FromString("[]");
goto Done;
}
/* Add "[]" decorations to the first and last items. */
assert(PyList_GET_SIZE(pieces) > 0);
- s = PyBytes_FromString("[");
+ s = PyString_FromString("[");
if (s == NULL)
goto Done;
temp = PyList_GET_ITEM(pieces, 0);
- PyBytes_ConcatAndDel(&s, temp);
+ PyString_ConcatAndDel(&s, temp);
PyList_SET_ITEM(pieces, 0, s);
if (s == NULL)
goto Done;
- s = PyBytes_FromString("]");
+ s = PyString_FromString("]");
if (s == NULL)
goto Done;
temp = PyList_GET_ITEM(pieces, PyList_GET_SIZE(pieces) - 1);
- PyBytes_ConcatAndDel(&temp, s);
+ PyString_ConcatAndDel(&temp, s);
PyList_SET_ITEM(pieces, PyList_GET_SIZE(pieces) - 1, temp);
if (temp == NULL)
goto Done;
/* Paste them all together with ", " between. */
- s = PyBytes_FromString(", ");
+ s = PyString_FromString(", ");
if (s == NULL)
goto Done;
- result = _PyBytes_Join(s, pieces);
+ result = _PyString_Join(s, pieces);
Py_DECREF(s);
Done:
{
if (i < 0 || i >= Py_SIZE(a)) {
if (indexerr == NULL)
- indexerr = PyBytes_FromString(
+ indexerr = PyString_FromString(
"list index out of range");
PyErr_SetObject(PyExc_IndexError, indexerr);
return NULL;
_PyLong_Format(PyObject *aa, int base, int addL, int newstyle)
{
register PyLongObject *a = (PyLongObject *)aa;
- PyBytesObject *str;
+ PyStringObject *str;
Py_ssize_t i, j, sz;
Py_ssize_t size_a;
char *p;
"long is too large to format");
return NULL;
}
- str = (PyBytesObject *) PyBytes_FromStringAndSize((char *)0, sz);
+ str = (PyStringObject *) PyString_FromStringAndSize((char *)0, sz);
if (str == NULL)
return NULL;
- p = PyBytes_AS_STRING(str) + sz;
+ p = PyString_AS_STRING(str) + sz;
*p = '\0';
if (addL)
*--p = 'L';
do {
char cdigit = (char)(accum & (base - 1));
cdigit += (cdigit < 10) ? '0' : 'a'-10;
- assert(p > PyBytes_AS_STRING(str));
+ assert(p > PyString_AS_STRING(str));
*--p = cdigit;
accumbits -= basebits;
accum >>= basebits;
do {
digit nextrem = (digit)(rem / base);
char c = (char)(rem - nextrem * base);
- assert(p > PyBytes_AS_STRING(str));
+ assert(p > PyString_AS_STRING(str));
c += (c < 10) ? '0' : 'a'-10;
*--p = c;
rem = nextrem;
}
if (sign)
*--p = sign;
- if (p != PyBytes_AS_STRING(str)) {
- char *q = PyBytes_AS_STRING(str);
+ if (p != PyString_AS_STRING(str)) {
+ char *q = PyString_AS_STRING(str);
assert(p > q);
do {
} while ((*q++ = *p++) != '\0');
q--;
- _PyBytes_Resize((PyObject **)&str,
- (Py_ssize_t) (q - PyBytes_AS_STRING(str)));
+ _PyString_Resize((PyObject **)&str,
+ (Py_ssize_t) (q - PyString_AS_STRING(str)));
}
return (PyObject *)str;
}
onError:
Py_XDECREF(z);
slen = strlen(orig_str) < 200 ? strlen(orig_str) : 200;
- strobj = PyBytes_FromStringAndSize(orig_str, slen);
+ strobj = PyString_FromStringAndSize(orig_str, slen);
if (strobj == NULL)
return NULL;
strrepr = PyObject_Repr(strobj);
return NULL;
PyErr_Format(PyExc_ValueError,
"invalid literal for long() with base %d: %s",
- base, PyBytes_AS_STRING(strrepr));
+ base, PyString_AS_STRING(strrepr));
Py_DECREF(strrepr);
return NULL;
}
return PyLong_FromLong(0L);
if (base == -909)
return PyNumber_Long(x);
- else if (PyBytes_Check(x)) {
+ else if (PyString_Check(x)) {
/* Since PyLong_FromString doesn't have a length parameter,
* check here for possible NULs in the string. */
- char *string = PyBytes_AS_STRING(x);
- if (strlen(string) != PyBytes_Size(x)) {
+ char *string = PyString_AS_STRING(x);
+ if (strlen(string) != PyString_Size(x)) {
/* create a repr() of the input string,
* just like PyLong_FromString does. */
PyObject *srepr;
return NULL;
PyErr_Format(PyExc_ValueError,
"invalid literal for long() with base %d: %s",
- base, PyBytes_AS_STRING(srepr));
+ base, PyString_AS_STRING(srepr));
Py_DECREF(srepr);
return NULL;
}
- return PyLong_FromString(PyBytes_AS_STRING(x), NULL, base);
+ return PyLong_FromString(PyString_AS_STRING(x), NULL, base);
}
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(x))
const char *doc = m->m_ml->ml_doc;
if (doc != NULL)
- return PyBytes_FromString(doc);
+ return PyString_FromString(doc);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
meth_get__name__(PyCFunctionObject *m, void *closure)
{
- return PyBytes_FromString(m->m_ml->ml_name);
+ return PyString_FromString(m->m_ml->ml_name);
}
static int
meth_repr(PyCFunctionObject *m)
{
if (m->m_self == NULL)
- return PyBytes_FromFormat("<built-in function %s>",
+ return PyString_FromFormat("<built-in function %s>",
m->m_ml->ml_name);
- return PyBytes_FromFormat("<built-in method %s of %s object at %p>",
+ return PyString_FromFormat("<built-in method %s of %s object at %p>",
m->m_ml->ml_name,
m->m_self->ob_type->tp_name,
m->m_self);
i = 0;
for (c = chain; c != NULL; c = c->link) {
for (ml = c->methods; ml->ml_name != NULL; ml++) {
- PyList_SetItem(v, i, PyBytes_FromString(ml->ml_name));
+ PyList_SetItem(v, i, PyString_FromString(ml->ml_name));
i++;
}
}
if (strcmp(name, "__doc__") == 0) {
const char *doc = self->ob_type->tp_doc;
if (doc != NULL)
- return PyBytes_FromString(doc);
+ return PyString_FromString(doc);
}
}
while (chain != NULL) {
m = PyObject_GC_New(PyModuleObject, &PyModule_Type);
if (m == NULL)
return NULL;
- nameobj = PyBytes_FromString(name);
+ nameobj = PyString_FromString(name);
m->md_dict = PyDict_New();
if (m->md_dict == NULL || nameobj == NULL)
goto fail;
d = ((PyModuleObject *)m)->md_dict;
if (d == NULL ||
(nameobj = PyDict_GetItemString(d, "__name__")) == NULL ||
- !PyBytes_Check(nameobj))
+ !PyString_Check(nameobj))
{
PyErr_SetString(PyExc_SystemError, "nameless module");
return NULL;
}
- return PyBytes_AsString(nameobj);
+ return PyString_AsString(nameobj);
}
char *
d = ((PyModuleObject *)m)->md_dict;
if (d == NULL ||
(fileobj = PyDict_GetItemString(d, "__file__")) == NULL ||
- !PyBytes_Check(fileobj))
+ !PyString_Check(fileobj))
{
PyErr_SetString(PyExc_SystemError, "module filename missing");
return NULL;
}
- return PyBytes_AsString(fileobj);
+ return PyString_AsString(fileobj);
}
void
/* First, clear only names starting with a single underscore */
pos = 0;
while (PyDict_Next(d, &pos, &key, &value)) {
- if (value != Py_None && PyBytes_Check(key)) {
- char *s = PyBytes_AsString(key);
+ if (value != Py_None && PyString_Check(key)) {
+ char *s = PyString_AsString(key);
if (s[0] == '_' && s[1] != '_') {
if (Py_VerboseFlag > 1)
PySys_WriteStderr("# clear[1] %s\n", s);
/* Next, clear all names except for __builtins__ */
pos = 0;
while (PyDict_Next(d, &pos, &key, &value)) {
- if (value != Py_None && PyBytes_Check(key)) {
- char *s = PyBytes_AsString(key);
+ if (value != Py_None && PyString_Check(key)) {
+ char *s = PyString_AsString(key);
if (s[0] != '_' || strcmp(s, "__builtins__") != 0) {
if (Py_VerboseFlag > 1)
PySys_WriteStderr("# clear[2] %s\n", s);
filename = PyModule_GetFilename((PyObject *)m);
if (filename == NULL) {
PyErr_Clear();
- return PyBytes_FromFormat("<module '%s' (built-in)>", name);
+ return PyString_FromFormat("<module '%s' (built-in)>", name);
}
- return PyBytes_FromFormat("<module '%s' from '%s'>", name, filename);
+ return PyString_FromFormat("<module '%s' from '%s'>", name, filename);
}
/* We only need a traverse function, no clear function: If the module
}
#endif
if (v == NULL)
- return PyBytes_FromString("<NULL>");
+ return PyString_FromString("<NULL>");
else if (Py_TYPE(v)->tp_repr == NULL)
- return PyBytes_FromFormat("<%s object at %p>",
+ return PyString_FromFormat("<%s object at %p>",
Py_TYPE(v)->tp_name, v);
else {
PyObject *res;
return NULL;
}
#endif
- if (!PyBytes_Check(res)) {
+ if (!PyString_Check(res)) {
PyErr_Format(PyExc_TypeError,
"__repr__ returned non-string (type %.200s)",
Py_TYPE(res)->tp_name);
PyObject *res;
int type_ok;
if (v == NULL)
- return PyBytes_FromString("<NULL>");
- if (PyBytes_CheckExact(v)) {
+ return PyString_FromString("<NULL>");
+ if (PyString_CheckExact(v)) {
Py_INCREF(v);
return v;
}
Py_LeaveRecursiveCall();
if (res == NULL)
return NULL;
- type_ok = PyBytes_Check(res);
+ type_ok = PyString_Check(res);
#ifdef Py_USING_UNICODE
type_ok = type_ok || PyUnicode_Check(res);
#endif
return NULL;
}
#endif
- assert(PyBytes_Check(res));
+ assert(PyString_Check(res));
return res;
}
static PyObject *unicodestr;
if (v == NULL) {
- res = PyBytes_FromString("<NULL>");
+ res = PyString_FromString("<NULL>");
if (res == NULL)
return NULL;
str = PyUnicode_FromEncodedObject(res, NULL, "strict");
check this before trying the __unicode__
method. */
if (unicodestr == NULL) {
- unicodestr= PyBytes_InternFromString("__unicode__");
+ unicodestr= PyString_InternFromString("__unicode__");
if (unicodestr == NULL)
return NULL;
}
return PyUnicode_FromUnicode(PyUnicode_AS_UNICODE(v),
PyUnicode_GET_SIZE(v));
}
- if (PyBytes_CheckExact(v)) {
+ if (PyString_CheckExact(v)) {
Py_INCREF(v);
res = v;
}
if (Py_TYPE(v)->tp_getattr != NULL)
return (*Py_TYPE(v)->tp_getattr)(v, (char*)name);
- w = PyBytes_InternFromString(name);
+ w = PyString_InternFromString(name);
if (w == NULL)
return NULL;
res = PyObject_GetAttr(v, w);
if (Py_TYPE(v)->tp_setattr != NULL)
return (*Py_TYPE(v)->tp_setattr)(v, (char*)name, w);
- s = PyBytes_InternFromString(name);
+ s = PyString_InternFromString(name);
if (s == NULL)
return -1;
res = PyObject_SetAttr(v, s, w);
{
PyTypeObject *tp = Py_TYPE(v);
- if (!PyBytes_Check(name)) {
+ if (!PyString_Check(name)) {
#ifdef Py_USING_UNICODE
/* The Unicode to string conversion is done here because the
existing tp_getattro slots expect a string object as name
if (tp->tp_getattro != NULL)
return (*tp->tp_getattro)(v, name);
if (tp->tp_getattr != NULL)
- return (*tp->tp_getattr)(v, PyBytes_AS_STRING(name));
+ return (*tp->tp_getattr)(v, PyString_AS_STRING(name));
PyErr_Format(PyExc_AttributeError,
"'%.50s' object has no attribute '%.400s'",
- tp->tp_name, PyBytes_AS_STRING(name));
+ tp->tp_name, PyString_AS_STRING(name));
return NULL;
}
PyTypeObject *tp = Py_TYPE(v);
int err;
- if (!PyBytes_Check(name)){
+ if (!PyString_Check(name)){
#ifdef Py_USING_UNICODE
/* The Unicode to string conversion is done here because the
existing tp_setattro slots expect a string object as name
else
Py_INCREF(name);
- PyBytes_InternInPlace(&name);
+ PyString_InternInPlace(&name);
if (tp->tp_setattro != NULL) {
err = (*tp->tp_setattro)(v, name, value);
Py_DECREF(name);
return err;
}
if (tp->tp_setattr != NULL) {
- err = (*tp->tp_setattr)(v, PyBytes_AS_STRING(name), value);
+ err = (*tp->tp_setattr)(v, PyString_AS_STRING(name), value);
Py_DECREF(name);
return err;
}
"(%s .%.100s)",
tp->tp_name,
value==NULL ? "del" : "assign to",
- PyBytes_AS_STRING(name));
+ PyString_AS_STRING(name));
else
PyErr_Format(PyExc_TypeError,
"'%.100s' object has only read-only attributes "
"(%s .%.100s)",
tp->tp_name,
value==NULL ? "del" : "assign to",
- PyBytes_AS_STRING(name));
+ PyString_AS_STRING(name));
return -1;
}
Py_ssize_t dictoffset;
PyObject **dictptr;
- if (!PyBytes_Check(name)){
+ if (!PyString_Check(name)){
#ifdef Py_USING_UNICODE
/* The Unicode to string conversion is done here because the
existing tp_setattro slots expect a string object as name
PyErr_Format(PyExc_AttributeError,
"'%.50s' object has no attribute '%.400s'",
- tp->tp_name, PyBytes_AS_STRING(name));
+ tp->tp_name, PyString_AS_STRING(name));
done:
Py_DECREF(name);
return res;
PyObject **dictptr;
int res = -1;
- if (!PyBytes_Check(name)){
+ if (!PyString_Check(name)){
#ifdef Py_USING_UNICODE
/* The Unicode to string conversion is done here because the
existing tp_setattro slots expect a string object as name
if (descr == NULL) {
PyErr_Format(PyExc_AttributeError,
"'%.100s' object has no attribute '%.200s'",
- tp->tp_name, PyBytes_AS_STRING(name));
+ tp->tp_name, PyString_AS_STRING(name));
goto done;
}
PyErr_Format(PyExc_AttributeError,
"'%.50s' object attribute '%.400s' is read-only",
- tp->tp_name, PyBytes_AS_STRING(name));
+ tp->tp_name, PyString_AS_STRING(name));
done:
Py_DECREF(name);
return res;
int i;
for (i = 0; i < PyList_GET_SIZE(list); ++i) {
PyObject *item = PyList_GET_ITEM(list, i);
- if (PyBytes_Check(item)) {
+ if (PyString_Check(item)) {
result = PyDict_SetItem(dict, item, Py_None);
if (result < 0)
break;
static PyObject *
none_repr(PyObject *op)
{
- return PyBytes_FromString("None");
+ return PyString_FromString("None");
}
/* ARGUSED */
static PyObject *
NotImplemented_repr(PyObject *op)
{
- return PyBytes_FromString("NotImplemented");
+ return PyString_FromString("NotImplemented");
}
static PyTypeObject PyNotImplemented_Type = {
if (PyType_Ready(&PyBool_Type) < 0)
Py_FatalError("Can't initialize 'bool'");
- if (PyType_Ready(&PyBytes_Type) < 0)
+ if (PyType_Ready(&PyString_Type) < 0)
Py_FatalError("Can't initialize 'str'");
if (PyType_Ready(&PyByteArray_Type) < 0)
PyObject *rtn;
if (r->start == 0 && r->step == 1)
- rtn = PyBytes_FromFormat("xrange(%ld)",
+ rtn = PyString_FromFormat("xrange(%ld)",
r->start + r->len * r->step);
else if (r->step == 1)
- rtn = PyBytes_FromFormat("xrange(%ld, %ld)",
+ rtn = PyString_FromFormat("xrange(%ld, %ld)",
r->start,
r->start + r->len * r->step);
else
- rtn = PyBytes_FromFormat("xrange(%ld, %ld, %ld)",
+ rtn = PyString_FromFormat("xrange(%ld, %ld, %ld)",
r->start,
r->start + r->len * r->step,
r->step);
/*
* Hacked up version of set_lookkey which can assume keys are always strings;
- * This means we can always use _PyBytes_Eq directly and not have to check to
+ * This means we can always use _PyString_Eq directly and not have to check to
* see if the comparison altered the table.
*/
static setentry *
including subclasses of str; e.g., one reason to subclass
strings is to override __eq__, and for speed we don't cater to
that here. */
- if (!PyBytes_CheckExact(key)) {
+ if (!PyString_CheckExact(key)) {
so->lookup = set_lookkey;
return set_lookkey(so, key, hash);
}
if (entry->key == dummy)
freeslot = entry;
else {
- if (entry->hash == hash && _PyBytes_Eq(entry->key, key))
+ if (entry->hash == hash && _PyString_Eq(entry->key, key))
return entry;
freeslot = NULL;
}
if (entry->key == key
|| (entry->hash == hash
&& entry->key != dummy
- && _PyBytes_Eq(entry->key, key)))
+ && _PyString_Eq(entry->key, key)))
return entry;
if (entry->key == dummy && freeslot == NULL)
freeslot = entry;
register long hash;
register Py_ssize_t n_used;
- if (!PyBytes_CheckExact(key) ||
- (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
+ if (!PyString_CheckExact(key) ||
+ (hash = ((PyStringObject *) key)->ob_shash) == -1) {
hash = PyObject_Hash(key);
if (hash == -1)
return -1;
PyObject *old_key;
assert (PyAnySet_Check(so));
- if (!PyBytes_CheckExact(key) ||
- (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
+ if (!PyString_CheckExact(key) ||
+ (hash = ((PyStringObject *) key)->ob_shash) == -1) {
hash = PyObject_Hash(key);
if (hash == -1)
return -1;
if (status != 0) {
if (status < 0)
return NULL;
- return PyBytes_FromFormat("%s(...)", so->ob_type->tp_name);
+ return PyString_FromFormat("%s(...)", so->ob_type->tp_name);
}
keys = PySequence_List((PyObject *)so);
if (listrepr == NULL)
goto done;
- result = PyBytes_FromFormat("%s(%s)", so->ob_type->tp_name,
- PyBytes_AS_STRING(listrepr));
+ result = PyString_FromFormat("%s(%s)", so->ob_type->tp_name,
+ PyString_AS_STRING(listrepr));
Py_DECREF(listrepr);
done:
Py_ReprLeave((PyObject*)so);
long hash;
setentry *entry;
- if (!PyBytes_CheckExact(key) ||
- (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
+ if (!PyString_CheckExact(key) ||
+ (hash = ((PyStringObject *) key)->ob_shash) == -1) {
hash = PyObject_Hash(key);
if (hash == -1)
return -1;
register PySetObject *so = NULL;
if (dummy == NULL) { /* Auto-initialize dummy */
- dummy = PyBytes_FromString("<dummy key>");
+ dummy = PyString_FromString("<dummy key>");
if (dummy == NULL)
return NULL;
}
/* Exercise direct iteration */
i = 0, count = 0;
while (_PySet_Next((PyObject *)dup, &i, &x)) {
- s = PyBytes_AsString(x);
+ s = PyString_AsString(x);
assert(s && (s[0] == 'a' || s[0] == 'b' || s[0] == 'c'));
count++;
}
static PyObject *
ellipsis_repr(PyObject *op)
{
- return PyBytes_FromString("Ellipsis");
+ return PyString_FromString("Ellipsis");
}
static PyTypeObject PyEllipsis_Type = {
{
PyObject *s, *comma;
- s = PyBytes_FromString("slice(");
- comma = PyBytes_FromString(", ");
- PyBytes_ConcatAndDel(&s, PyObject_Repr(r->start));
- PyBytes_Concat(&s, comma);
- PyBytes_ConcatAndDel(&s, PyObject_Repr(r->stop));
- PyBytes_Concat(&s, comma);
- PyBytes_ConcatAndDel(&s, PyObject_Repr(r->step));
- PyBytes_ConcatAndDel(&s, PyBytes_FromString(")"));
+ s = PyString_FromString("slice(");
+ comma = PyString_FromString(", ");
+ PyString_ConcatAndDel(&s, PyObject_Repr(r->start));
+ PyString_Concat(&s, comma);
+ PyString_ConcatAndDel(&s, PyObject_Repr(r->stop));
+ PyString_Concat(&s, comma);
+ PyString_ConcatAndDel(&s, PyObject_Repr(r->step));
+ PyString_ConcatAndDel(&s, PyString_FromString(")"));
Py_DECREF(comma);
return s;
}
#if PY_VERSION_HEX >= 0x03000000
assert(PyUnicode_Check(result));
#else
- assert(PyBytes_Check(result) || PyUnicode_Check(result));
+ assert(PyString_Check(result) || PyUnicode_Check(result));
/* Convert result to our type. We could be str, and result could
be unicode */
compiled as unicode. */
#define STRINGLIB_IS_UNICODE 0
-#define STRINGLIB_OBJECT PyBytesObject
+#define STRINGLIB_OBJECT PyStringObject
#define STRINGLIB_CHAR char
#define STRINGLIB_TYPE_NAME "string"
#define STRINGLIB_PARSE_CODE "S"
#define STRINGLIB_TOUPPER toupper
#define STRINGLIB_TOLOWER tolower
#define STRINGLIB_FILL memset
-#define STRINGLIB_STR PyBytes_AS_STRING
-#define STRINGLIB_LEN PyBytes_GET_SIZE
-#define STRINGLIB_NEW PyBytes_FromStringAndSize
-#define STRINGLIB_RESIZE _PyBytes_Resize
-#define STRINGLIB_CHECK PyBytes_Check
+#define STRINGLIB_STR PyString_AS_STRING
+#define STRINGLIB_LEN PyString_GET_SIZE
+#define STRINGLIB_NEW PyString_FromStringAndSize
+#define STRINGLIB_RESIZE _PyString_Resize
+#define STRINGLIB_CHECK PyString_Check
#define STRINGLIB_CMP memcmp
#define STRINGLIB_TOSTR PyObject_Str
-#define STRINGLIB_GROUPING _PyBytes_InsertThousandsGrouping
+#define STRINGLIB_GROUPING _PyString_InsertThousandsGrouping
#endif /* !STRINGLIB_STRINGDEFS_H */
Py_DECREF(tup);
return NULL;
}
- crepr = PyBytes_AsString(repr);
+ crepr = PyString_AsString(repr);
if (crepr == NULL) {
Py_DECREF(tup);
Py_DECREF(repr);
*pbuf++ = ')';
*pbuf = '\0';
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
static PyObject *
n = Py_SIZE(v);
if (n == 0)
- return PyBytes_FromString("()");
+ return PyString_FromString("()");
/* While not mutable, it is still possible to end up with a cycle in a
tuple through an object that stores itself within a tuple (and thus
possible within a type. */
i = Py_ReprEnter((PyObject *)v);
if (i != 0) {
- return i > 0 ? PyBytes_FromString("(...)") : NULL;
+ return i > 0 ? PyString_FromString("(...)") : NULL;
}
pieces = PyTuple_New(n);
/* Add "()" decorations to the first and last items. */
assert(n > 0);
- s = PyBytes_FromString("(");
+ s = PyString_FromString("(");
if (s == NULL)
goto Done;
temp = PyTuple_GET_ITEM(pieces, 0);
- PyBytes_ConcatAndDel(&s, temp);
+ PyString_ConcatAndDel(&s, temp);
PyTuple_SET_ITEM(pieces, 0, s);
if (s == NULL)
goto Done;
- s = PyBytes_FromString(n == 1 ? ",)" : ")");
+ s = PyString_FromString(n == 1 ? ",)" : ")");
if (s == NULL)
goto Done;
temp = PyTuple_GET_ITEM(pieces, n-1);
- PyBytes_ConcatAndDel(&temp, s);
+ PyString_ConcatAndDel(&temp, s);
PyTuple_SET_ITEM(pieces, n-1, temp);
if (temp == NULL)
goto Done;
/* Paste them all together with ", " between. */
- s = PyBytes_FromString(", ");
+ s = PyString_FromString(", ");
if (s == NULL)
goto Done;
- result = _PyBytes_Join(s, pieces);
+ result = _PyString_Join(s, pieces);
Py_DECREF(s);
Done:
>> (8*sizeof(unsigned int) - MCACHE_SIZE_EXP))
#define MCACHE_HASH_METHOD(type, name) \
MCACHE_HASH((type)->tp_version_tag, \
- ((PyBytesObject *)(name))->ob_shash)
+ ((PyStringObject *)(name))->ob_shash)
#define MCACHE_CACHEABLE_NAME(name) \
- PyBytes_CheckExact(name) && \
- PyBytes_GET_SIZE(name) <= MCACHE_MAX_ATTR_SIZE
+ PyString_CheckExact(name) && \
+ PyString_GET_SIZE(name) <= MCACHE_MAX_ATTR_SIZE
struct method_cache_entry {
unsigned int version;
s = type->tp_name;
else
s++;
- return PyBytes_FromString(s);
+ return PyString_FromString(s);
}
}
"can't delete %s.__name__", type->tp_name);
return -1;
}
- if (!PyBytes_Check(value)) {
+ if (!PyString_Check(value)) {
PyErr_Format(PyExc_TypeError,
"can only assign string to %s.__name__, not '%s'",
type->tp_name, Py_TYPE(value)->tp_name);
return -1;
}
- if (strlen(PyBytes_AS_STRING(value))
- != (size_t)PyBytes_GET_SIZE(value)) {
+ if (strlen(PyString_AS_STRING(value))
+ != (size_t)PyString_GET_SIZE(value)) {
PyErr_Format(PyExc_ValueError,
"__name__ must not contain null bytes");
return -1;
Py_DECREF(et->ht_name);
et->ht_name = value;
- type->tp_name = PyBytes_AS_STRING(value);
+ type->tp_name = PyString_AS_STRING(value);
return 0;
}
else {
s = strrchr(type->tp_name, '.');
if (s != NULL)
- return PyBytes_FromStringAndSize(
+ return PyString_FromStringAndSize(
type->tp_name, (Py_ssize_t)(s - type->tp_name));
- return PyBytes_FromString("__builtin__");
+ return PyString_FromString("__builtin__");
}
}
{
PyObject *result;
if (!(type->tp_flags & Py_TPFLAGS_HEAPTYPE) && type->tp_doc != NULL)
- return PyBytes_FromString(type->tp_doc);
+ return PyString_FromString(type->tp_doc);
result = PyDict_GetItemString(type->tp_dict, "__doc__");
if (result == NULL) {
result = Py_None;
mod = type_module(type, NULL);
if (mod == NULL)
PyErr_Clear();
- else if (!PyBytes_Check(mod)) {
+ else if (!PyString_Check(mod)) {
Py_DECREF(mod);
mod = NULL;
}
else
kind = "type";
- if (mod != NULL && strcmp(PyBytes_AS_STRING(mod), "__builtin__")) {
- rtn = PyBytes_FromFormat("<%s '%s.%s'>",
+ if (mod != NULL && strcmp(PyString_AS_STRING(mod), "__builtin__")) {
+ rtn = PyString_FromFormat("<%s '%s.%s'>",
kind,
- PyBytes_AS_STRING(mod),
- PyBytes_AS_STRING(name));
+ PyString_AS_STRING(mod),
+ PyString_AS_STRING(name));
}
else
- rtn = PyBytes_FromFormat("<%s '%s'>", kind, type->tp_name);
+ rtn = PyString_FromFormat("<%s '%s'>", kind, type->tp_name);
Py_XDECREF(mod);
Py_DECREF(name);
PyObject *res;
if (*attrobj == NULL) {
- *attrobj = PyBytes_InternFromString(attrstr);
+ *attrobj = PyString_InternFromString(attrstr);
if (*attrobj == NULL)
return NULL;
}
}
if (name == NULL)
return NULL;
- if (!PyBytes_Check(name)) {
+ if (!PyString_Check(name)) {
Py_DECREF(name);
return NULL;
}
o = class_name(o);
PyErr_Format(PyExc_TypeError,
"duplicate base class %s",
- o ? PyBytes_AS_STRING(o) : "?");
+ o ? PyString_AS_STRING(o) : "?");
Py_XDECREF(o);
return -1;
}
while (PyDict_Next(set, &i, &k, &v) && (size_t)off < sizeof(buf)) {
PyObject *name = class_name(k);
off += PyOS_snprintf(buf + off, sizeof(buf) - off, " %s",
- name ? PyBytes_AS_STRING(name) : "?");
+ name ? PyString_AS_STRING(name) : "?");
Py_XDECREF(name);
if (--n && (size_t)(off+1) < sizeof(buf)) {
buf[off++] = ',';
PyObject *descr;
if (dict_str == NULL) {
- dict_str = PyBytes_InternFromString("__dict__");
+ dict_str = PyString_InternFromString("__dict__");
if (dict_str == NULL)
return NULL;
}
unsigned char *p;
Py_ssize_t i, n;
- if (!PyBytes_Check(s)) {
+ if (!PyString_Check(s)) {
PyErr_Format(PyExc_TypeError,
"__slots__ items must be strings, not '%.200s'",
Py_TYPE(s)->tp_name);
return 0;
}
- p = (unsigned char *) PyBytes_AS_STRING(s);
- n = PyBytes_GET_SIZE(s);
+ p = (unsigned char *) PyString_AS_STRING(s);
+ n = PyString_GET_SIZE(s);
/* We must reject an empty name. As a hack, we bump the
length to 1 so that the loop will balk on the trailing \0. */
if (n == 0)
/* Have slots */
/* Make it into a tuple */
- if (PyBytes_Check(slots) || PyUnicode_Check(slots))
+ if (PyString_Check(slots) || PyUnicode_Check(slots))
slots = PyTuple_Pack(1, slots);
else
slots = PySequence_Tuple(slots);
char *s;
if (!valid_identifier(tmp))
goto bad_slots;
- assert(PyBytes_Check(tmp));
- s = PyBytes_AS_STRING(tmp);
+ assert(PyString_Check(tmp));
+ s = PyString_AS_STRING(tmp);
if (strcmp(s, "__dict__") == 0) {
if (!may_add_dict || add_dict) {
PyErr_SetString(PyExc_TypeError,
for (i = j = 0; i < nslots; i++) {
char *s;
tmp = PyTuple_GET_ITEM(slots, i);
- s = PyBytes_AS_STRING(tmp);
+ s = PyString_AS_STRING(tmp);
if ((add_dict && strcmp(s, "__dict__") == 0) ||
(add_weak && strcmp(s, "__weakref__") == 0))
continue;
type->tp_as_sequence = &et->as_sequence;
type->tp_as_mapping = &et->as_mapping;
type->tp_as_buffer = &et->as_buffer;
- type->tp_name = PyBytes_AS_STRING(name);
+ type->tp_name = PyString_AS_STRING(name);
/* Set tp_base and tp_bases */
type->tp_bases = bases;
*/
{
PyObject *doc = PyDict_GetItemString(dict, "__doc__");
- if (doc != NULL && PyBytes_Check(doc)) {
- const size_t n = (size_t)PyBytes_GET_SIZE(doc);
+ if (doc != NULL && PyString_Check(doc)) {
+ const size_t n = (size_t)PyString_GET_SIZE(doc);
char *tp_doc = (char *)PyObject_MALLOC(n+1);
if (tp_doc == NULL) {
Py_DECREF(type);
return NULL;
}
- memcpy(tp_doc, PyBytes_AS_STRING(doc), n+1);
+ memcpy(tp_doc, PyString_AS_STRING(doc), n+1);
type->tp_doc = tp_doc;
}
}
slotoffset = base->tp_basicsize;
if (slots != NULL) {
for (i = 0; i < nslots; i++, mp++) {
- mp->name = PyBytes_AS_STRING(
+ mp->name = PyString_AS_STRING(
PyTuple_GET_ITEM(slots, i));
mp->type = T_OBJECT_EX;
mp->offset = slotoffset;
/* Give up */
PyErr_Format(PyExc_AttributeError,
"type object '%.50s' has no attribute '%.400s'",
- type->tp_name, PyBytes_AS_STRING(name));
+ type->tp_name, PyString_AS_STRING(name));
return NULL;
}
if (sorted_methods == NULL)
goto error;
if (comma == NULL) {
- comma = PyBytes_InternFromString(", ");
+ comma = PyString_InternFromString(", ");
if (comma == NULL)
goto error;
}
"O", sorted_methods);
if (joined == NULL)
goto error;
- joined_str = PyBytes_AsString(joined);
+ joined_str = PyString_AsString(joined);
if (joined_str == NULL)
goto error;
mod = type_module(type, NULL);
if (mod == NULL)
PyErr_Clear();
- else if (!PyBytes_Check(mod)) {
+ else if (!PyString_Check(mod)) {
Py_DECREF(mod);
mod = NULL;
}
name = type_name(type, NULL);
if (name == NULL)
return NULL;
- if (mod != NULL && strcmp(PyBytes_AS_STRING(mod), "__builtin__"))
- rtn = PyBytes_FromFormat("<%s.%s object at %p>",
- PyBytes_AS_STRING(mod),
- PyBytes_AS_STRING(name),
+ if (mod != NULL && strcmp(PyString_AS_STRING(mod), "__builtin__"))
+ rtn = PyString_FromFormat("<%s.%s object at %p>",
+ PyString_AS_STRING(mod),
+ PyString_AS_STRING(name),
self);
else
- rtn = PyBytes_FromFormat("<%s object at %p>",
+ rtn = PyString_FromFormat("<%s object at %p>",
type->tp_name, self);
Py_XDECREF(mod);
Py_DECREF(name);
static PyObject *copyreg_str;
if (!copyreg_str) {
- copyreg_str = PyBytes_InternFromString("copy_reg");
+ copyreg_str = PyString_InternFromString("copy_reg");
if (copyreg_str == NULL)
return NULL;
}
return NULL;
if (PyUnicode_Check(format_spec)) {
self_as_str = PyObject_Unicode(self);
- } else if (PyBytes_Check(format_spec)) {
+ } else if (PyString_Check(format_spec)) {
self_as_str = PyObject_Str(self);
} else {
PyErr_SetString(PyExc_TypeError, "argument to __format__ must be unicode or str");
type->tp_flags |= Py_TPFLAGS_INT_SUBCLASS;
else if (PyType_IsSubtype(base, &PyLong_Type))
type->tp_flags |= Py_TPFLAGS_LONG_SUBCLASS;
- else if (PyType_IsSubtype(base, &PyBytes_Type))
+ else if (PyType_IsSubtype(base, &PyString_Type))
type->tp_flags |= Py_TPFLAGS_STRING_SUBCLASS;
#ifdef Py_USING_UNICODE
else if (PyType_IsSubtype(base, &PyUnicode_Type))
*/
if (PyDict_GetItemString(type->tp_dict, "__doc__") == NULL) {
if (type->tp_doc != NULL) {
- PyObject *doc = PyBytes_FromString(type->tp_doc);
+ PyObject *doc = PyString_FromString(type->tp_doc);
if (doc == NULL)
goto error;
PyDict_SetItemString(type->tp_dict, "__doc__", doc);
descrgetfunc f;
if (getitem_str == NULL) {
- getitem_str = PyBytes_InternFromString("__getitem__");
+ getitem_str = PyString_InternFromString("__getitem__");
if (getitem_str == NULL)
return NULL;
}
return res;
}
PyErr_Clear();
- return PyBytes_FromFormat("<%s object at %p>",
+ return PyString_FromFormat("<%s object at %p>",
Py_TYPE(self)->tp_name, self);
}
static PyObject *getattr_str = NULL;
if (getattr_str == NULL) {
- getattr_str = PyBytes_InternFromString("__getattr__");
+ getattr_str = PyString_InternFromString("__getattr__");
if (getattr_str == NULL)
return NULL;
}
if (getattribute_str == NULL) {
getattribute_str =
- PyBytes_InternFromString("__getattribute__");
+ PyString_InternFromString("__getattribute__");
if (getattribute_str == NULL)
return NULL;
}
static PyObject *get_str = NULL;
if (get_str == NULL) {
- get_str = PyBytes_InternFromString("__get__");
+ get_str = PyString_InternFromString("__get__");
if (get_str == NULL)
return NULL;
}
Py_ssize_t i, n;
if (new_str == NULL) {
- new_str = PyBytes_InternFromString("__new__");
+ new_str = PyString_InternFromString("__new__");
if (new_str == NULL)
return NULL;
}
if (initialized)
return;
for (p = slotdefs; p->name; p++) {
- p->name_strobj = PyBytes_InternFromString(p->name);
+ p->name_strobj = PyString_InternFromString(p->name);
if (!p->name_strobj)
Py_FatalError("Out of memory interning slotdef names");
}
superobject *su = (superobject *)self;
if (su->obj_type)
- return PyBytes_FromFormat(
+ return PyString_FromFormat(
"<super: <class '%s'>, <%s object>>",
su->type ? su->type->tp_name : "NULL",
su->obj_type->tp_name);
else
- return PyBytes_FromFormat(
+ return PyString_FromFormat(
"<super: <class '%s'>, NULL>",
su->type ? su->type->tp_name : "NULL");
}
if (!skip) {
/* We want __class__ to return the class of the super object
(i.e. super, or a subclass), not the class of su->obj. */
- skip = (PyBytes_Check(name) &&
- PyBytes_GET_SIZE(name) == 9 &&
- strcmp(PyBytes_AS_STRING(name), "__class__") == 0);
+ skip = (PyString_Check(name) &&
+ PyString_GET_SIZE(name) == 9 &&
+ strcmp(PyString_AS_STRING(name), "__class__") == 0);
}
if (!skip) {
PyObject *class_attr;
if (class_str == NULL) {
- class_str = PyBytes_FromString("__class__");
+ class_str = PyString_FromString("__class__");
if (class_str == NULL)
return NULL;
}
#endif
/* Coerce object */
- if (PyBytes_Check(obj)) {
- s = PyBytes_AS_STRING(obj);
- len = PyBytes_GET_SIZE(obj);
+ if (PyString_Check(obj)) {
+ s = PyString_AS_STRING(obj);
+ len = PyString_GET_SIZE(obj);
}
else if (PyByteArray_Check(obj)) {
/* Python 2.x specific */
v = PyCodec_Encode(unicode, encoding, errors);
if (v == NULL)
goto onError;
- if (!PyBytes_Check(v)) {
+ if (!PyString_Check(v)) {
PyErr_Format(PyExc_TypeError,
"encoder did not return a string object (type=%.400s)",
Py_TYPE(v)->tp_name);
char * start;
if (size == 0)
- return PyBytes_FromStringAndSize(NULL, 0);
+ return PyString_FromStringAndSize(NULL, 0);
- v = PyBytes_FromStringAndSize(NULL, cbAllocated);
+ v = PyString_FromStringAndSize(NULL, cbAllocated);
if (v == NULL)
return NULL;
- start = out = PyBytes_AS_STRING(v);
+ start = out = PyString_AS_STRING(v);
for (;i < size; ++i) {
Py_UNICODE ch = s[i];
*out++ = '-';
}
- _PyBytes_Resize(&v, out - start);
+ _PyString_Resize(&v, out - start);
return v;
}
nallocated = size * 4;
if (nallocated / 4 != size) /* overflow! */
return PyErr_NoMemory();
- v = PyBytes_FromStringAndSize(NULL, nallocated);
+ v = PyString_FromStringAndSize(NULL, nallocated);
if (v == NULL)
return NULL;
- p = PyBytes_AS_STRING(v);
+ p = PyString_AS_STRING(v);
}
for (i = 0; i < size;) {
/* This was stack allocated. */
nneeded = p - stackbuf;
assert(nneeded <= nallocated);
- v = PyBytes_FromStringAndSize(stackbuf, nneeded);
+ v = PyString_FromStringAndSize(stackbuf, nneeded);
}
else {
/* Cut back to size actually needed. */
- nneeded = p - PyBytes_AS_STRING(v);
+ nneeded = p - PyString_AS_STRING(v);
assert(nneeded <= nallocated);
- _PyBytes_Resize(&v, nneeded);
+ _PyString_Resize(&v, nneeded);
}
return v;
0xDC00 <= s[i+1] && s[i+1] <= 0xDFFF)
pairs++;
#endif
- v = PyBytes_FromStringAndSize(NULL,
+ v = PyString_FromStringAndSize(NULL,
4 * (size - pairs + (byteorder == 0)));
if (v == NULL)
return NULL;
- p = (unsigned char *)PyBytes_AS_STRING(v);
+ p = (unsigned char *)PyString_AS_STRING(v);
if (byteorder == 0)
STORECHAR(0xFEFF);
if (size == 0)
if (s[i] >= 0x10000)
pairs++;
#endif
- v = PyBytes_FromStringAndSize(NULL,
+ v = PyString_FromStringAndSize(NULL,
2 * (size + pairs + (byteorder == 0)));
if (v == NULL)
return NULL;
- p = (unsigned char *)PyBytes_AS_STRING(v);
+ p = (unsigned char *)PyString_AS_STRING(v);
if (byteorder == 0)
STORECHAR(0xFEFF);
if (size == 0)
escape.
*/
- repr = PyBytes_FromStringAndSize(NULL,
+ repr = PyString_FromStringAndSize(NULL,
2
#ifdef Py_UNICODE_WIDE
+ 10*size
if (repr == NULL)
return NULL;
- p = PyBytes_AS_STRING(repr);
+ p = PyString_AS_STRING(repr);
if (quotes) {
*p++ = 'u';
/* Escape quotes and backslashes */
if ((quotes &&
- ch == (Py_UNICODE) PyBytes_AS_STRING(repr)[1]) || ch == '\\') {
+ ch == (Py_UNICODE) PyString_AS_STRING(repr)[1]) || ch == '\\') {
*p++ = '\\';
*p++ = (char) ch;
continue;
*p++ = (char) ch;
}
if (quotes)
- *p++ = PyBytes_AS_STRING(repr)[1];
+ *p++ = PyString_AS_STRING(repr)[1];
*p = '\0';
- _PyBytes_Resize(&repr, p - PyBytes_AS_STRING(repr));
+ _PyString_Resize(&repr, p - PyString_AS_STRING(repr));
return repr;
}
static const char *hexdigit = "0123456789abcdef";
#ifdef Py_UNICODE_WIDE
- repr = PyBytes_FromStringAndSize(NULL, 10 * size);
+ repr = PyString_FromStringAndSize(NULL, 10 * size);
#else
- repr = PyBytes_FromStringAndSize(NULL, 6 * size);
+ repr = PyString_FromStringAndSize(NULL, 6 * size);
#endif
if (repr == NULL)
return NULL;
if (size == 0)
return repr;
- p = q = PyBytes_AS_STRING(repr);
+ p = q = PyString_AS_STRING(repr);
while (size-- > 0) {
Py_UNICODE ch = *s++;
#ifdef Py_UNICODE_WIDE
*p++ = (char) ch;
}
*p = '\0';
- _PyBytes_Resize(&repr, p - q);
+ _PyString_Resize(&repr, p - q);
return repr;
}
/* allocate enough for a simple encoding without
replacements, if we need more, we'll resize */
- res = PyBytes_FromStringAndSize(NULL, size);
+ res = PyString_FromStringAndSize(NULL, size);
if (res == NULL)
goto onError;
if (size == 0)
return res;
- str = PyBytes_AS_STRING(res);
+ str = PyString_AS_STRING(res);
ressize = size;
while (p<endp) {
p = collend;
break;
case 4: /* xmlcharrefreplace */
- respos = str-PyBytes_AS_STRING(res);
+ respos = str-PyString_AS_STRING(res);
/* determine replacement size (temporarily (mis)uses p) */
for (p = collstart, repsize = 0; p < collend; ++p) {
if (*p<10)
if (requiredsize > ressize) {
if (requiredsize<2*ressize)
requiredsize = 2*ressize;
- if (_PyBytes_Resize(&res, requiredsize))
+ if (_PyString_Resize(&res, requiredsize))
goto onError;
- str = PyBytes_AS_STRING(res) + respos;
+ str = PyString_AS_STRING(res) + respos;
ressize = requiredsize;
}
/* generate replacement (temporarily (mis)uses p) */
/* need more space? (at least enough for what we
have+the replacement+the rest of the string, so
we won't have to check space for encodable characters) */
- respos = str-PyBytes_AS_STRING(res);
+ respos = str-PyString_AS_STRING(res);
repsize = PyUnicode_GET_SIZE(repunicode);
requiredsize = respos+repsize+(endp-collend);
if (requiredsize > ressize) {
if (requiredsize<2*ressize)
requiredsize = 2*ressize;
- if (_PyBytes_Resize(&res, requiredsize)) {
+ if (_PyString_Resize(&res, requiredsize)) {
Py_DECREF(repunicode);
goto onError;
}
- str = PyBytes_AS_STRING(res) + respos;
+ str = PyString_AS_STRING(res) + respos;
ressize = requiredsize;
}
/* check if there is anything unencodable in the replacement
}
}
/* Resize if we allocated to much */
- respos = str-PyBytes_AS_STRING(res);
+ respos = str-PyString_AS_STRING(res);
if (respos<ressize)
/* If this falls res will be NULL */
- _PyBytes_Resize(&res, respos);
+ _PyString_Resize(&res, respos);
Py_XDECREF(errorHandler);
Py_XDECREF(exc);
return res;
goto onError;
}
}
- if (p - PyUnicode_AS_UNICODE(v) < PyBytes_GET_SIZE(v))
+ if (p - PyUnicode_AS_UNICODE(v) < PyString_GET_SIZE(v))
if (_PyUnicode_Resize(&v, p - PyUnicode_AS_UNICODE(v)) < 0)
goto onError;
Py_XDECREF(errorHandler);
if (*repr == NULL) {
/* Create string object */
- *repr = PyBytes_FromStringAndSize(NULL, mbcssize);
+ *repr = PyString_FromStringAndSize(NULL, mbcssize);
if (*repr == NULL)
return -1;
}
else {
/* Extend string object */
- n = PyBytes_Size(*repr);
- if (_PyBytes_Resize(repr, n + mbcssize) < 0)
+ n = PyString_Size(*repr);
+ if (_PyString_Resize(repr, n + mbcssize) < 0)
return -1;
}
/* Do the conversion */
if (size > 0) {
- char *s = PyBytes_AS_STRING(*repr) + n;
+ char *s = PyString_AS_STRING(*repr) + n;
if (0 == WideCharToMultiByte(CP_ACP, 0, p, size, s, mbcssize, NULL, NULL)) {
PyErr_SetFromWindowsErrWithFilename(0, NULL);
return -1;
}
return x;
}
- else if (PyBytes_Check(x))
+ else if (PyString_Check(x))
return x;
else {
/* wrong return value */
static int
charmapencode_resize(PyObject **outobj, Py_ssize_t *outpos, Py_ssize_t requiredsize)
{
- Py_ssize_t outsize = PyBytes_GET_SIZE(*outobj);
+ Py_ssize_t outsize = PyString_GET_SIZE(*outobj);
/* exponentially overallocate to minimize reallocations */
if (requiredsize < 2*outsize)
requiredsize = 2*outsize;
- if (_PyBytes_Resize(outobj, requiredsize)) {
+ if (_PyString_Resize(outobj, requiredsize)) {
return 0;
}
return 1;
{
PyObject *rep;
char *outstart;
- Py_ssize_t outsize = PyBytes_GET_SIZE(*outobj);
+ Py_ssize_t outsize = PyString_GET_SIZE(*outobj);
if (Py_TYPE(mapping) == &EncodingMapType) {
int res = encoding_map_lookup(c, mapping);
if (outsize<requiredsize)
if (!charmapencode_resize(outobj, outpos, requiredsize))
return enc_EXCEPTION;
- outstart = PyBytes_AS_STRING(*outobj);
+ outstart = PyString_AS_STRING(*outobj);
outstart[(*outpos)++] = (char)res;
return enc_SUCCESS;
}
Py_DECREF(rep);
return enc_EXCEPTION;
}
- outstart = PyBytes_AS_STRING(*outobj);
+ outstart = PyString_AS_STRING(*outobj);
outstart[(*outpos)++] = (char)PyInt_AS_LONG(rep);
}
else {
- const char *repchars = PyBytes_AS_STRING(rep);
- Py_ssize_t repsize = PyBytes_GET_SIZE(rep);
+ const char *repchars = PyString_AS_STRING(rep);
+ Py_ssize_t repsize = PyString_GET_SIZE(rep);
Py_ssize_t requiredsize = *outpos+repsize;
if (outsize<requiredsize)
if (!charmapencode_resize(outobj, outpos, requiredsize)) {
Py_DECREF(rep);
return enc_EXCEPTION;
}
- outstart = PyBytes_AS_STRING(*outobj);
+ outstart = PyString_AS_STRING(*outobj);
memcpy(outstart + *outpos, repchars, repsize);
*outpos += repsize;
}
/* allocate enough for a simple encoding without
replacements, if we need more, we'll resize */
- res = PyBytes_FromStringAndSize(NULL, size);
+ res = PyString_FromStringAndSize(NULL, size);
if (res == NULL)
goto onError;
if (size == 0)
}
/* Resize if we allocated to much */
- if (respos<PyBytes_GET_SIZE(res)) {
- if (_PyBytes_Resize(&res, respos))
+ if (respos<PyString_GET_SIZE(res)) {
+ if (_PyString_Resize(&res, respos))
goto onError;
}
Py_XDECREF(exc);
item = PySequence_Fast_GET_ITEM(fseq, i);
/* Convert item to Unicode. */
- if (! PyUnicode_Check(item) && ! PyBytes_Check(item)) {
+ if (! PyUnicode_Check(item) && ! PyString_Check(item)) {
PyErr_Format(PyExc_TypeError,
"sequence item %zd: expected string or Unicode,"
" %.80s found",
v = PyUnicode_AsEncodedObject((PyObject *)self, encoding, errors);
if (v == NULL)
goto onError;
- if (!PyBytes_Check(v) && !PyUnicode_Check(v)) {
+ if (!PyString_Check(v) && !PyUnicode_Check(v)) {
PyErr_Format(PyExc_TypeError,
"encoder did not return a string/unicode object "
"(type=%.400s)",
v = PyUnicode_AsDecodedObject((PyObject *)self, encoding, errors);
if (v == NULL)
goto onError;
- if (!PyBytes_Check(v) && !PyUnicode_Check(v)) {
+ if (!PyString_Check(v) && !PyUnicode_Check(v)) {
PyErr_Format(PyExc_TypeError,
"decoder did not return a string/unicode object "
"(type=%.400s)",
if (sep != NULL && sep != Py_None) {
if (PyUnicode_Check(sep))
return _PyUnicode_XStrip(self, striptype, sep);
- else if (PyBytes_Check(sep)) {
+ else if (PyString_Check(sep)) {
PyObject *res;
sep = PyUnicode_FromObject(sep);
if (sep==NULL)
str = _PyUnicode_AsDefaultEncodedString((PyObject *)self, NULL);
if (str == NULL)
return -1;
- *ptr = (void *) PyBytes_AS_STRING(str);
- return PyBytes_GET_SIZE(str);
+ *ptr = (void *) PyString_AS_STRING(str);
+ return PyString_GET_SIZE(str);
}
/* Helpers for PyUnicode_Format() */
PyObject *str; /* temporary string object. */
PyUnicodeObject *result;
- str = _PyBytes_FormatLong(val, flags, prec, type, &buf, &len);
+ str = _PyString_FormatLong(val, flags, prec, type, &buf, &len);
if (!str)
return NULL;
result = _PyUnicode_New(len);
buf[0] = PyUnicode_AS_UNICODE(v)[0];
}
- else if (PyBytes_Check(v)) {
- if (PyBytes_GET_SIZE(v) != 1)
+ else if (PyString_Check(v)) {
+ if (PyString_GET_SIZE(v) != 1)
goto onError;
- buf[0] = (Py_UNICODE)PyBytes_AS_STRING(v)[0];
+ buf[0] = (Py_UNICODE)PyString_AS_STRING(v)[0];
}
else {
goto onError;
if (PyUnicode_Check(temp))
/* nothing to do */;
- else if (PyBytes_Check(temp)) {
+ else if (PyString_Check(temp)) {
/* convert to string to Unicode */
- unicode = PyUnicode_Decode(PyBytes_AS_STRING(temp),
- PyBytes_GET_SIZE(temp),
+ unicode = PyUnicode_Decode(PyString_AS_STRING(temp),
+ PyString_GET_SIZE(temp),
NULL,
"strict");
Py_DECREF(temp);
"__name__");
if (nameobj == NULL)
PyErr_Clear();
- else if (PyBytes_Check(nameobj))
- name = PyBytes_AS_STRING(nameobj);
+ else if (PyString_Check(nameobj))
+ name = PyString_AS_STRING(nameobj);
PyOS_snprintf(buffer, sizeof(buffer),
name ? "<weakref at %p; to '%.50s' at %p (%s)>"
: "<weakref at %p; to '%.50s' at %p>",
name);
Py_XDECREF(nameobj);
}
- return PyBytes_FromString(buffer);
+ return PyString_FromString(buffer);
}
/* Weak references only support equality, not ordering. Two weak references
"<weakproxy at %p to %.100s at %p>", proxy,
Py_TYPE(PyWeakref_GET_OBJECT(proxy))->tp_name,
PyWeakref_GET_OBJECT(proxy));
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
return NULL;
}
- oresult = PyBytes_FromString(cresult);
+ oresult = PyString_FromString(cresult);
RpcStringFree(&cresult);
return oresult;
PyObject *result = PyObject_CallMethod(pv, "getnextcabinet", "i", pccab->iCab);
if (result == NULL)
return -1;
- if (!PyBytes_Check(result)) {
+ if (!PyString_Check(result)) {
PyErr_Format(PyExc_TypeError,
"Incorrect return type %s from getnextcabinet",
result->ob_type->tp_name);
Py_DECREF(result);
return FALSE;
}
- strncpy(pccab->szCab, PyBytes_AsString(result), sizeof(pccab->szCab));
+ strncpy(pccab->szCab, PyString_AsString(result), sizeof(pccab->szCab));
return TRUE;
}
return FALSE;
PyErr_SetString(PyExc_NotImplementedError, "FILETIME result");
return NULL;
case VT_LPSTR:
- result = PyBytes_FromStringAndSize(sval, ssize);
+ result = PyString_FromStringAndSize(sval, ssize);
if (sval != sbuf)
free(sval);
return result;
if (!PyArg_ParseTuple(args, "iO:SetProperty", &field, &data))
return NULL;
- if (PyBytes_Check(data)) {
+ if (PyString_Check(data)) {
status = MsiSummaryInfoSetProperty(si->h, field, VT_LPSTR,
- 0, NULL, PyBytes_AsString(data));
+ 0, NULL, PyString_AsString(data));
} else if (PyInt_Check(data)) {
status = MsiSummaryInfoSetProperty(si->h, field, VT_I4,
PyInt_AsLong(data), NULL, NULL);
if (!keys || !values)
goto error;
- out = PyBytes_FromStringAndSize(NULL, 2048);
+ out = PyString_FromStringAndSize(NULL, 2048);
if (! out)
goto error;
- p = PyBytes_AS_STRING(out);
+ p = PyString_AS_STRING(out);
for (i = 0; i < envsize; i++) {
int ksize, vsize, totalsize;
PyObject* key = PyList_GET_ITEM(keys, i);
PyObject* value = PyList_GET_ITEM(values, i);
- if (! PyBytes_Check(key) || ! PyBytes_Check(value)) {
+ if (! PyString_Check(key) || ! PyString_Check(value)) {
PyErr_SetString(PyExc_TypeError,
"environment can only contain strings");
goto error;
}
- ksize = PyBytes_GET_SIZE(key);
- vsize = PyBytes_GET_SIZE(value);
- totalsize = (p - PyBytes_AS_STRING(out)) + ksize + 1 +
+ ksize = PyString_GET_SIZE(key);
+ vsize = PyString_GET_SIZE(value);
+ totalsize = (p - PyString_AS_STRING(out)) + ksize + 1 +
vsize + 1 + 1;
- if (totalsize > PyBytes_GET_SIZE(out)) {
- int offset = p - PyBytes_AS_STRING(out);
- _PyBytes_Resize(&out, totalsize + 1024);
- p = PyBytes_AS_STRING(out) + offset;
+ if (totalsize > PyString_GET_SIZE(out)) {
+ int offset = p - PyString_AS_STRING(out);
+ _PyString_Resize(&out, totalsize + 1024);
+ p = PyString_AS_STRING(out) + offset;
}
- memcpy(p, PyBytes_AS_STRING(key), ksize);
+ memcpy(p, PyString_AS_STRING(key), ksize);
p += ksize;
*p++ = '=';
- memcpy(p, PyBytes_AS_STRING(value), vsize);
+ memcpy(p, PyString_AS_STRING(value), vsize);
p += vsize;
*p++ = '\0';
}
/* add trailing null byte */
*p++ = '\0';
- _PyBytes_Resize(&out, p - PyBytes_AS_STRING(out));
+ _PyString_Resize(&out, p - PyString_AS_STRING(out));
/* PyObject_Print(out, stdout, 0); */
NULL,
inherit_handles,
creation_flags,
- environment ? PyBytes_AS_STRING(environment) : NULL,
+ environment ? PyString_AS_STRING(environment) : NULL,
current_directory,
&si,
&pi);
if (! result)
return PyErr_SetFromWindowsErr(GetLastError());
- return PyBytes_FromString(filename);
+ return PyString_FromString(filename);
}
static PyMethodDef sp_functions[] = {
PyHKEYObject *pyhkey = (PyHKEYObject *)ob;
char resBuf[160];
wsprintf(resBuf, "<PyHKEY:%p>", pyhkey->hkey);
- return PyBytes_FromString(resBuf);
+ return PyString_FromString(resBuf);
}
static int
return FALSE;
need_decref = 1;
}
- if (!PyBytes_Check(value))
+ if (!PyString_Check(value))
return FALSE;
*retDataSize = 1 + strlen(
- PyBytes_AS_STRING(
- (PyBytesObject *)value));
+ PyString_AS_STRING(
+ (PyStringObject *)value));
}
*retDataBuf = (BYTE *)PyMem_NEW(DWORD, *retDataSize);
if (*retDataBuf==NULL){
strcpy((char *)*retDataBuf, "");
else
strcpy((char *)*retDataBuf,
- PyBytes_AS_STRING(
- (PyBytesObject *)value));
+ PyString_AS_STRING(
+ (PyStringObject *)value));
if (need_decref)
Py_DECREF(value);
break;
PyObject *t;
t = PyList_GET_ITEM(
(PyListObject *)value,j);
- if (PyBytes_Check(t)) {
+ if (PyString_Check(t)) {
obs[j] = t;
Py_INCREF(t);
} else if (PyUnicode_Check(t)) {
} else
goto reg_multi_fail;
size += 1 + strlen(
- PyBytes_AS_STRING(
- (PyBytesObject *)obs[j]));
+ PyString_AS_STRING(
+ (PyStringObject *)obs[j]));
}
*retDataSize = size + 1;
PyObject *t;
t = obs[j];
strcpy(P,
- PyBytes_AS_STRING(
- (PyBytesObject *)t));
+ PyString_AS_STRING(
+ (PyStringObject *)t));
P += 1 + strlen(
- PyBytes_AS_STRING(
- (PyBytesObject *)t));
+ PyString_AS_STRING(
+ (PyStringObject *)t));
Py_DECREF(obs[j]);
}
/* And doubly-terminate the list... */
if (rc != ERROR_SUCCESS)
return PyErr_SetFromWindowsErrWithFunction(rc, "RegEnumKeyEx");
- retStr = PyBytes_FromStringAndSize(tmpbuf, len);
+ retStr = PyString_FromStringAndSize(tmpbuf, len);
return retStr; /* can be NULL */
}
!= ERROR_SUCCESS)
return PyErr_SetFromWindowsErrWithFunction(rc,
"RegQueryValue");
- retStr = PyBytes_FromStringAndSize(NULL, bufSize);
+ retStr = PyString_FromStringAndSize(NULL, bufSize);
if (retStr == NULL)
return NULL;
- retBuf = PyBytes_AS_STRING(retStr);
+ retBuf = PyString_AS_STRING(retStr);
if ((rc = RegQueryValue(hKey, subKey, retBuf, &bufSize))
!= ERROR_SUCCESS) {
Py_DECREF(retStr);
return PyErr_SetFromWindowsErrWithFunction(rc,
"RegQueryValue");
}
- _PyBytes_Resize(&retStr, strlen(retBuf));
+ _PyString_Resize(&retStr, strlen(retBuf));
return retStr;
}
return NULL;
}
/* XXX - need Unicode support */
- str = PyBytes_AsString(obStrVal);
+ str = PyString_AsString(obStrVal);
if (str == NULL)
return NULL;
- len = PyBytes_Size(obStrVal);
+ len = PyString_Size(obStrVal);
if (obSubKey == Py_None)
subKey = NULL;
else {
- subKey = PyBytes_AsString(obSubKey);
+ subKey = PyString_AsString(obSubKey);
if (subKey == NULL)
return NULL;
}
ch = _getch();
Py_END_ALLOW_THREADS
s[0] = ch;
- return PyBytes_FromStringAndSize(s, 1);
+ return PyString_FromStringAndSize(s, 1);
}
static PyObject *
ch = _getche();
Py_END_ALLOW_THREADS
s[0] = ch;
- return PyBytes_FromStringAndSize(s, 1);
+ return PyString_FromStringAndSize(s, 1);
}
static PyObject *
static void
add_define(PyObject *dict, const char *key, long value)
{
- PyObject *k=PyBytes_FromString(key);
+ PyObject *k=PyString_FromString(key);
PyObject *v=PyLong_FromLong(value);
if(v&&k)
{
# there's really nothing more we can do if this fails ...
self.emit("if (tmp == NULL) goto failed;", 1)
error = "expected some sort of %s, but got %%.400s" % name
- format = "PyErr_Format(PyExc_TypeError, \"%s\", PyBytes_AS_STRING(tmp));"
+ format = "PyErr_Format(PyExc_TypeError, \"%s\", PyString_AS_STRING(tmp));"
self.emit(format % error, 1, reflow=False)
self.emit("failed:", 0)
self.emit("Py_XDECREF(tmp);", 1)
fnames = PyTuple_New(num_fields);
if (!fnames) return NULL;
for (i = 0; i < num_fields; i++) {
- PyObject *field = PyBytes_FromString(fields[i]);
+ PyObject *field = PyString_FromString(fields[i]);
if (!field) {
Py_DECREF(fnames);
return NULL;
PyObject *s, *l = PyTuple_New(num_fields);
if (!l) return 0;
for(i = 0; i < num_fields; i++) {
- s = PyBytes_FromString(attrs[i]);
+ s = PyString_FromString(attrs[i]);
if (!s) {
Py_DECREF(l);
return 0;
PyObject *s = PyObject_Repr(obj);
if (s == NULL) return 1;
PyErr_Format(PyExc_ValueError, "invalid integer value: %.400s",
- PyBytes_AS_STRING(s));
+ PyString_AS_STRING(s));
Py_DECREF(s);
return 1;
}
PyObject *s = PyObject_Repr(obj);
if (s == NULL) return 1;
PyErr_Format(PyExc_ValueError, "invalid boolean value: %.400s",
- PyBytes_AS_STRING(s));
+ PyString_AS_STRING(s));
Py_DECREF(s);
return 1;
}
#ifndef PGEN
#include "unicodeobject.h"
-#include "bytesobject.h"
+#include "stringobject.h"
#include "fileobject.h"
#include "codecs.h"
#include "abstract.h"
1) NULL: need to call tok->decoding_readline to get a new line
2) PyUnicodeObject *: decoding_feof has called tok->decoding_readline and
stored the result in tok->decoding_buffer
- 3) PyBytesObject *: previous call to fp_readl did not have enough room
+ 3) PyStringObject *: previous call to fp_readl did not have enough room
(in the s buffer) to copy entire contents of the line read
by tok->decoding_readline. tok->decoding_buffer has the overflow.
In this case, fp_readl is called in a loop (with an expanded buffer)
return error_ret(tok);
} else {
tok->decoding_buffer = NULL;
- if (PyBytes_CheckExact(buf))
+ if (PyString_CheckExact(buf))
utf8 = buf;
}
if (utf8 == NULL) {
if (utf8 == NULL)
return error_ret(tok);
}
- str = PyBytes_AsString(utf8);
- utf8len = PyBytes_GET_SIZE(utf8);
+ str = PyString_AsString(utf8);
+ utf8len = PyString_GET_SIZE(utf8);
if (utf8len > size) {
- tok->decoding_buffer = PyBytes_FromStringAndSize(str+size, utf8len-size);
+ tok->decoding_buffer = PyString_FromStringAndSize(str+size, utf8len-size);
if (tok->decoding_buffer == NULL) {
Py_DECREF(utf8);
return error_ret(tok);
utf8 = translate_into_utf8(str, tok->enc);
if (utf8 == NULL)
return error_ret(tok);
- str = PyBytes_AsString(utf8);
+ str = PyString_AsString(utf8);
}
#endif
for (s = str;; s++) {
"unknown encoding: %s", tok->enc);
return error_ret(tok);
}
- str = PyBytes_AsString(utf8);
+ str = PyString_AsString(utf8);
}
#endif
assert(tok->decoding_buffer == NULL);
return 0;
enc = ((PyFileObject *)sysstdin)->f_encoding;
- if (enc == NULL || !PyBytes_Check(enc))
+ if (enc == NULL || !PyString_Check(enc))
return 0;
Py_INCREF(enc);
- encoding = PyBytes_AsString(enc);
+ encoding = PyString_AsString(enc);
decoded = PyUnicode_Decode(*inp, strlen(*inp), encoding, NULL);
if (decoded == NULL)
goto error_clear;
if (utf8 == NULL)
goto error_clear;
- assert(PyBytes_Check(utf8));
- converted = new_string(PyBytes_AS_STRING(utf8),
- PyBytes_GET_SIZE(utf8));
+ assert(PyString_Check(utf8));
+ converted = new_string(PyString_AS_STRING(utf8),
+ PyString_GET_SIZE(utf8));
Py_DECREF(utf8);
if (converted == NULL)
goto error_nomem;
/* convert source to original encondig */
PyObject *lineobj = dec_utf8(tok->encoding, tok->buf, len);
if (lineobj != NULL) {
- int linelen = PyBytes_Size(lineobj);
- const char *line = PyBytes_AsString(lineobj);
+ int linelen = PyString_Size(lineobj);
+ const char *line = PyString_AsString(lineobj);
text = PyObject_MALLOC(linelen + 1);
if (text != NULL && line != NULL) {
if (linelen)
PyObject *offsetobj = dec_utf8(tok->encoding,
tok->buf, *offset-1);
if (offsetobj) {
- *offset = PyBytes_Size(offsetobj) + 1;
+ *offset = PyString_Size(offsetobj) + 1;
Py_DECREF(offsetobj);
}
}
fnames = PyTuple_New(num_fields);
if (!fnames) return NULL;
for (i = 0; i < num_fields; i++) {
- PyObject *field = PyBytes_FromString(fields[i]);
+ PyObject *field = PyString_FromString(fields[i]);
if (!field) {
Py_DECREF(fnames);
return NULL;
PyObject *s, *l = PyTuple_New(num_fields);
if (!l) return 0;
for(i = 0; i < num_fields; i++) {
- s = PyBytes_FromString(attrs[i]);
+ s = PyString_FromString(attrs[i]);
if (!s) {
Py_DECREF(l);
return 0;
PyObject *s = PyObject_Repr(obj);
if (s == NULL) return 1;
PyErr_Format(PyExc_ValueError, "invalid integer value: %.400s",
- PyBytes_AS_STRING(s));
+ PyString_AS_STRING(s));
Py_DECREF(s);
return 1;
}
PyObject *s = PyObject_Repr(obj);
if (s == NULL) return 1;
PyErr_Format(PyExc_ValueError, "invalid boolean value: %.400s",
- PyBytes_AS_STRING(s));
+ PyString_AS_STRING(s));
Py_DECREF(s);
return 1;
}
tmp = PyObject_Repr(obj);
if (tmp == NULL) goto failed;
- PyErr_Format(PyExc_TypeError, "expected some sort of mod, but got %.400s", PyBytes_AS_STRING(tmp));
+ PyErr_Format(PyExc_TypeError, "expected some sort of mod, but got %.400s", PyString_AS_STRING(tmp));
failed:
Py_XDECREF(tmp);
return 1;
tmp = PyObject_Repr(obj);
if (tmp == NULL) goto failed;
- PyErr_Format(PyExc_TypeError, "expected some sort of stmt, but got %.400s", PyBytes_AS_STRING(tmp));
+ PyErr_Format(PyExc_TypeError, "expected some sort of stmt, but got %.400s", PyString_AS_STRING(tmp));
failed:
Py_XDECREF(tmp);
return 1;
tmp = PyObject_Repr(obj);
if (tmp == NULL) goto failed;
- PyErr_Format(PyExc_TypeError, "expected some sort of expr, but got %.400s", PyBytes_AS_STRING(tmp));
+ PyErr_Format(PyExc_TypeError, "expected some sort of expr, but got %.400s", PyString_AS_STRING(tmp));
failed:
Py_XDECREF(tmp);
return 1;
tmp = PyObject_Repr(obj);
if (tmp == NULL) goto failed;
- PyErr_Format(PyExc_TypeError, "expected some sort of expr_context, but got %.400s", PyBytes_AS_STRING(tmp));
+ PyErr_Format(PyExc_TypeError, "expected some sort of expr_context, but got %.400s", PyString_AS_STRING(tmp));
failed:
Py_XDECREF(tmp);
return 1;
tmp = PyObject_Repr(obj);
if (tmp == NULL) goto failed;
- PyErr_Format(PyExc_TypeError, "expected some sort of slice, but got %.400s", PyBytes_AS_STRING(tmp));
+ PyErr_Format(PyExc_TypeError, "expected some sort of slice, but got %.400s", PyString_AS_STRING(tmp));
failed:
Py_XDECREF(tmp);
return 1;
tmp = PyObject_Repr(obj);
if (tmp == NULL) goto failed;
- PyErr_Format(PyExc_TypeError, "expected some sort of boolop, but got %.400s", PyBytes_AS_STRING(tmp));
+ PyErr_Format(PyExc_TypeError, "expected some sort of boolop, but got %.400s", PyString_AS_STRING(tmp));
failed:
Py_XDECREF(tmp);
return 1;
tmp = PyObject_Repr(obj);
if (tmp == NULL) goto failed;
- PyErr_Format(PyExc_TypeError, "expected some sort of operator, but got %.400s", PyBytes_AS_STRING(tmp));
+ PyErr_Format(PyExc_TypeError, "expected some sort of operator, but got %.400s", PyString_AS_STRING(tmp));
failed:
Py_XDECREF(tmp);
return 1;
tmp = PyObject_Repr(obj);
if (tmp == NULL) goto failed;
- PyErr_Format(PyExc_TypeError, "expected some sort of unaryop, but got %.400s", PyBytes_AS_STRING(tmp));
+ PyErr_Format(PyExc_TypeError, "expected some sort of unaryop, but got %.400s", PyString_AS_STRING(tmp));
failed:
Py_XDECREF(tmp);
return 1;
tmp = PyObject_Repr(obj);
if (tmp == NULL) goto failed;
- PyErr_Format(PyExc_TypeError, "expected some sort of cmpop, but got %.400s", PyBytes_AS_STRING(tmp));
+ PyErr_Format(PyExc_TypeError, "expected some sort of cmpop, but got %.400s", PyString_AS_STRING(tmp));
failed:
Py_XDECREF(tmp);
return 1;
tmp = PyObject_Repr(obj);
if (tmp == NULL) goto failed;
- PyErr_Format(PyExc_TypeError, "expected some sort of excepthandler, but got %.400s", PyBytes_AS_STRING(tmp));
+ PyErr_Format(PyExc_TypeError, "expected some sort of excepthandler, but got %.400s", PyString_AS_STRING(tmp));
failed:
Py_XDECREF(tmp);
return 1;
int result;
if (warnings_str == NULL) {
- warnings_str = PyBytes_InternFromString("warnings");
+ warnings_str = PyString_InternFromString("warnings");
if (warnings_str == NULL)
return NULL;
}
return NULL;
if (good_msg && is_subclass && good_mod && (ln == 0 || lineno == ln))
- return PyBytes_AsString(action);
+ return PyString_AsString(action);
}
m = PyImport_ImportModule(MODULE_NAME);
return NULL;
action = PyDict_GetItemString(d, DEFAULT_ACTION_NAME);
if (action != NULL)
- return PyBytes_AsString(action);
+ return PyString_AsString(action);
PyErr_SetString(PyExc_ValueError,
MODULE_NAME "." DEFAULT_ACTION_NAME " not found");
if (rc == -1)
return NULL;
else if (rc == 0)
- return PyBytes_FromString("<unknown>");
+ return PyString_FromString("<unknown>");
- mod_str = PyBytes_AsString(filename);
+ mod_str = PyString_AsString(filename);
if (mod_str == NULL)
return NULL;
- len = PyBytes_Size(filename);
+ len = PyString_Size(filename);
if (len < 0)
return NULL;
if (len >= 3 &&
strncmp(mod_str + (len - 3), ".py", 3) == 0) {
- module = PyBytes_FromStringAndSize(mod_str, len-3);
+ module = PyString_FromStringAndSize(mod_str, len-3);
}
else {
module = filename;
/* Print " source_line\n" */
PyFile_WriteString(" ", f_stderr);
if (sourceline) {
- char *source_line_str = PyBytes_AS_STRING(sourceline);
+ char *source_line_str = PyString_AS_STRING(sourceline);
while (*source_line_str == ' ' || *source_line_str == '\t' ||
*source_line_str == '\014')
source_line_str++;
PyFile_WriteString("\n", f_stderr);
}
else
- Py_DisplaySourceLine(f_stderr, PyBytes_AS_STRING(filename), lineno);
+ Py_DisplaySourceLine(f_stderr, PyString_AS_STRING(filename), lineno);
PyErr_Clear();
}
const char *err_str = "???";
if (to_str != NULL)
- err_str = PyBytes_AS_STRING(to_str);
+ err_str = PyString_AS_STRING(to_str);
PyErr_Format(PyExc_RuntimeError,
"Unrecognized action (%s) in warnings.filters:\n %s",
action, err_str);
else {
const char *msg = "functions overriding warnings.showwarning() "
"must support the 'line' argument";
- const char *text_char = PyBytes_AS_STRING(text);
+ const char *text_char = PyString_AS_STRING(text);
if (strcmp(msg, text_char) == 0) {
/* Prevent infinite recursion by using built-in implementation
/* Setup module. */
*module = PyDict_GetItemString(globals, "__name__");
if (*module == NULL) {
- *module = PyBytes_FromString("<string>");
+ *module = PyString_FromString("<string>");
if (*module == NULL)
goto handle_error;
}
/* Setup filename. */
*filename = PyDict_GetItemString(globals, "__file__");
if (*filename != NULL) {
- Py_ssize_t len = PyBytes_Size(*filename);
- const char *file_str = PyBytes_AsString(*filename);
+ Py_ssize_t len = PyString_Size(*filename);
+ const char *file_str = PyString_AsString(*filename);
if (file_str == NULL || (len < 0 && PyErr_Occurred()))
goto handle_error;
(tolower(file_str[len-1]) == 'c' ||
tolower(file_str[len-1]) == 'o'))
{
- *filename = PyBytes_FromStringAndSize(file_str, len-1);
+ *filename = PyString_FromStringAndSize(file_str, len-1);
if (*filename == NULL)
goto handle_error;
}
Py_INCREF(*filename);
}
else {
- const char *module_str = PyBytes_AsString(*module);
+ const char *module_str = PyString_AsString(*module);
if (module_str && strcmp(module_str, "__main__") == 0) {
PyObject *argv = PySys_GetObject("argv");
if (argv != NULL && PyList_Size(argv) > 0) {
}
else if (!is_true) {
Py_DECREF(*filename);
- *filename = PyBytes_FromString("__main__");
+ *filename = PyString_FromString("__main__");
if (*filename == NULL)
goto handle_error;
}
}
else {
/* embedded interpreters don't have sys.argv, see bug #839151 */
- *filename = PyBytes_FromString("__main__");
+ *filename = PyString_FromString("__main__");
if (*filename == NULL)
goto handle_error;
}
PyObject *returned;
if (get_source_name == NULL) {
- get_source_name = PyBytes_InternFromString("get_source");
+ get_source_name = PyString_InternFromString("get_source");
if (!get_source_name)
return NULL;
}
if (splitlines_name == NULL) {
- splitlines_name = PyBytes_InternFromString("splitlines");
+ splitlines_name = PyString_InternFromString("splitlines");
if (!splitlines_name)
return NULL;
}
PyErr_WarnEx(PyObject *category, const char *text, Py_ssize_t stack_level)
{
PyObject *res;
- PyObject *message = PyBytes_FromString(text);
+ PyObject *message = PyString_FromString(text);
if (message == NULL)
return -1;
const char *module_str, PyObject *registry)
{
PyObject *res;
- PyObject *message = PyBytes_FromString(text);
- PyObject *filename = PyBytes_FromString(filename_str);
+ PyObject *message = PyString_FromString(text);
+ PyObject *filename = PyString_FromString(filename_str);
PyObject *module = NULL;
int ret = -1;
if (message == NULL || filename == NULL)
goto exit;
if (module_str != NULL) {
- module = PyBytes_FromString(module_str);
+ module = PyString_FromString(module_str);
if (module == NULL)
goto exit;
}
if (!strcmp(action, "ignore")) {
if (ignore_str == NULL) {
- ignore_str = PyBytes_InternFromString("ignore");
+ ignore_str = PyString_InternFromString("ignore");
if (ignore_str == NULL)
return NULL;
}
}
else if (!strcmp(action, "error")) {
if (error_str == NULL) {
- error_str = PyBytes_InternFromString("error");
+ error_str = PyString_InternFromString("error");
if (error_str == NULL)
return NULL;
}
}
else if (!strcmp(action, "default")) {
if (default_str == NULL) {
- default_str = PyBytes_InternFromString("default");
+ default_str = PyString_InternFromString("default");
if (default_str == NULL)
return NULL;
}
if (PyModule_AddObject(m, "once_registry", _once_registry) < 0)
return;
- default_action = PyBytes_InternFromString("default");
+ default_action = PyString_InternFromString("default");
if (default_action == NULL)
return;
if (PyModule_AddObject(m, DEFAULT_ACTION_NAME, default_action) < 0)
static identifier
new_identifier(const char* n, PyArena *arena) {
- PyObject* id = PyBytes_InternFromString(n);
+ PyObject* id = PyString_InternFromString(n);
PyArena_AddPyObject(arena, id);
return id;
}
if (errstr) {
char *s = "";
char buf[128];
- s = PyBytes_AsString(errstr);
+ s = PyString_AsString(errstr);
PyOS_snprintf(buf, sizeof(buf), "(unicode error) %s", s);
ast_error(n, buf);
} else {
/* length of string plus one for the dot */
len += strlen(STR(CHILD(n, i))) + 1;
len--; /* the last name doesn't have a dot */
- str = PyBytes_FromStringAndSize(NULL, len);
+ str = PyString_FromStringAndSize(NULL, len);
if (!str)
return NULL;
- s = PyBytes_AS_STRING(str);
+ s = PyString_AS_STRING(str);
if (!s)
return NULL;
for (i = 0; i < NCH(n); i += 2) {
}
--s;
*s = '\0';
- PyBytes_InternInPlace(&str);
+ PyString_InternInPlace(&str);
PyArena_AddPyObject(c->c_arena, str);
return alias(str, NULL, c->c_arena);
}
break;
case STAR:
- str = PyBytes_InternFromString("*");
+ str = PyString_InternFromString("*");
PyArena_AddPyObject(c->c_arena, str);
return alias(str, NULL, c->c_arena);
default:
u = NULL;
} else {
/* "\XX" may become "\u005c\uHHLL" (12 bytes) */
- u = PyBytes_FromStringAndSize((char *)NULL, len * 4);
+ u = PyString_FromStringAndSize((char *)NULL, len * 4);
if (u == NULL)
return NULL;
- p = buf = PyBytes_AsString(u);
+ p = buf = PyString_AsString(u);
end = s + len;
while (s < end) {
if (*s == '\\') {
Py_DECREF(u);
return NULL;
}
- r = PyBytes_AsString(w);
- rn = PyBytes_Size(w);
+ r = PyString_AsString(w);
+ rn = PyString_Size(w);
assert(rn % 2 == 0);
for (i = 0; i < rn; i += 2) {
sprintf(p, "\\u%02x%02x",
return v;
#endif
} else {
- return PyBytes_FromStringAndSize(s, len);
+ return PyString_FromStringAndSize(s, len);
}
}
- return PyBytes_DecodeEscape(s, len, NULL, unicode,
+ return PyString_DecodeEscape(s, len, NULL, unicode,
need_encoding ? c->c_encoding : NULL);
}
s = parsestr(c, STR(CHILD(n, i)));
if (s == NULL)
goto onError;
- if (PyBytes_Check(v) && PyBytes_Check(s)) {
- PyBytes_ConcatAndDel(&v, s);
+ if (PyString_Check(v) && PyString_Check(s)) {
+ PyString_ConcatAndDel(&v, s);
if (v == NULL)
goto onError;
}
return NULL;
/* Strings and tuples return a result of the same type. */
- if (PyBytes_Check(seq))
+ if (PyString_Check(seq))
return filterstring(func, seq);
#ifdef Py_USING_UNICODE
if (PyUnicode_Check(seq))
return NULL;
}
s[0] = (char)x;
- return PyBytes_FromStringAndSize(s, 1);
+ return PyString_FromStringAndSize(s, 1);
}
PyDoc_STRVAR(chr_doc,
return PyEval_EvalCode((PyCodeObject *) cmd, globals, locals);
}
- if (!PyBytes_Check(cmd) &&
+ if (!PyString_Check(cmd) &&
!PyUnicode_Check(cmd)) {
PyErr_SetString(PyExc_TypeError,
"eval() arg 1 must be a string or code object");
cf.cf_flags |= PyCF_SOURCE_IS_UTF8;
}
#endif
- if (PyBytes_AsStringAndSize(cmd, &str, NULL)) {
+ if (PyString_AsStringAndSize(cmd, &str, NULL)) {
Py_XDECREF(tmp);
return NULL;
}
}
#endif
- if (!PyBytes_Check(name)) {
+ if (!PyString_Check(name)) {
PyErr_SetString(PyExc_TypeError,
"getattr(): attribute name must be string");
return NULL;
}
#endif
- if (!PyBytes_Check(name)) {
+ if (!PyString_Check(name)) {
PyErr_SetString(PyExc_TypeError,
"hasattr(): attribute name must be string");
return NULL;
return NULL;
}
res = (*nb->nb_hex)(v);
- if (res && !PyBytes_Check(res)) {
+ if (res && !PyString_Check(res)) {
PyErr_Format(PyExc_TypeError,
"__hex__ returned non-string (type %.200s)",
res->ob_type->tp_name);
PyObject *s;
if (!PyArg_ParseTuple(args, "S:intern", &s))
return NULL;
- if (!PyBytes_CheckExact(s)) {
+ if (!PyString_CheckExact(s)) {
PyErr_SetString(PyExc_TypeError,
"can't intern subclass of string");
return NULL;
}
Py_INCREF(s);
- PyBytes_InternInPlace(&s);
+ PyString_InternInPlace(&s);
return s;
}
return NULL;
}
res = (*nb->nb_oct)(v);
- if (res && !PyBytes_Check(res)) {
+ if (res && !PyString_Check(res)) {
PyErr_Format(PyExc_TypeError,
"__oct__ returned non-string (type %.200s)",
res->ob_type->tp_name);
long ord;
Py_ssize_t size;
- if (PyBytes_Check(obj)) {
- size = PyBytes_GET_SIZE(obj);
+ if (PyString_Check(obj)) {
+ size = PyString_GET_SIZE(obj);
if (size == 1) {
- ord = (long)((unsigned char)*PyBytes_AS_STRING(obj));
+ ord = (long)((unsigned char)*PyString_AS_STRING(obj));
return PyInt_FromLong(ord);
}
} else if (PyByteArray_Check(obj)) {
Py_RETURN_NONE;
}
- if (sep && sep != Py_None && !PyBytes_Check(sep) &&
+ if (sep && sep != Py_None && !PyString_Check(sep) &&
!PyUnicode_Check(sep)) {
PyErr_Format(PyExc_TypeError,
"sep must be None, str or unicode, not %.200s",
sep->ob_type->tp_name);
return NULL;
}
- if (end && end != Py_None && !PyBytes_Check(end) &&
+ if (end && end != Py_None && !PyString_Check(end) &&
!PyUnicode_Check(end)) {
PyErr_Format(PyExc_TypeError,
"end must be None, str or unicode, not %.200s",
po = PyObject_Str(v);
if (po == NULL)
return NULL;
- prompt = PyBytes_AsString(po);
+ prompt = PyString_AsString(po);
if (prompt == NULL)
return NULL;
}
result = NULL;
}
else {
- result = PyBytes_FromStringAndSize(s, len-1);
+ result = PyString_FromStringAndSize(s, len-1);
}
}
PyMem_FREE(s);
SETBUILTIN("bool", &PyBool_Type);
/* SETBUILTIN("memoryview", &PyMemoryView_Type); */
SETBUILTIN("bytearray", &PyByteArray_Type);
- SETBUILTIN("bytes", &PyBytes_Type);
+ SETBUILTIN("bytes", &PyString_Type);
SETBUILTIN("buffer", &PyBuffer_Type);
SETBUILTIN("classmethod", &PyClassMethod_Type);
#ifndef WITHOUT_COMPLEX
SETBUILTIN("set", &PySet_Type);
SETBUILTIN("slice", &PySlice_Type);
SETBUILTIN("staticmethod", &PyStaticMethod_Type);
- SETBUILTIN("str", &PyBytes_Type);
+ SETBUILTIN("str", &PyString_Type);
SETBUILTIN("super", &PySuper_Type);
SETBUILTIN("tuple", &PyTuple_Type);
SETBUILTIN("type", &PyType_Type);
{
PyObject *result;
Py_ssize_t i, j;
- Py_ssize_t len = PyBytes_Size(strobj);
+ Py_ssize_t len = PyString_Size(strobj);
Py_ssize_t outlen = len;
if (func == Py_None) {
* as no character is ever false and __getitem__
* does return this character. If it's a subclass
* we must go through the __getitem__ loop */
- if (PyBytes_CheckExact(strobj)) {
+ if (PyString_CheckExact(strobj)) {
Py_INCREF(strobj);
return strobj;
}
}
- if ((result = PyBytes_FromStringAndSize(NULL, len)) == NULL)
+ if ((result = PyString_FromStringAndSize(NULL, len)) == NULL)
return NULL;
for (i = j = 0; i < len; ++i) {
}
if (ok) {
Py_ssize_t reslen;
- if (!PyBytes_Check(item)) {
+ if (!PyString_Check(item)) {
PyErr_SetString(PyExc_TypeError, "can't filter str to str:"
" __getitem__ returned different type");
Py_DECREF(item);
goto Fail_1;
}
- reslen = PyBytes_GET_SIZE(item);
+ reslen = PyString_GET_SIZE(item);
if (reslen == 1) {
- PyBytes_AS_STRING(result)[j++] =
- PyBytes_AS_STRING(item)[0];
+ PyString_AS_STRING(result)[j++] =
+ PyString_AS_STRING(item)[0];
} else {
/* do we need more space? */
Py_ssize_t need = j + reslen + len-i-1;
/* overallocate, to avoid reallocations */
if (need<2*outlen)
need = 2*outlen;
- if (_PyBytes_Resize(&result, need)) {
+ if (_PyString_Resize(&result, need)) {
Py_DECREF(item);
return NULL;
}
outlen = need;
}
memcpy(
- PyBytes_AS_STRING(result) + j,
- PyBytes_AS_STRING(item),
+ PyString_AS_STRING(result) + j,
+ PyString_AS_STRING(item),
reslen
);
j += reslen;
}
if (j < outlen)
- _PyBytes_Resize(&result, j);
+ _PyString_Resize(&result, j);
return result;
consts = co->co_consts;
fastlocals = f->f_localsplus;
freevars = f->f_localsplus + co->co_nlocals;
- first_instr = (unsigned char*) PyBytes_AS_STRING(co->co_code);
+ first_instr = (unsigned char*) PyString_AS_STRING(co->co_code);
/* An explanation is in order for the next line.
f->f_lasti now refers to the index of the last instruction
lltrace = PyDict_GetItemString(f->f_globals, "__lltrace__") != NULL;
#endif
#if defined(Py_DEBUG) || defined(LLTRACE)
- filename = PyBytes_AsString(co->co_filename);
+ filename = PyString_AsString(co->co_filename);
#endif
why = WHY_NOT;
goto slow_add;
x = PyInt_FromLong(i);
}
- else if (PyBytes_CheckExact(v) &&
- PyBytes_CheckExact(w)) {
+ else if (PyString_CheckExact(v) &&
+ PyString_CheckExact(w)) {
x = string_concatenate(v, w, f, next_instr);
/* string_concatenate consumed the ref to v */
goto skip_decref_vx;
goto slow_iadd;
x = PyInt_FromLong(i);
}
- else if (PyBytes_CheckExact(v) &&
- PyBytes_CheckExact(w)) {
+ else if (PyString_CheckExact(v) &&
+ PyString_CheckExact(w)) {
x = string_concatenate(v, w, f, next_instr);
/* string_concatenate consumed the ref to v */
goto skip_decref_v;
err = PyFile_WriteObject(v, w, Py_PRINT_RAW);
if (err == 0) {
/* XXX move into writeobject() ? */
- if (PyBytes_Check(v)) {
- char *s = PyBytes_AS_STRING(v);
- Py_ssize_t len = PyBytes_GET_SIZE(v);
+ if (PyString_Check(v)) {
+ char *s = PyString_AS_STRING(v);
+ Py_ssize_t len = PyString_GET_SIZE(v);
if (len == 0 ||
!isspace(Py_CHARMASK(s[len-1])) ||
s[len-1] == ' ')
retval = POP();
}
else if (PyExceptionClass_Check(v) ||
- PyBytes_Check(v)) {
+ PyString_Check(v)) {
w = POP();
u = POP();
PyErr_Restore(v, w, u);
case LOAD_GLOBAL:
w = GETITEM(names, oparg);
- if (PyBytes_CheckExact(w)) {
+ if (PyString_CheckExact(w)) {
/* Inline the PyDict_GetItem() calls.
WARNING: this is an extreme speed hack.
Do not try this at home. */
- long hash = ((PyBytesObject *)w)->ob_shash;
+ long hash = ((PyStringObject *)w)->ob_shash;
if (hash != -1) {
PyDictObject *d;
PyDictEntry *e;
PyErr_Format(PyExc_TypeError,
"%.200s() takes %s %d "
"%sargument%s (%d given)",
- PyBytes_AsString(co->co_name),
+ PyString_AsString(co->co_name),
defcount ? "at most" : "exactly",
co->co_argcount,
kwcount ? "non-keyword " : "",
PyObject *keyword = kws[2*i];
PyObject *value = kws[2*i + 1];
int j;
- if (keyword == NULL || !PyBytes_Check(keyword)) {
+ if (keyword == NULL || !PyString_Check(keyword)) {
PyErr_Format(PyExc_TypeError,
"%.200s() keywords must be strings",
- PyBytes_AsString(co->co_name));
+ PyString_AsString(co->co_name));
goto fail;
}
/* XXX slow -- speed up using dictionary? */
PyErr_Format(PyExc_TypeError,
"%.200s() got an unexpected "
"keyword argument '%.400s'",
- PyBytes_AsString(co->co_name),
- PyBytes_AsString(keyword));
+ PyString_AsString(co->co_name),
+ PyString_AsString(keyword));
goto fail;
}
PyDict_SetItem(kwdict, keyword, value);
"%.200s() got multiple "
"values for keyword "
"argument '%.400s'",
- PyBytes_AsString(co->co_name),
- PyBytes_AsString(keyword));
+ PyString_AsString(co->co_name),
+ PyString_AsString(keyword));
goto fail;
}
Py_INCREF(value);
PyErr_Format(PyExc_TypeError,
"%.200s() takes %s %d "
"%sargument%s (%d given)",
- PyBytes_AsString(co->co_name),
+ PyString_AsString(co->co_name),
((co->co_flags & CO_VARARGS) ||
defcount) ? "at least"
: "exactly",
if (argcount > 0 || kwcount > 0) {
PyErr_Format(PyExc_TypeError,
"%.200s() takes no arguments (%d given)",
- PyBytes_AsString(co->co_name),
+ PyString_AsString(co->co_name),
argcount + kwcount);
goto fail;
}
list so that we can march over it more efficiently?
*/
for (i = 0; i < PyTuple_GET_SIZE(co->co_cellvars); ++i) {
- cellname = PyBytes_AS_STRING(
+ cellname = PyString_AS_STRING(
PyTuple_GET_ITEM(co->co_cellvars, i));
found = 0;
for (j = 0; j < nargs; j++) {
- argname = PyBytes_AS_STRING(
+ argname = PyString_AS_STRING(
PyTuple_GET_ITEM(co->co_varnames, j));
if (strcmp(cellname, argname) == 0) {
c = PyCell_New(GETLOCAL(j));
if (PyMethod_Check(func))
return PyEval_GetFuncName(PyMethod_GET_FUNCTION(func));
else if (PyFunction_Check(func))
- return PyBytes_AsString(((PyFunctionObject*)func)->func_name);
+ return PyString_AsString(((PyFunctionObject*)func)->func_name);
else if (PyCFunction_Check(func))
return ((PyCFunctionObject*)func)->m_ml->ml_name;
else if (PyClass_Check(func))
- return PyBytes_AsString(((PyClassObject*)func)->cl_name);
+ return PyString_AsString(((PyClassObject*)func)->cl_name);
else if (PyInstance_Check(func)) {
- return PyBytes_AsString(
+ return PyString_AsString(
((PyInstanceObject*)func)->in_class->cl_name);
} else {
return func->ob_type->tp_name;
"for keyword argument '%.200s'",
PyEval_GetFuncName(func),
PyEval_GetFuncDesc(func),
- PyBytes_AsString(key));
+ PyString_AsString(key));
Py_DECREF(key);
Py_DECREF(value);
Py_DECREF(kwdict);
length = PyTuple_Size(w);
for (i = 0; i < length; i += 1) {
PyObject *exc = PyTuple_GET_ITEM(w, i);
- if (PyBytes_Check(exc)) {
+ if (PyString_Check(exc)) {
int ret_val;
ret_val = PyErr_WarnEx(
PyExc_DeprecationWarning,
}
}
else {
- if (PyBytes_Check(w)) {
+ if (PyString_Check(w)) {
int ret_val;
ret_val = PyErr_WarnEx(
PyExc_DeprecationWarning,
if (x == NULL && PyErr_ExceptionMatches(PyExc_AttributeError)) {
PyErr_Format(PyExc_ImportError,
"cannot import name %.230s",
- PyBytes_AsString(name));
+ PyString_AsString(name));
}
return x;
}
break;
}
if (skip_leading_underscores &&
- PyBytes_Check(name) &&
- PyBytes_AS_STRING(name)[0] == '_')
+ PyString_Check(name) &&
+ PyString_AS_STRING(name)[0] == '_')
{
Py_DECREF(name);
continue;
PyObject *ptype, *pvalue, *ptraceback;
PyErr_Fetch(&ptype, &pvalue, &ptraceback);
- if (PyBytes_Check(pvalue)) {
+ if (PyString_Check(pvalue)) {
PyObject *newmsg;
- newmsg = PyBytes_FromFormat(
+ newmsg = PyString_FromFormat(
"Error when calling the metaclass bases\n"
" %s",
- PyBytes_AS_STRING(pvalue));
+ PyString_AS_STRING(pvalue));
if (newmsg != NULL) {
Py_DECREF(pvalue);
pvalue = newmsg;
}
else if (locals == Py_None)
locals = globals;
- if (!PyBytes_Check(prog) &&
+ if (!PyString_Check(prog) &&
!PyUnicode_Check(prog) &&
!PyCode_Check(prog) &&
!PyFile_Check(prog)) {
}
else if (PyFile_Check(prog)) {
FILE *fp = PyFile_AsFile(prog);
- char *name = PyBytes_AsString(PyFile_Name(prog));
+ char *name = PyString_AsString(PyFile_Name(prog));
PyCompilerFlags cf;
if (name == NULL)
return -1;
cf.cf_flags |= PyCF_SOURCE_IS_UTF8;
}
#endif
- if (PyBytes_AsStringAndSize(prog, &str, NULL))
+ if (PyString_AsStringAndSize(prog, &str, NULL))
return -1;
if (PyEval_MergeCompilerFlags(&cf))
v = PyRun_StringFlags(str, Py_file_input, globals,
if (!obj)
return;
- obj_str = PyBytes_AsString(obj);
+ obj_str = PyString_AsString(obj);
if (!obj_str)
return;
{
/* This function implements 'variable += expr' when both arguments
are strings. */
- Py_ssize_t v_len = PyBytes_GET_SIZE(v);
- Py_ssize_t w_len = PyBytes_GET_SIZE(w);
+ Py_ssize_t v_len = PyString_GET_SIZE(v);
+ Py_ssize_t w_len = PyString_GET_SIZE(w);
Py_ssize_t new_len = v_len + w_len;
if (new_len < 0) {
PyErr_SetString(PyExc_OverflowError,
}
}
- if (v->ob_refcnt == 1 && !PyBytes_CHECK_INTERNED(v)) {
+ if (v->ob_refcnt == 1 && !PyString_CHECK_INTERNED(v)) {
/* Now we own the last reference to 'v', so we can resize it
* in-place.
*/
- if (_PyBytes_Resize(&v, new_len) != 0) {
- /* XXX if _PyBytes_Resize() fails, 'v' has been
+ if (_PyString_Resize(&v, new_len) != 0) {
+ /* XXX if _PyString_Resize() fails, 'v' has been
* deallocated so it cannot be put back into
* 'variable'. The MemoryError is raised when there
* is no value in 'variable', which might (very
return NULL;
}
/* copy 'w' into the newly allocated area of 'v' */
- memcpy(PyBytes_AS_STRING(v) + v_len,
- PyBytes_AS_STRING(w), w_len);
+ memcpy(PyString_AS_STRING(v) + v_len,
+ PyString_AS_STRING(w), w_len);
return v;
}
else {
/* When in-place resizing is not an option. */
- PyBytes_Concat(&v, w);
+ PyString_Concat(&v, w);
return v;
}
}
return NULL;
}
- v = PyBytes_FromStringAndSize(NULL, len);
+ v = PyString_FromStringAndSize(NULL, len);
if (v == NULL)
return NULL;
- p = PyBytes_AS_STRING(v);
+ p = PyString_AS_STRING(v);
for (i = 0; i < len; i++) {
register char ch = string[i];
if (ch == ' ')
v = normalizestring(encoding);
if (v == NULL)
goto onError;
- PyBytes_InternInPlace(&v);
+ PyString_InternInPlace(&v);
/* First, try to lookup the name in the registry dictionary */
result = PyDict_GetItem(interp->codec_search_cache, v);
if (errors) {
PyObject *v;
- v = PyBytes_FromString(errors);
+ v = PyString_FromString(errors);
if (v == NULL) {
Py_DECREF(args);
return NULL;
if (string != NULL) {
PyErr_Format(PyExc_TypeError,
"don't know how to handle %.400s in error callback",
- PyBytes_AS_STRING(string));
+ PyString_AS_STRING(string));
Py_DECREF(string);
}
}
{
/* Name mangling: __private becomes _classname__private.
This is independent from how the name is used. */
- const char *p, *name = PyBytes_AsString(ident);
+ const char *p, *name = PyString_AsString(ident);
char *buffer;
size_t nlen, plen;
- if (privateobj == NULL || !PyBytes_Check(privateobj) ||
+ if (privateobj == NULL || !PyString_Check(privateobj) ||
name == NULL || name[0] != '_' || name[1] != '_') {
Py_INCREF(ident);
return ident;
}
- p = PyBytes_AsString(privateobj);
+ p = PyString_AsString(privateobj);
nlen = strlen(name);
/* Don't mangle __id__ or names with dots.
return ident; /* Don't mangle if class is just underscores */
}
plen = strlen(p);
- ident = PyBytes_FromStringAndSize(NULL, 1 + nlen + plen);
+ ident = PyString_FromStringAndSize(NULL, 1 + nlen + plen);
if (!ident)
return 0;
/* ident = "_" + p[:plen] + name # i.e. 1+plen+nlen bytes */
- buffer = PyBytes_AS_STRING(ident);
+ buffer = PyString_AS_STRING(ident);
buffer[0] = '_';
strncpy(buffer+1, p, plen);
strcpy(buffer+1+plen, name);
int merged;
if (!__doc__) {
- __doc__ = PyBytes_InternFromString("__doc__");
+ __doc__ = PyString_InternFromString("__doc__");
if (!__doc__)
return NULL;
}
{
char tmpname[256];
PyOS_snprintf(tmpname, sizeof(tmpname), "_[%d]", ++c->u->u_tmpname);
- return PyBytes_FromString(tmpname);
+ return PyString_FromString(tmpname);
}
/* Allocate a new block and return a pointer to it.
int addNone = 1;
static PyObject *module;
if (!module) {
- module = PyBytes_InternFromString("<module>");
+ module = PyString_InternFromString("<module>");
if (!module)
return NULL;
}
PyOS_snprintf(buf, sizeof(buf),
"unknown scope for %.100s in %.100s(%s) in %s\n"
"symbols: %s\nlocals: %s\nglobals: %s\n",
- PyBytes_AS_STRING(name),
- PyBytes_AS_STRING(c->u->u_name),
+ PyString_AS_STRING(name),
+ PyString_AS_STRING(c->u->u_name),
PyObject_REPR(c->u->u_ste->ste_id),
c->c_filename,
PyObject_REPR(c->u->u_ste->ste_symbols),
printf("lookup %s in %s %d %d\n"
"freevars of %s: %s\n",
PyObject_REPR(name),
- PyBytes_AS_STRING(c->u->u_name),
+ PyString_AS_STRING(c->u->u_name),
reftype, arg,
- PyBytes_AS_STRING(co->co_name),
+ PyString_AS_STRING(co->co_name),
PyObject_REPR(co->co_freevars));
Py_FatalError("compiler_make_closure()");
}
for (i = 0; i < n; i++) {
expr_ty arg = (expr_ty)asdl_seq_GET(args->args, i);
if (arg->kind == Tuple_kind) {
- PyObject *id = PyBytes_FromFormat(".%d", i);
+ PyObject *id = PyString_FromFormat(".%d", i);
if (id == NULL) {
return 0;
}
Py_XDECREF(c->u->u_private);
c->u->u_private = s->v.ClassDef.name;
Py_INCREF(c->u->u_private);
- str = PyBytes_InternFromString("__name__");
+ str = PyString_InternFromString("__name__");
if (!str || !compiler_nameop(c, str, Load)) {
Py_XDECREF(str);
compiler_exit_scope(c);
}
Py_DECREF(str);
- str = PyBytes_InternFromString("__module__");
+ str = PyString_InternFromString("__module__");
if (!str || !compiler_nameop(c, str, Store)) {
Py_XDECREF(str);
compiler_exit_scope(c);
assert(e->kind == Lambda_kind);
if (!name) {
- name = PyBytes_InternFromString("<lambda>");
+ name = PyString_InternFromString("<lambda>");
if (!name)
return 0;
}
If there is a dot in name, we need to split it and emit a
LOAD_ATTR for each name.
*/
- const char *src = PyBytes_AS_STRING(name);
+ const char *src = PyString_AS_STRING(name);
const char *dot = strchr(src, '.');
if (dot) {
/* Consume the base module name to get the first attribute */
/* NB src is only defined when dot != NULL */
PyObject *attr;
dot = strchr(src, '.');
- attr = PyBytes_FromStringAndSize(src,
+ attr = PyString_FromStringAndSize(src,
dot ? dot - src : strlen(src));
if (!attr)
return -1;
}
else {
identifier tmp = alias->name;
- const char *base = PyBytes_AS_STRING(alias->name);
+ const char *base = PyString_AS_STRING(alias->name);
char *dot = strchr(base, '.');
if (dot)
- tmp = PyBytes_FromStringAndSize(base,
+ tmp = PyString_FromStringAndSize(base,
dot - base);
r = compiler_nameop(c, tmp, Store);
if (dot) {
}
if (s->lineno > c->c_future->ff_lineno) {
- if (!strcmp(PyBytes_AS_STRING(s->v.ImportFrom.module),
+ if (!strcmp(PyString_AS_STRING(s->v.ImportFrom.module),
"__future__")) {
Py_DECREF(level);
Py_DECREF(names);
alias_ty alias = (alias_ty)asdl_seq_GET(s->v.ImportFrom.names, i);
identifier store_name;
- if (i == 0 && *PyBytes_AS_STRING(alias->name) == '*') {
+ if (i == 0 && *PyString_AS_STRING(alias->name) == '*') {
assert(n == 1);
ADDOP(c, IMPORT_STAR);
return 1;
if (Py_OptimizeFlag)
return 1;
if (assertion_error == NULL) {
- assertion_error = PyBytes_InternFromString("AssertionError");
+ assertion_error = PyString_InternFromString("AssertionError");
if (assertion_error == NULL)
return 0;
}
/* First check for assignment to __debug__. Param? */
if ((ctx == Store || ctx == AugStore || ctx == Del)
- && !strcmp(PyBytes_AS_STRING(name), "__debug__")) {
+ && !strcmp(PyString_AS_STRING(name), "__debug__")) {
return compiler_error(c, "can not assign to __debug__");
}
}
/* XXX Leave assert here, but handle __doc__ and the like better */
- assert(scope || PyBytes_AS_STRING(name)[0] == '_');
+ assert(scope || PyString_AS_STRING(name)[0] == '_');
switch (optype) {
case OP_DEREF:
PyErr_Format(PyExc_SyntaxError,
"can not delete variable '%s' referenced "
"in nested scope",
- PyBytes_AS_STRING(name));
+ PyString_AS_STRING(name));
Py_DECREF(mangled);
return 0;
case Param:
0)))->iter;
if (!name) {
- name = PyBytes_FromString("<genexpr>");
+ name = PyString_FromString("<genexpr>");
if (!name)
return 0;
}
case Name_kind:
/* __debug__ is not assignable, so we can optimize
* it away in if and while statements */
- if (strcmp(PyBytes_AS_STRING(e->v.Name.id),
+ if (strcmp(PyString_AS_STRING(e->v.Name.id),
"__debug__") == 0)
return ! Py_OptimizeFlag;
/* fall through */
assert(s->kind == With_kind);
if (!enter_attr) {
- enter_attr = PyBytes_InternFromString("__enter__");
+ enter_attr = PyString_InternFromString("__enter__");
if (!enter_attr)
return 0;
}
if (!exit_attr) {
- exit_attr = PyBytes_InternFromString("__exit__");
+ exit_attr = PyString_InternFromString("__exit__");
if (!exit_attr)
return 0;
}
{
memset(a, 0, sizeof(struct assembler));
a->a_lineno = firstlineno;
- a->a_bytecode = PyBytes_FromStringAndSize(NULL, DEFAULT_CODE_SIZE);
+ a->a_bytecode = PyString_FromStringAndSize(NULL, DEFAULT_CODE_SIZE);
if (!a->a_bytecode)
return 0;
- a->a_lnotab = PyBytes_FromStringAndSize(NULL, DEFAULT_LNOTAB_SIZE);
+ a->a_lnotab = PyString_FromStringAndSize(NULL, DEFAULT_LNOTAB_SIZE);
if (!a->a_lnotab)
return 0;
a->a_postorder = (basicblock **)PyObject_Malloc(
if (d_bytecode > 255) {
int j, nbytes, ncodes = d_bytecode / 255;
nbytes = a->a_lnotab_off + 2 * ncodes;
- len = PyBytes_GET_SIZE(a->a_lnotab);
+ len = PyString_GET_SIZE(a->a_lnotab);
if (nbytes >= len) {
if (len * 2 < nbytes)
len = nbytes;
else
len *= 2;
- if (_PyBytes_Resize(&a->a_lnotab, len) < 0)
+ if (_PyString_Resize(&a->a_lnotab, len) < 0)
return 0;
}
lnotab = (unsigned char *)
- PyBytes_AS_STRING(a->a_lnotab) + a->a_lnotab_off;
+ PyString_AS_STRING(a->a_lnotab) + a->a_lnotab_off;
for (j = 0; j < ncodes; j++) {
*lnotab++ = 255;
*lnotab++ = 0;
if (d_lineno > 255) {
int j, nbytes, ncodes = d_lineno / 255;
nbytes = a->a_lnotab_off + 2 * ncodes;
- len = PyBytes_GET_SIZE(a->a_lnotab);
+ len = PyString_GET_SIZE(a->a_lnotab);
if (nbytes >= len) {
if (len * 2 < nbytes)
len = nbytes;
else
len *= 2;
- if (_PyBytes_Resize(&a->a_lnotab, len) < 0)
+ if (_PyString_Resize(&a->a_lnotab, len) < 0)
return 0;
}
lnotab = (unsigned char *)
- PyBytes_AS_STRING(a->a_lnotab) + a->a_lnotab_off;
+ PyString_AS_STRING(a->a_lnotab) + a->a_lnotab_off;
*lnotab++ = d_bytecode;
*lnotab++ = 255;
d_bytecode = 0;
a->a_lnotab_off += ncodes * 2;
}
- len = PyBytes_GET_SIZE(a->a_lnotab);
+ len = PyString_GET_SIZE(a->a_lnotab);
if (a->a_lnotab_off + 2 >= len) {
- if (_PyBytes_Resize(&a->a_lnotab, len * 2) < 0)
+ if (_PyString_Resize(&a->a_lnotab, len * 2) < 0)
return 0;
}
lnotab = (unsigned char *)
- PyBytes_AS_STRING(a->a_lnotab) + a->a_lnotab_off;
+ PyString_AS_STRING(a->a_lnotab) + a->a_lnotab_off;
a->a_lnotab_off += 2;
if (d_bytecode) {
assemble_emit(struct assembler *a, struct instr *i)
{
int size, arg = 0, ext = 0;
- Py_ssize_t len = PyBytes_GET_SIZE(a->a_bytecode);
+ Py_ssize_t len = PyString_GET_SIZE(a->a_bytecode);
char *code;
size = instrsize(i);
if (i->i_lineno && !assemble_lnotab(a, i))
return 0;
if (a->a_offset + size >= len) {
- if (_PyBytes_Resize(&a->a_bytecode, len * 2) < 0)
+ if (_PyString_Resize(&a->a_bytecode, len * 2) < 0)
return 0;
}
- code = PyBytes_AS_STRING(a->a_bytecode) + a->a_offset;
+ code = PyString_AS_STRING(a->a_bytecode) + a->a_offset;
a->a_offset += size;
if (size == 6) {
assert(i->i_hasarg);
freevars = dict_keys_inorder(c->u->u_freevars, PyTuple_Size(cellvars));
if (!freevars)
goto error;
- filename = PyBytes_FromString(c->c_filename);
+ filename = PyString_FromString(c->c_filename);
if (!filename)
goto error;
goto error;
}
- if (_PyBytes_Resize(&a.a_lnotab, a.a_lnotab_off) < 0)
+ if (_PyString_Resize(&a.a_lnotab, a.a_lnotab_off) < 0)
goto error;
- if (_PyBytes_Resize(&a.a_bytecode, a.a_offset) < 0)
+ if (_PyString_Resize(&a.a_bytecode, a.a_offset) < 0)
goto error;
co = makecode(c, &a);
void
PyErr_SetString(PyObject *exception, const char *string)
{
- PyObject *value = PyBytes_FromString(string);
+ PyObject *value = PyString_FromString(string);
PyErr_SetObject(exception, value);
Py_XDECREF(value);
}
PyObject *
PyErr_SetFromErrnoWithFilename(PyObject *exc, char *filename)
{
- PyObject *name = filename ? PyBytes_FromString(filename) : NULL;
+ PyObject *name = filename ? PyString_FromString(filename) : NULL;
PyObject *result = PyErr_SetFromErrnoWithFilenameObject(exc, name);
Py_XDECREF(name);
return result;
int ierr,
const char *filename)
{
- PyObject *name = filename ? PyBytes_FromString(filename) : NULL;
+ PyObject *name = filename ? PyString_FromString(filename) : NULL;
PyObject *ret = PyErr_SetExcFromWindowsErrWithFilenameObject(exc,
ierr,
name);
int ierr,
const char *filename)
{
- PyObject *name = filename ? PyBytes_FromString(filename) : NULL;
+ PyObject *name = filename ? PyString_FromString(filename) : NULL;
PyObject *result = PyErr_SetExcFromWindowsErrWithFilenameObject(
PyExc_WindowsError,
ierr, name);
va_start(vargs);
#endif
- string = PyBytes_FromFormatV(format, vargs);
+ string = PyString_FromFormatV(format, vargs);
PyErr_SetObject(exception, string);
Py_XDECREF(string);
va_end(vargs);
goto failure;
}
if (PyDict_GetItemString(dict, "__module__") == NULL) {
- modulename = PyBytes_FromStringAndSize(name,
+ modulename = PyString_FromStringAndSize(name,
(Py_ssize_t)(dot-name));
if (modulename == NULL)
goto failure;
if (moduleName == NULL)
PyFile_WriteString("<unknown>", f);
else {
- char* modstr = PyBytes_AsString(moduleName);
+ char* modstr = PyString_AsString(moduleName);
if (modstr &&
strcmp(modstr, "exceptions") != 0)
{
Py_DECREF(tmp);
}
if (filename != NULL) {
- tmp = PyBytes_FromString(filename);
+ tmp = PyString_FromString(filename);
if (tmp == NULL)
PyErr_Clear();
else {
char *p = linebuf;
while (*p == ' ' || *p == '\t' || *p == '\014')
p++;
- return PyBytes_FromString(p);
+ return PyString_FromString(p);
}
return NULL;
}
names = s->v.ImportFrom.names;
for (i = 0; i < asdl_seq_LEN(names); i++) {
alias_ty name = (alias_ty)asdl_seq_GET(names, i);
- const char *feature = PyBytes_AsString(name->name);
+ const char *feature = PyString_AsString(name->name);
if (!feature)
return 0;
if (strcmp(feature, FUTURE_NESTED_SCOPES) == 0) {
static PyObject *future;
if (!future) {
- future = PyBytes_InternFromString("__future__");
+ future = PyString_InternFromString("__future__");
if (!future)
return 0;
}
n++;
}
- if (!PySequence_Check(arg) || PyBytes_Check(arg)) {
+ if (!PySequence_Check(arg) || PyString_Check(arg)) {
levels[0] = 0;
PyOS_snprintf(msgbuf, bufsize,
toplevel ? "expected %d arguments, not %.50s" :
case 'c': {/* char */
char *p = va_arg(*p_va, char *);
- if (PyBytes_Check(arg) && PyBytes_Size(arg) == 1)
- *p = PyBytes_AS_STRING(arg)[0];
+ if (PyString_Check(arg) && PyString_Size(arg) == 1)
+ *p = PyString_AS_STRING(arg)[0];
else
return converterr("char", arg, msgbuf, bufsize);
break;
void **p = (void **)va_arg(*p_va, char **);
FETCH_SIZE;
- if (PyBytes_Check(arg)) {
- *p = PyBytes_AS_STRING(arg);
- STORE_SIZE(PyBytes_GET_SIZE(arg));
+ if (PyString_Check(arg)) {
+ *p = PyString_AS_STRING(arg);
+ STORE_SIZE(PyString_GET_SIZE(arg));
}
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(arg)) {
if (uarg == NULL)
return converterr(CONV_UNICODE,
arg, msgbuf, bufsize);
- *p = PyBytes_AS_STRING(uarg);
- STORE_SIZE(PyBytes_GET_SIZE(uarg));
+ *p = PyString_AS_STRING(uarg);
+ STORE_SIZE(PyString_GET_SIZE(uarg));
}
#endif
else { /* any buffer-like object */
} else {
char **p = va_arg(*p_va, char **);
- if (PyBytes_Check(arg))
- *p = PyBytes_AS_STRING(arg);
+ if (PyString_Check(arg))
+ *p = PyString_AS_STRING(arg);
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(arg)) {
uarg = UNICODE_DEFAULT_ENCODING(arg);
if (uarg == NULL)
return converterr(CONV_UNICODE,
arg, msgbuf, bufsize);
- *p = PyBytes_AS_STRING(uarg);
+ *p = PyString_AS_STRING(uarg);
}
#endif
else
return converterr("string", arg, msgbuf, bufsize);
- if ((Py_ssize_t)strlen(*p) != PyBytes_Size(arg))
+ if ((Py_ssize_t)strlen(*p) != PyString_Size(arg))
return converterr("string without null bytes",
arg, msgbuf, bufsize);
}
*p = 0;
STORE_SIZE(0);
}
- else if (PyBytes_Check(arg)) {
- *p = PyBytes_AS_STRING(arg);
- STORE_SIZE(PyBytes_GET_SIZE(arg));
+ else if (PyString_Check(arg)) {
+ *p = PyString_AS_STRING(arg);
+ STORE_SIZE(PyString_GET_SIZE(arg));
}
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(arg)) {
if (uarg == NULL)
return converterr(CONV_UNICODE,
arg, msgbuf, bufsize);
- *p = PyBytes_AS_STRING(uarg);
- STORE_SIZE(PyBytes_GET_SIZE(uarg));
+ *p = PyString_AS_STRING(uarg);
+ STORE_SIZE(PyString_GET_SIZE(uarg));
}
#endif
else { /* any buffer-like object */
if (arg == Py_None)
*p = 0;
- else if (PyBytes_Check(arg))
- *p = PyBytes_AS_STRING(arg);
+ else if (PyString_Check(arg))
+ *p = PyString_AS_STRING(arg);
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(arg)) {
uarg = UNICODE_DEFAULT_ENCODING(arg);
if (uarg == NULL)
return converterr(CONV_UNICODE,
arg, msgbuf, bufsize);
- *p = PyBytes_AS_STRING(uarg);
+ *p = PyString_AS_STRING(uarg);
}
#endif
else
if (arg == Py_None)
*q = 0;
else
- *q = PyBytes_Size(arg);
+ *q = PyString_Size(arg);
format++;
}
else if (*p != NULL &&
- (Py_ssize_t)strlen(*p) != PyBytes_Size(arg))
+ (Py_ssize_t)strlen(*p) != PyString_Size(arg))
return converterr(
"string without null bytes or None",
arg, msgbuf, bufsize);
arg, msgbuf, bufsize);
/* Encode object */
- if (!recode_strings && PyBytes_Check(arg)) {
+ if (!recode_strings && PyString_Check(arg)) {
s = arg;
Py_INCREF(s);
}
if (s == NULL)
return converterr("(encoding failed)",
arg, msgbuf, bufsize);
- if (!PyBytes_Check(s)) {
+ if (!PyString_Check(s)) {
Py_DECREF(s);
return converterr(
"(encoder failed to return a string)",
return converterr("string<e>", arg, msgbuf, bufsize);
#endif
}
- size = PyBytes_GET_SIZE(s);
+ size = PyString_GET_SIZE(s);
/* Write output; output is guaranteed to be 0-terminated */
if (*format == '#') {
}
}
memcpy(*buffer,
- PyBytes_AS_STRING(s),
+ PyString_AS_STRING(s),
size + 1);
STORE_SIZE(size);
} else {
PyMem_Free()ing it after usage
*/
- if ((Py_ssize_t)strlen(PyBytes_AS_STRING(s))
+ if ((Py_ssize_t)strlen(PyString_AS_STRING(s))
!= size) {
Py_DECREF(s);
return converterr(
arg, msgbuf, bufsize);
}
memcpy(*buffer,
- PyBytes_AS_STRING(s),
+ PyString_AS_STRING(s),
size + 1);
}
Py_DECREF(s);
case 'S': { /* string object */
PyObject **p = va_arg(*p_va, PyObject **);
- if (PyBytes_Check(arg))
+ if (PyString_Check(arg))
*p = arg;
else
return converterr("string", arg, msgbuf, bufsize);
while (PyDict_Next(keywords, &pos, &key, &value)) {
int match = 0;
char *ks;
- if (!PyBytes_Check(key)) {
+ if (!PyString_Check(key)) {
PyErr_SetString(PyExc_TypeError,
"keywords must be strings");
return cleanreturn(0, freelist);
}
- ks = PyBytes_AsString(key);
+ ks = PyString_AsString(key);
for (i = 0; i < len; i++) {
if (!strcmp(ks, kwlist[i])) {
match = 1;
while (PyDict_Next(modules, &pos, &key, &value)) {
if (value->ob_refcnt != 1)
continue;
- if (PyBytes_Check(key) && PyModule_Check(value)) {
- name = PyBytes_AS_STRING(key);
+ if (PyString_Check(key) && PyModule_Check(value)) {
+ name = PyString_AS_STRING(key);
if (strcmp(name, "__builtin__") == 0)
continue;
if (strcmp(name, "sys") == 0)
/* Next, delete all modules (still skipping __builtin__ and sys) */
pos = 0;
while (PyDict_Next(modules, &pos, &key, &value)) {
- if (PyBytes_Check(key) && PyModule_Check(value)) {
- name = PyBytes_AS_STRING(key);
+ if (PyString_Check(key) && PyModule_Check(value)) {
+ name = PyString_AS_STRING(key);
if (strcmp(name, "__builtin__") == 0)
continue;
if (strcmp(name, "sys") == 0)
/* Remember the filename as the __file__ attribute */
v = NULL;
if (pathname != NULL) {
- v = PyBytes_FromString(pathname);
+ v = PyString_FromString(pathname);
if (v == NULL)
PyErr_Clear();
}
PySys_WriteStderr("import %s # directory %s\n",
name, pathname);
d = PyModule_GetDict(m);
- file = PyBytes_FromString(pathname);
+ file = PyString_FromString(pathname);
if (file == NULL)
goto error;
path = Py_BuildValue("[O]", file);
Py_DECREF(meta_path);
}
- if (path != NULL && PyBytes_Check(path)) {
+ if (path != NULL && PyString_Check(path)) {
/* The only type of submodule allowed inside a "frozen"
package are other frozen modules or packages. */
- if (PyBytes_Size(path) + 1 + strlen(name) >= (size_t)buflen) {
+ if (PyString_Size(path) + 1 + strlen(name) >= (size_t)buflen) {
PyErr_SetString(PyExc_ImportError,
"full frozen module name too long");
return NULL;
}
- strcpy(buf, PyBytes_AsString(path));
+ strcpy(buf, PyString_AsString(path));
strcat(buf, ".");
strcat(buf, name);
strcpy(name, buf);
}
else
#endif
- if (!PyBytes_Check(v))
+ if (!PyString_Check(v))
continue;
- len = PyBytes_GET_SIZE(v);
+ len = PyString_GET_SIZE(v);
if (len + 2 + namelen + MAXSUFFIXSIZE >= buflen) {
Py_XDECREF(copy);
continue; /* Too long */
}
- strcpy(buf, PyBytes_AS_STRING(v));
+ strcpy(buf, PyString_AS_STRING(v));
if (strlen(buf) != len) {
Py_XDECREF(copy);
continue; /* v contains '\0' */
if (m == NULL)
goto err_return;
d = PyModule_GetDict(m);
- s = PyBytes_InternFromString(name);
+ s = PyString_InternFromString(name);
if (s == NULL)
goto err_return;
err = PyDict_SetItemString(d, "__path__", s);
PyObject *pname;
PyObject *result;
- pname = PyBytes_FromString(name);
+ pname = PyString_FromString(name);
if (pname == NULL)
return NULL;
result = PyImport_Import(pname);
return Py_None;
if (namestr == NULL) {
- namestr = PyBytes_InternFromString("__name__");
+ namestr = PyString_InternFromString("__name__");
if (namestr == NULL)
return NULL;
}
if (pathstr == NULL) {
- pathstr = PyBytes_InternFromString("__path__");
+ pathstr = PyString_InternFromString("__path__");
if (pathstr == NULL)
return NULL;
}
if (pkgstr == NULL) {
- pkgstr = PyBytes_InternFromString("__package__");
+ pkgstr = PyString_InternFromString("__package__");
if (pkgstr == NULL)
return NULL;
}
if ((pkgname != NULL) && (pkgname != Py_None)) {
/* __package__ is set, so use it */
Py_ssize_t len;
- if (!PyBytes_Check(pkgname)) {
+ if (!PyString_Check(pkgname)) {
PyErr_SetString(PyExc_ValueError,
"__package__ set to non-string");
return NULL;
}
- len = PyBytes_GET_SIZE(pkgname);
+ len = PyString_GET_SIZE(pkgname);
if (len == 0) {
if (level > 0) {
PyErr_SetString(PyExc_ValueError,
"Package name too long");
return NULL;
}
- strcpy(buf, PyBytes_AS_STRING(pkgname));
+ strcpy(buf, PyString_AS_STRING(pkgname));
} else {
/* __package__ not set, so figure it out and set it */
modname = PyDict_GetItem(globals, namestr);
- if (modname == NULL || !PyBytes_Check(modname))
+ if (modname == NULL || !PyString_Check(modname))
return Py_None;
modpath = PyDict_GetItem(globals, pathstr);
if (modpath != NULL) {
/* __path__ is set, so modname is already the package name */
- Py_ssize_t len = PyBytes_GET_SIZE(modname);
+ Py_ssize_t len = PyString_GET_SIZE(modname);
int error;
if (len > MAXPATHLEN) {
PyErr_SetString(PyExc_ValueError,
"Module name too long");
return NULL;
}
- strcpy(buf, PyBytes_AS_STRING(modname));
+ strcpy(buf, PyString_AS_STRING(modname));
error = PyDict_SetItem(globals, pkgstr, modname);
if (error) {
PyErr_SetString(PyExc_ValueError,
}
} else {
/* Normal module, so work out the package name if any */
- char *start = PyBytes_AS_STRING(modname);
+ char *start = PyString_AS_STRING(modname);
char *lastdot = strrchr(start, '.');
size_t len;
int error;
}
strncpy(buf, start, len);
buf[len] = '\0';
- pkgname = PyBytes_FromString(buf);
+ pkgname = PyString_FromString(buf);
if (pkgname == NULL) {
return NULL;
}
}
return 0;
}
- if (!PyBytes_Check(item)) {
+ if (!PyString_Check(item)) {
PyErr_SetString(PyExc_TypeError,
"Item in ``from list'' not a string");
Py_DECREF(item);
return 0;
}
- if (PyBytes_AS_STRING(item)[0] == '*') {
+ if (PyString_AS_STRING(item)[0] == '*') {
PyObject *all;
Py_DECREF(item);
/* See if the package defines __all__ */
}
hasit = PyObject_HasAttr(mod, item);
if (!hasit) {
- char *subname = PyBytes_AS_STRING(item);
+ char *subname = PyString_AS_STRING(item);
PyObject *submod;
char *p;
if (buflen + strlen(subname) >= MAXPATHLEN) {
subname = name;
else {
PyObject *parentname, *parent;
- parentname = PyBytes_FromStringAndSize(name, (subname-name));
+ parentname = PyString_FromStringAndSize(name, (subname-name));
if (parentname == NULL) {
imp_modules_reloading_clear();
return NULL;
if (parent == NULL) {
PyErr_Format(PyExc_ImportError,
"reload(): parent %.200s not in sys.modules",
- PyBytes_AS_STRING(parentname));
+ PyString_AS_STRING(parentname));
Py_DECREF(parentname);
imp_modules_reloading_clear();
return NULL;
done using whatever import hooks are installed in the current
environment, e.g. by "rexec".
A dummy list ["__doc__"] is passed as the 4th argument so that
- e.g. PyImport_Import(PyBytes_FromString("win32com.client.gencache"))
+ e.g. PyImport_Import(PyString_FromString("win32com.client.gencache"))
will return <module "gencache"> instead of <module "win32com">. */
PyObject *
/* Initialize constant string objects */
if (silly_list == NULL) {
- import_str = PyBytes_InternFromString("__import__");
+ import_str = PyString_InternFromString("__import__");
if (import_str == NULL)
return NULL;
- builtins_str = PyBytes_InternFromString("__builtins__");
+ builtins_str = PyString_InternFromString("__builtins__");
if (builtins_str == NULL)
return NULL;
silly_list = Py_BuildValue("[s]", "__doc__");
buf[2] = (char) ((pyc_magic >> 16) & 0xff);
buf[3] = (char) ((pyc_magic >> 24) & 0xff);
- return PyBytes_FromStringAndSize(buf, 4);
+ return PyString_FromStringAndSize(buf, 4);
}
static PyObject *
buf[0] = '\0';
}
else {
- char *input = PyBytes_AsString(rv);
+ char *input = PyString_AsString(rv);
if (!input) {
PyErr_Clear();
buf[0] = '\0';
if (!rv)
goto error;
- input = PyBytes_AsString(rv);
+ input = PyString_AsString(rv);
if (!input)
goto error;
PyMac_GetOSType(PyObject *v, OSType *pr)
{
uint32_t tmp;
- if (!PyBytes_Check(v) || PyBytes_Size(v) != 4) {
+ if (!PyString_Check(v) || PyString_Size(v) != 4) {
PyErr_SetString(PyExc_TypeError,
"OSType arg must be string of 4 chars");
return 0;
}
- memcpy((char *)&tmp, PyBytes_AsString(v), 4);
+ memcpy((char *)&tmp, PyString_AsString(v), 4);
*pr = (OSType)ntohl(tmp);
return 1;
}
PyMac_BuildOSType(OSType t)
{
uint32_t tmp = htonl((uint32_t)t);
- return PyBytes_FromStringAndSize((char *)&tmp, 4);
+ return PyString_FromStringAndSize((char *)&tmp, 4);
}
/* Convert an NumVersion value to a 4-element tuple */
PyMac_GetStr255(PyObject *v, Str255 pbuf)
{
int len;
- if (!PyBytes_Check(v) || (len = PyBytes_Size(v)) > 255) {
+ if (!PyString_Check(v) || (len = PyString_Size(v)) > 255) {
PyErr_SetString(PyExc_TypeError,
"Str255 arg must be string of at most 255 chars");
return 0;
}
pbuf[0] = len;
- memcpy((char *)(pbuf+1), PyBytes_AsString(v), len);
+ memcpy((char *)(pbuf+1), PyString_AsString(v), len);
return 1;
}
PyErr_SetString(PyExc_SystemError, "Str255 pointer is NULL");
return NULL;
}
- return PyBytes_FromStringAndSize((char *)&s[1], (int)s[0]);
+ return PyString_FromStringAndSize((char *)&s[1], (int)s[0]);
}
PyObject *
Py_INCREF(Py_None);
return Py_None;
}
- return PyBytes_FromStringAndSize((char *)&s[1], (int)s[0]);
+ return PyString_FromStringAndSize((char *)&s[1], (int)s[0]);
}
Py_ssize_t size, newsize;
if (p->str == NULL)
return; /* An error already occurred */
- size = PyBytes_Size(p->str);
+ size = PyString_Size(p->str);
newsize = size + size + 1024;
if (newsize > 32*1024*1024) {
newsize = size + 1024*1024;
}
- if (_PyBytes_Resize(&p->str, newsize) != 0) {
+ if (_PyString_Resize(&p->str, newsize) != 0) {
p->ptr = p->end = NULL;
}
else {
- p->ptr = PyBytes_AS_STRING((PyBytesObject *)p->str) + size;
+ p->ptr = PyString_AS_STRING((PyStringObject *)p->str) + size;
p->end =
- PyBytes_AS_STRING((PyBytesObject *)p->str) + newsize;
+ PyString_AS_STRING((PyStringObject *)p->str) + newsize;
*p->ptr++ = Py_SAFE_DOWNCAST(c, int, char);
}
}
}
}
#endif
- else if (PyBytes_CheckExact(v)) {
- if (p->strings && PyBytes_CHECK_INTERNED(v)) {
+ else if (PyString_CheckExact(v)) {
+ if (p->strings && PyString_CHECK_INTERNED(v)) {
PyObject *o = PyDict_GetItem(p->strings, v);
if (o) {
long w = PyInt_AsLong(o);
else {
w_byte(TYPE_STRING, p);
}
- n = PyBytes_GET_SIZE(v);
+ n = PyString_GET_SIZE(v);
if (n > INT_MAX) {
/* huge strings are not supported */
p->depth--;
return;
}
w_long((long)n, p);
- w_string(PyBytes_AS_STRING(v), (int)n, p);
+ w_string(PyString_AS_STRING(v), (int)n, p);
}
#ifdef Py_USING_UNICODE
else if (PyUnicode_CheckExact(v)) {
return;
}
w_byte(TYPE_UNICODE, p);
- n = PyBytes_GET_SIZE(utf8);
+ n = PyString_GET_SIZE(utf8);
if (n > INT_MAX) {
p->depth--;
p->error = 1;
return;
}
w_long((long)n, p);
- w_string(PyBytes_AS_STRING(utf8), (int)n, p);
+ w_string(PyString_AS_STRING(utf8), (int)n, p);
Py_DECREF(utf8);
}
#endif
retval = NULL;
break;
}
- v = PyBytes_FromStringAndSize((char *)NULL, n);
+ v = PyString_FromStringAndSize((char *)NULL, n);
if (v == NULL) {
retval = NULL;
break;
}
- if (r_string(PyBytes_AS_STRING(v), (int)n, p) != n) {
+ if (r_string(PyString_AS_STRING(v), (int)n, p) != n) {
Py_DECREF(v);
PyErr_SetString(PyExc_EOFError,
"EOF read where object expected");
break;
}
if (type == TYPE_INTERNED) {
- PyBytes_InternInPlace(&v);
+ PyString_InternInPlace(&v);
if (PyList_Append(p->strings, v) < 0) {
retval = NULL;
break;
{
WFILE wf;
wf.fp = NULL;
- wf.str = PyBytes_FromStringAndSize((char *)NULL, 50);
+ wf.str = PyString_FromStringAndSize((char *)NULL, 50);
if (wf.str == NULL)
return NULL;
- wf.ptr = PyBytes_AS_STRING((PyBytesObject *)wf.str);
- wf.end = wf.ptr + PyBytes_Size(wf.str);
+ wf.ptr = PyString_AS_STRING((PyStringObject *)wf.str);
+ wf.end = wf.ptr + PyString_Size(wf.str);
wf.error = 0;
wf.depth = 0;
wf.version = version;
w_object(x, &wf);
Py_XDECREF(wf.strings);
if (wf.str != NULL) {
- char *base = PyBytes_AS_STRING((PyBytesObject *)wf.str);
+ char *base = PyString_AS_STRING((PyStringObject *)wf.str);
if (wf.ptr - base > PY_SSIZE_T_MAX) {
Py_DECREF(wf.str);
PyErr_SetString(PyExc_OverflowError,
"too much marshall data for a string");
return NULL;
}
- _PyBytes_Resize(&wf.str, (Py_ssize_t)(wf.ptr - base));
+ _PyString_Resize(&wf.str, (Py_ssize_t)(wf.ptr - base));
}
if (wf.error) {
Py_XDECREF(wf.str);
return NULL;
d = PyModule_GetDict(m);
if (methods != NULL) {
- n = PyBytes_FromString(name);
+ n = PyString_FromString(name);
if (n == NULL)
return NULL;
for (ml = methods; ml->ml_name != NULL; ml++) {
Py_DECREF(n);
}
if (doc != NULL) {
- v = PyBytes_FromString(doc);
+ v = PyString_FromString(doc);
if (v == NULL || PyDict_SetItemString(d, "__doc__", v) != 0) {
Py_XDECREF(v);
return NULL;
{
char p[1];
p[0] = (char)va_arg(*p_va, int);
- return PyBytes_FromStringAndSize(p, 1);
+ return PyString_FromStringAndSize(p, 1);
}
case 's':
}
n = (Py_ssize_t)m;
}
- v = PyBytes_FromStringAndSize(str, n);
+ v = PyString_FromStringAndSize(str, n);
}
return v;
}
int
PyModule_AddStringConstant(PyObject *m, const char *name, const char *value)
{
- PyObject *o = PyBytes_FromString(value);
+ PyObject *o = PyString_FromString(value);
if (!o)
return -1;
if (PyModule_AddObject(m, name, o) == 0)
goto exitUnchanged;
/* Bypass optimization when the lineno table is too complex */
- assert(PyBytes_Check(lineno_obj));
- lineno = (unsigned char*)PyBytes_AS_STRING(lineno_obj);
- tabsiz = PyBytes_GET_SIZE(lineno_obj);
+ assert(PyString_Check(lineno_obj));
+ lineno = (unsigned char*)PyString_AS_STRING(lineno_obj);
+ tabsiz = PyString_GET_SIZE(lineno_obj);
if (memchr(lineno, 255, tabsiz) != NULL)
goto exitUnchanged;
/* Avoid situations where jump retargeting could overflow */
- assert(PyBytes_Check(code));
- codelen = PyBytes_GET_SIZE(code);
+ assert(PyString_Check(code));
+ codelen = PyString_GET_SIZE(code);
if (codelen > 32700)
goto exitUnchanged;
if (codestr == NULL)
goto exitUnchanged;
codestr = (unsigned char *)memcpy(codestr,
- PyBytes_AS_STRING(code), codelen);
+ PyString_AS_STRING(code), codelen);
/* Verify that RETURN_VALUE terminates the codestring. This allows
the various transformation patterns to look ahead several
case LOAD_NAME:
case LOAD_GLOBAL:
j = GETARG(codestr, i);
- name = PyBytes_AsString(PyTuple_GET_ITEM(names, j));
+ name = PyString_AsString(PyTuple_GET_ITEM(names, j));
if (name == NULL || strcmp(name, "None") != 0)
continue;
for (j=0 ; j < PyList_GET_SIZE(consts) ; j++) {
}
assert(h + nops == codelen);
- code = PyBytes_FromStringAndSize((char *)codestr, h);
+ code = PyString_FromStringAndSize((char *)codestr, h);
PyMem_Free(addrmap);
PyMem_Free(codestr);
PyMem_Free(blocks);
/* At this point, p points just past the right-most character we
want to format. We need to add the grouping string for the
characters between buffer and p. */
- return _PyBytes_InsertThousandsGrouping(buffer, len, p,
+ return _PyString_InsertThousandsGrouping(buffer, len, p,
buf_size, NULL, 1);
}
PyTuple_Fini();
PyList_Fini();
PySet_Fini();
- PyBytes_Fini();
+ PyString_Fini();
PyByteArray_Fini();
PyInt_Fini();
PyFloat_Fini();
}
v = PySys_GetObject("ps1");
if (v == NULL) {
- PySys_SetObject("ps1", v = PyBytes_FromString(">>> "));
+ PySys_SetObject("ps1", v = PyString_FromString(">>> "));
Py_XDECREF(v);
}
v = PySys_GetObject("ps2");
if (v == NULL) {
- PySys_SetObject("ps2", v = PyBytes_FromString("... "));
+ PySys_SetObject("ps2", v = PyString_FromString("... "));
Py_XDECREF(v);
}
for (;;) {
v = PyObject_Str(v);
if (v == NULL)
PyErr_Clear();
- else if (PyBytes_Check(v))
- ps1 = PyBytes_AsString(v);
+ else if (PyString_Check(v))
+ ps1 = PyString_AsString(v);
}
w = PySys_GetObject("ps2");
if (w != NULL) {
w = PyObject_Str(w);
if (w == NULL)
PyErr_Clear();
- else if (PyBytes_Check(w))
- ps2 = PyBytes_AsString(w);
+ else if (PyString_Check(w))
+ ps2 = PyString_AsString(w);
}
arena = PyArena_New();
if (arena == NULL) {
return -1;
d = PyModule_GetDict(m);
if (PyDict_GetItemString(d, "__file__") == NULL) {
- PyObject *f = PyBytes_FromString(filename);
+ PyObject *f = PyString_FromString(filename);
if (f == NULL)
return -1;
if (PyDict_SetItemString(d, "__file__", f) < 0) {
goto finally;
if (v == Py_None)
*filename = NULL;
- else if (! (*filename = PyBytes_AsString(v)))
+ else if (! (*filename = PyString_AsString(v)))
goto finally;
Py_DECREF(v);
goto finally;
if (v == Py_None)
*text = NULL;
- else if (! (*text = PyBytes_AsString(v)))
+ else if (! (*text = PyString_AsString(v)))
goto finally;
Py_DECREF(v);
return 1;
if (moduleName == NULL)
err = PyFile_WriteString("<unknown>", f);
else {
- char* modstr = PyBytes_AsString(moduleName);
+ char* modstr = PyString_AsString(moduleName);
if (modstr && strcmp(modstr, "exceptions"))
{
err = PyFile_WriteString(modstr, f);
*/
if (s == NULL)
err = -1;
- else if (!PyBytes_Check(s) ||
- PyBytes_GET_SIZE(s) != 0)
+ else if (!PyString_Check(s) ||
+ PyString_GET_SIZE(s) != 0)
err = PyFile_WriteString(": ", f);
if (err == 0)
err = PyFile_WriteObject(s, f, Py_PRINT_RAW);
if (value != NULL) {
u = PyObject_Str(value);
if (u != NULL) {
- msg = PyBytes_AsString(u);
+ msg = PyString_AsString(u);
}
}
if (msg == NULL)
if (v != NULL) {
for (i = 0; i < n; i++)
PyList_SetItem(v, i,
- PyBytes_FromString(mlist[i].name));
+ PyString_FromString(mlist[i].name));
if (PyErr_Occurred()) {
Py_DECREF(v);
v = NULL;
v = Py_None;
}
else
- v = PyBytes_FromString(*(char**)addr);
+ v = PyString_FromString(*(char**)addr);
break;
case T_STRING_INPLACE:
- v = PyBytes_FromString((char*)addr);
+ v = PyString_FromString((char*)addr);
break;
case T_CHAR:
- v = PyBytes_FromStringAndSize((char*)addr, 1);
+ v = PyString_FromStringAndSize((char*)addr, 1);
break;
case T_OBJECT:
v = *(PyObject **)addr;
Py_XDECREF(oldv);
break;
case T_CHAR:
- if (PyBytes_Check(v) && PyBytes_Size(v) == 1) {
- *(char*)addr = PyBytes_AsString(v)[0];
+ if (PyString_Check(v) && PyString_Size(v) == 1) {
+ *(char*)addr = PyString_AsString(v)[0];
}
else {
PyErr_BadArgument();
PyOS_snprintf(buf, sizeof(buf),
"<symtable entry %.100s(%ld), line %d>",
- PyBytes_AS_STRING(ste->ste_name),
+ PyString_AS_STRING(ste->ste_name),
PyInt_AS_LONG(ste->ste_id), ste->ste_lineno);
- return PyBytes_FromString(buf);
+ return PyString_FromString(buf);
}
static void
static identifier top = NULL, lambda = NULL, genexpr = NULL;
#define GET_IDENTIFIER(VAR) \
- ((VAR) ? (VAR) : ((VAR) = PyBytes_InternFromString(# VAR)))
+ ((VAR) ? (VAR) : ((VAR) = PyString_InternFromString(# VAR)))
#define DUPLICATE_ARGUMENT \
"duplicate argument '%s' in function definition"
if (flags & DEF_PARAM) {
PyErr_Format(PyExc_SyntaxError,
"name '%s' is local and global",
- PyBytes_AS_STRING(name));
+ PyString_AS_STRING(name));
return 0;
}
SET_SCOPE(dict, name, GLOBAL_EXPLICIT);
PyOS_snprintf(buf, sizeof(buf),
"import * is not allowed in function '%.100s' "
"because it is %s",
- PyBytes_AS_STRING(ste->ste_name), trailer);
+ PyString_AS_STRING(ste->ste_name), trailer);
break;
case OPT_BARE_EXEC:
PyOS_snprintf(buf, sizeof(buf),
"unqualified exec is not allowed in function "
"'%.100s' it %s",
- PyBytes_AS_STRING(ste->ste_name), trailer);
+ PyString_AS_STRING(ste->ste_name), trailer);
break;
default:
PyOS_snprintf(buf, sizeof(buf),
"function '%.100s' uses import * and bare exec, "
"which are illegal because it %s",
- PyBytes_AS_STRING(ste->ste_name), trailer);
+ PyString_AS_STRING(ste->ste_name), trailer);
break;
}
if ((flag & DEF_PARAM) && (val & DEF_PARAM)) {
/* Is it better to use 'mangled' or 'name' here? */
PyErr_Format(PyExc_SyntaxError, DUPLICATE_ARGUMENT,
- PyBytes_AsString(name));
+ PyString_AsString(name));
PyErr_SyntaxLocation(st->st_filename,
st->st_cur->ste_lineno);
goto error;
PyOS_snprintf(tmpname, sizeof(tmpname), "_[%d]",
++st->st_cur->ste_tmpname);
- tmp = PyBytes_InternFromString(tmpname);
+ tmp = PyString_InternFromString(tmpname);
if (!tmp)
return 0;
if (!symtable_add_def(st, tmp, DEF_LOCAL))
asdl_seq *seq = s->v.Global.names;
for (i = 0; i < asdl_seq_LEN(seq); i++) {
identifier name = (identifier)asdl_seq_GET(seq, i);
- char *c_name = PyBytes_AS_STRING(name);
+ char *c_name = PyString_AS_STRING(name);
long cur = symtable_lookup(st, name);
if (cur < 0)
return 0;
static int
symtable_implicit_arg(struct symtable *st, int pos)
{
- PyObject *id = PyBytes_FromFormat(".%d", pos);
+ PyObject *id = PyString_FromFormat(".%d", pos);
if (id == NULL)
return 0;
if (!symtable_add_def(st, id, DEF_PARAM)) {
*/
PyObject *store_name;
PyObject *name = (a->asname == NULL) ? a->name : a->asname;
- const char *base = PyBytes_AS_STRING(name);
+ const char *base = PyString_AS_STRING(name);
char *dot = strchr(base, '.');
if (dot) {
- store_name = PyBytes_FromStringAndSize(base, dot - base);
+ store_name = PyString_FromStringAndSize(base, dot - base);
if (!store_name)
return 0;
}
store_name = name;
Py_INCREF(store_name);
}
- if (strcmp(PyBytes_AS_STRING(name), "*")) {
+ if (strcmp(PyString_AS_STRING(name), "*")) {
int r = symtable_add_def(st, store_name, DEF_IMPORT);
Py_DECREF(store_name);
return r;
static PyObject *
sys_getdefaultencoding(PyObject *self)
{
- return PyBytes_FromString(PyUnicode_GetDefaultEncoding());
+ return PyString_FromString(PyUnicode_GetDefaultEncoding());
}
PyDoc_STRVAR(getdefaultencoding_doc,
sys_getfilesystemencoding(PyObject *self)
{
if (Py_FileSystemDefaultEncoding)
- return PyBytes_FromString(Py_FileSystemDefaultEncoding);
+ return PyString_FromString(Py_FileSystemDefaultEncoding);
Py_INCREF(Py_None);
return Py_None;
}
int i;
for (i = 0; i < 7; ++i) {
if (whatstrings[i] == NULL) {
- name = PyBytes_InternFromString(whatnames[i]);
+ name = PyString_InternFromString(whatnames[i]);
if (name == NULL)
return -1;
whatstrings[i] = name;
if (list == NULL)
return NULL;
for (i = 0; PyImport_Inittab[i].name != NULL; i++) {
- PyObject *name = PyBytes_FromString(
+ PyObject *name = PyString_FromString(
PyImport_Inittab[i].name);
if (name == NULL)
break;
if (warnoptions == NULL)
return;
}
- str = PyBytes_FromString(s);
+ str = PyString_FromString(s);
if (str != NULL) {
PyList_Append(warnoptions, str);
Py_DECREF(str);
Py_XDECREF(syserr);
SET_SYS_FROM_STRING("version",
- PyBytes_FromString(Py_GetVersion()));
+ PyString_FromString(Py_GetVersion()));
SET_SYS_FROM_STRING("hexversion",
PyInt_FromLong(PY_VERSION_HEX));
svnversion_init();
SET_SYS_FROM_STRING("api_version",
PyInt_FromLong(PYTHON_API_VERSION));
SET_SYS_FROM_STRING("copyright",
- PyBytes_FromString(Py_GetCopyright()));
+ PyString_FromString(Py_GetCopyright()));
SET_SYS_FROM_STRING("platform",
- PyBytes_FromString(Py_GetPlatform()));
+ PyString_FromString(Py_GetPlatform()));
SET_SYS_FROM_STRING("executable",
- PyBytes_FromString(Py_GetProgramFullPath()));
+ PyString_FromString(Py_GetProgramFullPath()));
SET_SYS_FROM_STRING("prefix",
- PyBytes_FromString(Py_GetPrefix()));
+ PyString_FromString(Py_GetPrefix()));
SET_SYS_FROM_STRING("exec_prefix",
- PyBytes_FromString(Py_GetExecPrefix()));
+ PyString_FromString(Py_GetExecPrefix()));
SET_SYS_FROM_STRING("maxsize",
PyInt_FromSsize_t(PY_SSIZE_T_MAX));
SET_SYS_FROM_STRING("maxint",
else
value = "little";
SET_SYS_FROM_STRING("byteorder",
- PyBytes_FromString(value));
+ PyString_FromString(value));
}
#ifdef MS_COREDLL
SET_SYS_FROM_STRING("dllhandle",
PyLong_FromVoidPtr(PyWin_DLLhModule));
SET_SYS_FROM_STRING("winver",
- PyBytes_FromString(PyWin_DLLVersionString));
+ PyString_FromString(PyWin_DLLVersionString));
#endif
if (warnoptions == NULL) {
warnoptions = PyList_New(0);
p = strchr(path, delim);
if (p == NULL)
p = strchr(path, '\0'); /* End of string */
- w = PyBytes_FromStringAndSize(path, (Py_ssize_t) (p - path));
+ w = PyString_FromStringAndSize(path, (Py_ssize_t) (p - path));
if (w == NULL) {
Py_DECREF(v);
return NULL;
if (i == 0) {
char* fn = decc$translate_vms(argv[0]);
if ((fn == (char *)0) || fn == (char *)-1)
- v = PyBytes_FromString(argv[0]);
+ v = PyString_FromString(argv[0]);
else
- v = PyBytes_FromString(
+ v = PyString_FromString(
decc$translate_vms(argv[0]));
} else
- v = PyBytes_FromString(argv[i]);
+ v = PyString_FromString(argv[i]);
#else
- PyObject *v = PyBytes_FromString(argv[i]);
+ PyObject *v = PyString_FromString(argv[i]);
#endif
if (v == NULL) {
Py_DECREF(av);
#endif /* Unix */
}
#endif /* All others */
- a = PyBytes_FromStringAndSize(argv0, n);
+ a = PyString_FromStringAndSize(argv0, n);
if (a == NULL)
Py_FatalError("no mem for sys.path insertion");
if (PyList_Insert(path, 0, a) < 0)
PyErr_Clear();
break;
}
- if (PyBytes_Check(v)) {
+ if (PyString_Check(v)) {
size_t len;
- len = PyBytes_GET_SIZE(v);
+ len = PyString_GET_SIZE(v);
if (len + 1 + taillen >= MAXPATHLEN)
continue; /* Too long */
- strcpy(namebuf, PyBytes_AsString(v));
+ strcpy(namebuf, PyString_AsString(v));
if (strlen(namebuf) != len)
continue; /* v contains '\0' */
if (len > 0 && namebuf[len-1] != SEP)
while (tb != NULL && err == 0) {
if (depth <= limit) {
err = tb_displayline(f,
- PyBytes_AsString(
+ PyString_AsString(
tb->tb_frame->f_code->co_filename),
tb->tb_lineno,
- PyBytes_AsString(tb->tb_frame->f_code->co_name));
+ PyString_AsString(tb->tb_frame->f_code->co_name));
}
depth--;
tb = tb->tb_next;
char *dtable;
if(!PyArg_ParseTuple(arg,"O!",&PyDict_Type,&d)) return NULL;
while(PyDict_Next(d,&n,&key,&value))
- { int m=PyBytes_Size(value);
+ { int m=PyString_Size(value);
if(m<0||!PyInt_Check(key)) return NULL;
size+=m+2;
}
memset(dtable,0,size-8);
n=0;
while(PyDict_Next(d,&n,&key,&value))
- { int m=PyBytes_Size(value);
+ { int m=PyString_Size(value);
*dtable=(char)PyInt_AsLong(key);
- strcpy(dtable+1,PyBytes_AsString(value));
+ strcpy(dtable+1,PyString_AsString(value));
dtable+=m+2;
}
Py_INCREF(Py_None);return Py_None;
if (!strcmp(name, "__members__"))
{ PyObject *list = PyList_New(2);
if (list)
- { PyList_SetItem(list, 0, PyBytes_FromString("size"));
- PyList_SetItem(list, 1, PyBytes_FromString("start"));
+ { PyList_SetItem(list, 0, PyString_FromString("size"));
+ PyList_SetItem(list, 1, PyString_FromString("start"));
if (PyErr_Occurred()) { Py_DECREF(list);list = NULL;}
}
return list;
{ PyObject *m, *d;
m = Py_InitModule("drawf", DrawFMethods);
d = PyModule_GetDict(m);
- DrawFError=PyBytes_FromString("drawf.error");
+ DrawFError=PyString_FromString("drawf.error");
PyDict_SetItemString(d,"error",DrawFError);
}
char *buf;
e=xosfscontrol_canonicalise_path(path,0,0,0,0,&len);
if(e) return riscos_oserror();
- obj=PyBytes_FromStringAndSize(NULL,-len);
+ obj=PyString_FromStringAndSize(NULL,-len);
if(obj==NULL) return NULL;
- buf=PyBytes_AsString(obj);
+ buf=PyString_AsString(obj);
e=xosfscontrol_canonicalise_path(path,buf,0,0,1-len,&len);
if(len!=1) return riscos_error("Error expanding path");
if(!e) return obj;
{ Py_DECREF(d);return riscos_oserror();
}
if(count)
- { v=PyBytes_FromString(buf);
+ { v=PyString_FromString(buf);
if(!v) { Py_DECREF(d);return 0;}
if(PyList_Append(d,v)) {Py_DECREF(d);Py_DECREF(v);return 0;}
}
char *name,*value;
if(!PyArg_ParseTuple(args,"s:getenv",&name)) return NULL;
value=getenv(name);
- if(value) return PyBytes_FromString(value);
+ if(value) return PyString_FromString(value);
Py_INCREF(Py_None);
return Py_None;
}
os_VARTYPE_EXPANDED,&size,(int *)&context,0))
{ PyObject *v;
value[size]='\0';
- v = PyBytes_FromString(value);
+ v = PyString_FromString(value);
if (v == NULL) continue;
PyDict_SetItemString(dict, context, v);
Py_DECREF(v);
b->length=4*size;
b->heap=1;
if(init)
- { if(PyBytes_Check(init))
- { int n=PyBytes_Size(init);
+ { if(PyString_Check(init))
+ { int n=PyString_Size(init);
if (n>4*size) n=4*size;
- memcpy(b->block,PyBytes_AsString(init),n);
+ memcpy(b->block,PyString_AsString(init),n);
memset((char*)b->block+n,0,4*size-n);
}
else
{ PyErr_SetString(PyExc_IndexError,"block index out of range");
return NULL;
}
- return PyBytes_FromStringAndSize((char*)self->block+s,e-s);
+ return PyString_FromStringAndSize((char*)self->block+s,e-s);
}
static PyObject *PyBlock_NullString(PyBlockObject *self,PyObject *arg)
return NULL;
}
for(i=s;i<e;i++) if(p[i]==0) break;
- return PyBytes_FromStringAndSize((char*)self->block+s,i-s);
+ return PyString_FromStringAndSize((char*)self->block+s,i-s);
}
static PyObject *PyBlock_CtrlString(PyBlockObject *self,PyObject *arg)
return NULL;
}
for(i=s;i<e;i++) if(p[i]<32) break;
- return PyBytes_FromStringAndSize((char*)self->block+s,i-s);
+ return PyString_FromStringAndSize((char*)self->block+s,i-s);
}
static PyObject *PyBlock_PadString(PyBlockObject *self,PyObject *arg)
if (!strcmp(name, "__members__"))
{ PyObject *list = PyList_New(3);
if (list)
- { PyList_SetItem(list, 0, PyBytes_FromString("length"));
- PyList_SetItem(list, 1, PyBytes_FromString("start"));
- PyList_SetItem(list, 2, PyBytes_FromString("end"));
+ { PyList_SetItem(list, 0, PyString_FromString("length"));
+ PyList_SetItem(list, 1, PyString_FromString("start"));
+ PyList_SetItem(list, 2, PyString_FromString("end"));
if (PyErr_Occurred()) { Py_DECREF(list);list = NULL;}
}
return list;
for(;*fmt;fmt++)
{ switch(*fmt)
{ case 'i':v=PyInt_FromLong((long)r.r[rno++]); break;
- case 's':v=PyBytes_FromString((char*)(r.r[rno++])); break;
+ case 's':v=PyString_FromString((char*)(r.r[rno++])); break;
case '.':rno++; continue;
case '*':v=PyInt_FromLong((long)carry); break;
}
if(!PyArg_ParseTuple(arg,"i|i",(unsigned int *)&s, &l)) return NULL;
if (l==-1)
l = strlen(s);
- return PyBytes_FromStringAndSize((char*)s, l);
+ return PyString_FromStringAndSize((char*)s, l);
}
static char swi_string__doc__[] =
projects / python / commitdiff