1991-02-19 12:39:46 +00:00
|
|
|
/***********************************************************
|
2000-06-30 23:50:40 +00:00
|
|
|
Copyright (c) 2000, BeOpen.com.
|
|
|
|
Copyright (c) 1995-2000, Corporation for National Research Initiatives.
|
|
|
|
Copyright (c) 1990-1995, Stichting Mathematisch Centrum.
|
|
|
|
All rights reserved.
|
|
|
|
|
|
|
|
See the file "Misc/COPYRIGHT" for information on usage and
|
|
|
|
redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES.
|
1991-02-19 12:39:46 +00:00
|
|
|
******************************************************************/
|
|
|
|
|
1997-04-29 18:22:47 +00:00
|
|
|
/* Error handling */
|
1990-12-20 15:06:42 +00:00
|
|
|
|
1997-04-29 18:22:47 +00:00
|
|
|
#include "Python.h"
|
1990-12-20 23:05:40 +00:00
|
|
|
|
1994-12-14 12:54:54 +00:00
|
|
|
#ifdef macintosh
|
2000-07-09 03:09:57 +00:00
|
|
|
extern char *PyMac_StrError(int);
|
1995-01-19 12:16:44 +00:00
|
|
|
#undef strerror
|
1995-02-18 14:52:19 +00:00
|
|
|
#define strerror PyMac_StrError
|
|
|
|
#endif /* macintosh */
|
|
|
|
|
1995-03-09 12:11:31 +00:00
|
|
|
#ifndef __STDC__
|
1997-04-11 20:44:04 +00:00
|
|
|
#ifndef MS_WINDOWS
|
2000-07-09 03:09:57 +00:00
|
|
|
extern char *strerror(int);
|
1995-03-09 12:11:31 +00:00
|
|
|
#endif
|
1997-04-11 20:44:04 +00:00
|
|
|
#endif
|
1990-11-02 17:50:28 +00:00
|
|
|
|
1999-04-21 15:27:31 +00:00
|
|
|
#ifdef MS_WIN32
|
|
|
|
#include "windows.h"
|
|
|
|
#include "winbase.h"
|
|
|
|
#endif
|
|
|
|
|
1990-10-14 12:07:46 +00:00
|
|
|
void
|
2000-07-22 18:47:25 +00:00
|
|
|
PyErr_Restore(PyObject *type, PyObject *value, PyObject *traceback)
|
1990-10-14 12:07:46 +00:00
|
|
|
{
|
1998-12-21 18:33:30 +00:00
|
|
|
PyThreadState *tstate = PyThreadState_GET();
|
1997-05-05 20:56:21 +00:00
|
|
|
PyObject *oldtype, *oldvalue, *oldtraceback;
|
|
|
|
|
|
|
|
if (traceback != NULL && !PyTraceBack_Check(traceback)) {
|
|
|
|
/* XXX Should never happen -- fatal error instead? */
|
|
|
|
Py_DECREF(traceback);
|
|
|
|
traceback = NULL;
|
|
|
|
}
|
1994-11-10 22:34:33 +00:00
|
|
|
|
1997-05-05 20:56:21 +00:00
|
|
|
/* Save these in locals to safeguard against recursive
|
|
|
|
invocation through Py_XDECREF */
|
|
|
|
oldtype = tstate->curexc_type;
|
|
|
|
oldvalue = tstate->curexc_value;
|
|
|
|
oldtraceback = tstate->curexc_traceback;
|
|
|
|
|
|
|
|
tstate->curexc_type = type;
|
|
|
|
tstate->curexc_value = value;
|
|
|
|
tstate->curexc_traceback = traceback;
|
|
|
|
|
|
|
|
Py_XDECREF(oldtype);
|
|
|
|
Py_XDECREF(oldvalue);
|
|
|
|
Py_XDECREF(oldtraceback);
|
1995-01-02 19:04:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2000-07-22 18:47:25 +00:00
|
|
|
PyErr_SetObject(PyObject *exception, PyObject *value)
|
1995-01-02 19:04:15 +00:00
|
|
|
{
|
1997-04-29 18:22:47 +00:00
|
|
|
Py_XINCREF(exception);
|
|
|
|
Py_XINCREF(value);
|
|
|
|
PyErr_Restore(exception, value, (PyObject *)NULL);
|
1990-10-14 12:07:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2000-07-22 18:47:25 +00:00
|
|
|
PyErr_SetNone(PyObject *exception)
|
1990-10-14 12:07:46 +00:00
|
|
|
{
|
1997-04-29 18:22:47 +00:00
|
|
|
PyErr_SetObject(exception, (PyObject *)NULL);
|
1990-10-14 12:07:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2000-07-22 18:47:25 +00:00
|
|
|
PyErr_SetString(PyObject *exception, const char *string)
|
1990-10-14 12:07:46 +00:00
|
|
|
{
|
1997-04-29 18:22:47 +00:00
|
|
|
PyObject *value = PyString_FromString(string);
|
|
|
|
PyErr_SetObject(exception, value);
|
|
|
|
Py_XDECREF(value);
|
1990-10-14 12:07:46 +00:00
|
|
|
}
|
|
|
|
|
1994-08-29 12:14:12 +00:00
|
|
|
|
1997-04-29 18:22:47 +00:00
|
|
|
PyObject *
|
2000-07-22 18:47:25 +00:00
|
|
|
PyErr_Occurred(void)
|
1990-10-14 12:07:46 +00:00
|
|
|
{
|
1997-05-05 20:56:21 +00:00
|
|
|
PyThreadState *tstate = PyThreadState_Get();
|
|
|
|
|
|
|
|
return tstate->curexc_type;
|
1990-10-14 12:07:46 +00:00
|
|
|
}
|
|
|
|
|
Three new C API functions:
- int PyErr_GivenExceptionMatches(obj1, obj2)
Returns 1 if obj1 and obj2 are the same object, or if obj1 is an
instance of type obj2, or of a class derived from obj2
- int PyErr_ExceptionMatches(obj)
Higher level wrapper around PyErr_GivenExceptionMatches() which uses
PyErr_Occurred() as obj1. This will be the more commonly called
function.
- void PyErr_NormalizeException(typeptr, valptr, tbptr)
Normalizes exceptions, and places the normalized values in the
arguments. If type is not a class, this does nothing. If type is a
class, then it makes sure that value is an instance of the class by:
1. if instance is of the type, or a class derived from type, it does
nothing.
2. otherwise it instantiates the class, using the value as an
argument. If value is None, it uses an empty arg tuple, and if
the value is a tuple, it uses just that.
1997-08-22 21:22:58 +00:00
|
|
|
|
|
|
|
int
|
2000-07-22 18:47:25 +00:00
|
|
|
PyErr_GivenExceptionMatches(PyObject *err, PyObject *exc)
|
Three new C API functions:
- int PyErr_GivenExceptionMatches(obj1, obj2)
Returns 1 if obj1 and obj2 are the same object, or if obj1 is an
instance of type obj2, or of a class derived from obj2
- int PyErr_ExceptionMatches(obj)
Higher level wrapper around PyErr_GivenExceptionMatches() which uses
PyErr_Occurred() as obj1. This will be the more commonly called
function.
- void PyErr_NormalizeException(typeptr, valptr, tbptr)
Normalizes exceptions, and places the normalized values in the
arguments. If type is not a class, this does nothing. If type is a
class, then it makes sure that value is an instance of the class by:
1. if instance is of the type, or a class derived from type, it does
nothing.
2. otherwise it instantiates the class, using the value as an
argument. If value is None, it uses an empty arg tuple, and if
the value is a tuple, it uses just that.
1997-08-22 21:22:58 +00:00
|
|
|
{
|
2000-05-02 19:27:51 +00:00
|
|
|
if (err == NULL || exc == NULL) {
|
|
|
|
/* maybe caused by "import exceptions" that failed early on */
|
|
|
|
return 0;
|
|
|
|
}
|
Three new C API functions:
- int PyErr_GivenExceptionMatches(obj1, obj2)
Returns 1 if obj1 and obj2 are the same object, or if obj1 is an
instance of type obj2, or of a class derived from obj2
- int PyErr_ExceptionMatches(obj)
Higher level wrapper around PyErr_GivenExceptionMatches() which uses
PyErr_Occurred() as obj1. This will be the more commonly called
function.
- void PyErr_NormalizeException(typeptr, valptr, tbptr)
Normalizes exceptions, and places the normalized values in the
arguments. If type is not a class, this does nothing. If type is a
class, then it makes sure that value is an instance of the class by:
1. if instance is of the type, or a class derived from type, it does
nothing.
2. otherwise it instantiates the class, using the value as an
argument. If value is None, it uses an empty arg tuple, and if
the value is a tuple, it uses just that.
1997-08-22 21:22:58 +00:00
|
|
|
if (PyTuple_Check(exc)) {
|
|
|
|
int i, n;
|
|
|
|
n = PyTuple_Size(exc);
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
/* Test recursively */
|
|
|
|
if (PyErr_GivenExceptionMatches(
|
|
|
|
err, PyTuple_GET_ITEM(exc, i)))
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
/* err might be an instance, so check its class. */
|
|
|
|
if (PyInstance_Check(err))
|
|
|
|
err = (PyObject*)((PyInstanceObject*)err)->in_class;
|
|
|
|
|
|
|
|
if (PyClass_Check(err) && PyClass_Check(exc))
|
|
|
|
return PyClass_IsSubclass(err, exc);
|
|
|
|
|
|
|
|
return err == exc;
|
|
|
|
}
|
1999-04-21 15:27:31 +00:00
|
|
|
|
Three new C API functions:
- int PyErr_GivenExceptionMatches(obj1, obj2)
Returns 1 if obj1 and obj2 are the same object, or if obj1 is an
instance of type obj2, or of a class derived from obj2
- int PyErr_ExceptionMatches(obj)
Higher level wrapper around PyErr_GivenExceptionMatches() which uses
PyErr_Occurred() as obj1. This will be the more commonly called
function.
- void PyErr_NormalizeException(typeptr, valptr, tbptr)
Normalizes exceptions, and places the normalized values in the
arguments. If type is not a class, this does nothing. If type is a
class, then it makes sure that value is an instance of the class by:
1. if instance is of the type, or a class derived from type, it does
nothing.
2. otherwise it instantiates the class, using the value as an
argument. If value is None, it uses an empty arg tuple, and if
the value is a tuple, it uses just that.
1997-08-22 21:22:58 +00:00
|
|
|
|
|
|
|
int
|
2000-07-22 18:47:25 +00:00
|
|
|
PyErr_ExceptionMatches(PyObject *exc)
|
Three new C API functions:
- int PyErr_GivenExceptionMatches(obj1, obj2)
Returns 1 if obj1 and obj2 are the same object, or if obj1 is an
instance of type obj2, or of a class derived from obj2
- int PyErr_ExceptionMatches(obj)
Higher level wrapper around PyErr_GivenExceptionMatches() which uses
PyErr_Occurred() as obj1. This will be the more commonly called
function.
- void PyErr_NormalizeException(typeptr, valptr, tbptr)
Normalizes exceptions, and places the normalized values in the
arguments. If type is not a class, this does nothing. If type is a
class, then it makes sure that value is an instance of the class by:
1. if instance is of the type, or a class derived from type, it does
nothing.
2. otherwise it instantiates the class, using the value as an
argument. If value is None, it uses an empty arg tuple, and if
the value is a tuple, it uses just that.
1997-08-22 21:22:58 +00:00
|
|
|
{
|
|
|
|
return PyErr_GivenExceptionMatches(PyErr_Occurred(), exc);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Used in many places to normalize a raised exception, including in
|
|
|
|
eval_code2(), do_raise(), and PyErr_Print()
|
|
|
|
*/
|
|
|
|
void
|
2000-07-22 18:47:25 +00:00
|
|
|
PyErr_NormalizeException(PyObject **exc, PyObject **val, PyObject **tb)
|
Three new C API functions:
- int PyErr_GivenExceptionMatches(obj1, obj2)
Returns 1 if obj1 and obj2 are the same object, or if obj1 is an
instance of type obj2, or of a class derived from obj2
- int PyErr_ExceptionMatches(obj)
Higher level wrapper around PyErr_GivenExceptionMatches() which uses
PyErr_Occurred() as obj1. This will be the more commonly called
function.
- void PyErr_NormalizeException(typeptr, valptr, tbptr)
Normalizes exceptions, and places the normalized values in the
arguments. If type is not a class, this does nothing. If type is a
class, then it makes sure that value is an instance of the class by:
1. if instance is of the type, or a class derived from type, it does
nothing.
2. otherwise it instantiates the class, using the value as an
argument. If value is None, it uses an empty arg tuple, and if
the value is a tuple, it uses just that.
1997-08-22 21:22:58 +00:00
|
|
|
{
|
|
|
|
PyObject *type = *exc;
|
|
|
|
PyObject *value = *val;
|
|
|
|
PyObject *inclass = NULL;
|
|
|
|
|
2000-08-07 19:18:27 +00:00
|
|
|
if (type == NULL) {
|
|
|
|
/* This is a bug. Should never happen. Don't dump core. */
|
|
|
|
PyErr_SetString(PyExc_SystemError,
|
|
|
|
"PyErr_NormalizeException() called without exception");
|
|
|
|
}
|
|
|
|
|
Three new C API functions:
- int PyErr_GivenExceptionMatches(obj1, obj2)
Returns 1 if obj1 and obj2 are the same object, or if obj1 is an
instance of type obj2, or of a class derived from obj2
- int PyErr_ExceptionMatches(obj)
Higher level wrapper around PyErr_GivenExceptionMatches() which uses
PyErr_Occurred() as obj1. This will be the more commonly called
function.
- void PyErr_NormalizeException(typeptr, valptr, tbptr)
Normalizes exceptions, and places the normalized values in the
arguments. If type is not a class, this does nothing. If type is a
class, then it makes sure that value is an instance of the class by:
1. if instance is of the type, or a class derived from type, it does
nothing.
2. otherwise it instantiates the class, using the value as an
argument. If value is None, it uses an empty arg tuple, and if
the value is a tuple, it uses just that.
1997-08-22 21:22:58 +00:00
|
|
|
/* If PyErr_SetNone() was used, the value will have been actually
|
|
|
|
set to NULL.
|
|
|
|
*/
|
|
|
|
if (!value) {
|
|
|
|
value = Py_None;
|
|
|
|
Py_INCREF(value);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (PyInstance_Check(value))
|
|
|
|
inclass = (PyObject*)((PyInstanceObject*)value)->in_class;
|
|
|
|
|
|
|
|
/* Normalize the exception so that if the type is a class, the
|
|
|
|
value will be an instance.
|
|
|
|
*/
|
|
|
|
if (PyClass_Check(type)) {
|
|
|
|
/* if the value was not an instance, or is not an instance
|
|
|
|
whose class is (or is derived from) type, then use the
|
|
|
|
value as an argument to instantiation of the type
|
|
|
|
class.
|
|
|
|
*/
|
|
|
|
if (!inclass || !PyClass_IsSubclass(inclass, type)) {
|
|
|
|
PyObject *args, *res;
|
|
|
|
|
|
|
|
if (value == Py_None)
|
|
|
|
args = Py_BuildValue("()");
|
|
|
|
else if (PyTuple_Check(value)) {
|
|
|
|
Py_INCREF(value);
|
|
|
|
args = value;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
args = Py_BuildValue("(O)", value);
|
|
|
|
|
|
|
|
if (args == NULL)
|
|
|
|
goto finally;
|
|
|
|
res = PyEval_CallObject(type, args);
|
|
|
|
Py_DECREF(args);
|
|
|
|
if (res == NULL)
|
|
|
|
goto finally;
|
|
|
|
Py_DECREF(value);
|
|
|
|
value = res;
|
|
|
|
}
|
1997-09-30 15:00:18 +00:00
|
|
|
/* if the class of the instance doesn't exactly match the
|
|
|
|
class of the type, believe the instance
|
|
|
|
*/
|
|
|
|
else if (inclass != type) {
|
|
|
|
Py_DECREF(type);
|
|
|
|
type = inclass;
|
|
|
|
Py_INCREF(type);
|
|
|
|
}
|
Three new C API functions:
- int PyErr_GivenExceptionMatches(obj1, obj2)
Returns 1 if obj1 and obj2 are the same object, or if obj1 is an
instance of type obj2, or of a class derived from obj2
- int PyErr_ExceptionMatches(obj)
Higher level wrapper around PyErr_GivenExceptionMatches() which uses
PyErr_Occurred() as obj1. This will be the more commonly called
function.
- void PyErr_NormalizeException(typeptr, valptr, tbptr)
Normalizes exceptions, and places the normalized values in the
arguments. If type is not a class, this does nothing. If type is a
class, then it makes sure that value is an instance of the class by:
1. if instance is of the type, or a class derived from type, it does
nothing.
2. otherwise it instantiates the class, using the value as an
argument. If value is None, it uses an empty arg tuple, and if
the value is a tuple, it uses just that.
1997-08-22 21:22:58 +00:00
|
|
|
}
|
|
|
|
*exc = type;
|
|
|
|
*val = value;
|
|
|
|
return;
|
|
|
|
finally:
|
1997-12-09 14:11:39 +00:00
|
|
|
Py_DECREF(type);
|
|
|
|
Py_DECREF(value);
|
Three new C API functions:
- int PyErr_GivenExceptionMatches(obj1, obj2)
Returns 1 if obj1 and obj2 are the same object, or if obj1 is an
instance of type obj2, or of a class derived from obj2
- int PyErr_ExceptionMatches(obj)
Higher level wrapper around PyErr_GivenExceptionMatches() which uses
PyErr_Occurred() as obj1. This will be the more commonly called
function.
- void PyErr_NormalizeException(typeptr, valptr, tbptr)
Normalizes exceptions, and places the normalized values in the
arguments. If type is not a class, this does nothing. If type is a
class, then it makes sure that value is an instance of the class by:
1. if instance is of the type, or a class derived from type, it does
nothing.
2. otherwise it instantiates the class, using the value as an
argument. If value is None, it uses an empty arg tuple, and if
the value is a tuple, it uses just that.
1997-08-22 21:22:58 +00:00
|
|
|
Py_XDECREF(*tb);
|
|
|
|
PyErr_Fetch(exc, val, tb);
|
|
|
|
/* normalize recursively */
|
|
|
|
PyErr_NormalizeException(exc, val, tb);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1990-10-14 12:07:46 +00:00
|
|
|
void
|
2000-07-22 18:47:25 +00:00
|
|
|
PyErr_Fetch(PyObject **p_type, PyObject **p_value, PyObject **p_traceback)
|
1990-10-14 12:07:46 +00:00
|
|
|
{
|
1997-05-05 20:56:21 +00:00
|
|
|
PyThreadState *tstate = PyThreadState_Get();
|
|
|
|
|
|
|
|
*p_type = tstate->curexc_type;
|
|
|
|
*p_value = tstate->curexc_value;
|
|
|
|
*p_traceback = tstate->curexc_traceback;
|
|
|
|
|
|
|
|
tstate->curexc_type = NULL;
|
|
|
|
tstate->curexc_value = NULL;
|
|
|
|
tstate->curexc_traceback = NULL;
|
1990-10-14 12:07:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2000-07-22 18:47:25 +00:00
|
|
|
PyErr_Clear(void)
|
1990-10-14 12:07:46 +00:00
|
|
|
{
|
1997-05-05 20:56:21 +00:00
|
|
|
PyErr_Restore(NULL, NULL, NULL);
|
1990-10-14 12:07:46 +00:00
|
|
|
}
|
1990-10-14 20:00:05 +00:00
|
|
|
|
|
|
|
/* Convenience functions to set a type error exception and return 0 */
|
|
|
|
|
|
|
|
int
|
2000-07-22 18:47:25 +00:00
|
|
|
PyErr_BadArgument(void)
|
1990-10-14 20:00:05 +00:00
|
|
|
{
|
1997-05-05 20:56:21 +00:00
|
|
|
PyErr_SetString(PyExc_TypeError,
|
|
|
|
"illegal argument type for built-in operation");
|
1990-10-14 20:00:05 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
1997-04-29 18:22:47 +00:00
|
|
|
PyObject *
|
2000-07-22 18:47:25 +00:00
|
|
|
PyErr_NoMemory(void)
|
1990-10-14 20:00:05 +00:00
|
|
|
{
|
2000-08-18 18:01:06 +00:00
|
|
|
if (PyErr_ExceptionMatches(PyExc_MemoryError))
|
|
|
|
/* already current */
|
|
|
|
return NULL;
|
|
|
|
|
1997-08-29 21:54:35 +00:00
|
|
|
/* raise the pre-allocated instance if it still exists */
|
|
|
|
if (PyExc_MemoryErrorInst)
|
|
|
|
PyErr_SetObject(PyExc_MemoryError, PyExc_MemoryErrorInst);
|
|
|
|
else
|
|
|
|
/* this will probably fail since there's no memory and hee,
|
|
|
|
hee, we have to instantiate this class
|
|
|
|
*/
|
|
|
|
PyErr_SetNone(PyExc_MemoryError);
|
|
|
|
|
1990-10-14 20:00:05 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
1997-04-29 18:22:47 +00:00
|
|
|
PyObject *
|
2000-07-22 18:47:25 +00:00
|
|
|
PyErr_SetFromErrnoWithFilename(PyObject *exc, char *filename)
|
1990-10-14 20:00:05 +00:00
|
|
|
{
|
1997-04-29 18:22:47 +00:00
|
|
|
PyObject *v;
|
1998-10-14 20:38:13 +00:00
|
|
|
char *s;
|
1994-08-29 12:14:12 +00:00
|
|
|
int i = errno;
|
2000-02-17 15:19:15 +00:00
|
|
|
#ifdef MS_WIN32
|
|
|
|
char *s_buf = NULL;
|
|
|
|
#endif
|
1995-02-18 14:52:19 +00:00
|
|
|
#ifdef EINTR
|
1997-04-29 18:22:47 +00:00
|
|
|
if (i == EINTR && PyErr_CheckSignals())
|
1991-10-20 20:14:56 +00:00
|
|
|
return NULL;
|
1995-02-18 14:52:19 +00:00
|
|
|
#endif
|
1998-10-14 20:38:13 +00:00
|
|
|
if (i == 0)
|
|
|
|
s = "Error"; /* Sometimes errno didn't get set */
|
|
|
|
else
|
1999-04-21 15:27:31 +00:00
|
|
|
#ifndef MS_WIN32
|
1998-10-14 20:38:13 +00:00
|
|
|
s = strerror(i);
|
1999-04-21 15:27:31 +00:00
|
|
|
#else
|
|
|
|
{
|
2000-02-17 15:19:15 +00:00
|
|
|
/* Note that the Win32 errors do not lineup with the
|
|
|
|
errno error. So if the error is in the MSVC error
|
|
|
|
table, we use it, otherwise we assume it really _is_
|
|
|
|
a Win32 error code
|
|
|
|
*/
|
2000-02-21 16:50:31 +00:00
|
|
|
if (i > 0 && i < _sys_nerr) {
|
2000-02-17 15:19:15 +00:00
|
|
|
s = _sys_errlist[i];
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
int len = FormatMessage(
|
|
|
|
FORMAT_MESSAGE_ALLOCATE_BUFFER |
|
|
|
|
FORMAT_MESSAGE_FROM_SYSTEM |
|
|
|
|
FORMAT_MESSAGE_IGNORE_INSERTS,
|
|
|
|
NULL, /* no message source */
|
|
|
|
i,
|
|
|
|
MAKELANGID(LANG_NEUTRAL,
|
|
|
|
SUBLANG_DEFAULT),
|
|
|
|
/* Default language */
|
|
|
|
(LPTSTR) &s_buf,
|
|
|
|
0, /* size not used */
|
|
|
|
NULL); /* no args */
|
|
|
|
s = s_buf;
|
|
|
|
/* remove trailing cr/lf and dots */
|
|
|
|
while (len > 0 && (s[len-1] <= ' ' || s[len-1] == '.'))
|
|
|
|
s[--len] = '\0';
|
|
|
|
}
|
1999-04-21 15:27:31 +00:00
|
|
|
}
|
|
|
|
#endif
|
2000-05-02 19:27:51 +00:00
|
|
|
if (filename != NULL)
|
1998-10-14 20:38:13 +00:00
|
|
|
v = Py_BuildValue("(iss)", i, s, filename);
|
1998-07-23 16:05:56 +00:00
|
|
|
else
|
1998-10-14 20:38:13 +00:00
|
|
|
v = Py_BuildValue("(is)", i, s);
|
1990-10-14 20:00:05 +00:00
|
|
|
if (v != NULL) {
|
1997-04-29 18:22:47 +00:00
|
|
|
PyErr_SetObject(exc, v);
|
|
|
|
Py_DECREF(v);
|
1990-10-14 20:00:05 +00:00
|
|
|
}
|
1999-04-21 15:27:31 +00:00
|
|
|
#ifdef MS_WIN32
|
2000-02-17 15:19:15 +00:00
|
|
|
LocalFree(s_buf);
|
1999-04-21 15:27:31 +00:00
|
|
|
#endif
|
1990-10-14 20:00:05 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
1999-04-21 15:27:31 +00:00
|
|
|
|
1998-07-23 16:05:56 +00:00
|
|
|
|
|
|
|
PyObject *
|
2000-07-22 18:47:25 +00:00
|
|
|
PyErr_SetFromErrno(PyObject *exc)
|
1998-07-23 16:05:56 +00:00
|
|
|
{
|
|
|
|
return PyErr_SetFromErrnoWithFilename(exc, NULL);
|
|
|
|
}
|
1990-10-21 22:09:12 +00:00
|
|
|
|
2000-02-17 15:19:15 +00:00
|
|
|
#ifdef MS_WINDOWS
|
|
|
|
/* Windows specific error code handling */
|
|
|
|
PyObject *PyErr_SetFromWindowsErrWithFilename(
|
2000-07-22 18:47:25 +00:00
|
|
|
int ierr,
|
2000-02-17 15:19:15 +00:00
|
|
|
const char *filename)
|
|
|
|
{
|
|
|
|
int len;
|
|
|
|
char *s;
|
|
|
|
PyObject *v;
|
|
|
|
DWORD err = (DWORD)ierr;
|
|
|
|
if (err==0) err = GetLastError();
|
|
|
|
len = FormatMessage(
|
|
|
|
/* Error API error */
|
|
|
|
FORMAT_MESSAGE_ALLOCATE_BUFFER |
|
|
|
|
FORMAT_MESSAGE_FROM_SYSTEM |
|
|
|
|
FORMAT_MESSAGE_IGNORE_INSERTS,
|
|
|
|
NULL, /* no message source */
|
|
|
|
err,
|
|
|
|
MAKELANGID(LANG_NEUTRAL,
|
|
|
|
SUBLANG_DEFAULT), /* Default language */
|
|
|
|
(LPTSTR) &s,
|
|
|
|
0, /* size not used */
|
|
|
|
NULL); /* no args */
|
|
|
|
/* remove trailing cr/lf and dots */
|
|
|
|
while (len > 0 && (s[len-1] <= ' ' || s[len-1] == '.'))
|
|
|
|
s[--len] = '\0';
|
2000-05-02 19:27:51 +00:00
|
|
|
if (filename != NULL)
|
2000-02-17 15:19:15 +00:00
|
|
|
v = Py_BuildValue("(iss)", err, s, filename);
|
|
|
|
else
|
|
|
|
v = Py_BuildValue("(is)", err, s);
|
|
|
|
if (v != NULL) {
|
2000-03-02 13:55:01 +00:00
|
|
|
PyErr_SetObject(PyExc_WindowsError, v);
|
2000-02-17 15:19:15 +00:00
|
|
|
Py_DECREF(v);
|
|
|
|
}
|
|
|
|
LocalFree(s);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
PyObject *PyErr_SetFromWindowsErr(int ierr)
|
|
|
|
{
|
|
|
|
return PyErr_SetFromWindowsErrWithFilename(ierr, NULL);
|
|
|
|
|
|
|
|
}
|
|
|
|
#endif /* MS_WINDOWS */
|
|
|
|
|
2000-08-24 22:38:39 +00:00
|
|
|
void
|
|
|
|
_PyErr_BadInternalCall(char *filename, int lineno)
|
|
|
|
{
|
|
|
|
PyErr_Format(PyExc_SystemError,
|
|
|
|
"%s:%d: bad argument to internal function",
|
|
|
|
filename, lineno);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Remove the preprocessor macro for PyErr_BadInternalCall() so that we can
|
|
|
|
export the entry point for existing object code: */
|
|
|
|
#undef PyErr_BadInternalCall
|
1990-10-21 22:09:12 +00:00
|
|
|
void
|
2000-07-22 18:47:25 +00:00
|
|
|
PyErr_BadInternalCall(void)
|
1990-10-21 22:09:12 +00:00
|
|
|
{
|
2000-08-24 22:38:39 +00:00
|
|
|
PyErr_Format(PyExc_SystemError,
|
|
|
|
"bad argument to internal function");
|
1990-10-21 22:09:12 +00:00
|
|
|
}
|
2000-08-24 22:38:39 +00:00
|
|
|
#define PyErr_BadInternalCall() _PyErr_BadInternalCall(__FILE__, __LINE__)
|
|
|
|
|
1997-02-14 17:09:47 +00:00
|
|
|
|
|
|
|
|
|
|
|
PyObject *
|
|
|
|
PyErr_Format(PyObject *exception, const char *format, ...)
|
|
|
|
{
|
|
|
|
va_list vargs;
|
|
|
|
char buffer[500]; /* Caller is responsible for limiting the format */
|
|
|
|
|
|
|
|
va_start(vargs, format);
|
|
|
|
|
|
|
|
vsprintf(buffer, format, vargs);
|
|
|
|
PyErr_SetString(exception, buffer);
|
|
|
|
return NULL;
|
|
|
|
}
|
1997-09-16 18:43:50 +00:00
|
|
|
|
|
|
|
|
|
|
|
PyObject *
|
2000-07-22 18:47:25 +00:00
|
|
|
PyErr_NewException(char *name, PyObject *base, PyObject *dict)
|
1997-09-16 18:43:50 +00:00
|
|
|
{
|
1997-10-03 19:50:55 +00:00
|
|
|
char *dot;
|
|
|
|
PyObject *modulename = NULL;
|
|
|
|
PyObject *classname = NULL;
|
|
|
|
PyObject *mydict = NULL;
|
|
|
|
PyObject *bases = NULL;
|
1997-09-16 18:43:50 +00:00
|
|
|
PyObject *result = NULL;
|
1997-10-03 19:50:55 +00:00
|
|
|
dot = strrchr(name, '.');
|
|
|
|
if (dot == NULL) {
|
|
|
|
PyErr_SetString(PyExc_SystemError,
|
|
|
|
"PyErr_NewException: name must be module.class");
|
1997-09-16 18:43:50 +00:00
|
|
|
return NULL;
|
1997-10-03 19:50:55 +00:00
|
|
|
}
|
|
|
|
if (base == NULL)
|
|
|
|
base = PyExc_Exception;
|
|
|
|
if (!PyClass_Check(base)) {
|
|
|
|
/* Must be using string-based standard exceptions (-X) */
|
|
|
|
return PyString_FromString(name);
|
|
|
|
}
|
1997-09-16 18:43:50 +00:00
|
|
|
if (dict == NULL) {
|
1997-10-03 19:50:55 +00:00
|
|
|
dict = mydict = PyDict_New();
|
1997-09-16 18:43:50 +00:00
|
|
|
if (dict == NULL)
|
|
|
|
goto failure;
|
|
|
|
}
|
1997-10-03 19:50:55 +00:00
|
|
|
if (PyDict_GetItemString(dict, "__module__") == NULL) {
|
|
|
|
modulename = PyString_FromStringAndSize(name, (int)(dot-name));
|
|
|
|
if (modulename == NULL)
|
|
|
|
goto failure;
|
|
|
|
if (PyDict_SetItemString(dict, "__module__", modulename) != 0)
|
|
|
|
goto failure;
|
|
|
|
}
|
|
|
|
classname = PyString_FromString(dot+1);
|
|
|
|
if (classname == NULL)
|
|
|
|
goto failure;
|
|
|
|
bases = Py_BuildValue("(O)", base);
|
|
|
|
if (bases == NULL)
|
1997-09-16 18:43:50 +00:00
|
|
|
goto failure;
|
1997-10-03 19:50:55 +00:00
|
|
|
result = PyClass_New(bases, dict, classname);
|
1997-09-16 18:43:50 +00:00
|
|
|
failure:
|
1997-10-03 19:50:55 +00:00
|
|
|
Py_XDECREF(bases);
|
|
|
|
Py_XDECREF(mydict);
|
|
|
|
Py_XDECREF(classname);
|
|
|
|
Py_XDECREF(modulename);
|
1997-09-16 18:43:50 +00:00
|
|
|
return result;
|
|
|
|
}
|