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 not be used in advertising or publicity pertaining to
  13 distribution of the software without specific, written prior permission.
  14
  15 STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
  16 THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17 FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
  18 FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  20 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  21 OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22
  23 ******************************************************************/
  24
  25 /* Error handling -- see also run.c */
  26
  27 /* New error handling interface.
  28
  29    The following problem exists (existed): methods of built-in modules
  30    are called with 'self' and 'args' arguments, but without a context
  31    argument, so they have no way to raise a specific exception.
  32    The same is true for the object implementations: no context argument.
  33    The old convention was to set 'errno' and to return NULL.
  34    The caller (usually call_function() in eval.c) detects the NULL
  35    return value and then calls puterrno(ctx) to turn the errno value
  36    into a true exception.  Problems with this approach are:
  37    - it used standard errno values to indicate Python-specific errors,
  38      but this means that when such an error code is reported by a system
  39      call (e.g., in module posix), the user gets a confusing message
  40    - errno is a global variable, which makes extensions to a multi-
  41      threading environment difficult; e.g., in IRIX, multi-threaded
  42      programs must use the function oserror() instead of looking in errno
  43    - there is no portable way to add new error numbers for specic
  44      situations -- the value space for errno is reserved to the OS, yet
  45      the way to turn module-specific errors into a module-specific
  46      exception requires module-specific values for errno
  47    - there is no way to add a more situation-specific message to an
  48      error.
  49
  50   The new interface solves all these problems.  To return an error, a
  51   built-in function calls err_set(exception), err_setval(exception,
  52   value) or err_setstr(exception, string), and returns NULL.  These
  53   functions save the value for later use by puterrno().  To adapt this
  54   scheme to a multi-threaded environment, only the implementation of
  55   err_setval() has to be changed.
  56 */
  57
  58 #include "allobjects.h"
  59 #include "traceback.h"
  60
  61 #include <errno.h>
  62
  63 #ifdef __CFM68K__
  64 #pragma lib_export on
  65 #endif
  66
  67 #ifdef macintosh
  68 /* Replace strerror with a Mac specific routine.
  69    XXX PROBLEM: some positive errors have a meaning for MacOS,
  70    but some library routines set Unix error numbers...
  71 */
  72 extern char *PyMac_StrError PROTO((int));
  73 #undef strerror
  74 #define strerror PyMac_StrError
  75 #endif /* macintosh */
  76
  77 #ifndef __STDC__
  78 extern char *strerror PROTO((int));
  79 #endif
  80
  81 /* Last exception stored by err_setval() */
  82
  83 static object *last_exception;
  84 static object *last_exc_val;
  85
  86 void
  87 err_restore(exception, value, traceback)
  88         object *exception;
  89         object *value;
  90         object *traceback;
  91 {
  92         err_clear();
  93
  94         last_exception = exception;
  95         last_exc_val = value;
  96         (void) tb_store(traceback);
  97         XDECREF(traceback);
  98 }
  99
 100 void
 101 err_setval(exception, value)
 102         object *exception;
 103         object *value;
 104 {
 105         XINCREF(exception);
 106         XINCREF(value);
 107         err_restore(exception, value, (object *)NULL);
 108 }
 109
 110 void
 111 err_set(exception)
 112         object *exception;
 113 {
 114         err_setval(exception, (object *)NULL);
 115 }
 116
 117 void
 118 err_setstr(exception, string)
 119         object *exception;
 120         char *string;
 121 {
 122         object *value = newstringobject(string);
 123         err_setval(exception, value);
 124         XDECREF(value);
 125 }
 126
 127
 128 object *
 129 err_occurred()
 130 {
 131         return last_exception;
 132 }
 133
 134 void
 135 err_fetch(p_exc, p_val, p_tb)
 136         object **p_exc;
 137         object **p_val;
 138         object **p_tb;
 139 {
 140         *p_exc = last_exception;
 141         last_exception = NULL;
 142         *p_val = last_exc_val;
 143         last_exc_val = NULL;
 144         *p_tb = tb_fetch();
 145 }
 146
 147 void
 148 err_clear()
 149 {
 150         object *tb;
 151         XDECREF(last_exception);
 152         last_exception = NULL;
 153         XDECREF(last_exc_val);
 154         last_exc_val = NULL;
 155         /* Also clear interpreter stack trace */
 156         tb = tb_fetch();
 157         XDECREF(tb);
 158 }
 159
 160 /* Convenience functions to set a type error exception and return 0 */
 161
 162 int
 163 err_badarg()
 164 {
 165         err_setstr(TypeError, "illegal argument type for built-in operation");
 166         return 0;
 167 }
 168
 169 object *
 170 err_nomem()
 171 {
 172         err_set(MemoryError);
 173         return NULL;
 174 }
 175
 176 object *
 177 err_errno(exc)
 178         object *exc;
 179 {
 180         object *v;
 181         int i = errno;
 182 #ifdef EINTR
 183         if (i == EINTR && sigcheck())
 184                 return NULL;
 185 #endif
 186         v = mkvalue("(is)", i, strerror(i));
 187         if (v != NULL) {
 188                 err_setval(exc, v);
 189                 DECREF(v);
 190         }
 191         return NULL;
 192 }
 193
 194 void
 195 err_badcall()
 196 {
 197         err_setstr(SystemError, "bad argument to internal function");
 198 }