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, 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 Py_WIN_WIDE_FILENAMES
 383 PyObject *
 384 PyErr_SetFromErrnoWithUnicodeFilename(PyObject *exc, 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 /* Py_WIN_WIDE_FILENAMES */
 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 #ifdef Py_WIN_WIDE_FILENAMES
 464 PyObject *PyErr_SetExcFromWindowsErrWithUnicodeFilename(
 465         PyObject *exc,
 466         int ierr,
 467         const Py_UNICODE *filename)
 468 {
 469         PyObject *name = filename ?
 470                          PyUnicode_FromUnicode(filename, wcslen(filename)) :
 471                          NULL;
 472         PyObject *ret = PyErr_SetExcFromWindowsErrWithFilenameObject(exc,
 473                                                                      ierr,
 474                                                                      name);
 475         Py_XDECREF(name);
 476         return ret;
 477 }
 478 #endif /* Py_WIN_WIDE_FILENAMES */
 479
 480 PyObject *PyErr_SetExcFromWindowsErr(PyObject *exc, int ierr)
 481 {
 482         return PyErr_SetExcFromWindowsErrWithFilename(exc, ierr, NULL);
 483 }
 484
 485 PyObject *PyErr_SetFromWindowsErr(int ierr)
 486 {
 487         return PyErr_SetExcFromWindowsErrWithFilename(PyExc_WindowsError,
 488                                                       ierr, NULL);
 489 }
 490 PyObject *PyErr_SetFromWindowsErrWithFilename(
 491         int ierr,
 492         const char *filename)
 493 {
 494         PyObject *name = filename ? PyString_FromString(filename) : NULL;
 495         PyObject *result = PyErr_SetExcFromWindowsErrWithFilenameObject(
 496                                                       PyExc_WindowsError,
 497                                                       ierr, name);
 498         Py_XDECREF(name);
 499         return result;
 500 }
 501
 502 #ifdef Py_WIN_WIDE_FILENAMES
 503 PyObject *PyErr_SetFromWindowsErrWithUnicodeFilename(
 504         int ierr,
 505         const Py_UNICODE *filename)
 506 {
 507         PyObject *name = filename ?
 508                          PyUnicode_FromUnicode(filename, wcslen(filename)) :
 509                          NULL;
 510         PyObject *result = PyErr_SetExcFromWindowsErrWithFilenameObject(
 511                                                       PyExc_WindowsError,
 512                                                       ierr, name);
 513         Py_XDECREF(name);
 514         return result;
 515 }
 516 #endif /* Py_WIN_WIDE_FILENAMES */
 517 #endif /* MS_WINDOWS */
 518
 519 void
 520 _PyErr_BadInternalCall(char *filename, int lineno)
 521 {
 522         PyErr_Format(PyExc_SystemError,
 523                      "%s:%d: bad argument to internal function",
 524                      filename, lineno);
 525 }
 526
 527 /* Remove the preprocessor macro for PyErr_BadInternalCall() so that we can
 528    export the entry point for existing object code: */
 529 #undef PyErr_BadInternalCall
 530 void
 531 PyErr_BadInternalCall(void)
 532 {
 533         PyErr_Format(PyExc_SystemError,
 534                      "bad argument to internal function");
 535 }
 536 #define PyErr_BadInternalCall() _PyErr_BadInternalCall(__FILE__, __LINE__)
 537
 538
 539
 540 PyObject *
 541 PyErr_Format(PyObject *exception, const char *format, ...)
 542 {
 543         va_list vargs;
 544         PyObject* string;
 545
 546 #ifdef HAVE_STDARG_PROTOTYPES
 547         va_start(vargs, format);
 548 #else
 549         va_start(vargs);
 550 #endif
 551
 552         string = PyString_FromFormatV(format, vargs);
 553         PyErr_SetObject(exception, string);
 554         Py_XDECREF(string);
 555         va_end(vargs);
 556         return NULL;
 557 }
 558
 559
 560
 561 PyObject *
 562 PyErr_NewException(char *name, PyObject *base, PyObject *dict)
 563 {
 564         char *dot;
 565         PyObject *modulename = NULL;
 566         PyObject *classname = NULL;
 567         PyObject *mydict = NULL;
 568         PyObject *bases = NULL;
 569         PyObject *result = NULL;
 570         dot = strrchr(name, '.');
 571         if (dot == NULL) {
 572                 PyErr_SetString(PyExc_SystemError,
 573                         "PyErr_NewException: name must be module.class");
 574                 return NULL;
 575         }
 576         if (base == NULL)
 577                 base = PyExc_Exception;
 578         if (dict == NULL) {
 579                 dict = mydict = PyDict_New();
 580                 if (dict == NULL)
 581                         goto failure;
 582         }
 583         if (PyDict_GetItemString(dict, "__module__") == NULL) {
 584                 modulename = PyString_FromStringAndSize(name,
 585                                                      (Py_ssize_t)(dot-name));
 586                 if (modulename == NULL)
 587                         goto failure;
 588                 if (PyDict_SetItemString(dict, "__module__", modulename) != 0)
 589                         goto failure;
 590         }
 591         if (PyTuple_Check(base)) {
 592                 bases = base;
 593                 /* INCREF as we create a new ref in the else branch */
 594                 Py_INCREF(bases);
 595         } else {
 596                 bases = PyTuple_Pack(1, base);
 597                 if (bases == NULL)
 598                         goto failure;
 599         }
 600         /* Create a real new-style class. */
 601         result = PyObject_CallFunction((PyObject *)&PyType_Type, "sOO",
 602                                        dot+1, bases, dict);
 603   failure:
 604         Py_XDECREF(bases);
 605         Py_XDECREF(mydict);
 606         Py_XDECREF(classname);
 607         Py_XDECREF(modulename);
 608         return result;
 609 }
 610
 611 /* Call when an exception has occurred but there is no way for Python
 612    to handle it.  Examples: exception in __del__ or during GC. */
 613 void
 614 PyErr_WriteUnraisable(PyObject *obj)
 615 {
 616         PyObject *f, *t, *v, *tb;
 617         PyErr_Fetch(&t, &v, &tb);
 618         f = PySys_GetObject("stderr");
 619         if (f != NULL) {
 620                 PyFile_WriteString("Exception ", f);
 621                 if (t) {
 622                         PyObject* moduleName;
 623                         char* className;
 624                         assert(PyExceptionClass_Check(t));
 625                         className = PyExceptionClass_Name(t);
 626                         if (className != NULL) {
 627                                 char *dot = strrchr(className, '.');
 628                                 if (dot != NULL)
 629                                         className = dot+1;
 630                         }
 631
 632                         moduleName = PyObject_GetAttrString(t, "__module__");
 633                         if (moduleName == NULL)
 634                                 PyFile_WriteString("<unknown>", f);
 635                         else {
 636                                 char* modstr = PyString_AsString(moduleName);
 637                                 if (modstr &&
 638                                     strcmp(modstr, "exceptions") != 0)
 639                                 {
 640                                         PyFile_WriteString(modstr, f);
 641                                         PyFile_WriteString(".", f);
 642                                 }
 643                         }
 644                         if (className == NULL)
 645                                 PyFile_WriteString("<unknown>", f);
 646                         else
 647                                 PyFile_WriteString(className, f);
 648                         if (v && v != Py_None) {
 649                                 PyFile_WriteString(": ", f);
 650                                 PyFile_WriteObject(v, f, 0);
 651                         }
 652                         Py_XDECREF(moduleName);
 653                 }
 654                 PyFile_WriteString(" in ", f);
 655                 PyFile_WriteObject(obj, f, 0);
 656                 PyFile_WriteString(" ignored\n", f);
 657                 PyErr_Clear(); /* Just in case */
 658         }
 659         Py_XDECREF(t);
 660         Py_XDECREF(v);
 661         Py_XDECREF(tb);
 662 }
 663
 664 extern PyObject *PyModule_GetWarningsModule(void);
 665
 666
 667 /* Set file and line information for the current exception.
 668    If the exception is not a SyntaxError, also sets additional attributes
 669    to make printing of exceptions believe it is a syntax error. */
 670
 671 void
 672 PyErr_SyntaxLocation(const char *filename, int lineno)
 673 {
 674         PyObject *exc, *v, *tb, *tmp;
 675
 676         /* add attributes for the line number and filename for the error */
 677         PyErr_Fetch(&exc, &v, &tb);
 678         PyErr_NormalizeException(&exc, &v, &tb);
 679         /* XXX check that it is, indeed, a syntax error. It might not
 680          * be, though. */
 681         tmp = PyInt_FromLong(lineno);
 682         if (tmp == NULL)
 683                 PyErr_Clear();
 684         else {
 685                 if (PyObject_SetAttrString(v, "lineno", tmp))
 686                         PyErr_Clear();
 687                 Py_DECREF(tmp);
 688         }
 689         if (filename != NULL) {
 690                 tmp = PyString_FromString(filename);
 691                 if (tmp == NULL)
 692                         PyErr_Clear();
 693                 else {
 694                         if (PyObject_SetAttrString(v, "filename", tmp))
 695                                 PyErr_Clear();
 696                         Py_DECREF(tmp);
 697                 }
 698
 699                 tmp = PyErr_ProgramText(filename, lineno);
 700                 if (tmp) {
 701                         if (PyObject_SetAttrString(v, "text", tmp))
 702                                 PyErr_Clear();
 703                         Py_DECREF(tmp);
 704                 }
 705         }
 706         if (PyObject_SetAttrString(v, "offset", Py_None)) {
 707                 PyErr_Clear();
 708         }
 709         if (exc != PyExc_SyntaxError) {
 710                 if (!PyObject_HasAttrString(v, "msg")) {
 711                         tmp = PyObject_Str(v);
 712                         if (tmp) {
 713                                 if (PyObject_SetAttrString(v, "msg", tmp))
 714                                         PyErr_Clear();
 715                                 Py_DECREF(tmp);
 716                         } else {
 717                                 PyErr_Clear();
 718                         }
 719                 }
 720                 if (!PyObject_HasAttrString(v, "print_file_and_line")) {
 721                         if (PyObject_SetAttrString(v, "print_file_and_line",
 722                                                    Py_None))
 723                                 PyErr_Clear();
 724                 }
 725         }
 726         PyErr_Restore(exc, v, tb);
 727 }
 728
 729 /* com_fetch_program_text will attempt to load the line of text that
 730    the exception refers to.  If it fails, it will return NULL but will
 731    not set an exception.
 732
 733    XXX The functionality of this function is quite similar to the
 734    functionality in tb_displayline() in traceback.c.
 735 */
 736
 737 PyObject *
 738 PyErr_ProgramText(const char *filename, int lineno)
 739 {
 740         FILE *fp;
 741         int i;
 742         char linebuf[1000];
 743
 744         if (filename == NULL || *filename == '\0' || lineno <= 0)
 745                 return NULL;
 746         fp = fopen(filename, "r" PY_STDIOTEXTMODE);
 747         if (fp == NULL)
 748                 return NULL;
 749         for (i = 0; i < lineno; i++) {
 750                 char *pLastChar = &linebuf[sizeof(linebuf) - 2];
 751                 do {
 752                         *pLastChar = '\0';
 753                         if (Py_UniversalNewlineFgets(linebuf, sizeof linebuf, fp, NULL) == NULL)
 754                                 break;
 755                         /* fgets read *something*; if it didn't get as
 756                            far as pLastChar, it must have found a newline
 757                            or hit the end of the file; if pLastChar is \n,
 758                            it obviously found a newline; else we haven't
 759                            yet seen a newline, so must continue */
 760                 } while (*pLastChar != '\0' && *pLastChar != '\n');
 761         }
 762         fclose(fp);
 763         if (i == lineno) {
 764                 char *p = linebuf;
 765                 while (*p == ' ' || *p == '\t' || *p == '\014')
 766                         p++;
 767                 return PyString_FromString(p);
 768         }
 769         return NULL;
 770 }
 771
 772 #ifdef __cplusplus
 773 }
 774 #endif
 775