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         PyObject *initial_tb = NULL;
 132
 133         if (type == NULL) {
 134                 /* This is a bug.  Should never happen.  Don't dump core. */
 135                 PyErr_SetString(PyExc_SystemError,
 136                         "PyErr_NormalizeException() called without exception");
 137         }
 138
 139         /* If PyErr_SetNone() was used, the value will have been actually
 140            set to NULL.
 141         */
 142         if (!value) {
 143                 value = Py_None;
 144                 Py_INCREF(value);
 145         }
 146
 147         if (PyInstance_Check(value))
 148                 inclass = (PyObject*)((PyInstanceObject*)value)->in_class;
 149
 150         /* Normalize the exception so that if the type is a class, the
 151            value will be an instance.
 152         */
 153         if (PyClass_Check(type)) {
 154                 /* if the value was not an instance, or is not an instance
 155                    whose class is (or is derived from) type, then use the
 156                    value as an argument to instantiation of the type
 157                    class.
 158                 */
 159                 if (!inclass || !PyClass_IsSubclass(inclass, type)) {
 160                         PyObject *args, *res;
 161
 162                         if (value == Py_None)
 163                                 args = Py_BuildValue("()");
 164                         else if (PyTuple_Check(value)) {
 165                                 Py_INCREF(value);
 166                                 args = value;
 167                         }
 168                         else
 169                                 args = Py_BuildValue("(O)", value);
 170
 171                         if (args == NULL)
 172                                 goto finally;
 173                         res = PyEval_CallObject(type, args);
 174                         Py_DECREF(args);
 175                         if (res == NULL)
 176                                 goto finally;
 177                         Py_DECREF(value);
 178                         value = res;
 179                 }
 180                 /* if the class of the instance doesn't exactly match the
 181                    class of the type, believe the instance
 182                 */
 183                 else if (inclass != type) {
 184                         Py_DECREF(type);
 185                         type = inclass;
 186                         Py_INCREF(type);
 187                 }
 188         }
 189         *exc = type;
 190         *val = value;
 191         return;
 192 finally:
 193         Py_DECREF(type);
 194         Py_DECREF(value);
 195         /* If the new exception doesn't set a traceback and the old
 196            exception had a traceback, use the old traceback for the
 197            new exception.  It's better than nothing.
 198         */
 199         initial_tb = *tb;
 200         PyErr_Fetch(exc, val, tb);
 201         if (initial_tb != NULL) {
 202                 if (*tb == NULL)
 203                         *tb = initial_tb;
 204                 else
 205                         Py_DECREF(initial_tb);
 206         }
 207         /* normalize recursively */
 208         PyErr_NormalizeException(exc, val, tb);
 209 }
 210
 211
 212 void
 213 PyErr_Fetch(PyObject **p_type, PyObject **p_value, PyObject **p_traceback)
 214 {
 215         PyThreadState *tstate = PyThreadState_Get();
 216
 217         *p_type = tstate->curexc_type;
 218         *p_value = tstate->curexc_value;
 219         *p_traceback = tstate->curexc_traceback;
 220
 221         tstate->curexc_type = NULL;
 222         tstate->curexc_value = NULL;
 223         tstate->curexc_traceback = NULL;
 224 }
 225
 226 void
 227 PyErr_Clear(void)
 228 {
 229         PyErr_Restore(NULL, NULL, NULL);
 230 }
 231
 232 /* Convenience functions to set a type error exception and return 0 */
 233
 234 int
 235 PyErr_BadArgument(void)
 236 {
 237         PyErr_SetString(PyExc_TypeError,
 238                         "bad argument type for built-in operation");
 239         return 0;
 240 }
 241
 242 PyObject *
 243 PyErr_NoMemory(void)
 244 {
 245         if (PyErr_ExceptionMatches(PyExc_MemoryError))
 246                 /* already current */
 247                 return NULL;
 248
 249         /* raise the pre-allocated instance if it still exists */
 250         if (PyExc_MemoryErrorInst)
 251                 PyErr_SetObject(PyExc_MemoryError, PyExc_MemoryErrorInst);
 252         else
 253                 /* this will probably fail since there's no memory and hee,
 254                    hee, we have to instantiate this class
 255                 */
 256                 PyErr_SetNone(PyExc_MemoryError);
 257
 258         return NULL;
 259 }
 260
 261 PyObject *
 262 PyErr_SetFromErrnoWithFilename(PyObject *exc, char *filename)
 263 {
 264         PyObject *v;
 265         char *s;
 266         int i = errno;
 267 #ifdef MS_WIN32
 268         char *s_buf = NULL;
 269 #endif
 270 #ifdef EINTR
 271         if (i == EINTR && PyErr_CheckSignals())
 272                 return NULL;
 273 #endif
 274         if (i == 0)
 275                 s = "Error"; /* Sometimes errno didn't get set */
 276         else
 277 #ifndef MS_WIN32
 278                 s = strerror(i);
 279 #else
 280         {
 281                 /* Note that the Win32 errors do not lineup with the
 282                    errno error.  So if the error is in the MSVC error
 283                    table, we use it, otherwise we assume it really _is_
 284                    a Win32 error code
 285                 */
 286                 if (i > 0 && i < _sys_nerr) {
 287                         s = _sys_errlist[i];
 288                 }
 289                 else {
 290                         int len = FormatMessage(
 291                                 FORMAT_MESSAGE_ALLOCATE_BUFFER |
 292                                 FORMAT_MESSAGE_FROM_SYSTEM |
 293                                 FORMAT_MESSAGE_IGNORE_INSERTS,
 294                                 NULL,   /* no message source */
 295                                 i,
 296                                 MAKELANGID(LANG_NEUTRAL,
 297                                            SUBLANG_DEFAULT),
 298                                            /* Default language */
 299                                 (LPTSTR) &s_buf,
 300                                 0,      /* size not used */
 301                                 NULL);  /* no args */
 302                         s = s_buf;
 303                         /* remove trailing cr/lf and dots */
 304                         while (len > 0 && (s[len-1] <= ' ' || s[len-1] == '.'))
 305                                 s[--len] = '\0';
 306                 }
 307         }
 308 #endif
 309         if (filename != NULL)
 310                 v = Py_BuildValue("(iss)", i, s, filename);
 311         else
 312                 v = Py_BuildValue("(is)", i, s);
 313         if (v != NULL) {
 314                 PyErr_SetObject(exc, v);
 315                 Py_DECREF(v);
 316         }
 317 #ifdef MS_WIN32
 318         LocalFree(s_buf);
 319 #endif
 320         return NULL;
 321 }
 322
 323
 324 PyObject *
 325 PyErr_SetFromErrno(PyObject *exc)
 326 {
 327         return PyErr_SetFromErrnoWithFilename(exc, NULL);
 328 }
 329
 330 #ifdef MS_WINDOWS
 331 /* Windows specific error code handling */
 332 PyObject *PyErr_SetFromWindowsErrWithFilename(
 333         int ierr,
 334         const char *filename)
 335 {
 336         int len;
 337         char *s;
 338         PyObject *v;
 339         DWORD err = (DWORD)ierr;
 340         if (err==0) err = GetLastError();
 341         len = FormatMessage(
 342                 /* Error API error */
 343                 FORMAT_MESSAGE_ALLOCATE_BUFFER |
 344                 FORMAT_MESSAGE_FROM_SYSTEM |
 345                 FORMAT_MESSAGE_IGNORE_INSERTS,
 346                 NULL,   /* no message source */
 347                 err,
 348                 MAKELANGID(LANG_NEUTRAL,
 349                 SUBLANG_DEFAULT), /* Default language */
 350                 (LPTSTR) &s,
 351                 0,      /* size not used */
 352                 NULL);  /* no args */
 353         /* remove trailing cr/lf and dots */
 354         while (len > 0 && (s[len-1] <= ' ' || s[len-1] == '.'))
 355                 s[--len] = '\0';
 356         if (filename != NULL)
 357                 v = Py_BuildValue("(iss)", err, s, filename);
 358         else
 359                 v = Py_BuildValue("(is)", err, s);
 360         if (v != NULL) {
 361                 PyErr_SetObject(PyExc_WindowsError, v);
 362                 Py_DECREF(v);
 363         }
 364         LocalFree(s);
 365         return NULL;
 366 }
 367
 368 PyObject *PyErr_SetFromWindowsErr(int ierr)
 369 {
 370         return PyErr_SetFromWindowsErrWithFilename(ierr, NULL);
 371 }
 372 #endif /* MS_WINDOWS */
 373
 374 void
 375 _PyErr_BadInternalCall(char *filename, int lineno)
 376 {
 377         PyErr_Format(PyExc_SystemError,
 378                      "%s:%d: bad argument to internal function",
 379                      filename, lineno);
 380 }
 381
 382 /* Remove the preprocessor macro for PyErr_BadInternalCall() so that we can
 383    export the entry point for existing object code: */
 384 #undef PyErr_BadInternalCall
 385 void
 386 PyErr_BadInternalCall(void)
 387 {
 388         PyErr_Format(PyExc_SystemError,
 389                      "bad argument to internal function");
 390 }
 391 #define PyErr_BadInternalCall() _PyErr_BadInternalCall(__FILE__, __LINE__)
 392
 393
 394
 395 PyObject *
 396 PyErr_Format(PyObject *exception, const char *format, ...)
 397 {
 398         va_list vargs;
 399         PyObject* string;
 400
 401 #ifdef HAVE_STDARG_PROTOTYPES
 402         va_start(vargs, format);
 403 #else
 404         va_start(vargs);
 405 #endif
 406
 407         string = PyString_FromFormatV(format, vargs);
 408         PyErr_SetObject(exception, string);
 409         Py_XDECREF(string);
 410         va_end(vargs);
 411         return NULL;
 412 }
 413
 414
 415 PyObject *
 416 PyErr_NewException(char *name, PyObject *base, PyObject *dict)
 417 {
 418         char *dot;
 419         PyObject *modulename = NULL;
 420         PyObject *classname = NULL;
 421         PyObject *mydict = NULL;
 422         PyObject *bases = NULL;
 423         PyObject *result = NULL;
 424         dot = strrchr(name, '.');
 425         if (dot == NULL) {
 426                 PyErr_SetString(PyExc_SystemError,
 427                         "PyErr_NewException: name must be module.class");
 428                 return NULL;
 429         }
 430         if (base == NULL)
 431                 base = PyExc_Exception;
 432         if (!PyClass_Check(base)) {
 433                 /* Must be using string-based standard exceptions (-X) */
 434                 return PyString_FromString(name);
 435         }
 436         if (dict == NULL) {
 437                 dict = mydict = PyDict_New();
 438                 if (dict == NULL)
 439                         goto failure;
 440         }
 441         if (PyDict_GetItemString(dict, "__module__") == NULL) {
 442                 modulename = PyString_FromStringAndSize(name, (int)(dot-name));
 443                 if (modulename == NULL)
 444                         goto failure;
 445                 if (PyDict_SetItemString(dict, "__module__", modulename) != 0)
 446                         goto failure;
 447         }
 448         classname = PyString_FromString(dot+1);
 449         if (classname == NULL)
 450                 goto failure;
 451         bases = Py_BuildValue("(O)", base);
 452         if (bases == NULL)
 453                 goto failure;
 454         result = PyClass_New(bases, dict, classname);
 455   failure:
 456         Py_XDECREF(bases);
 457         Py_XDECREF(mydict);
 458         Py_XDECREF(classname);
 459         Py_XDECREF(modulename);
 460         return result;
 461 }
 462
 463 /* Call when an exception has occurred but there is no way for Python
 464    to handle it.  Examples: exception in __del__ or during GC. */
 465 void
 466 PyErr_WriteUnraisable(PyObject *obj)
 467 {
 468         PyObject *f, *t, *v, *tb;
 469         PyErr_Fetch(&t, &v, &tb);
 470         f = PySys_GetObject("stderr");
 471         if (f != NULL) {
 472                 PyFile_WriteString("Exception ", f);
 473                 if (t) {
 474                         PyFile_WriteObject(t, f, Py_PRINT_RAW);
 475                         if (v && v != Py_None) {
 476                                 PyFile_WriteString(": ", f);
 477                                 PyFile_WriteObject(v, f, 0);
 478                         }
 479                 }
 480                 PyFile_WriteString(" in ", f);
 481                 PyFile_WriteObject(obj, f, 0);
 482                 PyFile_WriteString(" ignored\n", f);
 483                 PyErr_Clear(); /* Just in case */
 484         }
 485         Py_XDECREF(t);
 486         Py_XDECREF(v);
 487         Py_XDECREF(tb);
 488 }
 489
 490
 491 /* Function to issue a warning message; may raise an exception. */
 492 int
 493 PyErr_Warn(PyObject *category, char *message)
 494 {
 495         PyObject *mod, *dict, *func = NULL;
 496
 497         mod = PyImport_ImportModule("warnings");
 498         if (mod != NULL) {
 499                 dict = PyModule_GetDict(mod);
 500                 func = PyDict_GetItemString(dict, "warn");
 501                 Py_DECREF(mod);
 502         }
 503         if (func == NULL) {
 504                 PySys_WriteStderr("warning: %s\n", message);
 505                 return 0;
 506         }
 507         else {
 508                 PyObject *args, *res;
 509
 510                 if (category == NULL)
 511                         category = PyExc_RuntimeWarning;
 512                 args = Py_BuildValue("(sO)", message, category);
 513                 if (args == NULL)
 514                         return -1;
 515                 res = PyEval_CallObject(func, args);
 516                 Py_DECREF(args);
 517                 if (res == NULL)
 518                         return -1;
 519                 Py_DECREF(res);
 520                 return 0;
 521         }
 522 }
 523
 524
 525 /* Warning with explicit origin */
 526 int
 527 PyErr_WarnExplicit(PyObject *category, char *message,
 528                    char *filename, int lineno,
 529                    char *module, PyObject *registry)
 530 {
 531         PyObject *mod, *dict, *func = NULL;
 532
 533         mod = PyImport_ImportModule("warnings");
 534         if (mod != NULL) {
 535                 dict = PyModule_GetDict(mod);
 536                 func = PyDict_GetItemString(dict, "warn_explicit");
 537                 Py_DECREF(mod);
 538         }
 539         if (func == NULL) {
 540                 PySys_WriteStderr("warning: %s\n", message);
 541                 return 0;
 542         }
 543         else {
 544                 PyObject *args, *res;
 545
 546                 if (category == NULL)
 547                         category = PyExc_RuntimeWarning;
 548                 if (registry == NULL)
 549                         registry = Py_None;
 550                 args = Py_BuildValue("(sOsizO)", message, category,
 551                                      filename, lineno, module, registry);
 552                 if (args == NULL)
 553                         return -1;
 554                 res = PyEval_CallObject(func, args);
 555                 Py_DECREF(args);
 556                 if (res == NULL)
 557                         return -1;
 558                 Py_DECREF(res);
 559                 return 0;
 560         }
 561 }
 562
 563
 564 /* Set file and line information for the current exception.
 565    If the exception is not a SyntaxError, also sets additional attributes
 566    to make printing of exceptions believe it is a syntax error. */
 567
 568 void
 569 PyErr_SyntaxLocation(char *filename, int lineno)
 570 {
 571         PyObject *exc, *v, *tb, *tmp;
 572
 573         /* add attributes for the line number and filename for the error */
 574         PyErr_Fetch(&exc, &v, &tb);
 575         PyErr_NormalizeException(&exc, &v, &tb);
 576         /* XXX check that it is, indeed, a syntax error */
 577         tmp = PyInt_FromLong(lineno);
 578         if (tmp == NULL)
 579                 PyErr_Clear();
 580         else {
 581                 if (PyObject_SetAttrString(v, "lineno", tmp))
 582                         PyErr_Clear();
 583                 Py_DECREF(tmp);
 584         }
 585         if (filename != NULL) {
 586                 tmp = PyString_FromString(filename);
 587                 if (tmp == NULL)
 588                         PyErr_Clear();
 589                 else {
 590                         if (PyObject_SetAttrString(v, "filename", tmp))
 591                                 PyErr_Clear();
 592                         Py_DECREF(tmp);
 593                 }
 594
 595                 tmp = PyErr_ProgramText(filename, lineno);
 596                 if (tmp) {
 597                         PyObject_SetAttrString(v, "text", tmp);
 598                         Py_DECREF(tmp);
 599                 }
 600         }
 601         if (PyObject_SetAttrString(v, "offset", Py_None)) {
 602                 PyErr_Clear();
 603         }
 604         if (exc != PyExc_SyntaxError) {
 605                 if (!PyObject_HasAttrString(v, "msg")) {
 606                         tmp = PyObject_Str(v);
 607                         if (tmp) {
 608                                 if (PyObject_SetAttrString(v, "msg", tmp))
 609                                         PyErr_Clear();
 610                                 Py_DECREF(tmp);
 611                         } else {
 612                                 PyErr_Clear();
 613                         }
 614                 }
 615                 if (!PyObject_HasAttrString(v, "print_file_and_line")) {
 616                         if (PyObject_SetAttrString(v, "print_file_and_line",
 617                                                    Py_None))
 618                                 PyErr_Clear();
 619                 }
 620         }
 621         PyErr_Restore(exc, v, tb);
 622 }
 623
 624 /* com_fetch_program_text will attempt to load the line of text that
 625    the exception refers to.  If it fails, it will return NULL but will
 626    not set an exception.
 627
 628    XXX The functionality of this function is quite similar to the
 629    functionality in tb_displayline() in traceback.c.
 630 */
 631
 632 PyObject *
 633 PyErr_ProgramText(char *filename, int lineno)
 634 {
 635         FILE *fp;
 636         int i;
 637         char linebuf[1000];
 638
 639         if (filename == NULL || lineno <= 0)
 640                 return NULL;
 641         fp = fopen(filename, "r");
 642         if (fp == NULL)
 643                 return NULL;
 644         for (i = 0; i < lineno; i++) {
 645                 char *pLastChar = &linebuf[sizeof(linebuf) - 2];
 646                 do {
 647                         *pLastChar = '\0';
 648                         if (fgets(linebuf, sizeof linebuf, fp) == NULL)
 649                                 break;
 650                         /* fgets read *something*; if it didn't get as
 651                            far as pLastChar, it must have found a newline
 652                            or hit the end of the file;  if pLastChar is \n,
 653                            it obviously found a newline; else we haven't
 654                            yet seen a newline, so must continue */
 655                 } while (*pLastChar != '\0' && *pLastChar != '\n');
 656         }
 657         fclose(fp);
 658         if (i == lineno) {
 659                 char *p = linebuf;
 660                 while (*p == ' ' || *p == '\t' || *p == '\014')
 661                         p++;
 662                 return PyString_FromString(p);
 663         }
 664         return NULL;
 665 }