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