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 #ifdef MS_WIN32
  53 #include "windows.h"
  54 #include "winbase.h"
  55 #endif
  56
  57 void
  58 PyErr_Restore(type, value, traceback)
  59         PyObject *type;
  60         PyObject *value;
  61         PyObject *traceback;
  62 {
  63         PyThreadState *tstate = PyThreadState_GET();
  64         PyObject *oldtype, *oldvalue, *oldtraceback;
  65
  66         if (traceback != NULL && !PyTraceBack_Check(traceback)) {
  67                 /* XXX Should never happen -- fatal error instead? */
  68                 Py_DECREF(traceback);
  69                 traceback = NULL;
  70         }
  71
  72         /* Save these in locals to safeguard against recursive
  73            invocation through Py_XDECREF */
  74         oldtype = tstate->curexc_type;
  75         oldvalue = tstate->curexc_value;
  76         oldtraceback = tstate->curexc_traceback;
  77
  78         tstate->curexc_type = type;
  79         tstate->curexc_value = value;
  80         tstate->curexc_traceback = traceback;
  81
  82         Py_XDECREF(oldtype);
  83         Py_XDECREF(oldvalue);
  84         Py_XDECREF(oldtraceback);
  85 }
  86
  87 void
  88 PyErr_SetObject(exception, value)
  89         PyObject *exception;
  90         PyObject *value;
  91 {
  92         Py_XINCREF(exception);
  93         Py_XINCREF(value);
  94         PyErr_Restore(exception, value, (PyObject *)NULL);
  95 }
  96
  97 void
  98 PyErr_SetNone(exception)
  99         PyObject *exception;
 100 {
 101         PyErr_SetObject(exception, (PyObject *)NULL);
 102 }
 103
 104 void
 105 PyErr_SetString(exception, string)
 106         PyObject *exception;
 107         const char *string;
 108 {
 109         PyObject *value = PyString_FromString(string);
 110         PyErr_SetObject(exception, value);
 111         Py_XDECREF(value);
 112 }
 113
 114
 115 PyObject *
 116 PyErr_Occurred()
 117 {
 118         PyThreadState *tstate = PyThreadState_Get();
 119
 120         return tstate->curexc_type;
 121 }
 122
 123
 124 int
 125 PyErr_GivenExceptionMatches(err, exc)
 126      PyObject *err, *exc;
 127 {
 128         if (PyTuple_Check(exc)) {
 129                 int i, n;
 130                 n = PyTuple_Size(exc);
 131                 for (i = 0; i < n; i++) {
 132                         /* Test recursively */
 133                      if (PyErr_GivenExceptionMatches(
 134                              err, PyTuple_GET_ITEM(exc, i)))
 135                      {
 136                              return 1;
 137                      }
 138                 }
 139                 return 0;
 140         }
 141         /* err might be an instance, so check its class. */
 142         if (PyInstance_Check(err))
 143                 err = (PyObject*)((PyInstanceObject*)err)->in_class;
 144
 145         if (PyClass_Check(err) && PyClass_Check(exc))
 146                 return PyClass_IsSubclass(err, exc);
 147
 148         return err == exc;
 149 }
 150
 151
 152 int
 153 PyErr_ExceptionMatches(exc)
 154      PyObject *exc;
 155 {
 156         return PyErr_GivenExceptionMatches(PyErr_Occurred(), exc);
 157 }
 158
 159
 160 /* Used in many places to normalize a raised exception, including in
 161    eval_code2(), do_raise(), and PyErr_Print()
 162 */
 163 void
 164 PyErr_NormalizeException(exc, val, tb)
 165      PyObject **exc;
 166      PyObject **val;
 167      PyObject **tb;
 168 {
 169         PyObject *type = *exc;
 170         PyObject *value = *val;
 171         PyObject *inclass = NULL;
 172
 173         /* If PyErr_SetNone() was used, the value will have been actually
 174            set to NULL.
 175         */
 176         if (!value) {
 177                 value = Py_None;
 178                 Py_INCREF(value);
 179         }
 180
 181         if (PyInstance_Check(value))
 182                 inclass = (PyObject*)((PyInstanceObject*)value)->in_class;
 183
 184         /* Normalize the exception so that if the type is a class, the
 185            value will be an instance.
 186         */
 187         if (PyClass_Check(type)) {
 188                 /* if the value was not an instance, or is not an instance
 189                    whose class is (or is derived from) type, then use the
 190                    value as an argument to instantiation of the type
 191                    class.
 192                 */
 193                 if (!inclass || !PyClass_IsSubclass(inclass, type)) {
 194                         PyObject *args, *res;
 195
 196                         if (value == Py_None)
 197                                 args = Py_BuildValue("()");
 198                         else if (PyTuple_Check(value)) {
 199                                 Py_INCREF(value);
 200                                 args = value;
 201                         }
 202                         else
 203                                 args = Py_BuildValue("(O)", value);
 204
 205                         if (args == NULL)
 206                                 goto finally;
 207                         res = PyEval_CallObject(type, args);
 208                         Py_DECREF(args);
 209                         if (res == NULL)
 210                                 goto finally;
 211                         Py_DECREF(value);
 212                         value = res;
 213                 }
 214                 /* if the class of the instance doesn't exactly match the
 215                    class of the type, believe the instance
 216                 */
 217                 else if (inclass != type) {
 218                         Py_DECREF(type);
 219                         type = inclass;
 220                         Py_INCREF(type);
 221                 }
 222         }
 223         *exc = type;
 224         *val = value;
 225         return;
 226 finally:
 227         Py_DECREF(type);
 228         Py_DECREF(value);
 229         Py_XDECREF(*tb);
 230         PyErr_Fetch(exc, val, tb);
 231         /* normalize recursively */
 232         PyErr_NormalizeException(exc, val, tb);
 233 }
 234
 235
 236 void
 237 PyErr_Fetch(p_type, p_value, p_traceback)
 238         PyObject **p_type;
 239         PyObject **p_value;
 240         PyObject **p_traceback;
 241 {
 242         PyThreadState *tstate = PyThreadState_Get();
 243
 244         *p_type = tstate->curexc_type;
 245         *p_value = tstate->curexc_value;
 246         *p_traceback = tstate->curexc_traceback;
 247
 248         tstate->curexc_type = NULL;
 249         tstate->curexc_value = NULL;
 250         tstate->curexc_traceback = NULL;
 251 }
 252
 253 void
 254 PyErr_Clear()
 255 {
 256         PyErr_Restore(NULL, NULL, NULL);
 257 }
 258
 259 /* Convenience functions to set a type error exception and return 0 */
 260
 261 int
 262 PyErr_BadArgument()
 263 {
 264         PyErr_SetString(PyExc_TypeError,
 265                         "illegal argument type for built-in operation");
 266         return 0;
 267 }
 268
 269 PyObject *
 270 PyErr_NoMemory()
 271 {
 272         /* raise the pre-allocated instance if it still exists */
 273         if (PyExc_MemoryErrorInst)
 274                 PyErr_SetObject(PyExc_MemoryError, PyExc_MemoryErrorInst);
 275         else
 276                 /* this will probably fail since there's no memory and hee,
 277                    hee, we have to instantiate this class
 278                 */
 279                 PyErr_SetNone(PyExc_MemoryError);
 280
 281         return NULL;
 282 }
 283
 284 PyObject *
 285 PyErr_SetFromErrnoWithFilename(exc, filename)
 286         PyObject *exc;
 287         char *filename;
 288 {
 289         PyObject *v;
 290         char *s;
 291         int i = errno;
 292 #ifdef EINTR
 293         if (i == EINTR && PyErr_CheckSignals())
 294                 return NULL;
 295 #endif
 296         if (i == 0)
 297                 s = "Error"; /* Sometimes errno didn't get set */
 298         else
 299 #ifndef MS_WIN32
 300                 s = strerror(i);
 301 #else
 302         {
 303                 int len = FormatMessage(
 304                         FORMAT_MESSAGE_ALLOCATE_BUFFER |
 305                         FORMAT_MESSAGE_FROM_SYSTEM |
 306                         FORMAT_MESSAGE_IGNORE_INSERTS,
 307                         NULL,   /* no message source */
 308                         i,
 309                         MAKELANGID(LANG_NEUTRAL,
 310                                    SUBLANG_DEFAULT), /* Default language */
 311                         (LPTSTR) &s,
 312                         0,      /* size not used */
 313                         NULL);  /* no args */
 314                 /* remove trailing cr/lf and dots */
 315                 while (len > 0 && s[len-1] <= '.')
 316                         s[--len] = '\0';
 317         }
 318 #endif
 319         if (filename != NULL && Py_UseClassExceptionsFlag)
 320                 v = Py_BuildValue("(iss)", i, s, filename);
 321         else
 322                 v = Py_BuildValue("(is)", i, s);
 323         if (v != NULL) {
 324                 PyErr_SetObject(exc, v);
 325                 Py_DECREF(v);
 326         }
 327 #ifdef MS_WIN32
 328         LocalFree(s);
 329 #endif
 330         return NULL;
 331 }
 332
 333
 334 PyObject *
 335 PyErr_SetFromErrno(exc)
 336         PyObject *exc;
 337 {
 338         return PyErr_SetFromErrnoWithFilename(exc, NULL);
 339 }
 340
 341 void
 342 PyErr_BadInternalCall()
 343 {
 344         PyErr_SetString(PyExc_SystemError,
 345                         "bad argument to internal function");
 346 }
 347
 348
 349 #ifdef HAVE_STDARG_PROTOTYPES
 350 PyObject *
 351 PyErr_Format(PyObject *exception, const char *format, ...)
 352 #else
 353 PyObject *
 354 PyErr_Format(exception, format, va_alist)
 355         PyObject *exception;
 356         const char *format;
 357         va_dcl
 358 #endif
 359 {
 360         va_list vargs;
 361         char buffer[500]; /* Caller is responsible for limiting the format */
 362
 363 #ifdef HAVE_STDARG_PROTOTYPES
 364         va_start(vargs, format);
 365 #else
 366         va_start(vargs);
 367 #endif
 368
 369         vsprintf(buffer, format, vargs);
 370         PyErr_SetString(exception, buffer);
 371         return NULL;
 372 }
 373
 374
 375 PyObject *
 376 PyErr_NewException(name, base, dict)
 377         char *name; /* modulename.classname */
 378         PyObject *base;
 379         PyObject *dict;
 380 {
 381         char *dot;
 382         PyObject *modulename = NULL;
 383         PyObject *classname = NULL;
 384         PyObject *mydict = NULL;
 385         PyObject *bases = NULL;
 386         PyObject *result = NULL;
 387         dot = strrchr(name, '.');
 388         if (dot == NULL) {
 389                 PyErr_SetString(PyExc_SystemError,
 390                         "PyErr_NewException: name must be module.class");
 391                 return NULL;
 392         }
 393         if (base == NULL)
 394                 base = PyExc_Exception;
 395         if (!PyClass_Check(base)) {
 396                 /* Must be using string-based standard exceptions (-X) */
 397                 return PyString_FromString(name);
 398         }
 399         if (dict == NULL) {
 400                 dict = mydict = PyDict_New();
 401                 if (dict == NULL)
 402                         goto failure;
 403         }
 404         if (PyDict_GetItemString(dict, "__module__") == NULL) {
 405                 modulename = PyString_FromStringAndSize(name, (int)(dot-name));
 406                 if (modulename == NULL)
 407                         goto failure;
 408                 if (PyDict_SetItemString(dict, "__module__", modulename) != 0)
 409                         goto failure;
 410         }
 411         classname = PyString_FromString(dot+1);
 412         if (classname == NULL)
 413                 goto failure;
 414         bases = Py_BuildValue("(O)", base);
 415         if (bases == NULL)
 416                 goto failure;
 417         result = PyClass_New(bases, dict, classname);
 418   failure:
 419         Py_XDECREF(bases);
 420         Py_XDECREF(mydict);
 421         Py_XDECREF(classname);
 422         Py_XDECREF(modulename);
 423         return result;
 424 }