Python/errors.c

   1
   2 /* Error handling */
   3
   4 #include "Python.h"
   5
   6 #ifndef __STDC__
   7 #ifndef MS_WINDOWS
   8 extern char *strerror(int);
   9 #endif
  10 #endif
  11
  12 #ifdef MS_WINDOWS
  13 #include <windows.h>
  14 #include <winbase.h>
  15 #endif
  16
  17 #include <ctype.h>
  18
  19 #ifdef __cplusplus
  20 extern "C" {
  21 #endif
  22
  23
  24 void
  25 PyErr_Restore(PyObject *type, PyObject *value, PyObject *traceback)
  26 {
  27         PyThreadState *tstate = PyThreadState_GET();
  28         PyObject *oldtype, *oldvalue, *oldtraceback;
  29
  30         if (traceback != NULL && !PyTraceBack_Check(traceback)) {
  31                 /* XXX Should never happen -- fatal error instead? */
  32                 /* Well, it could be None. */
  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         PyThreadState *tstate = PyThreadState_GET();
  56         PyObject *exc_value;
  57         PyObject *tb = NULL;
  58
  59         if (exception != NULL &&
  60             !PyExceptionClass_Check(exception)) {
  61                 PyErr_Format(PyExc_SystemError,
  62                              "exception %R not a BaseException subclass",
  63                              exception);
  64                 return;
  65         }
  66         Py_XINCREF(value);
  67         exc_value = tstate->exc_value;
  68         if (exc_value != NULL && exc_value != Py_None) {
  69                 /* Implicit exception chaining */
  70                 Py_INCREF(exc_value);
  71                 if (value == NULL || !PyExceptionInstance_Check(value)) {
  72                         /* We must normalize the value right now */
  73                         PyObject *args, *fixed_value;
  74                         if (value == NULL || value == Py_None)
  75                                 args = PyTuple_New(0);
  76                         else if (PyTuple_Check(value)) {
  77                                 Py_INCREF(value);
  78                                 args = value;
  79                         }
  80                         else
  81                                 args = PyTuple_Pack(1, value);
  82                         fixed_value = args ?
  83                                 PyEval_CallObject(exception, args) : NULL;
  84                         Py_XDECREF(args);
  85                         Py_XDECREF(value);
  86                         if (fixed_value == NULL)
  87                                 return;
  88                         value = fixed_value;
  89                 }
  90                 /* Avoid reference cycles through the context chain.
  91                    This is O(chain length) but context chains are
  92                    usually very short. Sensitive readers may try
  93                    to inline the call to PyException_GetContext. */
  94                 if (exc_value != value) {
  95                         PyObject *o = exc_value, *context;
  96                         while ((context = PyException_GetContext(o))) {
  97                                 Py_DECREF(context);
  98                                 if (context == value) {
  99                                         PyException_SetContext(o, NULL);
 100                                         break;
 101                                 }
 102                                 o = context;
 103                         }
 104                         PyException_SetContext(value, exc_value);
 105                 } else {
 106                         Py_DECREF(exc_value);
 107                 }
 108         }
 109         if (value != NULL && PyExceptionInstance_Check(value))
 110                 tb = PyException_GetTraceback(value);
 111         Py_XINCREF(exception);
 112         PyErr_Restore(exception, value, tb);
 113 }
 114
 115 void
 116 PyErr_SetNone(PyObject *exception)
 117 {
 118         PyErr_SetObject(exception, (PyObject *)NULL);
 119 }
 120
 121 void
 122 PyErr_SetString(PyObject *exception, const char *string)
 123 {
 124         PyObject *value = PyUnicode_FromString(string);
 125         PyErr_SetObject(exception, value);
 126         Py_XDECREF(value);
 127 }
 128
 129
 130 PyObject *
 131 PyErr_Occurred(void)
 132 {
 133         PyThreadState *tstate = PyThreadState_GET();
 134
 135         return tstate->curexc_type;
 136 }
 137
 138
 139 int
 140 PyErr_GivenExceptionMatches(PyObject *err, PyObject *exc)
 141 {
 142         if (err == NULL || exc == NULL) {
 143                 /* maybe caused by "import exceptions" that failed early on */
 144                 return 0;
 145         }
 146         if (PyTuple_Check(exc)) {
 147                 Py_ssize_t i, n;
 148                 n = PyTuple_Size(exc);
 149                 for (i = 0; i < n; i++) {
 150                         /* Test recursively */
 151                      if (PyErr_GivenExceptionMatches(
 152                              err, PyTuple_GET_ITEM(exc, i)))
 153                      {
 154                              return 1;
 155                      }
 156                 }
 157                 return 0;
 158         }
 159         /* err might be an instance, so check its class. */
 160         if (PyExceptionInstance_Check(err))
 161                 err = PyExceptionInstance_Class(err);
 162
 163         if (PyExceptionClass_Check(err) && PyExceptionClass_Check(exc)) {
 164                 int res = 0;
 165                 PyObject *exception, *value, *tb;
 166                 PyErr_Fetch(&exception, &value, &tb);
 167                 /* PyObject_IsSubclass() can recurse and therefore is
 168                    not safe (see test_bad_getattr in test.pickletester). */
 169                 res = PyType_IsSubtype((PyTypeObject *)err, (PyTypeObject *)exc);
 170                 /* This function must not fail, so print the error here */
 171                 if (res == -1) {
 172                         PyErr_WriteUnraisable(err);
 173                         res = 0;
 174                 }
 175                 PyErr_Restore(exception, value, tb);
 176                 return res;
 177         }
 178
 179         return err == exc;
 180 }
 181
 182
 183 int
 184 PyErr_ExceptionMatches(PyObject *exc)
 185 {
 186         return PyErr_GivenExceptionMatches(PyErr_Occurred(), exc);
 187 }
 188
 189
 190 /* Used in many places to normalize a raised exception, including in
 191    eval_code2(), do_raise(), and PyErr_Print()
 192
 193    XXX: should PyErr_NormalizeException() also call
 194             PyException_SetTraceback() with the resulting value and tb?
 195 */
 196 void
 197 PyErr_NormalizeException(PyObject **exc, PyObject **val, PyObject **tb)
 198 {
 199         PyObject *type = *exc;
 200         PyObject *value = *val;
 201         PyObject *inclass = NULL;
 202         PyObject *initial_tb = NULL;
 203         PyThreadState *tstate = NULL;
 204
 205         if (type == NULL) {
 206                 /* There was no exception, so nothing to do. */
 207                 return;
 208         }
 209
 210         /* If PyErr_SetNone() was used, the value will have been actually
 211            set to NULL.
 212         */
 213         if (!value) {
 214                 value = Py_None;
 215                 Py_INCREF(value);
 216         }
 217
 218         if (PyExceptionInstance_Check(value))
 219                 inclass = PyExceptionInstance_Class(value);
 220
 221         /* Normalize the exception so that if the type is a class, the
 222            value will be an instance.
 223         */
 224         if (PyExceptionClass_Check(type)) {
 225                 /* if the value was not an instance, or is not an instance
 226                    whose class is (or is derived from) type, then use the
 227                    value as an argument to instantiation of the type
 228                    class.
 229                 */
 230                 if (!inclass || !PyObject_IsSubclass(inclass, type)) {
 231                         PyObject *args, *res;
 232
 233                         if (value == Py_None)
 234                                 args = PyTuple_New(0);
 235                         else if (PyTuple_Check(value)) {
 236                                 Py_INCREF(value);
 237                                 args = value;
 238                         }
 239                         else
 240                                 args = PyTuple_Pack(1, value);
 241
 242                         if (args == NULL)
 243                                 goto finally;
 244                         res = PyEval_CallObject(type, args);
 245                         Py_DECREF(args);
 246                         if (res == NULL)
 247                                 goto finally;
 248                         Py_DECREF(value);
 249                         value = res;
 250                 }
 251                 /* if the class of the instance doesn't exactly match the
 252                    class of the type, believe the instance
 253                 */
 254                 else if (inclass != type) {
 255                         Py_DECREF(type);
 256                         type = inclass;
 257                         Py_INCREF(type);
 258                 }
 259         }
 260         *exc = type;
 261         *val = value;
 262         return;
 263 finally:
 264         Py_DECREF(type);
 265         Py_DECREF(value);
 266         /* If the new exception doesn't set a traceback and the old
 267            exception had a traceback, use the old traceback for the
 268            new exception.  It's better than nothing.
 269         */
 270         initial_tb = *tb;
 271         PyErr_Fetch(exc, val, tb);
 272         if (initial_tb != NULL) {
 273                 if (*tb == NULL)
 274                         *tb = initial_tb;
 275                 else
 276                         Py_DECREF(initial_tb);
 277         }
 278         /* normalize recursively */
 279         tstate = PyThreadState_GET();
 280         if (++tstate->recursion_depth > Py_GetRecursionLimit()) {
 281             --tstate->recursion_depth;
 282             /* throw away the old exception... */
 283             Py_DECREF(*exc);
 284             Py_DECREF(*val);
 285             /* ... and use the recursion error instead */
 286             *exc = PyExc_RuntimeError;
 287             *val = PyExc_RecursionErrorInst;
 288             Py_INCREF(*exc);
 289             Py_INCREF(*val);
 290             /* just keeping the old traceback */
 291             return;
 292         }
 293         PyErr_NormalizeException(exc, val, tb);
 294         --tstate->recursion_depth;
 295 }
 296
 297
 298 void
 299 PyErr_Fetch(PyObject **p_type, PyObject **p_value, PyObject **p_traceback)
 300 {
 301         PyThreadState *tstate = PyThreadState_GET();
 302
 303         *p_type = tstate->curexc_type;
 304         *p_value = tstate->curexc_value;
 305         *p_traceback = tstate->curexc_traceback;
 306
 307         tstate->curexc_type = NULL;
 308         tstate->curexc_value = NULL;
 309         tstate->curexc_traceback = NULL;
 310 }
 311
 312 void
 313 PyErr_Clear(void)
 314 {
 315         PyErr_Restore(NULL, NULL, NULL);
 316 }
 317
 318 /* Convenience functions to set a type error exception and return 0 */
 319
 320 int
 321 PyErr_BadArgument(void)
 322 {
 323         PyErr_SetString(PyExc_TypeError,
 324                         "bad argument type for built-in operation");
 325         return 0;
 326 }
 327
 328 PyObject *
 329 PyErr_NoMemory(void)
 330 {
 331         if (PyErr_ExceptionMatches(PyExc_MemoryError))
 332                 /* already current */
 333                 return NULL;
 334
 335         /* raise the pre-allocated instance if it still exists */
 336         if (PyExc_MemoryErrorInst)
 337         {
 338                 /* Clear the previous traceback, otherwise it will be appended
 339                  * to the current one.
 340                  *
 341                  * The following statement is not likely to raise any error;
 342                  * if it does, we simply discard it.
 343                  */
 344                 PyException_SetTraceback(PyExc_MemoryErrorInst, Py_None);
 345
 346                 PyErr_SetObject(PyExc_MemoryError, PyExc_MemoryErrorInst);
 347         }
 348         else
 349                 /* this will probably fail since there's no memory and hee,
 350                    hee, we have to instantiate this class
 351                 */
 352                 PyErr_SetNone(PyExc_MemoryError);
 353
 354         return NULL;
 355 }
 356
 357 PyObject *
 358 PyErr_SetFromErrnoWithFilenameObject(PyObject *exc, PyObject *filenameObject)
 359 {
 360         PyObject *message;
 361         PyObject *v;
 362         int i = errno;
 363 #ifdef PLAN9
 364         char errbuf[ERRMAX];
 365 #else
 366 #ifndef MS_WINDOWS
 367         char *s;
 368 #else
 369         WCHAR *s_buf = NULL;
 370 #endif /* Unix/Windows */
 371 #endif /* PLAN 9*/
 372
 373 #ifdef EINTR
 374         if (i == EINTR && PyErr_CheckSignals())
 375                 return NULL;
 376 #endif
 377
 378 #ifdef PLAN9
 379         rerrstr(errbuf, sizeof errbuf);
 380         message = PyUnicode_DecodeUTF8(errbuf, strlen(errbuf), "ignore");
 381 #else
 382 #ifndef MS_WINDOWS
 383         if (i == 0)
 384                 s = "Error"; /* Sometimes errno didn't get set */
 385         else
 386                 s = strerror(i);
 387         message = PyUnicode_DecodeUTF8(s, strlen(s), "ignore");
 388 #else
 389         if (i == 0)
 390                 message = PyUnicode_FromString("Error"); /* Sometimes errno didn't get set */
 391         else
 392         {
 393                 /* Note that the Win32 errors do not lineup with the
 394                    errno error.  So if the error is in the MSVC error
 395                    table, we use it, otherwise we assume it really _is_
 396                    a Win32 error code
 397                 */
 398                 if (i > 0 && i < _sys_nerr) {
 399                         message = PyUnicode_FromString(_sys_errlist[i]);
 400                 }
 401                 else {
 402                         int len = FormatMessageW(
 403                                 FORMAT_MESSAGE_ALLOCATE_BUFFER |
 404                                 FORMAT_MESSAGE_FROM_SYSTEM |
 405                                 FORMAT_MESSAGE_IGNORE_INSERTS,
 406                                 NULL,   /* no message source */
 407                                 i,
 408                                 MAKELANGID(LANG_NEUTRAL,
 409                                            SUBLANG_DEFAULT),
 410                                            /* Default language */
 411                                 (LPWSTR) &s_buf,
 412                                 0,      /* size not used */
 413                                 NULL);  /* no args */
 414                         if (len==0) {
 415                                 /* Only ever seen this in out-of-mem
 416                                    situations */
 417                                 s_buf = NULL;
 418                                 message = PyUnicode_FromFormat("Windows Error 0x%X", i);
 419                         } else {
 420                                 /* remove trailing cr/lf and dots */
 421                                 while (len > 0 && (s_buf[len-1] <= L' ' || s_buf[len-1] == L'.'))
 422                                         s_buf[--len] = L'\0';
 423                                 message = PyUnicode_FromUnicode(s_buf, len);
 424                         }
 425                 }
 426         }
 427 #endif /* Unix/Windows */
 428 #endif /* PLAN 9*/
 429
 430         if (message == NULL)
 431         {
 432 #ifdef MS_WINDOWS
 433                 LocalFree(s_buf);
 434 #endif
 435                 return NULL;
 436         }
 437
 438         if (filenameObject != NULL)
 439                 v = Py_BuildValue("(iOO)", i, message, filenameObject);
 440         else
 441                 v = Py_BuildValue("(iO)", i, message);
 442         Py_DECREF(message);
 443
 444         if (v != NULL) {
 445                 PyErr_SetObject(exc, v);
 446                 Py_DECREF(v);
 447         }
 448 #ifdef MS_WINDOWS
 449         LocalFree(s_buf);
 450 #endif
 451         return NULL;
 452 }
 453
 454
 455 PyObject *
 456 PyErr_SetFromErrnoWithFilename(PyObject *exc, const char *filename)
 457 {
 458         PyObject *name = filename ? PyUnicode_FromString(filename) : NULL;
 459         PyObject *result = PyErr_SetFromErrnoWithFilenameObject(exc, name);
 460         Py_XDECREF(name);
 461         return result;
 462 }
 463
 464 #ifdef MS_WINDOWS
 465 PyObject *
 466 PyErr_SetFromErrnoWithUnicodeFilename(PyObject *exc, const Py_UNICODE *filename)
 467 {
 468         PyObject *name = filename ?
 469                          PyUnicode_FromUnicode(filename, wcslen(filename)) :
 470                          NULL;
 471         PyObject *result = PyErr_SetFromErrnoWithFilenameObject(exc, name);
 472         Py_XDECREF(name);
 473         return result;
 474 }
 475 #endif /* MS_WINDOWS */
 476
 477 PyObject *
 478 PyErr_SetFromErrno(PyObject *exc)
 479 {
 480         return PyErr_SetFromErrnoWithFilenameObject(exc, NULL);
 481 }
 482
 483 #ifdef MS_WINDOWS
 484 /* Windows specific error code handling */
 485 PyObject *PyErr_SetExcFromWindowsErrWithFilenameObject(
 486         PyObject *exc,
 487         int ierr,
 488         PyObject *filenameObject)
 489 {
 490         int len;
 491         WCHAR *s_buf = NULL; /* Free via LocalFree */
 492         PyObject *message;
 493         PyObject *v;
 494         DWORD err = (DWORD)ierr;
 495         if (err==0) err = GetLastError();
 496         len = FormatMessageW(
 497                 /* Error API error */
 498                 FORMAT_MESSAGE_ALLOCATE_BUFFER |
 499                 FORMAT_MESSAGE_FROM_SYSTEM |
 500                 FORMAT_MESSAGE_IGNORE_INSERTS,
 501                 NULL,   /* no message source */
 502                 err,
 503                 MAKELANGID(LANG_NEUTRAL,
 504                 SUBLANG_DEFAULT), /* Default language */
 505                 (LPWSTR) &s_buf,
 506                 0,      /* size not used */
 507                 NULL);  /* no args */
 508         if (len==0) {
 509                 /* Only seen this in out of mem situations */
 510                 message = PyUnicode_FromFormat("Windows Error 0x%X", err);
 511                 s_buf = NULL;
 512         } else {
 513                 /* remove trailing cr/lf and dots */
 514                 while (len > 0 && (s_buf[len-1] <= L' ' || s_buf[len-1] == L'.'))
 515                         s_buf[--len] = L'\0';
 516                 message = PyUnicode_FromUnicode(s_buf, len);
 517         }
 518
 519         if (message == NULL)
 520         {
 521                 LocalFree(s_buf);
 522                 return NULL;
 523         }
 524
 525         if (filenameObject != NULL)
 526                 v = Py_BuildValue("(iOO)", err, message, filenameObject);
 527         else
 528                 v = Py_BuildValue("(iO)", err, message);
 529         Py_DECREF(message);
 530
 531         if (v != NULL) {
 532                 PyErr_SetObject(exc, v);
 533                 Py_DECREF(v);
 534         }
 535         LocalFree(s_buf);
 536         return NULL;
 537 }
 538
 539 PyObject *PyErr_SetExcFromWindowsErrWithFilename(
 540         PyObject *exc,
 541         int ierr,
 542         const char *filename)
 543 {
 544         PyObject *name = filename ? PyUnicode_FromString(filename) : NULL;
 545         PyObject *ret = PyErr_SetExcFromWindowsErrWithFilenameObject(exc,
 546                                                                      ierr,
 547                                                                      name);
 548         Py_XDECREF(name);
 549         return ret;
 550 }
 551
 552 PyObject *PyErr_SetExcFromWindowsErrWithUnicodeFilename(
 553         PyObject *exc,
 554         int ierr,
 555         const Py_UNICODE *filename)
 556 {
 557         PyObject *name = filename ?
 558                          PyUnicode_FromUnicode(filename, wcslen(filename)) :
 559                          NULL;
 560         PyObject *ret = PyErr_SetExcFromWindowsErrWithFilenameObject(exc,
 561                                                                      ierr,
 562                                                                      name);
 563         Py_XDECREF(name);
 564         return ret;
 565 }
 566
 567 PyObject *PyErr_SetExcFromWindowsErr(PyObject *exc, int ierr)
 568 {
 569         return PyErr_SetExcFromWindowsErrWithFilename(exc, ierr, NULL);
 570 }
 571
 572 PyObject *PyErr_SetFromWindowsErr(int ierr)
 573 {
 574         return PyErr_SetExcFromWindowsErrWithFilename(PyExc_WindowsError,
 575                                                       ierr, NULL);
 576 }
 577 PyObject *PyErr_SetFromWindowsErrWithFilename(
 578         int ierr,
 579         const char *filename)
 580 {
 581         PyObject *name = filename ? PyUnicode_FromString(filename) : NULL;
 582         PyObject *result = PyErr_SetExcFromWindowsErrWithFilenameObject(
 583                                                       PyExc_WindowsError,
 584                                                       ierr, name);
 585         Py_XDECREF(name);
 586         return result;
 587 }
 588
 589 PyObject *PyErr_SetFromWindowsErrWithUnicodeFilename(
 590         int ierr,
 591         const Py_UNICODE *filename)
 592 {
 593         PyObject *name = filename ?
 594                          PyUnicode_FromUnicode(filename, wcslen(filename)) :
 595                          NULL;
 596         PyObject *result = PyErr_SetExcFromWindowsErrWithFilenameObject(
 597                                                       PyExc_WindowsError,
 598                                                       ierr, name);
 599         Py_XDECREF(name);
 600         return result;
 601 }
 602 #endif /* MS_WINDOWS */
 603
 604 void
 605 _PyErr_BadInternalCall(const char *filename, int lineno)
 606 {
 607         PyErr_Format(PyExc_SystemError,
 608                      "%s:%d: bad argument to internal function",
 609                      filename, lineno);
 610 }
 611
 612 /* Remove the preprocessor macro for PyErr_BadInternalCall() so that we can
 613    export the entry point for existing object code: */
 614 #undef PyErr_BadInternalCall
 615 void
 616 PyErr_BadInternalCall(void)
 617 {
 618         PyErr_Format(PyExc_SystemError,
 619                      "bad argument to internal function");
 620 }
 621 #define PyErr_BadInternalCall() _PyErr_BadInternalCall(__FILE__, __LINE__)
 622
 623
 624
 625 PyObject *
 626 PyErr_Format(PyObject *exception, const char *format, ...)
 627 {
 628         va_list vargs;
 629         PyObject* string;
 630
 631 #ifdef HAVE_STDARG_PROTOTYPES
 632         va_start(vargs, format);
 633 #else
 634         va_start(vargs);
 635 #endif
 636
 637         string = PyUnicode_FromFormatV(format, vargs);
 638         PyErr_SetObject(exception, string);
 639         Py_XDECREF(string);
 640         va_end(vargs);
 641         return NULL;
 642 }
 643
 644
 645
 646 PyObject *
 647 PyErr_NewException(const char *name, PyObject *base, PyObject *dict)
 648 {
 649         const char *dot;
 650         PyObject *modulename = NULL;
 651         PyObject *classname = NULL;
 652         PyObject *mydict = NULL;
 653         PyObject *bases = NULL;
 654         PyObject *result = NULL;
 655         dot = strrchr(name, '.');
 656         if (dot == NULL) {
 657                 PyErr_SetString(PyExc_SystemError,
 658                         "PyErr_NewException: name must be module.class");
 659                 return NULL;
 660         }
 661         if (base == NULL)
 662                 base = PyExc_Exception;
 663         if (dict == NULL) {
 664                 dict = mydict = PyDict_New();
 665                 if (dict == NULL)
 666                         goto failure;
 667         }
 668         if (PyDict_GetItemString(dict, "__module__") == NULL) {
 669                 modulename = PyUnicode_FromStringAndSize(name,
 670                                                      (Py_ssize_t)(dot-name));
 671                 if (modulename == NULL)
 672                         goto failure;
 673                 if (PyDict_SetItemString(dict, "__module__", modulename) != 0)
 674                         goto failure;
 675         }
 676         if (PyTuple_Check(base)) {
 677                 bases = base;
 678                 /* INCREF as we create a new ref in the else branch */
 679                 Py_INCREF(bases);
 680         } else {
 681                 bases = PyTuple_Pack(1, base);
 682                 if (bases == NULL)
 683                         goto failure;
 684         }
 685         /* Create a real new-style class. */
 686         result = PyObject_CallFunction((PyObject *)&PyType_Type, "UOO",
 687                                        dot+1, bases, dict);
 688   failure:
 689         Py_XDECREF(bases);
 690         Py_XDECREF(mydict);
 691         Py_XDECREF(classname);
 692         Py_XDECREF(modulename);
 693         return result;
 694 }
 695
 696 /* Call when an exception has occurred but there is no way for Python
 697    to handle it.  Examples: exception in __del__ or during GC. */
 698 void
 699 PyErr_WriteUnraisable(PyObject *obj)
 700 {
 701         PyObject *f, *t, *v, *tb;
 702         PyErr_Fetch(&t, &v, &tb);
 703         f = PySys_GetObject("stderr");
 704         if (f != NULL && f != Py_None) {
 705                 PyFile_WriteString("Exception ", f);
 706                 if (t) {
 707                         PyObject* moduleName;
 708                         char* className;
 709                         assert(PyExceptionClass_Check(t));
 710                         className = PyExceptionClass_Name(t);
 711                         if (className != NULL) {
 712                                 char *dot = strrchr(className, '.');
 713                                 if (dot != NULL)
 714                                         className = dot+1;
 715                         }
 716
 717                         moduleName = PyObject_GetAttrString(t, "__module__");
 718                         if (moduleName == NULL)
 719                                 PyFile_WriteString("<unknown>", f);
 720                         else {
 721                                 char* modstr = _PyUnicode_AsString(moduleName);
 722                                 if (modstr &&
 723                                     strcmp(modstr, "builtins") != 0)
 724                                 {
 725                                         PyFile_WriteString(modstr, f);
 726                                         PyFile_WriteString(".", f);
 727                                 }
 728                         }
 729                         if (className == NULL)
 730                                 PyFile_WriteString("<unknown>", f);
 731                         else
 732                                 PyFile_WriteString(className, f);
 733                         if (v && v != Py_None) {
 734                                 PyFile_WriteString(": ", f);
 735                                 PyFile_WriteObject(v, f, 0);
 736                         }
 737                         Py_XDECREF(moduleName);
 738                 }
 739                 PyFile_WriteString(" in ", f);
 740                 PyFile_WriteObject(obj, f, 0);
 741                 PyFile_WriteString(" ignored\n", f);
 742                 PyErr_Clear(); /* Just in case */
 743         }
 744         Py_XDECREF(t);
 745         Py_XDECREF(v);
 746         Py_XDECREF(tb);
 747 }
 748
 749 extern PyObject *PyModule_GetWarningsModule(void);
 750
 751
 752 /* Set file and line information for the current exception.
 753    If the exception is not a SyntaxError, also sets additional attributes
 754    to make printing of exceptions believe it is a syntax error. */
 755
 756 void
 757 PyErr_SyntaxLocation(const char *filename, int lineno)
 758 {
 759         PyObject *exc, *v, *tb, *tmp;
 760
 761         /* add attributes for the line number and filename for the error */
 762         PyErr_Fetch(&exc, &v, &tb);
 763         PyErr_NormalizeException(&exc, &v, &tb);
 764         /* XXX check that it is, indeed, a syntax error. It might not
 765          * be, though. */
 766         tmp = PyLong_FromLong(lineno);
 767         if (tmp == NULL)
 768                 PyErr_Clear();
 769         else {
 770                 if (PyObject_SetAttrString(v, "lineno", tmp))
 771                         PyErr_Clear();
 772                 Py_DECREF(tmp);
 773         }
 774         if (filename != NULL) {
 775                 tmp = PyUnicode_FromString(filename);
 776                 if (tmp == NULL)
 777                         PyErr_Clear();
 778                 else {
 779                         if (PyObject_SetAttrString(v, "filename", tmp))
 780                                 PyErr_Clear();
 781                         Py_DECREF(tmp);
 782                 }
 783
 784                 tmp = PyErr_ProgramText(filename, lineno);
 785                 if (tmp) {
 786                         if (PyObject_SetAttrString(v, "text", tmp))
 787                                 PyErr_Clear();
 788                         Py_DECREF(tmp);
 789                 }
 790         }
 791         if (PyObject_SetAttrString(v, "offset", Py_None)) {
 792                 PyErr_Clear();
 793         }
 794         if (exc != PyExc_SyntaxError) {
 795                 if (!PyObject_HasAttrString(v, "msg")) {
 796                         tmp = PyObject_Str(v);
 797                         if (tmp) {
 798                                 if (PyObject_SetAttrString(v, "msg", tmp))
 799                                         PyErr_Clear();
 800                                 Py_DECREF(tmp);
 801                         } else {
 802                                 PyErr_Clear();
 803                         }
 804                 }
 805                 if (!PyObject_HasAttrString(v, "print_file_and_line")) {
 806                         if (PyObject_SetAttrString(v, "print_file_and_line",
 807                                                    Py_None))
 808                                 PyErr_Clear();
 809                 }
 810         }
 811         PyErr_Restore(exc, v, tb);
 812 }
 813
 814 /* Attempt to load the line of text that the exception refers to.  If it
 815    fails, it will return NULL but will not set an exception.
 816
 817    XXX The functionality of this function is quite similar to the
 818    functionality in tb_displayline() in traceback.c. */
 819
 820 PyObject *
 821 PyErr_ProgramText(const char *filename, int lineno)
 822 {
 823         FILE *fp;
 824         int i;
 825         char linebuf[1000];
 826
 827         if (filename == NULL || *filename == '\0' || lineno <= 0)
 828                 return NULL;
 829         fp = fopen(filename, "r" PY_STDIOTEXTMODE);
 830         if (fp == NULL)
 831                 return NULL;
 832         for (i = 0; i < lineno; i++) {
 833                 char *pLastChar = &linebuf[sizeof(linebuf) - 2];
 834                 do {
 835                         *pLastChar = '\0';
 836                         if (Py_UniversalNewlineFgets(linebuf, sizeof linebuf,
 837                                                      fp, NULL) == NULL)
 838                                 break;
 839                         /* fgets read *something*; if it didn't get as
 840                            far as pLastChar, it must have found a newline
 841                            or hit the end of the file; if pLastChar is \n,
 842                            it obviously found a newline; else we haven't
 843                            yet seen a newline, so must continue */
 844                 } while (*pLastChar != '\0' && *pLastChar != '\n');
 845         }
 846         fclose(fp);
 847         if (i == lineno) {
 848                 char *p = linebuf;
 849                 PyObject *res;
 850                 while (*p == ' ' || *p == '\t' || *p == '\014')
 851                         p++;
 852                 res = PyUnicode_FromString(p);
 853                 if (res == NULL)
 854                         PyErr_Clear();
 855                 return res;
 856         }
 857         return NULL;
 858 }
 859
 860 #ifdef __cplusplus
 861 }
 862 #endif