mirrors
/
cpython
mirror of https://github.com/python/cpython.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Quality control, meet exceptions.c. 

Fix a number of problems with the need for speed code:

One is doing this sort of thing:

    Py_DECREF(self->field);
    self->field = newval;
    Py_INCREF(self->field);

without being very sure that self->field doesn't start with a
value that has a __del__, because that almost certainly can lead
to segfaults.

As self->args is constrained to be an exact tuple we may as well
exploit this fact consistently.  This leads to quite a lot of
simplification (and, hey, probably better performance).

Add some error checking in places lacking it.

Fix some rather strange indentation in the Unicode code.

Delete some trailing whitespace.

More to come, I haven't fixed all the reference leaks yet...
This commit is contained in:
Michael W. Hudson 2006-05-28 15:51:40 +00:00
parent 80f8e80c15
commit 22a80e7cb0
1 changed files with 105 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

233
Objects/exceptions.c
View File

@ -36,7 +36,7 @@ BaseException_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
return NULL; return NULL;
} }
self->message = PyString_FromString(""); self->message = PyString_FromString("");
if (!self->message) { if (!self->message) {
Py_DECREF(self); Py_DECREF(self);
return NULL; return NULL;
@ -53,9 +53,9 @@ BaseException_init(PyBaseExceptionObject *self, PyObject *args, PyObject *kwds)
Py_INCREF(self->args); Py_INCREF(self->args);
if (PyTuple_GET_SIZE(self->args) == 1) { if (PyTuple_GET_SIZE(self->args) == 1) {
Py_DECREF(self->message); Py_CLEAR(self->message);
self->message = PyTuple_GET_ITEM(self->args, 0); self->message = PyTuple_GET_ITEM(self->args, 0);
Py_INCREF(self->message); Py_INCREF(self->message);
} }
return 0; return 0;
} }
@ -79,8 +79,7 @@ BaseException_dealloc(PyBaseExceptionObject *self)
int int
BaseException_traverse(PyBaseExceptionObject *self, visitproc visit, void *arg) BaseException_traverse(PyBaseExceptionObject *self, visitproc visit, void *arg)
{ {
if (self->dict) Py_VISIT(self->dict);
Py_VISIT(self->dict);
Py_VISIT(self->args); Py_VISIT(self->args);
Py_VISIT(self->message); Py_VISIT(self->message);
return 0; return 0;
@ -91,24 +90,13 @@ BaseException_str(PyBaseExceptionObject *self)
{ {
PyObject *out; PyObject *out;
switch (PySequence_Length(self->args)) { switch (PyTuple_GET_SIZE(self->args)) {
case 0: case 0:
out = PyString_FromString(""); out = PyString_FromString("");
break; break;
case 1: case 1:
{ out = PyObject_Str(PyTuple_GET_ITEM(self->args, 0));
PyObject *tmp = PySequence_GetItem(self->args, 0);
if (tmp) {
out = PyObject_Str(tmp);
Py_DECREF(tmp);
}
else
out = NULL;
break; break;
}
case -1:
PyErr_Clear();
/* Fall through */
default: default:
out = PyObject_Str(self->args); out = PyObject_Str(self->args);
break; break;
@ -120,28 +108,14 @@ BaseException_str(PyBaseExceptionObject *self)
static PyObject * static PyObject *
BaseException_repr(PyBaseExceptionObject *self) BaseException_repr(PyBaseExceptionObject *self)
{ {
Py_ssize_t args_len;
PyObject *repr_suffix; PyObject *repr_suffix;
PyObject *repr; PyObject *repr;
char *name; char *name;
char *dot; char *dot;
args_len = PySequence_Length(self->args); repr_suffix = PyObject_Repr(self->args);
if (args_len < 0) { if (!repr_suffix)
return NULL; return NULL;
}
if (args_len == 0) {
repr_suffix = PyString_FromString("()");
if (!repr_suffix)
return NULL;
}
else {
PyObject *args_repr = PyObject_Repr(self->args);
if (!args_repr)
return NULL;
repr_suffix = args_repr;
}
name = (char *)self->ob_type->tp_name; name = (char *)self->ob_type->tp_name;
dot = strrchr(name, '.'); dot = strrchr(name, '.');
@ -172,18 +146,10 @@ BaseException_reduce(PyBaseExceptionObject *self)
static PyObject * static PyObject *
BaseException_unicode(PyBaseExceptionObject *self) BaseException_unicode(PyBaseExceptionObject *self)
{ {
if (PySequence_Length(self->args) == 0) if (PyTuple_GET_SIZE(self->args) == 0)
return PyUnicode_FromUnicode(NULL, 0); return PyUnicode_FromUnicode(NULL, 0);
if (PySequence_Length(self->args) == 1) { if (PyTuple_GET_SIZE(self->args) == 1)
PyObject *temp = PySequence_GetItem(self->args, 0); return PyObject_Unicode(PyTuple_GET_ITEM(self->args, 0));
PyObject *unicode_obj;
if (!temp) {
return NULL;
}
unicode_obj = PyObject_Unicode(temp);
Py_DECREF(temp);
return unicode_obj;
}
return PyObject_Unicode(self->args); return PyObject_Unicode(self->args);
} }
#endif /* Py_USING_UNICODE */ #endif /* Py_USING_UNICODE */
@ -394,7 +360,7 @@ SimpleExtendsException(PyExc_BaseException, Exception,
/* /*
* StandardError extends Exception * StandardError extends Exception
*/ */
SimpleExtendsException(PyExc_Exception, StandardError, SimpleExtendsException(PyExc_Exception, StandardError,
"Base class for all standard Python exceptions that do not represent\n" "Base class for all standard Python exceptions that do not represent\n"
"interpreter exiting."); "interpreter exiting.");
@ -445,7 +411,9 @@ SystemExit_init(PySystemExitObject *self, PyObject *args, PyObject *kwds)
if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1) if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)
return -1; return -1;
Py_DECREF(self->code); if (size == 0)
return 0;
Py_CLEAR(self->code);
if (size == 1) if (size == 1)
self->code = PyTuple_GET_ITEM(args, 0); self->code = PyTuple_GET_ITEM(args, 0);
else if (size > 1) else if (size > 1)
@ -514,12 +482,9 @@ EnvironmentError_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
if (!self) if (!self)
return NULL; return NULL;
self->myerrno = Py_None; MAKE_IT_NONE(self->myerrno);
Py_INCREF(Py_None); MAKE_IT_NONE(self->strerror);
self->strerror = Py_None; MAKE_IT_NONE(self->filename);
Py_INCREF(Py_None);
self->filename = Py_None;
Py_INCREF(Py_None);
return (PyObject *)self; return (PyObject *)self;
} }
@ -548,22 +513,22 @@ EnvironmentError_init(PyEnvironmentErrorObject *self, PyObject *args,
if (PyTuple_GET_SIZE(args) <= 1) { if (PyTuple_GET_SIZE(args) <= 1) {
return 0; return 0;
} }
if (!PyArg_UnpackTuple(args, "EnvironmentError", 2, 3, if (!PyArg_UnpackTuple(args, "EnvironmentError", 2, 3,
&myerrno, &strerror, &filename)) { &myerrno, &strerror, &filename)) {
return -1; return -1;
} }
Py_DECREF(self->myerrno); /* replacing */ Py_CLEAR(self->myerrno); /* replacing */
self->myerrno = myerrno; self->myerrno = myerrno;
Py_INCREF(self->myerrno); Py_INCREF(self->myerrno);
Py_DECREF(self->strerror); /* replacing */ Py_CLEAR(self->strerror); /* replacing */
self->strerror = strerror; self->strerror = strerror;
Py_INCREF(self->strerror); Py_INCREF(self->strerror);
/* self->filename will remain Py_None otherwise */ /* self->filename will remain Py_None otherwise */
if (filename != NULL) { if (filename != NULL) {
Py_DECREF(self->filename); /* replacing */ Py_CLEAR(self->filename); /* replacing */
self->filename = filename; self->filename = filename;
Py_INCREF(self->filename); Py_INCREF(self->filename);
@ -606,6 +571,9 @@ EnvironmentError_traverse(PyEnvironmentErrorObject *self, visitproc visit,
static PyObject * static PyObject *
EnvironmentError_str(PyEnvironmentErrorObject *self) EnvironmentError_str(PyEnvironmentErrorObject *self)
{ {
/* XXX this needs to be rewritten to cope with any of self->filename,
self->strerror and self->myerrno being NULL.
*/
PyObject *rtnval = NULL; PyObject *rtnval = NULL;
if (self->filename != Py_None) { if (self->filename != Py_None) {
@ -677,20 +645,17 @@ EnvironmentError_reduce(PyEnvironmentErrorObject *self)
PyObject *res = NULL, *tmp; PyObject *res = NULL, *tmp;
/* self->args is only the first two real arguments if there was a /* self->args is only the first two real arguments if there was a
* file name given to EnvironmentError. */ * file name given to EnvironmentError. */
if (PyTuple_Check(args) && if (PyTuple_GET_SIZE(args) == 2 &&
PyTuple_GET_SIZE(args) == 2 && self->filename != Py_None) {
self->filename != Py_None) {
args = PyTuple_New(3); args = PyTuple_New(3);
if (!args) return NULL; if (!args) return NULL;
tmp = PyTuple_GetItem(self->args, 0); tmp = PyTuple_GET_ITEM(self->args, 0);
if (!tmp) goto finish;
Py_INCREF(tmp); Py_INCREF(tmp);
PyTuple_SET_ITEM(args, 0, tmp); PyTuple_SET_ITEM(args, 0, tmp);
tmp = PyTuple_GetItem(self->args, 1); tmp = PyTuple_GET_ITEM(self->args, 1);
if (!tmp) goto finish;
Py_INCREF(tmp); Py_INCREF(tmp);
PyTuple_SET_ITEM(args, 1, tmp); PyTuple_SET_ITEM(args, 1, tmp);
@ -700,7 +665,6 @@ EnvironmentError_reduce(PyEnvironmentErrorObject *self)
Py_INCREF(args); Py_INCREF(args);
} }
res = PyTuple_Pack(3, self->ob_type, args, self->dict); res = PyTuple_Pack(3, self->ob_type, args, self->dict);
finish:
Py_DECREF(args); Py_DECREF(args);
return res; return res;
} }
@ -714,14 +678,14 @@ static PyMethodDef EnvironmentError_methods[] = {
ComplexExtendsException(PyExc_StandardError, EnvironmentError, ComplexExtendsException(PyExc_StandardError, EnvironmentError,
EnvironmentError, EnvironmentError_dealloc, EnvironmentError, EnvironmentError_dealloc,
EnvironmentError_methods, EnvironmentError_members, EnvironmentError_methods, EnvironmentError_members,
EnvironmentError_str, EnvironmentError_str,
"Base class for I/O related errors."); "Base class for I/O related errors.");
/* /*
* IOError extends EnvironmentError * IOError extends EnvironmentError
*/ */
MiddlingExtendsException(PyExc_EnvironmentError, IOError, MiddlingExtendsException(PyExc_EnvironmentError, IOError,
EnvironmentError, "I/O operation failed."); EnvironmentError, "I/O operation failed.");
@ -783,6 +747,9 @@ WindowsError_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
return (PyObject *)self; return (PyObject *)self;
} }
/* XXX this is dead code, surely? EnvironmentError_new always sets
self->myerrno to None! */
/* Set errno to the POSIX errno, and winerror to the Win32 /* Set errno to the POSIX errno, and winerror to the Win32
error code. */ error code. */
errcode = PyInt_AsLong(self->myerrno); errcode = PyInt_AsLong(self->myerrno);
@ -850,6 +817,8 @@ WindowsError_init(PyWindowsErrorObject *self, PyObject *args, PyObject *kwds)
static PyObject * static PyObject *
WindowsError_str(PyWindowsErrorObject *self) WindowsError_str(PyWindowsErrorObject *self)
{ {
/* XXX this probably also needs to be rewritten to cope with NULL-ness of
the fields */
PyObject *repr = NULL; PyObject *repr = NULL;
PyObject *fmt = NULL; PyObject *fmt = NULL;
PyObject *tuple = NULL; PyObject *tuple = NULL;
@ -995,7 +964,7 @@ SyntaxError_init(PySyntaxErrorObject *self, PyObject *args, PyObject *kwds)
return -1; return -1;
if (lenargs >= 1) { if (lenargs >= 1) {
Py_DECREF(self->msg); Py_CLEAR(self->msg);
self->msg = PyTuple_GET_ITEM(args, 0); self->msg = PyTuple_GET_ITEM(args, 0);
Py_INCREF(self->msg); Py_INCREF(self->msg);
} }
@ -1004,21 +973,30 @@ SyntaxError_init(PySyntaxErrorObject *self, PyObject *args, PyObject *kwds)
info = PySequence_Tuple(info); info = PySequence_Tuple(info);
if (!info) return -1; if (!info) return -1;
Py_DECREF(self->filename); if (PyTuple_GET_SIZE(info) != 4) {
/* not a very good error message, but it's what Python 2.4 gives */
PyErr_SetString(PyExc_IndexError, "tuple index out of range");
Py_DECREF(info);
return -1;
}
Py_CLEAR(self->filename);
self->filename = PyTuple_GET_ITEM(info, 0); self->filename = PyTuple_GET_ITEM(info, 0);
Py_INCREF(self->filename); Py_INCREF(self->filename);
Py_DECREF(self->lineno); Py_CLEAR(self->lineno);
self->lineno = PyTuple_GET_ITEM(info, 1); self->lineno = PyTuple_GET_ITEM(info, 1);
Py_INCREF(self->lineno); Py_INCREF(self->lineno);
Py_DECREF(self->offset); Py_CLEAR(self->offset);
self->offset = PyTuple_GET_ITEM(info, 2); self->offset = PyTuple_GET_ITEM(info, 2);
Py_INCREF(self->offset); Py_INCREF(self->offset);
Py_DECREF(self->text); Py_CLEAR(self->text);
self->text = PyTuple_GET_ITEM(info, 3); self->text = PyTuple_GET_ITEM(info, 3);
Py_INCREF(self->text); Py_INCREF(self->text);
Py_DECREF(info);
} }
return 0; return 0;
} }
@ -1091,7 +1069,7 @@ SyntaxError_str(PySyntaxErrorObject *self)
int have_lineno = 0; int have_lineno = 0;
char *buffer = NULL; char *buffer = NULL;
have_filename = (self->filename != NULL) && have_filename = (self->filename != NULL) &&
PyString_Check(self->filename); PyString_Check(self->filename);
have_lineno = (self->lineno != NULL) && PyInt_Check(self->lineno); have_lineno = (self->lineno != NULL) && PyInt_Check(self->lineno);
@ -1196,9 +1174,8 @@ KeyError_str(PyBaseExceptionObject *self)
string, that string will be displayed in quotes. Too bad. string, that string will be displayed in quotes. Too bad.
If args is anything else, use the default BaseException__str__(). If args is anything else, use the default BaseException__str__().
*/ */
if (PyTuple_Check(self->args) && PyTuple_GET_SIZE(self->args) == 1) { if (PyTuple_GET_SIZE(self->args) == 1) {
PyObject *key = PyTuple_GET_ITEM(self->args, 0); return PyObject_Repr(PyTuple_GET_ITEM(self->args, 0));
return PyObject_Repr(key);
} }
return BaseException_str(self); return BaseException_str(self);
} }
@ -1531,7 +1508,7 @@ UnicodeError_init(PyUnicodeErrorObject *self, PyObject *args, PyObject *kwds,
&PyInt_Type, &self->start, &PyInt_Type, &self->start,
&PyInt_Type, &self->end, &PyInt_Type, &self->end,
&PyString_Type, &self->reason)) { &PyString_Type, &self->reason)) {
self->encoding = self->object = self->start = self->end = self->encoding = self->object = self->start = self->end =
self->reason = NULL; self->reason = NULL;
return -1; return -1;
} }
@ -1616,27 +1593,27 @@ UnicodeEncodeError_str(PyObject *self)
Py_ssize_t end; Py_ssize_t end;
if (PyUnicodeEncodeError_GetStart(self, &start)) if (PyUnicodeEncodeError_GetStart(self, &start))
return NULL; return NULL;
if (PyUnicodeEncodeError_GetEnd(self, &end)) if (PyUnicodeEncodeError_GetEnd(self, &end))
return NULL; return NULL;
if (end==start+1) { if (end==start+1) {
int badchar = (int)PyUnicode_AS_UNICODE(((PyUnicodeErrorObject *)self)->object)[start]; int badchar = (int)PyUnicode_AS_UNICODE(((PyUnicodeErrorObject *)self)->object)[start];
char badchar_str[20]; char badchar_str[20];
if (badchar <= 0xff) if (badchar <= 0xff)
PyOS_snprintf(badchar_str, sizeof(badchar_str), "x%02x", badchar); PyOS_snprintf(badchar_str, sizeof(badchar_str), "x%02x", badchar);
else if (badchar <= 0xffff) else if (badchar <= 0xffff)
PyOS_snprintf(badchar_str, sizeof(badchar_str), "u%04x", badchar); PyOS_snprintf(badchar_str, sizeof(badchar_str), "u%04x", badchar);
else else
PyOS_snprintf(badchar_str, sizeof(badchar_str), "U%08x", badchar); PyOS_snprintf(badchar_str, sizeof(badchar_str), "U%08x", badchar);
return PyString_FromFormat( return PyString_FromFormat(
"'%.400s' codec can't encode character u'\\%s' in position %zd: %.400s", "'%.400s' codec can't encode character u'\\%s' in position %zd: %.400s",
PyString_AS_STRING(((PyUnicodeErrorObject *)self)->encoding), PyString_AS_STRING(((PyUnicodeErrorObject *)self)->encoding),
badchar_str, badchar_str,
start, start,
PyString_AS_STRING(((PyUnicodeErrorObject *)self)->reason) PyString_AS_STRING(((PyUnicodeErrorObject *)self)->reason)
); );
} }
return PyString_FromFormat( return PyString_FromFormat(
"'%.400s' codec can't encode characters in position %zd-%zd: %.400s", "'%.400s' codec can't encode characters in position %zd-%zd: %.400s",
@ -1668,7 +1645,7 @@ PyUnicodeEncodeError_Create(
Py_ssize_t start, Py_ssize_t end, const char *reason) Py_ssize_t start, Py_ssize_t end, const char *reason)
{ {
return PyObject_CallFunction(PyExc_UnicodeEncodeError, "su#nns", return PyObject_CallFunction(PyExc_UnicodeEncodeError, "su#nns",
encoding, object, length, start, end, reason); encoding, object, length, start, end, reason);
} }
@ -1703,17 +1680,17 @@ UnicodeDecodeError_str(PyObject *self)
return NULL; return NULL;
if (end==start+1) { if (end==start+1) {
/* FromFormat does not support %02x, so format that separately */ /* FromFormat does not support %02x, so format that separately */
char byte[4]; char byte[4];
PyOS_snprintf(byte, sizeof(byte), "%02x", PyOS_snprintf(byte, sizeof(byte), "%02x",
((int)PyString_AS_STRING(((PyUnicodeErrorObject *)self)->object)[start])&0xff); ((int)PyString_AS_STRING(((PyUnicodeErrorObject *)self)->object)[start])&0xff);
return PyString_FromFormat( return PyString_FromFormat(
"'%.400s' codec can't decode byte 0x%s in position %zd: %.400s", "'%.400s' codec can't decode byte 0x%s in position %zd: %.400s",
PyString_AS_STRING(((PyUnicodeErrorObject *)self)->encoding), PyString_AS_STRING(((PyUnicodeErrorObject *)self)->encoding),
byte, byte,
start, start,
PyString_AS_STRING(((PyUnicodeErrorObject *)self)->reason) PyString_AS_STRING(((PyUnicodeErrorObject *)self)->reason)
); );
} }
return PyString_FromFormat( return PyString_FromFormat(
"'%.400s' codec can't decode bytes in position %zd-%zd: %.400s", "'%.400s' codec can't decode bytes in position %zd-%zd: %.400s",
@ -1748,7 +1725,7 @@ PyUnicodeDecodeError_Create(
assert(start < INT_MAX); assert(start < INT_MAX);
assert(end < INT_MAX); assert(end < INT_MAX);
return PyObject_CallFunction(PyExc_UnicodeDecodeError, "ss#nns", return PyObject_CallFunction(PyExc_UnicodeDecodeError, "ss#nns",
encoding, object, length, start, end, reason); encoding, object, length, start, end, reason);
} }
@ -1793,7 +1770,7 @@ UnicodeTranslateError_init(PyUnicodeErrorObject *self, PyObject *args,
self->object = self->start = self->end = self->reason = NULL; self->object = self->start = self->end = self->reason = NULL;
return -1; return -1;
} }
Py_INCREF(self->object); Py_INCREF(self->object);
Py_INCREF(self->start); Py_INCREF(self->start);
Py_INCREF(self->end); Py_INCREF(self->end);
@ -1810,26 +1787,26 @@ UnicodeTranslateError_str(PyObject *self)
Py_ssize_t end; Py_ssize_t end;
if (PyUnicodeTranslateError_GetStart(self, &start)) if (PyUnicodeTranslateError_GetStart(self, &start))
return NULL; return NULL;
if (PyUnicodeTranslateError_GetEnd(self, &end)) if (PyUnicodeTranslateError_GetEnd(self, &end))
return NULL; return NULL;
if (end==start+1) { if (end==start+1) {
int badchar = (int)PyUnicode_AS_UNICODE(((PyUnicodeErrorObject *)self)->object)[start]; int badchar = (int)PyUnicode_AS_UNICODE(((PyUnicodeErrorObject *)self)->object)[start];
char badchar_str[20]; char badchar_str[20];
if (badchar <= 0xff) if (badchar <= 0xff)
PyOS_snprintf(badchar_str, sizeof(badchar_str), "x%02x", badchar); PyOS_snprintf(badchar_str, sizeof(badchar_str), "x%02x", badchar);
else if (badchar <= 0xffff) else if (badchar <= 0xffff)
PyOS_snprintf(badchar_str, sizeof(badchar_str), "u%04x", badchar); PyOS_snprintf(badchar_str, sizeof(badchar_str), "u%04x", badchar);
else else
PyOS_snprintf(badchar_str, sizeof(badchar_str), "U%08x", badchar); PyOS_snprintf(badchar_str, sizeof(badchar_str), "U%08x", badchar);
return PyString_FromFormat( return PyString_FromFormat(
"can't translate character u'\\%s' in position %zd: %.400s", "can't translate character u'\\%s' in position %zd: %.400s",
badchar_str, badchar_str,
start, start,
PyString_AS_STRING(((PyUnicodeErrorObject *)self)->reason) PyString_AS_STRING(((PyUnicodeErrorObject *)self)->reason)
); );
} }
return PyString_FromFormat( return PyString_FromFormat(
"can't translate characters in position %zd-%zd: %.400s", "can't translate characters in position %zd-%zd: %.400s",
@ -1860,7 +1837,7 @@ PyUnicodeTranslateError_Create(
Py_ssize_t start, Py_ssize_t end, const char *reason) Py_ssize_t start, Py_ssize_t end, const char *reason)
{ {
return PyObject_CallFunction(PyExc_UnicodeTranslateError, "u#nns", return PyObject_CallFunction(PyExc_UnicodeTranslateError, "u#nns",
object, length, start, end, reason); object, length, start, end, reason);
} }
#endif #endif
@ -2003,7 +1980,7 @@ static PyMethodDef functions[] = {
Py_FatalError("Module dictionary insertion problem."); Py_FatalError("Module dictionary insertion problem.");
PyMODINIT_FUNC PyMODINIT_FUNC
_PyExc_Init(void) _PyExc_Init(void)
{ {
PyObject *m, *bltinmod, *bdict; PyObject *m, *bltinmod, *bdict;