1991-02-19 12:39:46 +00:00
|
|
|
/***********************************************************
|
1995-01-04 19:12:13 +00:00
|
|
|
Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
|
|
|
|
The Netherlands.
|
1991-02-19 12:39:46 +00:00
|
|
|
|
|
|
|
All Rights Reserved
|
|
|
|
|
1996-10-25 14:44:06 +00:00
|
|
|
Permission to use, copy, modify, and distribute this software and its
|
|
|
|
documentation for any purpose and without fee is hereby granted,
|
1991-02-19 12:39:46 +00:00
|
|
|
provided that the above copyright notice appear in all copies and that
|
1996-10-25 14:44:06 +00:00
|
|
|
both that copyright notice and this permission notice appear in
|
1991-02-19 12:39:46 +00:00
|
|
|
supporting documentation, and that the names of Stichting Mathematisch
|
1996-10-25 14:44:06 +00:00
|
|
|
Centrum or CWI or Corporation for National Research Initiatives or
|
|
|
|
CNRI not be used in advertising or publicity pertaining to
|
|
|
|
distribution of the software without specific, written prior
|
|
|
|
permission.
|
1991-02-19 12:39:46 +00:00
|
|
|
|
1996-10-25 14:44:06 +00:00
|
|
|
While CWI is the initial source for this software, a modified version
|
|
|
|
is made available by the Corporation for National Research Initiatives
|
|
|
|
(CNRI) at the Internet address ftp://ftp.python.org.
|
|
|
|
|
|
|
|
STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
|
|
|
|
REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
|
|
|
|
MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
|
|
|
|
CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
|
|
|
|
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
|
|
|
|
PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
|
|
|
TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
|
|
|
PERFORMANCE OF THIS SOFTWARE.
|
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
|
|
|
|
1995-06-27 13:15:15 +00:00
|
|
|
#ifdef SYMANTEC__CFM68K__
|
1995-02-18 14:52:19 +00:00
|
|
|
#pragma lib_export on
|
|
|
|
#endif
|
|
|
|
|
1994-12-14 12:54:54 +00:00
|
|
|
#ifdef macintosh
|
1997-04-29 18:22:47 +00:00
|
|
|
extern char *PyMac_StrError Py_PROTO((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
|
1997-04-29 18:22:47 +00:00
|
|
|
extern char *strerror Py_PROTO((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
|
1997-05-05 20:56:21 +00:00
|
|
|
PyErr_Restore(type, value, traceback)
|
|
|
|
PyObject *type;
|
1997-04-29 18:22:47 +00:00
|
|
|
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
|
1997-04-29 18:22:47 +00:00
|
|
|
PyErr_SetObject(exception, value)
|
|
|
|
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
|
1997-04-29 18:22:47 +00:00
|
|
|
PyErr_SetNone(exception)
|
|
|
|
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
|
1997-04-29 18:22:47 +00:00
|
|
|
PyErr_SetString(exception, string)
|
|
|
|
PyObject *exception;
|
1996-12-10 15:33:34 +00:00
|
|
|
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 *
|
|
|
|
PyErr_Occurred()
|
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
|
|
|
|
PyErr_GivenExceptionMatches(err, exc)
|
|
|
|
PyObject *err, *exc;
|
|
|
|
{
|
|
|
|
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
|
|
|
|
PyErr_ExceptionMatches(exc)
|
|
|
|
PyObject *exc;
|
|
|
|
{
|
|
|
|
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
|
|
|
|
PyErr_NormalizeException(exc, val, tb)
|
|
|
|
PyObject **exc;
|
|
|
|
PyObject **val;
|
|
|
|
PyObject **tb;
|
|
|
|
{
|
|
|
|
PyObject *type = *exc;
|
|
|
|
PyObject *value = *val;
|
|
|
|
PyObject *inclass = NULL;
|
|
|
|
|
|
|
|
/* 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
|
1997-05-05 20:56:21 +00:00
|
|
|
PyErr_Fetch(p_type, p_value, p_traceback)
|
|
|
|
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
|
1997-04-29 18:22:47 +00:00
|
|
|
PyErr_Clear()
|
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
|
1997-04-29 18:22:47 +00:00
|
|
|
PyErr_BadArgument()
|
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 *
|
|
|
|
PyErr_NoMemory()
|
1990-10-14 20:00:05 +00:00
|
|
|
{
|
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 *
|
1998-07-23 16:05:56 +00:00
|
|
|
PyErr_SetFromErrnoWithFilename(exc, filename)
|
1997-04-29 18:22:47 +00:00
|
|
|
PyObject *exc;
|
1998-07-23 16:05:56 +00:00
|
|
|
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
|
1998-07-23 16:05:56 +00:00
|
|
|
if (filename != NULL && Py_UseClassExceptionsFlag)
|
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 *
|
|
|
|
PyErr_SetFromErrno(exc)
|
|
|
|
PyObject *exc;
|
|
|
|
{
|
|
|
|
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(
|
|
|
|
int ierr,
|
|
|
|
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';
|
|
|
|
if (filename != NULL && Py_UseClassExceptionsFlag)
|
|
|
|
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 */
|
|
|
|
|
1990-10-21 22:09:12 +00:00
|
|
|
void
|
1997-04-29 18:22:47 +00:00
|
|
|
PyErr_BadInternalCall()
|
1990-10-21 22:09:12 +00:00
|
|
|
{
|
1997-05-05 20:56:21 +00:00
|
|
|
PyErr_SetString(PyExc_SystemError,
|
|
|
|
"bad argument to internal function");
|
1990-10-21 22:09:12 +00:00
|
|
|
}
|
1997-02-14 17:09:47 +00:00
|
|
|
|
|
|
|
|
|
|
|
#ifdef HAVE_STDARG_PROTOTYPES
|
|
|
|
PyObject *
|
|
|
|
PyErr_Format(PyObject *exception, const char *format, ...)
|
|
|
|
#else
|
|
|
|
PyObject *
|
|
|
|
PyErr_Format(exception, format, va_alist)
|
|
|
|
PyObject *exception;
|
|
|
|
const char *format;
|
|
|
|
va_dcl
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
va_list vargs;
|
|
|
|
char buffer[500]; /* Caller is responsible for limiting the format */
|
|
|
|
|
|
|
|
#ifdef HAVE_STDARG_PROTOTYPES
|
|
|
|
va_start(vargs, format);
|
|
|
|
#else
|
|
|
|
va_start(vargs);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
vsprintf(buffer, format, vargs);
|
|
|
|
PyErr_SetString(exception, buffer);
|
|
|
|
return NULL;
|
|
|
|
}
|
1997-09-16 18:43:50 +00:00
|
|
|
|
|
|
|
|
|
|
|
PyObject *
|
|
|
|
PyErr_NewException(name, base, dict)
|
1997-10-03 19:50:55 +00:00
|
|
|
char *name; /* modulename.classname */
|
1997-09-16 18:43:50 +00:00
|
|
|
PyObject *base;
|
|
|
|
PyObject *dict;
|
|
|
|
{
|
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;
|
|
|
|
}
|