Python/errors.c

   1
   2 /* Error handling */
   3
   4 #include "Python.h"
   5
   6 #ifdef macintosh
   7 extern char *PyMac_StrError(int);
   8 #undef strerror
   9 #define strerror PyMac_StrError
  10 #endif /* macintosh */
  11
  12 #ifndef __STDC__
  13 #ifndef MS_WINDOWS
  14 extern char *strerror(int);
  15 #endif
  16 #endif
  17
  18 #ifdef MS_WIN32
  19 #include "windows.h"
  20 #include "winbase.h"
  21 #endif
  22
  23 #include <ctype.h>
  24
  25 void
  26 PyErr_Restore(PyObject *type, PyObject *value, PyObject *traceback)
  27 {
  28         PyThreadState *tstate = PyThreadState_GET();
  29         PyObject *oldtype, *oldvalue, *oldtraceback;
  30
  31         if (traceback != NULL && !PyTraceBack_Check(traceback)) {
  32                 /* XXX Should never happen -- fatal error instead? */
  33                 Py_DECREF(traceback);
  34                 traceback = NULL;
  35         }
  36
  37         /* Save these in locals to safeguard against recursive
  38            invocation through Py_XDECREF */
  39         oldtype = tstate->curexc_type;
  40         oldvalue = tstate->curexc_value;
  41         oldtraceback = tstate->curexc_traceback;
  42
  43         tstate->curexc_type = type;
  44         tstate->curexc_value = value;
  45         tstate->curexc_traceback = traceback;
  46
  47         Py_XDECREF(oldtype);
  48         Py_XDECREF(oldvalue);
  49         Py_XDECREF(oldtraceback);
  50 }
  51
  52 void
  53 PyErr_SetObject(PyObject *exception, PyObject *value)
  54 {
  55         Py_XINCREF(exception);
  56         Py_XINCREF(value);
  57         PyErr_Restore(exception, value, (PyObject *)NULL);
  58 }
  59
  60 void
  61 PyErr_SetNone(PyObject *exception)
  62 {
  63         PyErr_SetObject(exception, (PyObject *)NULL);
  64 }
  65
  66 void
  67 PyErr_SetString(PyObject *exception, const char *string)
  68 {
  69         PyObject *value = PyString_FromString(string);
  70         PyErr_SetObject(exception, value);
  71         Py_XDECREF(value);
  72 }
  73
  74
  75 PyObject *
  76 PyErr_Occurred(void)
  77 {
  78         PyThreadState *tstate = PyThreadState_Get();
  79
  80         return tstate->curexc_type;
  81 }
  82
  83
  84 int
  85 PyErr_GivenExceptionMatches(PyObject *err, PyObject *exc)
  86 {
  87         if (err == NULL || exc == NULL) {
  88                 /* maybe caused by "import exceptions" that failed early on */
  89                 return 0;
  90         }
  91         if (PyTuple_Check(exc)) {
  92                 int i, n;
  93                 n = PyTuple_Size(exc);
  94                 for (i = 0; i < n; i++) {
  95                         /* Test recursively */
  96                      if (PyErr_GivenExceptionMatches(
  97                              err, PyTuple_GET_ITEM(exc, i)))
  98                      {
  99                              return 1;
 100                      }
 101                 }
 102                 return 0;
 103         }
 104         /* err might be an instance, so check its class. */
 105         if (PyInstance_Check(err))
 106                 err = (PyObject*)((PyInstanceObject*)err)->in_class;
 107
 108         if (PyClass_Check(err) && PyClass_Check(exc))
 109                 return PyClass_IsSubclass(err, exc);
 110
 111         return err == exc;
 112 }
 113
 114
 115 int
 116 PyErr_ExceptionMatches(PyObject *exc)
 117 {
 118         return PyErr_GivenExceptionMatches(PyErr_Occurred(), exc);
 119 }
 120
 121
 122 /* Used in many places to normalize a raised exception, including in
 123    eval_code2(), do_raise(), and PyErr_Print()
 124 */
 125 void
 126 PyErr_NormalizeException(PyObject **exc, PyObject **val, PyObject **tb)
 127 {
 128         PyObject *type = *exc;
 129         PyObject *value = *val;
 130         PyObject *inclass = NULL;
 131
 132         if (type == NULL) {
 133                 /* This is a bug.  Should never happen.  Don't dump core. */
 134                 PyErr_SetString(PyExc_SystemError,
 135                         "PyErr_NormalizeException() called without exception");
 136         }
 137
 138         /* If PyErr_SetNone() was used, the value will have been actually
 139            set to NULL.
 140         */
 141         if (!value) {
 142                 value = Py_None;
 143                 Py_INCREF(value);
 144         }
 145
 146         if (PyInstance_Check(value))
 147                 inclass = (PyObject*)((PyInstanceObject*)value)->in_class;
 148
 149         /* Normalize the exception so that if the type is a class, the
 150            value will be an instance.
 151         */
 152         if (PyClass_Check(type)) {
 153                 /* if the value was not an instance, or is not an instance
 154                    whose class is (or is derived from) type, then use the
 155                    value as an argument to instantiation of the type
 156                    class.
 157                 */
 158                 if (!inclass || !PyClass_IsSubclass(inclass, type)) {
 159                         PyObject *args, *res;
 160
 161                         if (value == Py_None)
 162                                 args = Py_BuildValue("()");
 163                         else if (PyTuple_Check(value)) {
 164                                 Py_INCREF(value);
 165                                 args = value;
 166                         }
 167                         else
 168                                 args = Py_BuildValue("(O)", value);
 169
 170                         if (args == NULL)
 171                                 goto finally;
 172                         res = PyEval_CallObject(type, args);
 173                         Py_DECREF(args);
 174                         if (res == NULL)
 175                                 goto finally;
 176                         Py_DECREF(value);
 177                         value = res;
 178                 }
 179                 /* if the class of the instance doesn't exactly match the
 180                    class of the type, believe the instance
 181                 */
 182                 else if (inclass != type) {
 183                         Py_DECREF(type);
 184                         type = inclass;
 185                         Py_INCREF(type);
 186                 }
 187         }
 188         *exc = type;
 189         *val = value;
 190         return;
 191 finally:
 192         Py_DECREF(type);
 193         Py_DECREF(value);
 194         Py_XDECREF(*tb);
 195         PyErr_Fetch(exc, val, tb);
 196         /* normalize recursively */
 197         PyErr_NormalizeException(exc, val, tb);
 198 }
 199
 200
 201 void
 202 PyErr_Fetch(PyObject **p_type, PyObject **p_value, PyObject **p_traceback)
 203 {
 204         PyThreadState *tstate = PyThreadState_Get();
 205
 206         *p_type = tstate->curexc_type;
 207         *p_value = tstate->curexc_value;
 208         *p_traceback = tstate->curexc_traceback;
 209
 210         tstate->curexc_type = NULL;
 211         tstate->curexc_value = NULL;
 212         tstate->curexc_traceback = NULL;
 213 }
 214
 215 void
 216 PyErr_Clear(void)
 217 {
 218         PyErr_Restore(NULL, NULL, NULL);
 219 }
 220
 221 /* Convenience functions to set a type error exception and return 0 */
 222
 223 int
 224 PyErr_BadArgument(void)
 225 {
 226         PyErr_SetString(PyExc_TypeError,
 227                         "bad argument type for built-in operation");
 228         return 0;
 229 }
 230
 231 PyObject *
 232 PyErr_NoMemory(void)
 233 {
 234         if (PyErr_ExceptionMatches(PyExc_MemoryError))
 235                 /* already current */
 236                 return NULL;
 237
 238         /* raise the pre-allocated instance if it still exists */
 239         if (PyExc_MemoryErrorInst)
 240                 PyErr_SetObject(PyExc_MemoryError, PyExc_MemoryErrorInst);
 241         else
 242                 /* this will probably fail since there's no memory and hee,
 243                    hee, we have to instantiate this class
 244                 */
 245                 PyErr_SetNone(PyExc_MemoryError);
 246
 247         return NULL;
 248 }
 249
 250 PyObject *
 251 PyErr_SetFromErrnoWithFilename(PyObject *exc, char *filename)
 252 {
 253         PyObject *v;
 254         char *s;
 255         int i = errno;
 256 #ifdef MS_WIN32
 257         char *s_buf = NULL;
 258 #endif
 259 #ifdef EINTR
 260         if (i == EINTR && PyErr_CheckSignals())
 261                 return NULL;
 262 #endif
 263         if (i == 0)
 264                 s = "Error"; /* Sometimes errno didn't get set */
 265         else
 266 #ifndef MS_WIN32
 267                 s = strerror(i);
 268 #else
 269         {
 270                 /* Note that the Win32 errors do not lineup with the
 271                    errno error.  So if the error is in the MSVC error
 272                    table, we use it, otherwise we assume it really _is_
 273                    a Win32 error code
 274                 */
 275                 if (i > 0 && i < _sys_nerr) {
 276                         s = _sys_errlist[i];
 277                 }
 278                 else {
 279                         int len = FormatMessage(
 280                                 FORMAT_MESSAGE_ALLOCATE_BUFFER |
 281                                 FORMAT_MESSAGE_FROM_SYSTEM |
 282                                 FORMAT_MESSAGE_IGNORE_INSERTS,
 283                                 NULL,   /* no message source */
 284                                 i,
 285                                 MAKELANGID(LANG_NEUTRAL,
 286                                            SUBLANG_DEFAULT),
 287                                            /* Default language */
 288                                 (LPTSTR) &s_buf,
 289                                 0,      /* size not used */
 290                                 NULL);  /* no args */
 291                         s = s_buf;
 292                         /* remove trailing cr/lf and dots */
 293                         while (len > 0 && (s[len-1] <= ' ' || s[len-1] == '.'))
 294                                 s[--len] = '\0';
 295                 }
 296         }
 297 #endif
 298         if (filename != NULL)
 299                 v = Py_BuildValue("(iss)", i, s, filename);
 300         else
 301                 v = Py_BuildValue("(is)", i, s);
 302         if (v != NULL) {
 303                 PyErr_SetObject(exc, v);
 304                 Py_DECREF(v);
 305         }
 306 #ifdef MS_WIN32
 307         LocalFree(s_buf);
 308 #endif
 309         return NULL;
 310 }
 311
 312
 313 PyObject *
 314 PyErr_SetFromErrno(PyObject *exc)
 315 {
 316         return PyErr_SetFromErrnoWithFilename(exc, NULL);
 317 }
 318
 319 #ifdef MS_WINDOWS
 320 /* Windows specific error code handling */
 321 PyObject *PyErr_SetFromWindowsErrWithFilename(
 322         int ierr,
 323         const char *filename)
 324 {
 325         int len;
 326         char *s;
 327         PyObject *v;
 328         DWORD err = (DWORD)ierr;
 329         if (err==0) err = GetLastError();
 330         len = FormatMessage(
 331                 /* Error API error */
 332                 FORMAT_MESSAGE_ALLOCATE_BUFFER |
 333                 FORMAT_MESSAGE_FROM_SYSTEM |
 334                 FORMAT_MESSAGE_IGNORE_INSERTS,
 335                 NULL,   /* no message source */
 336                 err,
 337                 MAKELANGID(LANG_NEUTRAL,
 338                 SUBLANG_DEFAULT), /* Default language */
 339                 (LPTSTR) &s,
 340                 0,      /* size not used */
 341                 NULL);  /* no args */
 342         /* remove trailing cr/lf and dots */
 343         while (len > 0 && (s[len-1] <= ' ' || s[len-1] == '.'))
 344                 s[--len] = '\0';
 345         if (filename != NULL)
 346                 v = Py_BuildValue("(iss)", err, s, filename);
 347         else
 348                 v = Py_BuildValue("(is)", err, s);
 349         if (v != NULL) {
 350                 PyErr_SetObject(PyExc_WindowsError, v);
 351                 Py_DECREF(v);
 352         }
 353         LocalFree(s);
 354         return NULL;
 355 }
 356
 357 PyObject *PyErr_SetFromWindowsErr(int ierr)
 358 {
 359         return PyErr_SetFromWindowsErrWithFilename(ierr, NULL);
 360 }
 361 #endif /* MS_WINDOWS */
 362
 363 void
 364 _PyErr_BadInternalCall(char *filename, int lineno)
 365 {
 366         PyErr_Format(PyExc_SystemError,
 367                      "%s:%d: bad argument to internal function",
 368                      filename, lineno);
 369 }
 370
 371 /* Remove the preprocessor macro for PyErr_BadInternalCall() so that we can
 372    export the entry point for existing object code: */
 373 #undef PyErr_BadInternalCall
 374 void
 375 PyErr_BadInternalCall(void)
 376 {
 377         PyErr_Format(PyExc_SystemError,
 378                      "bad argument to internal function");
 379 }
 380 #define PyErr_BadInternalCall() _PyErr_BadInternalCall(__FILE__, __LINE__)
 381
 382
 383
 384 PyObject *
 385 PyErr_Format(PyObject *exception, const char *format, ...)
 386 {
 387         va_list vargs;
 388         int n, i;
 389         const char* f;
 390         char* s;
 391         PyObject* string;
 392
 393         /* step 1: figure out how large a buffer we need */
 394
 395 #ifdef HAVE_STDARG_PROTOTYPES
 396         va_start(vargs, format);
 397 #else
 398         va_start(vargs);
 399 #endif
 400
 401         n = 0;
 402         for (f = format; *f; f++) {
 403                 if (*f == '%') {
 404                         const char* p = f;
 405                         while (*++f && *f != '%' && !isalpha(*f))
 406                                 ;
 407                         switch (*f) {
 408                         case 'c':
 409                                 (void) va_arg(vargs, int);
 410                                 /* fall through... */
 411                         case '%':
 412                                 n++;
 413                                 break;
 414                         case 'd': case 'i': case 'x':
 415                                 (void) va_arg(vargs, int);
 416                                 /* 20 bytes should be enough to hold a 64-bit
 417                                    integer */
 418                                 n = n + 20;
 419                                 break;
 420                         case 's':
 421                                 s = va_arg(vargs, char*);
 422                                 n = n + strlen(s);
 423                                 break;
 424                         default:
 425                                 /* if we stumble upon an unknown
 426                                    formatting code, copy the rest of
 427                                    the format string to the output
 428                                    string. (we cannot just skip the
 429                                    code, since there's no way to know
 430                                    what's in the argument list) */
 431                                 n = n + strlen(p);
 432                                 goto expand;
 433                         }
 434                 } else
 435                         n = n + 1;
 436         }
 437
 438  expand:
 439
 440         string = PyString_FromStringAndSize(NULL, n);
 441         if (!string)
 442                 return NULL;
 443
 444 #ifdef HAVE_STDARG_PROTOTYPES
 445         va_start(vargs, format);
 446 #else
 447         va_start(vargs);
 448 #endif
 449
 450         /* step 2: fill the buffer */
 451
 452         s = PyString_AsString(string);
 453
 454         for (f = format; *f; f++) {
 455                 if (*f == '%') {
 456                         const char* p = f++;
 457                         /* parse the width.precision part (we're only
 458                            interested in the precision value, if any) */
 459                         n = 0;
 460                         while (isdigit(*f))
 461                                 n = (n*10) + *f++ - '0';
 462                         if (*f == '.') {
 463                                 f++;
 464                                 n = 0;
 465                                 while (isdigit(*f))
 466                                         n = (n*10) + *f++ - '0';
 467                         }
 468                         while (*f && *f != '%' && !isalpha(*f))
 469                                 f++;
 470                         switch (*f) {
 471                         case 'c':
 472                                 *s++ = va_arg(vargs, int);
 473                                 break;
 474                         case 'd':
 475                                 sprintf(s, "%d", va_arg(vargs, int));
 476                                 s = s + strlen(s);
 477                                 break;
 478                         case 'i':
 479                                 sprintf(s, "%i", va_arg(vargs, int));
 480                                 s = s + strlen(s);
 481                                 break;
 482                         case 'x':
 483                                 sprintf(s, "%x", va_arg(vargs, int));
 484                                 s = s + strlen(s);
 485                                 break;
 486                         case 's':
 487                                 p = va_arg(vargs, char*);
 488                                 i = strlen(p);
 489                                 if (n > 0 && i > n)
 490                                         i = n;
 491                                 memcpy(s, p, i);
 492                                 s = s + i;
 493                                 break;
 494                         case '%':
 495                                 *s++ = '%';
 496                                 break;
 497                         default:
 498                                 strcpy(s, p);
 499                                 s = s + strlen(s);
 500                                 goto end;
 501                         }
 502                 } else
 503                         *s++ = *f;
 504         }
 505
 506  end:
 507
 508         _PyString_Resize(&string, s - PyString_AsString(string));
 509
 510         PyErr_SetObject(exception, string);
 511         Py_XDECREF(string);
 512
 513         return NULL;
 514 }
 515
 516
 517 PyObject *
 518 PyErr_NewException(char *name, PyObject *base, PyObject *dict)
 519 {
 520         char *dot;
 521         PyObject *modulename = NULL;
 522         PyObject *classname = NULL;
 523         PyObject *mydict = NULL;
 524         PyObject *bases = NULL;
 525         PyObject *result = NULL;
 526         dot = strrchr(name, '.');
 527         if (dot == NULL) {
 528                 PyErr_SetString(PyExc_SystemError,
 529                         "PyErr_NewException: name must be module.class");
 530                 return NULL;
 531         }
 532         if (base == NULL)
 533                 base = PyExc_Exception;
 534         if (!PyClass_Check(base)) {
 535                 /* Must be using string-based standard exceptions (-X) */
 536                 return PyString_FromString(name);
 537         }
 538         if (dict == NULL) {
 539                 dict = mydict = PyDict_New();
 540                 if (dict == NULL)
 541                         goto failure;
 542         }
 543         if (PyDict_GetItemString(dict, "__module__") == NULL) {
 544                 modulename = PyString_FromStringAndSize(name, (int)(dot-name));
 545                 if (modulename == NULL)
 546                         goto failure;
 547                 if (PyDict_SetItemString(dict, "__module__", modulename) != 0)
 548                         goto failure;
 549         }
 550         classname = PyString_FromString(dot+1);
 551         if (classname == NULL)
 552                 goto failure;
 553         bases = Py_BuildValue("(O)", base);
 554         if (bases == NULL)
 555                 goto failure;
 556         result = PyClass_New(bases, dict, classname);
 557   failure:
 558         Py_XDECREF(bases);
 559         Py_XDECREF(mydict);
 560         Py_XDECREF(classname);
 561         Py_XDECREF(modulename);
 562         return result;
 563 }
 564
 565 /* Call when an exception has occurred but there is no way for Python
 566    to handle it.  Examples: exception in __del__ or during GC. */
 567 void
 568 PyErr_WriteUnraisable(PyObject *obj)
 569 {
 570         PyObject *f, *t, *v, *tb;
 571         PyErr_Fetch(&t, &v, &tb);
 572         f = PySys_GetObject("stderr");
 573         if (f != NULL) {
 574                 PyFile_WriteString("Exception ", f);
 575                 if (t) {
 576                         PyFile_WriteObject(t, f, Py_PRINT_RAW);
 577                         if (v && v != Py_None) {
 578                                 PyFile_WriteString(": ", f);
 579                                 PyFile_WriteObject(v, f, 0);
 580                         }
 581                 }
 582                 PyFile_WriteString(" in ", f);
 583                 PyFile_WriteObject(obj, f, 0);
 584                 PyFile_WriteString(" ignored\n", f);
 585                 PyErr_Clear(); /* Just in case */
 586         }
 587         Py_XDECREF(t);
 588         Py_XDECREF(v);
 589         Py_XDECREF(tb);
 590 }
 591
 592
 593 /* Function to issue a warning message; may raise an exception. */
 594 int
 595 PyErr_Warn(PyObject *category, char *message)
 596 {
 597         PyObject *mod, *dict, *func = NULL;
 598
 599         mod = PyImport_ImportModule("warnings");
 600         if (mod != NULL) {
 601                 dict = PyModule_GetDict(mod);
 602                 func = PyDict_GetItemString(dict, "warn");
 603                 Py_DECREF(mod);
 604         }
 605         if (func == NULL) {
 606                 PySys_WriteStderr("warning: %s\n", message);
 607                 return 0;
 608         }
 609         else {
 610                 PyObject *args, *res;
 611
 612                 if (category == NULL)
 613                         category = PyExc_RuntimeWarning;
 614                 args = Py_BuildValue("(sO)", message, category);
 615                 if (args == NULL)
 616                         return -1;
 617                 res = PyEval_CallObject(func, args);
 618                 Py_DECREF(args);
 619                 if (res == NULL)
 620                         return -1;
 621                 Py_DECREF(res);
 622                 return 0;
 623         }
 624 }