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 /* Function to issue a warning message; may raise an exception. */
 645 int
 646 PyErr_WarnEx(PyObject *category, const char *message, Py_ssize_t stack_level)
 647 {
 648         PyObject *dict, *func = NULL;
 649         PyObject *warnings_module = PyModule_GetWarningsModule();
 650
 651         if (warnings_module != NULL) {
 652                 dict = PyModule_GetDict(warnings_module);
 653                 if (dict != NULL)
 654                         func = PyDict_GetItemString(dict, "warn");
 655         }
 656         if (func == NULL) {
 657                 PySys_WriteStderr("warning: %s\n", message);
 658                 return 0;
 659         }
 660         else {
 661                 PyObject *res;
 662
 663                 if (category == NULL)
 664                         category = PyExc_RuntimeWarning;
 665                 res = PyObject_CallFunction(func, "sOn",
 666                                             message, category, stack_level);
 667                 if (res == NULL)
 668                         return -1;
 669                 Py_DECREF(res);
 670                 return 0;
 671         }
 672 }
 673
 674 /* PyErr_Warn is only for backwards compatability and will be removed.
 675    Use PyErr_WarnEx instead. */
 676
 677 #undef PyErr_Warn
 678
 679 PyAPI_FUNC(int)
 680 PyErr_Warn(PyObject *category, char *message)
 681 {
 682         return PyErr_WarnEx(category, message, 1);
 683 }
 684
 685 /* Warning with explicit origin */
 686 int
 687 PyErr_WarnExplicit(PyObject *category, const char *message,
 688                    const char *filename, int lineno,
 689                    const char *module, PyObject *registry)
 690 {
 691         PyObject *mod, *dict, *func = NULL;
 692
 693         mod = PyImport_ImportModuleNoBlock("warnings");
 694         if (mod != NULL) {
 695                 dict = PyModule_GetDict(mod);
 696                 func = PyDict_GetItemString(dict, "warn_explicit");
 697                 Py_DECREF(mod);
 698         }
 699         if (func == NULL) {
 700                 PySys_WriteStderr("warning: %s\n", message);
 701                 return 0;
 702         }
 703         else {
 704                 PyObject *res;
 705
 706                 if (category == NULL)
 707                         category = PyExc_RuntimeWarning;
 708                 if (registry == NULL)
 709                         registry = Py_None;
 710                 res = PyObject_CallFunction(func, "sOsizO", message, category,
 711                                             filename, lineno, module, registry);
 712                 if (res == NULL)
 713                         return -1;
 714                 Py_DECREF(res);
 715                 return 0;
 716         }
 717 }
 718
 719
 720 /* Set file and line information for the current exception.
 721    If the exception is not a SyntaxError, also sets additional attributes
 722    to make printing of exceptions believe it is a syntax error. */
 723
 724 void
 725 PyErr_SyntaxLocation(const char *filename, int lineno)
 726 {
 727         PyObject *exc, *v, *tb, *tmp;
 728
 729         /* add attributes for the line number and filename for the error */
 730         PyErr_Fetch(&exc, &v, &tb);
 731         PyErr_NormalizeException(&exc, &v, &tb);
 732         /* XXX check that it is, indeed, a syntax error. It might not
 733          * be, though. */
 734         tmp = PyInt_FromLong(lineno);
 735         if (tmp == NULL)
 736                 PyErr_Clear();
 737         else {
 738                 if (PyObject_SetAttrString(v, "lineno", tmp))
 739                         PyErr_Clear();
 740                 Py_DECREF(tmp);
 741         }
 742         if (filename != NULL) {
 743                 tmp = PyString_FromString(filename);
 744                 if (tmp == NULL)
 745                         PyErr_Clear();
 746                 else {
 747                         if (PyObject_SetAttrString(v, "filename", tmp))
 748                                 PyErr_Clear();
 749                         Py_DECREF(tmp);
 750                 }
 751
 752                 tmp = PyErr_ProgramText(filename, lineno);
 753                 if (tmp) {
 754                         if (PyObject_SetAttrString(v, "text", tmp))
 755                                 PyErr_Clear();
 756                         Py_DECREF(tmp);
 757                 }
 758         }
 759         if (PyObject_SetAttrString(v, "offset", Py_None)) {
 760                 PyErr_Clear();
 761         }
 762         if (exc != PyExc_SyntaxError) {
 763                 if (!PyObject_HasAttrString(v, "msg")) {
 764                         tmp = PyObject_Str(v);
 765                         if (tmp) {
 766                                 if (PyObject_SetAttrString(v, "msg", tmp))
 767                                         PyErr_Clear();
 768                                 Py_DECREF(tmp);
 769                         } else {
 770                                 PyErr_Clear();
 771                         }
 772                 }
 773                 if (!PyObject_HasAttrString(v, "print_file_and_line")) {
 774                         if (PyObject_SetAttrString(v, "print_file_and_line",
 775                                                    Py_None))
 776                                 PyErr_Clear();
 777                 }
 778         }
 779         PyErr_Restore(exc, v, tb);
 780 }
 781
 782 /* com_fetch_program_text will attempt to load the line of text that
 783    the exception refers to.  If it fails, it will return NULL but will
 784    not set an exception.
 785
 786    XXX The functionality of this function is quite similar to the
 787    functionality in tb_displayline() in traceback.c.
 788 */
 789
 790 PyObject *
 791 PyErr_ProgramText(const char *filename, int lineno)
 792 {
 793         FILE *fp;
 794         int i;
 795         char linebuf[1000];
 796
 797         if (filename == NULL || *filename == '\0' || lineno <= 0)
 798                 return NULL;
 799         fp = fopen(filename, "r" PY_STDIOTEXTMODE);
 800         if (fp == NULL)
 801                 return NULL;
 802         for (i = 0; i < lineno; i++) {
 803                 char *pLastChar = &linebuf[sizeof(linebuf) - 2];
 804                 do {
 805                         *pLastChar = '\0';
 806                         if (Py_UniversalNewlineFgets(linebuf, sizeof linebuf, fp, NULL) == NULL)
 807                                 break;
 808                         /* fgets read *something*; if it didn't get as
 809                            far as pLastChar, it must have found a newline
 810                            or hit the end of the file; if pLastChar is \n,
 811                            it obviously found a newline; else we haven't
 812                            yet seen a newline, so must continue */
 813                 } while (*pLastChar != '\0' && *pLastChar != '\n');
 814         }
 815         fclose(fp);
 816         if (i == lineno) {
 817                 char *p = linebuf;
 818                 while (*p == ' ' || *p == '\t' || *p == '\014')
 819                         p++;
 820                 return PyString_FromString(p);
 821         }
 822         return NULL;
 823 }
 824
 825 #ifdef __cplusplus
 826 }
 827 #endif
 828