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         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                 Py_ssize_t 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 (PyExceptionInstance_Check(err))
 106                 err = PyExceptionInstance_Class(err);
 107
 108         if (PyExceptionClass_Check(err) && PyExceptionClass_Check(exc)) {
 109                 int res = 0, reclimit;
 110                 PyObject *exception, *value, *tb;
 111                 PyErr_Fetch(&exception, &value, &tb);
 112                 /* Temporarily bump the recursion limit, so that in the most
 113                    common case PyObject_IsSubclass will not raise a recursion
 114                    error we have to ignore anyway. */
 115                 reclimit = Py_GetRecursionLimit();
 116                 Py_SetRecursionLimit(reclimit + 5);
 117                 res = PyObject_IsSubclass(err, exc);
 118                 Py_SetRecursionLimit(reclimit);
 119                 /* This function must not fail, so print the error here */
 120                 if (res == -1) {
 121                         PyErr_WriteUnraisable(err);
 122                         res = 0;
 123                 }
 124                 PyErr_Restore(exception, value, tb);
 125                 return res;
 126         }
 127
 128         return err == exc;
 129 }
 130
 131
 132 int
 133 PyErr_ExceptionMatches(PyObject *exc)
 134 {
 135         return PyErr_GivenExceptionMatches(PyErr_Occurred(), exc);
 136 }
 137
 138
 139 /* Used in many places to normalize a raised exception, including in
 140    eval_code2(), do_raise(), and PyErr_Print()
 141 */
 142 void
 143 PyErr_NormalizeException(PyObject **exc, PyObject **val, PyObject **tb)
 144 {
 145         PyObject *type = *exc;
 146         PyObject *value = *val;
 147         PyObject *inclass = NULL;
 148         PyObject *initial_tb = NULL;
 149         PyThreadState *tstate = NULL;
 150
 151         if (type == NULL) {
 152                 /* There was no exception, so nothing to do. */
 153                 return;
 154         }
 155
 156         /* If PyErr_SetNone() was used, the value will have been actually
 157            set to NULL.
 158         */
 159         if (!value) {
 160                 value = Py_None;
 161                 Py_INCREF(value);
 162         }
 163
 164         if (PyExceptionInstance_Check(value))
 165                 inclass = PyExceptionInstance_Class(value);
 166
 167         /* Normalize the exception so that if the type is a class, the
 168            value will be an instance.
 169         */
 170         if (PyExceptionClass_Check(type)) {
 171                 /* if the value was not an instance, or is not an instance
 172                    whose class is (or is derived from) type, then use the
 173                    value as an argument to instantiation of the type
 174                    class.
 175                 */
 176                 if (!inclass || !PyObject_IsSubclass(inclass, type)) {
 177                         PyObject *args, *res;
 178
 179                         if (value == Py_None)
 180                                 args = PyTuple_New(0);
 181                         else if (PyTuple_Check(value)) {
 182                                 Py_INCREF(value);
 183                                 args = value;
 184                         }
 185                         else
 186                                 args = PyTuple_Pack(1, value);
 187
 188                         if (args == NULL)
 189                                 goto finally;
 190                         res = PyEval_CallObject(type, args);
 191                         Py_DECREF(args);
 192                         if (res == NULL)
 193                                 goto finally;
 194                         Py_DECREF(value);
 195                         value = res;
 196                 }
 197                 /* if the class of the instance doesn't exactly match the
 198                    class of the type, believe the instance
 199                 */
 200                 else if (inclass != type) {
 201                         Py_DECREF(type);
 202                         type = inclass;
 203                         Py_INCREF(type);
 204                 }
 205         }
 206         *exc = type;
 207         *val = value;
 208         return;
 209 finally:
 210         Py_DECREF(type);
 211         Py_DECREF(value);
 212         /* If the new exception doesn't set a traceback and the old
 213            exception had a traceback, use the old traceback for the
 214            new exception.  It's better than nothing.
 215         */
 216         initial_tb = *tb;
 217         PyErr_Fetch(exc, val, tb);
 218         if (initial_tb != NULL) {
 219                 if (*tb == NULL)
 220                         *tb = initial_tb;
 221                 else
 222                         Py_DECREF(initial_tb);
 223         }
 224         /* normalize recursively */
 225         tstate = PyThreadState_GET();
 226         if (++tstate->recursion_depth > Py_GetRecursionLimit()) {
 227             --tstate->recursion_depth;
 228             /* throw away the old exception... */
 229             Py_DECREF(*exc);
 230             Py_DECREF(*val);
 231             /* ... and use the recursion error instead */
 232             *exc = PyExc_RuntimeError;
 233             *val = PyExc_RecursionErrorInst;
 234             Py_INCREF(*exc);
 235             Py_INCREF(*val);
 236             /* just keeping the old traceback */
 237             return;
 238         }
 239         PyErr_NormalizeException(exc, val, tb);
 240         --tstate->recursion_depth;
 241 }
 242
 243
 244 void
 245 PyErr_Fetch(PyObject **p_type, PyObject **p_value, PyObject **p_traceback)
 246 {
 247         PyThreadState *tstate = PyThreadState_GET();
 248
 249         *p_type = tstate->curexc_type;
 250         *p_value = tstate->curexc_value;
 251         *p_traceback = tstate->curexc_traceback;
 252
 253         tstate->curexc_type = NULL;
 254         tstate->curexc_value = NULL;
 255         tstate->curexc_traceback = NULL;
 256 }
 257
 258 void
 259 PyErr_Clear(void)
 260 {
 261         PyErr_Restore(NULL, NULL, NULL);
 262 }
 263
 264 /* Convenience functions to set a type error exception and return 0 */
 265
 266 int
 267 PyErr_BadArgument(void)
 268 {
 269         PyErr_SetString(PyExc_TypeError,
 270                         "bad argument type for built-in operation");
 271         return 0;
 272 }
 273
 274 PyObject *
 275 PyErr_NoMemory(void)
 276 {
 277         if (PyErr_ExceptionMatches(PyExc_MemoryError))
 278                 /* already current */
 279                 return NULL;
 280
 281         /* raise the pre-allocated instance if it still exists */
 282         if (PyExc_MemoryErrorInst)
 283                 PyErr_SetObject(PyExc_MemoryError, PyExc_MemoryErrorInst);
 284         else
 285                 /* this will probably fail since there's no memory and hee,
 286                    hee, we have to instantiate this class
 287                 */
 288                 PyErr_SetNone(PyExc_MemoryError);
 289
 290         return NULL;
 291 }
 292
 293 PyObject *
 294 PyErr_SetFromErrnoWithFilenameObject(PyObject *exc, PyObject *filenameObject)
 295 {
 296         PyObject *v;
 297         char *s;
 298         int i = errno;
 299 #ifdef PLAN9
 300         char errbuf[ERRMAX];
 301 #endif
 302 #ifdef MS_WINDOWS
 303         char *s_buf = NULL;
 304         char s_small_buf[28]; /* Room for "Windows Error 0xFFFFFFFF" */
 305 #endif
 306 #ifdef EINTR
 307         if (i == EINTR && PyErr_CheckSignals())
 308                 return NULL;
 309 #endif
 310 #ifdef PLAN9
 311         rerrstr(errbuf, sizeof errbuf);
 312         s = errbuf;
 313 #else
 314         if (i == 0)
 315                 s = "Error"; /* Sometimes errno didn't get set */
 316         else
 317 #ifndef MS_WINDOWS
 318                 s = strerror(i);
 319 #else
 320         {
 321                 /* Note that the Win32 errors do not lineup with the
 322                    errno error.  So if the error is in the MSVC error
 323                    table, we use it, otherwise we assume it really _is_
 324                    a Win32 error code
 325                 */
 326                 if (i > 0 && i < _sys_nerr) {
 327                         s = _sys_errlist[i];
 328                 }
 329                 else {
 330                         int len = FormatMessage(
 331                                 FORMAT_MESSAGE_ALLOCATE_BUFFER |
 332                                 FORMAT_MESSAGE_FROM_SYSTEM |
 333                                 FORMAT_MESSAGE_IGNORE_INSERTS,
 334                                 NULL,   /* no message source */
 335                                 i,
 336                                 MAKELANGID(LANG_NEUTRAL,
 337                                            SUBLANG_DEFAULT),
 338                                            /* Default language */
 339                                 (LPTSTR) &s_buf,
 340                                 0,      /* size not used */
 341                                 NULL);  /* no args */
 342                         if (len==0) {
 343                                 /* Only ever seen this in out-of-mem
 344                                    situations */
 345                                 sprintf(s_small_buf, "Windows Error 0x%X", i);
 346                                 s = s_small_buf;
 347                                 s_buf = NULL;
 348                         } else {
 349                                 s = s_buf;
 350                                 /* remove trailing cr/lf and dots */
 351                                 while (len > 0 && (s[len-1] <= ' ' || s[len-1] == '.'))
 352                                         s[--len] = '\0';
 353                         }
 354                 }
 355         }
 356 #endif /* Unix/Windows */
 357 #endif /* PLAN 9*/
 358         if (filenameObject != NULL)
 359                 v = Py_BuildValue("(isO)", i, s, filenameObject);
 360         else
 361                 v = Py_BuildValue("(is)", i, s);
 362         if (v != NULL) {
 363                 PyErr_SetObject(exc, v);
 364                 Py_DECREF(v);
 365         }
 366 #ifdef MS_WINDOWS
 367         LocalFree(s_buf);
 368 #endif
 369         return NULL;
 370 }
 371
 372
 373 PyObject *
 374 PyErr_SetFromErrnoWithFilename(PyObject *exc, const char *filename)
 375 {
 376         PyObject *name = filename ? PyString_FromString(filename) : NULL;
 377         PyObject *result = PyErr_SetFromErrnoWithFilenameObject(exc, name);
 378         Py_XDECREF(name);
 379         return result;
 380 }
 381
 382 #ifdef MS_WINDOWS
 383 PyObject *
 384 PyErr_SetFromErrnoWithUnicodeFilename(PyObject *exc, const Py_UNICODE *filename)
 385 {
 386         PyObject *name = filename ?
 387                          PyUnicode_FromUnicode(filename, wcslen(filename)) :
 388                          NULL;
 389         PyObject *result = PyErr_SetFromErrnoWithFilenameObject(exc, name);
 390         Py_XDECREF(name);
 391         return result;
 392 }
 393 #endif /* MS_WINDOWS */
 394
 395 PyObject *
 396 PyErr_SetFromErrno(PyObject *exc)
 397 {
 398         return PyErr_SetFromErrnoWithFilenameObject(exc, NULL);
 399 }
 400
 401 #ifdef MS_WINDOWS
 402 /* Windows specific error code handling */
 403 PyObject *PyErr_SetExcFromWindowsErrWithFilenameObject(
 404         PyObject *exc,
 405         int ierr,
 406         PyObject *filenameObject)
 407 {
 408         int len;
 409         char *s;
 410         char *s_buf = NULL; /* Free via LocalFree */
 411         char s_small_buf[28]; /* Room for "Windows Error 0xFFFFFFFF" */
 412         PyObject *v;
 413         DWORD err = (DWORD)ierr;
 414         if (err==0) err = GetLastError();
 415         len = FormatMessage(
 416                 /* Error API error */
 417                 FORMAT_MESSAGE_ALLOCATE_BUFFER |
 418                 FORMAT_MESSAGE_FROM_SYSTEM |
 419                 FORMAT_MESSAGE_IGNORE_INSERTS,
 420                 NULL,   /* no message source */
 421                 err,
 422                 MAKELANGID(LANG_NEUTRAL,
 423                 SUBLANG_DEFAULT), /* Default language */
 424                 (LPTSTR) &s_buf,
 425                 0,      /* size not used */
 426                 NULL);  /* no args */
 427         if (len==0) {
 428                 /* Only seen this in out of mem situations */
 429                 sprintf(s_small_buf, "Windows Error 0x%X", err);
 430                 s = s_small_buf;
 431                 s_buf = NULL;
 432         } else {
 433                 s = s_buf;
 434                 /* remove trailing cr/lf and dots */
 435                 while (len > 0 && (s[len-1] <= ' ' || s[len-1] == '.'))
 436                         s[--len] = '\0';
 437         }
 438         if (filenameObject != NULL)
 439                 v = Py_BuildValue("(isO)", err, s, filenameObject);
 440         else
 441                 v = Py_BuildValue("(is)", err, s);
 442         if (v != NULL) {
 443                 PyErr_SetObject(exc, v);
 444                 Py_DECREF(v);
 445         }
 446         LocalFree(s_buf);
 447         return NULL;
 448 }
 449
 450 PyObject *PyErr_SetExcFromWindowsErrWithFilename(
 451         PyObject *exc,
 452         int ierr,
 453         const char *filename)
 454 {
 455         PyObject *name = filename ? PyString_FromString(filename) : NULL;
 456         PyObject *ret = PyErr_SetExcFromWindowsErrWithFilenameObject(exc,
 457                                                                      ierr,
 458                                                                      name);
 459         Py_XDECREF(name);
 460         return ret;
 461 }
 462
 463 PyObject *PyErr_SetExcFromWindowsErrWithUnicodeFilename(
 464         PyObject *exc,
 465         int ierr,
 466         const Py_UNICODE *filename)
 467 {
 468         PyObject *name = filename ?
 469                          PyUnicode_FromUnicode(filename, wcslen(filename)) :
 470                          NULL;
 471         PyObject *ret = PyErr_SetExcFromWindowsErrWithFilenameObject(exc,
 472                                                                      ierr,
 473                                                                      name);
 474         Py_XDECREF(name);
 475         return ret;
 476 }
 477
 478 PyObject *PyErr_SetExcFromWindowsErr(PyObject *exc, int ierr)
 479 {
 480         return PyErr_SetExcFromWindowsErrWithFilename(exc, ierr, NULL);
 481 }
 482
 483 PyObject *PyErr_SetFromWindowsErr(int ierr)
 484 {
 485         return PyErr_SetExcFromWindowsErrWithFilename(PyExc_WindowsError,
 486                                                       ierr, NULL);
 487 }
 488 PyObject *PyErr_SetFromWindowsErrWithFilename(
 489         int ierr,
 490         const char *filename)
 491 {
 492         PyObject *name = filename ? PyString_FromString(filename) : NULL;
 493         PyObject *result = PyErr_SetExcFromWindowsErrWithFilenameObject(
 494                                                       PyExc_WindowsError,
 495                                                       ierr, name);
 496         Py_XDECREF(name);
 497         return result;
 498 }
 499
 500 PyObject *PyErr_SetFromWindowsErrWithUnicodeFilename(
 501         int ierr,
 502         const Py_UNICODE *filename)
 503 {
 504         PyObject *name = filename ?
 505                          PyUnicode_FromUnicode(filename, wcslen(filename)) :
 506                          NULL;
 507         PyObject *result = PyErr_SetExcFromWindowsErrWithFilenameObject(
 508                                                       PyExc_WindowsError,
 509                                                       ierr, name);
 510         Py_XDECREF(name);
 511         return result;
 512 }
 513 #endif /* MS_WINDOWS */
 514
 515 void
 516 _PyErr_BadInternalCall(char *filename, int lineno)
 517 {
 518         PyErr_Format(PyExc_SystemError,
 519                      "%s:%d: bad argument to internal function",
 520                      filename, lineno);
 521 }
 522
 523 /* Remove the preprocessor macro for PyErr_BadInternalCall() so that we can
 524    export the entry point for existing object code: */
 525 #undef PyErr_BadInternalCall
 526 void
 527 PyErr_BadInternalCall(void)
 528 {
 529         PyErr_Format(PyExc_SystemError,
 530                      "bad argument to internal function");
 531 }
 532 #define PyErr_BadInternalCall() _PyErr_BadInternalCall(__FILE__, __LINE__)
 533
 534
 535
 536 PyObject *
 537 PyErr_Format(PyObject *exception, const char *format, ...)
 538 {
 539         va_list vargs;
 540         PyObject* string;
 541
 542 #ifdef HAVE_STDARG_PROTOTYPES
 543         va_start(vargs, format);
 544 #else
 545         va_start(vargs);
 546 #endif
 547
 548         string = PyString_FromFormatV(format, vargs);
 549         PyErr_SetObject(exception, string);
 550         Py_XDECREF(string);
 551         va_end(vargs);
 552         return NULL;
 553 }
 554
 555
 556
 557 PyObject *
 558 PyErr_NewException(char *name, PyObject *base, PyObject *dict)
 559 {
 560         char *dot;
 561         PyObject *modulename = NULL;
 562         PyObject *classname = NULL;
 563         PyObject *mydict = NULL;
 564         PyObject *bases = NULL;
 565         PyObject *result = NULL;
 566         dot = strrchr(name, '.');
 567         if (dot == NULL) {
 568                 PyErr_SetString(PyExc_SystemError,
 569                         "PyErr_NewException: name must be module.class");
 570                 return NULL;
 571         }
 572         if (base == NULL)
 573                 base = PyExc_Exception;
 574         if (dict == NULL) {
 575                 dict = mydict = PyDict_New();
 576                 if (dict == NULL)
 577                         goto failure;
 578         }
 579         if (PyDict_GetItemString(dict, "__module__") == NULL) {
 580                 modulename = PyString_FromStringAndSize(name,
 581                                                      (Py_ssize_t)(dot-name));
 582                 if (modulename == NULL)
 583                         goto failure;
 584                 if (PyDict_SetItemString(dict, "__module__", modulename) != 0)
 585                         goto failure;
 586         }
 587         if (PyTuple_Check(base)) {
 588                 bases = base;
 589                 /* INCREF as we create a new ref in the else branch */
 590                 Py_INCREF(bases);
 591         } else {
 592                 bases = PyTuple_Pack(1, base);
 593                 if (bases == NULL)
 594                         goto failure;
 595         }
 596         /* Create a real new-style class. */
 597         result = PyObject_CallFunction((PyObject *)&PyType_Type, "sOO",
 598                                        dot+1, bases, dict);
 599   failure:
 600         Py_XDECREF(bases);
 601         Py_XDECREF(mydict);
 602         Py_XDECREF(classname);
 603         Py_XDECREF(modulename);
 604         return result;
 605 }
 606
 607 /* Call when an exception has occurred but there is no way for Python
 608    to handle it.  Examples: exception in __del__ or during GC. */
 609 void
 610 PyErr_WriteUnraisable(PyObject *obj)
 611 {
 612         PyObject *f, *t, *v, *tb;
 613         PyErr_Fetch(&t, &v, &tb);
 614         f = PySys_GetObject("stderr");
 615         if (f != NULL) {
 616                 PyFile_WriteString("Exception ", f);
 617                 if (t) {
 618                         PyObject* moduleName;
 619                         char* className;
 620                         assert(PyExceptionClass_Check(t));
 621                         className = PyExceptionClass_Name(t);
 622                         if (className != NULL) {
 623                                 char *dot = strrchr(className, '.');
 624                                 if (dot != NULL)
 625                                         className = dot+1;
 626                         }
 627
 628                         moduleName = PyObject_GetAttrString(t, "__module__");
 629                         if (moduleName == NULL)
 630                                 PyFile_WriteString("<unknown>", f);
 631                         else {
 632                                 char* modstr = PyString_AsString(moduleName);
 633                                 if (modstr &&
 634                                     strcmp(modstr, "exceptions") != 0)
 635                                 {
 636                                         PyFile_WriteString(modstr, f);
 637                                         PyFile_WriteString(".", f);
 638                                 }
 639                         }
 640                         if (className == NULL)
 641                                 PyFile_WriteString("<unknown>", f);
 642                         else
 643                                 PyFile_WriteString(className, f);
 644                         if (v && v != Py_None) {
 645                                 PyFile_WriteString(": ", f);
 646                                 PyFile_WriteObject(v, f, 0);
 647                         }
 648                         Py_XDECREF(moduleName);
 649                 }
 650                 PyFile_WriteString(" in ", f);
 651                 PyFile_WriteObject(obj, f, 0);
 652                 PyFile_WriteString(" ignored\n", f);
 653                 PyErr_Clear(); /* Just in case */
 654         }
 655         Py_XDECREF(t);
 656         Py_XDECREF(v);
 657         Py_XDECREF(tb);
 658 }
 659
 660 extern PyObject *PyModule_GetWarningsModule(void);
 661
 662
 663 /* Set file and line information for the current exception.
 664    If the exception is not a SyntaxError, also sets additional attributes
 665    to make printing of exceptions believe it is a syntax error. */
 666
 667 void
 668 PyErr_SyntaxLocation(const char *filename, int lineno)
 669 {
 670         PyObject *exc, *v, *tb, *tmp;
 671
 672         /* add attributes for the line number and filename for the error */
 673         PyErr_Fetch(&exc, &v, &tb);
 674         PyErr_NormalizeException(&exc, &v, &tb);
 675         /* XXX check that it is, indeed, a syntax error. It might not
 676          * be, though. */
 677         tmp = PyInt_FromLong(lineno);
 678         if (tmp == NULL)
 679                 PyErr_Clear();
 680         else {
 681                 if (PyObject_SetAttrString(v, "lineno", tmp))
 682                         PyErr_Clear();
 683                 Py_DECREF(tmp);
 684         }
 685         if (filename != NULL) {
 686                 tmp = PyString_FromString(filename);
 687                 if (tmp == NULL)
 688                         PyErr_Clear();
 689                 else {
 690                         if (PyObject_SetAttrString(v, "filename", tmp))
 691                                 PyErr_Clear();
 692                         Py_DECREF(tmp);
 693                 }
 694
 695                 tmp = PyErr_ProgramText(filename, lineno);
 696                 if (tmp) {
 697                         if (PyObject_SetAttrString(v, "text", tmp))
 698                                 PyErr_Clear();
 699                         Py_DECREF(tmp);
 700                 }
 701         }
 702         if (PyObject_SetAttrString(v, "offset", Py_None)) {
 703                 PyErr_Clear();
 704         }
 705         if (exc != PyExc_SyntaxError) {
 706                 if (!PyObject_HasAttrString(v, "msg")) {
 707                         tmp = PyObject_Str(v);
 708                         if (tmp) {
 709                                 if (PyObject_SetAttrString(v, "msg", tmp))
 710                                         PyErr_Clear();
 711                                 Py_DECREF(tmp);
 712                         } else {
 713                                 PyErr_Clear();
 714                         }
 715                 }
 716                 if (!PyObject_HasAttrString(v, "print_file_and_line")) {
 717                         if (PyObject_SetAttrString(v, "print_file_and_line",
 718                                                    Py_None))
 719                                 PyErr_Clear();
 720                 }
 721         }
 722         PyErr_Restore(exc, v, tb);
 723 }
 724
 725 /* com_fetch_program_text will attempt to load the line of text that
 726    the exception refers to.  If it fails, it will return NULL but will
 727    not set an exception.
 728
 729    XXX The functionality of this function is quite similar to the
 730    functionality in tb_displayline() in traceback.c.
 731 */
 732
 733 PyObject *
 734 PyErr_ProgramText(const char *filename, int lineno)
 735 {
 736         FILE *fp;
 737         int i;
 738         char linebuf[1000];
 739
 740         if (filename == NULL || *filename == '\0' || lineno <= 0)
 741                 return NULL;
 742         fp = fopen(filename, "r" PY_STDIOTEXTMODE);
 743         if (fp == NULL)
 744                 return NULL;
 745         for (i = 0; i < lineno; i++) {
 746                 char *pLastChar = &linebuf[sizeof(linebuf) - 2];
 747                 do {
 748                         *pLastChar = '\0';
 749                         if (Py_UniversalNewlineFgets(linebuf, sizeof linebuf, fp, NULL) == NULL)
 750                                 break;
 751                         /* fgets read *something*; if it didn't get as
 752                            far as pLastChar, it must have found a newline
 753                            or hit the end of the file; if pLastChar is \n,
 754                            it obviously found a newline; else we haven't
 755                            yet seen a newline, so must continue */
 756                 } while (*pLastChar != '\0' && *pLastChar != '\n');
 757         }
 758         fclose(fp);
 759         if (i == lineno) {
 760                 char *p = linebuf;
 761                 while (*p == ' ' || *p == '\t' || *p == '\014')
 762                         p++;
 763                 return PyString_FromString(p);
 764         }
 765         return NULL;
 766 }
 767
 768 #ifdef __cplusplus
 769 }
 770 #endif
 771