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