Python/errors.c

   1 /***********************************************************
   2 Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
   3 The Netherlands.
   4
   5                         All Rights Reserved
   6
   7 Permission to use, copy, modify, and distribute this software and its
   8 documentation for any purpose and without fee is hereby granted,
   9 provided that the above copyright notice appear in all copies and that
  10 both that copyright notice and this permission notice appear in
  11 supporting documentation, and that the names of Stichting Mathematisch
  12 Centrum or CWI or Corporation for National Research Initiatives or
  13 CNRI not be used in advertising or publicity pertaining to
  14 distribution of the software without specific, written prior
  15 permission.
  16
  17 While CWI is the initial source for this software, a modified version
  18 is made available by the Corporation for National Research Initiatives
  19 (CNRI) at the Internet address ftp://ftp.python.org.
  20
  21 STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
  22 REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
  23 MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
  24 CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  25 DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  26 PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  27 TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  28 PERFORMANCE OF THIS SOFTWARE.
  29
  30 ******************************************************************/
  31
  32 /* Error handling */
  33
  34 #include "Python.h"
  35
  36 #ifdef SYMANTEC__CFM68K__
  37 #pragma lib_export on
  38 #endif
  39
  40 #ifdef macintosh
  41 extern char *PyMac_StrError Py_PROTO((int));
  42 #undef strerror
  43 #define strerror PyMac_StrError
  44 #endif /* macintosh */
  45
  46 #ifndef __STDC__
  47 #ifndef MS_WINDOWS
  48 extern char *strerror Py_PROTO((int));
  49 #endif
  50 #endif
  51
  52 void
  53 PyErr_Restore(type, value, traceback)
  54         PyObject *type;
  55         PyObject *value;
  56         PyObject *traceback;
  57 {
  58         PyThreadState *tstate = PyThreadState_Get();
  59         PyObject *oldtype, *oldvalue, *oldtraceback;
  60
  61         if (traceback != NULL && !PyTraceBack_Check(traceback)) {
  62                 /* XXX Should never happen -- fatal error instead? */
  63                 Py_DECREF(traceback);
  64                 traceback = NULL;
  65         }
  66
  67         /* Save these in locals to safeguard against recursive
  68            invocation through Py_XDECREF */
  69         oldtype = tstate->curexc_type;
  70         oldvalue = tstate->curexc_value;
  71         oldtraceback = tstate->curexc_traceback;
  72
  73         tstate->curexc_type = type;
  74         tstate->curexc_value = value;
  75         tstate->curexc_traceback = traceback;
  76
  77         Py_XDECREF(oldtype);
  78         Py_XDECREF(oldvalue);
  79         Py_XDECREF(oldtraceback);
  80 }
  81
  82 void
  83 PyErr_SetObject(exception, value)
  84         PyObject *exception;
  85         PyObject *value;
  86 {
  87         Py_XINCREF(exception);
  88         Py_XINCREF(value);
  89         PyErr_Restore(exception, value, (PyObject *)NULL);
  90 }
  91
  92 void
  93 PyErr_SetNone(exception)
  94         PyObject *exception;
  95 {
  96         PyErr_SetObject(exception, (PyObject *)NULL);
  97 }
  98
  99 void
 100 PyErr_SetString(exception, string)
 101         PyObject *exception;
 102         const char *string;
 103 {
 104         PyObject *value = PyString_FromString(string);
 105         PyErr_SetObject(exception, value);
 106         Py_XDECREF(value);
 107 }
 108
 109
 110 PyObject *
 111 PyErr_Occurred()
 112 {
 113         PyThreadState *tstate = PyThreadState_Get();
 114
 115         return tstate->curexc_type;
 116 }
 117
 118
 119 int
 120 PyErr_GivenExceptionMatches(err, exc)
 121      PyObject *err, *exc;
 122 {
 123         if (PyTuple_Check(exc)) {
 124                 int i, n;
 125                 n = PyTuple_Size(exc);
 126                 for (i = 0; i < n; i++) {
 127                         /* Test recursively */
 128                      if (PyErr_GivenExceptionMatches(
 129                              err, PyTuple_GET_ITEM(exc, i)))
 130                      {
 131                              return 1;
 132                      }
 133                 }
 134                 return 0;
 135         }
 136         /* err might be an instance, so check its class. */
 137         if (PyInstance_Check(err))
 138                 err = (PyObject*)((PyInstanceObject*)err)->in_class;
 139
 140         if (PyClass_Check(err) && PyClass_Check(exc))
 141                 return PyClass_IsSubclass(err, exc);
 142
 143         return err == exc;
 144 }
 145
 146
 147 int
 148 PyErr_ExceptionMatches(exc)
 149      PyObject *exc;
 150 {
 151         return PyErr_GivenExceptionMatches(PyErr_Occurred(), exc);
 152 }
 153
 154
 155 /* Used in many places to normalize a raised exception, including in
 156    eval_code2(), do_raise(), and PyErr_Print()
 157 */
 158 void
 159 PyErr_NormalizeException(exc, val, tb)
 160      PyObject **exc;
 161      PyObject **val;
 162      PyObject **tb;
 163 {
 164         PyObject *type = *exc;
 165         PyObject *value = *val;
 166         PyObject *inclass = NULL;
 167
 168         /* If PyErr_SetNone() was used, the value will have been actually
 169            set to NULL.
 170         */
 171         if (!value) {
 172                 value = Py_None;
 173                 Py_INCREF(value);
 174         }
 175
 176         if (PyInstance_Check(value))
 177                 inclass = (PyObject*)((PyInstanceObject*)value)->in_class;
 178
 179         /* Normalize the exception so that if the type is a class, the
 180            value will be an instance.
 181         */
 182         if (PyClass_Check(type)) {
 183                 /* if the value was not an instance, or is not an instance
 184                    whose class is (or is derived from) type, then use the
 185                    value as an argument to instantiation of the type
 186                    class.
 187                 */
 188                 if (!inclass || !PyClass_IsSubclass(inclass, type)) {
 189                         PyObject *args, *res;
 190
 191                         if (value == Py_None)
 192                                 args = Py_BuildValue("()");
 193                         else if (PyTuple_Check(value)) {
 194                                 Py_INCREF(value);
 195                                 args = value;
 196                         }
 197                         else
 198                                 args = Py_BuildValue("(O)", value);
 199
 200                         if (args == NULL)
 201                                 goto finally;
 202                         res = PyEval_CallObject(type, args);
 203                         Py_DECREF(args);
 204                         if (res == NULL)
 205                                 goto finally;
 206                         Py_DECREF(value);
 207                         value = res;
 208                 }
 209                 /* if the class of the instance doesn't exactly match the
 210                    class of the type, believe the instance
 211                 */
 212                 else if (inclass != type) {
 213                         Py_DECREF(type);
 214                         type = inclass;
 215                         Py_INCREF(type);
 216                 }
 217         }
 218         *exc = type;
 219         *val = value;
 220         return;
 221 finally:
 222         Py_DECREF(type);
 223         Py_DECREF(value);
 224         Py_XDECREF(*tb);
 225         PyErr_Fetch(exc, val, tb);
 226         /* normalize recursively */
 227         PyErr_NormalizeException(exc, val, tb);
 228 }
 229
 230
 231 void
 232 PyErr_Fetch(p_type, p_value, p_traceback)
 233         PyObject **p_type;
 234         PyObject **p_value;
 235         PyObject **p_traceback;
 236 {
 237         PyThreadState *tstate = PyThreadState_Get();
 238
 239         *p_type = tstate->curexc_type;
 240         *p_value = tstate->curexc_value;
 241         *p_traceback = tstate->curexc_traceback;
 242
 243         tstate->curexc_type = NULL;
 244         tstate->curexc_value = NULL;
 245         tstate->curexc_traceback = NULL;
 246 }
 247
 248 void
 249 PyErr_Clear()
 250 {
 251         PyErr_Restore(NULL, NULL, NULL);
 252 }
 253
 254 /* Convenience functions to set a type error exception and return 0 */
 255
 256 int
 257 PyErr_BadArgument()
 258 {
 259         PyErr_SetString(PyExc_TypeError,
 260                         "illegal argument type for built-in operation");
 261         return 0;
 262 }
 263
 264 PyObject *
 265 PyErr_NoMemory()
 266 {
 267         /* raise the pre-allocated instance if it still exists */
 268         if (PyExc_MemoryErrorInst)
 269                 PyErr_SetObject(PyExc_MemoryError, PyExc_MemoryErrorInst);
 270         else
 271                 /* this will probably fail since there's no memory and hee,
 272                    hee, we have to instantiate this class
 273                 */
 274                 PyErr_SetNone(PyExc_MemoryError);
 275
 276         return NULL;
 277 }
 278
 279 PyObject *
 280 PyErr_SetFromErrnoWithFilename(exc, filename)
 281         PyObject *exc;
 282         char *filename;
 283 {
 284         PyObject *v;
 285         char *s;
 286         int i = errno;
 287 #ifdef EINTR
 288         if (i == EINTR && PyErr_CheckSignals())
 289                 return NULL;
 290 #endif
 291         if (i == 0)
 292                 s = "Error"; /* Sometimes errno didn't get set */
 293         else
 294                 s = strerror(i);
 295         if (filename != NULL && Py_UseClassExceptionsFlag)
 296                 v = Py_BuildValue("(iss)", i, s, filename);
 297         else
 298                 v = Py_BuildValue("(is)", i, s);
 299         if (v != NULL) {
 300                 PyErr_SetObject(exc, v);
 301                 Py_DECREF(v);
 302         }
 303         return NULL;
 304 }
 305
 306
 307 PyObject *
 308 PyErr_SetFromErrno(exc)
 309         PyObject *exc;
 310 {
 311         return PyErr_SetFromErrnoWithFilename(exc, NULL);
 312 }
 313
 314 void
 315 PyErr_BadInternalCall()
 316 {
 317         PyErr_SetString(PyExc_SystemError,
 318                         "bad argument to internal function");
 319 }
 320
 321
 322 #ifdef HAVE_STDARG_PROTOTYPES
 323 PyObject *
 324 PyErr_Format(PyObject *exception, const char *format, ...)
 325 #else
 326 PyObject *
 327 PyErr_Format(exception, format, va_alist)
 328         PyObject *exception;
 329         const char *format;
 330         va_dcl
 331 #endif
 332 {
 333         va_list vargs;
 334         char buffer[500]; /* Caller is responsible for limiting the format */
 335
 336 #ifdef HAVE_STDARG_PROTOTYPES
 337         va_start(vargs, format);
 338 #else
 339         va_start(vargs);
 340 #endif
 341
 342         vsprintf(buffer, format, vargs);
 343         PyErr_SetString(exception, buffer);
 344         return NULL;
 345 }
 346
 347
 348 PyObject *
 349 PyErr_NewException(name, base, dict)
 350         char *name; /* modulename.classname */
 351         PyObject *base;
 352         PyObject *dict;
 353 {
 354         char *dot;
 355         PyObject *modulename = NULL;
 356         PyObject *classname = NULL;
 357         PyObject *mydict = NULL;
 358         PyObject *bases = NULL;
 359         PyObject *result = NULL;
 360         dot = strrchr(name, '.');
 361         if (dot == NULL) {
 362                 PyErr_SetString(PyExc_SystemError,
 363                         "PyErr_NewException: name must be module.class");
 364                 return NULL;
 365         }
 366         if (base == NULL)
 367                 base = PyExc_Exception;
 368         if (!PyClass_Check(base)) {
 369                 /* Must be using string-based standard exceptions (-X) */
 370                 return PyString_FromString(name);
 371         }
 372         if (dict == NULL) {
 373                 dict = mydict = PyDict_New();
 374                 if (dict == NULL)
 375                         goto failure;
 376         }
 377         if (PyDict_GetItemString(dict, "__module__") == NULL) {
 378                 modulename = PyString_FromStringAndSize(name, (int)(dot-name));
 379                 if (modulename == NULL)
 380                         goto failure;
 381                 if (PyDict_SetItemString(dict, "__module__", modulename) != 0)
 382                         goto failure;
 383         }
 384         classname = PyString_FromString(dot+1);
 385         if (classname == NULL)
 386                 goto failure;
 387         bases = Py_BuildValue("(O)", base);
 388         if (bases == NULL)
 389                 goto failure;
 390         result = PyClass_New(bases, dict, classname);
 391   failure:
 392         Py_XDECREF(bases);
 393         Py_XDECREF(mydict);
 394         Py_XDECREF(classname);
 395         Py_XDECREF(modulename);
 396         return result;
 397 }