mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-08-01 07:33:08 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

This reverts r63675 based on the discussion in this thread:

Browse source 
http://mail.python.org/pipermail/python-dev/2008-June/079988.html

Python 2.6 should stick with PyString_* in its codebase.  The PyBytes_* names
in the spirit of 3.0 are available via a #define only.  See the email thread.
This commit is contained in:
Gregory P. Smith 2008-06-09 04:58:54 +00:00
parent e98839a1f4
commit dd96db63f6
173 changed files with 2275 additions and 2280 deletions
Download patch file Download diff file Expand all files Collapse all files

108
Objects/fileobject.c
View file

@ -26,7 +26,7 @@
#include <io.h>
#endif
#define BUF(v) PyBytes_AS_STRING((PyBytesObject *)v)
#define BUF(v) PyString_AS_STRING((PyStringObject *)v)
#ifndef DONT_HAVE_ERRNO_H
#include <errno.h>
@ -160,7 +160,7 @@ fill_file_fields(PyFileObject *f, FILE *fp, PyObject *name, char *mode,
Py_INCREF(name);
f->f_name = name;
f->f_mode = PyBytes_FromString(mode);
f->f_mode = PyString_FromString(mode);
f->f_close = close;
f->f_softspace = 0;
@ -370,7 +370,7 @@ PyFile_FromFile(FILE *fp, char *name, char *mode, int (*close)(FILE *))
PyFileObject *f = (PyFileObject *)PyFile_Type.tp_new(&PyFile_Type,
NULL, NULL);
if (f != NULL) {
PyObject *o_name = PyBytes_FromString(name);
PyObject *o_name = PyString_FromString(name);
if (o_name == NULL)
return NULL;
if (fill_file_fields(f, fp, o_name, mode, close) == NULL) {
@ -525,20 +525,20 @@ file_repr(PyFileObject *f)
#ifdef Py_USING_UNICODE
PyObject *ret = NULL;
PyObject *name = PyUnicode_AsUnicodeEscapeString(f->f_name);
const char *name_str = name ? PyBytes_AsString(name) : "?";
ret = PyBytes_FromFormat("<%s file u'%s', mode '%s' at %p>",
const char *name_str = name ? PyString_AsString(name) : "?";
ret = PyString_FromFormat("<%s file u'%s', mode '%s' at %p>",
f->f_fp == NULL ? "closed" : "open",
name_str,
PyBytes_AsString(f->f_mode),
PyString_AsString(f->f_mode),
f);
Py_XDECREF(name);
return ret;
#endif
} else {
return PyBytes_FromFormat("<%s file '%s', mode '%s' at %p>",
return PyString_FromFormat("<%s file '%s', mode '%s' at %p>",
f->f_fp == NULL ? "closed" : "open",
PyBytes_AsString(f->f_name),
PyBytes_AsString(f->f_mode),
PyString_AsString(f->f_name),
PyString_AsString(f->f_mode),
f);
}
}
@ -958,7 +958,7 @@ file_read(PyFileObject *f, PyObject *args)
"requested number of bytes is more than a Python string can hold");
return NULL;
}
v = PyBytes_FromStringAndSize((char *)NULL, buffersize);
v = PyString_FromStringAndSize((char *)NULL, buffersize);
if (v == NULL)
return NULL;
bytesread = 0;
@ -989,7 +989,7 @@ file_read(PyFileObject *f, PyObject *args)
}
if (bytesrequested < 0) {
buffersize = new_buffersize(f, buffersize);
if (_PyBytes_Resize(&v, buffersize) < 0)
if (_PyString_Resize(&v, buffersize) < 0)
return NULL;
} else {
/* Got what was requested. */
@ -997,7 +997,7 @@ file_read(PyFileObject *f, PyObject *args)
}
}
if (bytesread != buffersize)
_PyBytes_Resize(&v, bytesread);
_PyString_Resize(&v, bytesread);
return v;
}
@ -1115,7 +1115,7 @@ getline_via_fgets(PyFileObject *f, FILE *fp)
size_t increment; /* amount to increment the buffer */
size_t prev_v_size;
/* Optimize for normal case: avoid _PyBytes_Resize if at all
/* Optimize for normal case: avoid _PyString_Resize if at all
* possible via first reading into stack buffer "buf".
*/
total_v_size = INITBUFSIZE; /* start small and pray */
@ -1133,7 +1133,7 @@ getline_via_fgets(PyFileObject *f, FILE *fp)
clearerr(fp);
if (PyErr_CheckSignals())
return NULL;
v = PyBytes_FromStringAndSize(buf, pvfree - buf);
v = PyString_FromStringAndSize(buf, pvfree - buf);
return v;
}
/* fgets read *something* */
@ -1162,7 +1162,7 @@ getline_via_fgets(PyFileObject *f, FILE *fp)
assert(p > pvfree && *(p-1) == '\0');
--p; /* don't include \0 from fgets */
}
v = PyBytes_FromStringAndSize(buf, p - buf);
v = PyString_FromStringAndSize(buf, p - buf);
return v;
}
/* yuck: fgets overwrote all the newlines, i.e. the entire
@ -1183,7 +1183,7 @@ getline_via_fgets(PyFileObject *f, FILE *fp)
* into its buffer.
*/
total_v_size = MAXBUFSIZE << 1;
v = PyBytes_FromStringAndSize((char*)NULL, (int)total_v_size);
v = PyString_FromStringAndSize((char*)NULL, (int)total_v_size);
if (v == NULL)
return v;
/* copy over everything except the last null byte */
@ -1238,13 +1238,13 @@ getline_via_fgets(PyFileObject *f, FILE *fp)
Py_DECREF(v);
return NULL;
}
if (_PyBytes_Resize(&v, (int)total_v_size) < 0)
if (_PyString_Resize(&v, (int)total_v_size) < 0)
return NULL;
/* overwrite the trailing null byte */
pvfree = BUF(v) + (prev_v_size - 1);
}
if (BUF(v) + total_v_size != p)
_PyBytes_Resize(&v, p - BUF(v));
_PyString_Resize(&v, p - BUF(v));
return v;
#undef INITBUFSIZE
#undef MAXBUFSIZE
@ -1276,7 +1276,7 @@ get_line(PyFileObject *f, int n)
return getline_via_fgets(f, fp);
#endif
total_v_size = n > 0 ? n : 100;
v = PyBytes_FromStringAndSize((char *)NULL, total_v_size);
v = PyString_FromStringAndSize((char *)NULL, total_v_size);
if (v == NULL)
return NULL;
buf = BUF(v);
@ -1349,7 +1349,7 @@ get_line(PyFileObject *f, int n)
Py_DECREF(v);
return NULL;
}
if (_PyBytes_Resize(&v, total_v_size) < 0)
if (_PyString_Resize(&v, total_v_size) < 0)
return NULL;
buf = BUF(v) + used_v_size;
end = BUF(v) + total_v_size;
@ -1357,7 +1357,7 @@ get_line(PyFileObject *f, int n)
used_v_size = buf - BUF(v);
if (used_v_size != total_v_size)
_PyBytes_Resize(&v, used_v_size);
_PyString_Resize(&v, used_v_size);
return v;
}
@ -1402,7 +1402,7 @@ PyFile_GetLine(PyObject *f, int n)
result = PyEval_CallObject(reader, args);
Py_DECREF(reader);
Py_DECREF(args);
if (result != NULL && !PyBytes_Check(result) &&
if (result != NULL && !PyString_Check(result) &&
!PyUnicode_Check(result)) {
Py_DECREF(result);
result = NULL;
@ -1411,9 +1411,9 @@ PyFile_GetLine(PyObject *f, int n)
}
}
if (n < 0 && result != NULL && PyBytes_Check(result)) {
char *s = PyBytes_AS_STRING(result);
Py_ssize_t len = PyBytes_GET_SIZE(result);
if (n < 0 && result != NULL && PyString_Check(result)) {
char *s = PyString_AS_STRING(result);
Py_ssize_t len = PyString_GET_SIZE(result);
if (len == 0) {
Py_DECREF(result);
result = NULL;
@ -1422,10 +1422,10 @@ PyFile_GetLine(PyObject *f, int n)
}
else if (s[len-1] == '\n') {
if (result->ob_refcnt == 1)
_PyBytes_Resize(&result, len-1);
_PyString_Resize(&result, len-1);
else {
PyObject *v;
v = PyBytes_FromStringAndSize(s, len-1);
v = PyString_FromStringAndSize(s, len-1);
Py_DECREF(result);
result = v;
}
@ -1473,7 +1473,7 @@ file_readline(PyFileObject *f, PyObject *args)
if (!PyArg_ParseTuple(args, "|i:readline", &n))
return NULL;
if (n == 0)
return PyBytes_FromString("");
return PyString_FromString("");
if (n < 0)
n = 0;
return get_line(f, n);
@ -1539,18 +1539,18 @@ file_readlines(PyFileObject *f, PyObject *args)
}
if (big_buffer == NULL) {
/* Create the big buffer */
big_buffer = PyBytes_FromStringAndSize(
big_buffer = PyString_FromStringAndSize(
NULL, buffersize);
if (big_buffer == NULL)
goto error;
buffer = PyBytes_AS_STRING(big_buffer);
buffer = PyString_AS_STRING(big_buffer);
memcpy(buffer, small_buffer, nfilled);
}
else {
/* Grow the big buffer */
if ( _PyBytes_Resize(&big_buffer, buffersize) < 0 )
if ( _PyString_Resize(&big_buffer, buffersize) < 0 )
goto error;
buffer = PyBytes_AS_STRING(big_buffer);
buffer = PyString_AS_STRING(big_buffer);
}
continue;
}
@ -1559,7 +1559,7 @@ file_readlines(PyFileObject *f, PyObject *args)
do {
/* Process complete lines */
p++;
line = PyBytes_FromStringAndSize(q, p-q);
line = PyString_FromStringAndSize(q, p-q);
if (line == NULL)
goto error;
err = PyList_Append(list, line);
@ -1578,7 +1578,7 @@ file_readlines(PyFileObject *f, PyObject *args)
}
if (nfilled != 0) {
/* Partial last line */
line = PyBytes_FromStringAndSize(buffer, nfilled);
line = PyString_FromStringAndSize(buffer, nfilled);
if (line == NULL)
goto error;
if (sizehint > 0) {
@ -1588,7 +1588,7 @@ file_readlines(PyFileObject *f, PyObject *args)
Py_DECREF(line);
goto error;
}
PyBytes_Concat(&line, rest);
PyString_Concat(&line, rest);
Py_DECREF(rest);
if (line == NULL)
goto error;
@ -1695,7 +1695,7 @@ file_writelines(PyFileObject *f, PyObject *seq)
could potentially execute Python code. */
for (i = 0; i < j; i++) {
PyObject *v = PyList_GET_ITEM(list, i);
if (!PyBytes_Check(v)) {
if (!PyString_Check(v)) {
const char *buffer;
if (((f->f_binary &&
PyObject_AsReadBuffer(v,
@ -1708,7 +1708,7 @@ file_writelines(PyFileObject *f, PyObject *seq)
"writelines() argument must be a sequence of strings");
goto error;
}
line = PyBytes_FromStringAndSize(buffer,
line = PyString_FromStringAndSize(buffer,
len);
if (line == NULL)
goto error;
@ -1724,8 +1724,8 @@ file_writelines(PyFileObject *f, PyObject *seq)
errno = 0;
for (i = 0; i < j; i++) {
line = PyList_GET_ITEM(list, i);
len = PyBytes_GET_SIZE(line);
nwritten = fwrite(PyBytes_AS_STRING(line),
len = PyString_GET_SIZE(line);
nwritten = fwrite(PyString_AS_STRING(line),
1, len, f->f_fp);
if (nwritten != len) {
FILE_ABORT_ALLOW_THREADS(f)
@ -1921,13 +1921,13 @@ get_newlines(PyFileObject *f, void *closure)
Py_INCREF(Py_None);
return Py_None;
case NEWLINE_CR:
return PyBytes_FromString("\r");
return PyString_FromString("\r");
case NEWLINE_LF:
return PyBytes_FromString("\n");
return PyString_FromString("\n");
case NEWLINE_CR|NEWLINE_LF:
return Py_BuildValue("(ss)", "\r", "\n");
case NEWLINE_CRLF:
return PyBytes_FromString("\r\n");
return PyString_FromString("\r\n");
case NEWLINE_CR|NEWLINE_CRLF:
return Py_BuildValue("(ss)", "\r", "\r\n");
case NEWLINE_LF|NEWLINE_CRLF:
@ -2029,10 +2029,10 @@ readahead(PyFileObject *f, int bufsize)
horrified by the recursive call: maximum recursion depth is limited by
logarithmic buffer growth to about 50 even when reading a 1gb line. */
static PyBytesObject *
static PyStringObject *
readahead_get_line_skip(PyFileObject *f, int skip, int bufsize)
{
PyBytesObject* s;
PyStringObject* s;
char *bufptr;
char *buf;
Py_ssize_t len;
@ -2043,17 +2043,17 @@ readahead_get_line_skip(PyFileObject *f, int skip, int bufsize)
len = f->f_bufend - f->f_bufptr;
if (len == 0)
return (PyBytesObject *)
PyBytes_FromStringAndSize(NULL, skip);
return (PyStringObject *)
PyString_FromStringAndSize(NULL, skip);
bufptr = (char *)memchr(f->f_bufptr, '\n', len);
if (bufptr != NULL) {
bufptr++; /* Count the '\n' */
len = bufptr - f->f_bufptr;
s = (PyBytesObject *)
PyBytes_FromStringAndSize(NULL, skip+len);
s = (PyStringObject *)
PyString_FromStringAndSize(NULL, skip+len);
if (s == NULL)
return NULL;
memcpy(PyBytes_AS_STRING(s)+skip, f->f_bufptr, len);
memcpy(PyString_AS_STRING(s)+skip, f->f_bufptr, len);
f->f_bufptr = bufptr;
if (bufptr == f->f_bufend)
drop_readahead(f);
@ -2068,7 +2068,7 @@ readahead_get_line_skip(PyFileObject *f, int skip, int bufsize)
PyMem_Free(buf);
return NULL;
}
memcpy(PyBytes_AS_STRING(s)+skip, bufptr, len);
memcpy(PyString_AS_STRING(s)+skip, bufptr, len);
PyMem_Free(buf);
}
return s;
@ -2080,13 +2080,13 @@ readahead_get_line_skip(PyFileObject *f, int skip, int bufsize)
static PyObject *
file_iternext(PyFileObject *f)
{
PyBytesObject* l;
PyStringObject* l;
if (f->f_fp == NULL)
return err_closed();
l = readahead_get_line_skip(f, 0, READAHEAD_BUFSIZE);
if (l == NULL || PyBytes_GET_SIZE(l) == 0) {
if (l == NULL || PyString_GET_SIZE(l) == 0) {
Py_XDECREF(l);
return NULL;
}
@ -2103,7 +2103,7 @@ file_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
assert(type != NULL && type->tp_alloc != NULL);
if (not_yet_string == NULL) {
not_yet_string = PyBytes_InternFromString("<uninitialized file>");
not_yet_string = PyString_InternFromString("<uninitialized file>");
if (not_yet_string == NULL)
return NULL;
}
@ -2394,7 +2394,7 @@ PyFile_WriteString(const char *s, PyObject *f)
return 0;
}
else if (!PyErr_Occurred()) {
PyObject *v = PyBytes_FromString(s);
PyObject *v = PyString_FromString(s);
int err;
if (v == NULL)
return -1;