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
 608 /* Create an exception with docstring */
 609 PyObject *
 610 PyErr_NewExceptionWithDoc(char *name, char *doc, PyObject *base, PyObject *dict)
 611 {
 612         int result;
 613         PyObject *ret = NULL;
 614         PyObject *mydict = NULL; /* points to the dict only if we create it */
 615         PyObject *docobj;
 616
 617         if (dict == NULL) {
 618                 dict = mydict = PyDict_New();
 619                 if (dict == NULL) {
 620                         return NULL;
 621                 }
 622         }
 623
 624         if (doc != NULL) {
 625                 docobj = PyString_FromString(doc);
 626                 if (docobj == NULL)
 627                         goto failure;
 628                 result = PyDict_SetItemString(dict, "__doc__", docobj);
 629                 Py_DECREF(docobj);
 630                 if (result < 0)
 631                         goto failure;
 632         }
 633
 634         ret = PyErr_NewException(name, base, dict);
 635   failure:
 636         Py_XDECREF(mydict);
 637         return ret;
 638 }
 639
 640
 641 /* Call when an exception has occurred but there is no way for Python
 642    to handle it.  Examples: exception in __del__ or during GC. */
 643 void
 644 PyErr_WriteUnraisable(PyObject *obj)
 645 {
 646         PyObject *f, *t, *v, *tb;
 647         PyErr_Fetch(&t, &v, &tb);
 648         f = PySys_GetObject("stderr");
 649         if (f != NULL) {
 650                 PyFile_WriteString("Exception ", f);
 651                 if (t) {
 652                         PyObject* moduleName;
 653                         char* className;
 654                         assert(PyExceptionClass_Check(t));
 655                         className = PyExceptionClass_Name(t);
 656                         if (className != NULL) {
 657                                 char *dot = strrchr(className, '.');
 658                                 if (dot != NULL)
 659                                         className = dot+1;
 660                         }
 661
 662                         moduleName = PyObject_GetAttrString(t, "__module__");
 663                         if (moduleName == NULL)
 664                                 PyFile_WriteString("<unknown>", f);
 665                         else {
 666                                 char* modstr = PyString_AsString(moduleName);
 667                                 if (modstr &&
 668                                     strcmp(modstr, "exceptions") != 0)
 669                                 {
 670                                         PyFile_WriteString(modstr, f);
 671                                         PyFile_WriteString(".", f);
 672                                 }
 673                         }
 674                         if (className == NULL)
 675                                 PyFile_WriteString("<unknown>", f);
 676                         else
 677                                 PyFile_WriteString(className, f);
 678                         if (v && v != Py_None) {
 679                                 PyFile_WriteString(": ", f);
 680                                 PyFile_WriteObject(v, f, 0);
 681                         }
 682                         Py_XDECREF(moduleName);
 683                 }
 684                 PyFile_WriteString(" in ", f);
 685                 PyFile_WriteObject(obj, f, 0);
 686                 PyFile_WriteString(" ignored\n", f);
 687                 PyErr_Clear(); /* Just in case */
 688         }
 689         Py_XDECREF(t);
 690         Py_XDECREF(v);
 691         Py_XDECREF(tb);
 692 }
 693
 694 extern PyObject *PyModule_GetWarningsModule(void);
 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