errors.c revision ec766d3c159e0526db641505dbdf0a7f4271e5e4
1 2/* Error handling */ 3 4#include "Python.h" 5 6#ifndef __STDC__ 7#ifndef MS_WINDOWS 8extern 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 20extern "C" { 21#endif 22 23_Py_IDENTIFIER(builtins); 24_Py_IDENTIFIER(stderr); 25 26 27void 28PyErr_Restore(PyObject *type, PyObject *value, PyObject *traceback) 29{ 30 PyThreadState *tstate = PyThreadState_GET(); 31 PyObject *oldtype, *oldvalue, *oldtraceback; 32 33 if (traceback != NULL && !PyTraceBack_Check(traceback)) { 34 /* XXX Should never happen -- fatal error instead? */ 35 /* Well, it could be None. */ 36 Py_DECREF(traceback); 37 traceback = NULL; 38 } 39 40 /* Save these in locals to safeguard against recursive 41 invocation through Py_XDECREF */ 42 oldtype = tstate->curexc_type; 43 oldvalue = tstate->curexc_value; 44 oldtraceback = tstate->curexc_traceback; 45 46 tstate->curexc_type = type; 47 tstate->curexc_value = value; 48 tstate->curexc_traceback = traceback; 49 50 Py_XDECREF(oldtype); 51 Py_XDECREF(oldvalue); 52 Py_XDECREF(oldtraceback); 53} 54 55void 56PyErr_SetObject(PyObject *exception, PyObject *value) 57{ 58 PyThreadState *tstate = PyThreadState_GET(); 59 PyObject *exc_value; 60 PyObject *tb = NULL; 61 62 if (exception != NULL && 63 !PyExceptionClass_Check(exception)) { 64 PyErr_Format(PyExc_SystemError, 65 "exception %R not a BaseException subclass", 66 exception); 67 return; 68 } 69 Py_XINCREF(value); 70 exc_value = tstate->exc_value; 71 if (exc_value != NULL && exc_value != Py_None) { 72 /* Implicit exception chaining */ 73 Py_INCREF(exc_value); 74 if (value == NULL || !PyExceptionInstance_Check(value)) { 75 /* We must normalize the value right now */ 76 PyObject *args, *fixed_value; 77 78 /* Issue #23571: PyEval_CallObject() must not be called with an 79 exception set */ 80 PyErr_Clear(); 81 82 if (value == NULL || value == Py_None) 83 args = PyTuple_New(0); 84 else if (PyTuple_Check(value)) { 85 Py_INCREF(value); 86 args = value; 87 } 88 else 89 args = PyTuple_Pack(1, value); 90 fixed_value = args ? 91 PyEval_CallObject(exception, args) : NULL; 92 Py_XDECREF(args); 93 Py_XDECREF(value); 94 if (fixed_value == NULL) 95 return; 96 value = fixed_value; 97 } 98 /* Avoid reference cycles through the context chain. 99 This is O(chain length) but context chains are 100 usually very short. Sensitive readers may try 101 to inline the call to PyException_GetContext. */ 102 if (exc_value != value) { 103 PyObject *o = exc_value, *context; 104 while ((context = PyException_GetContext(o))) { 105 Py_DECREF(context); 106 if (context == value) { 107 PyException_SetContext(o, NULL); 108 break; 109 } 110 o = context; 111 } 112 PyException_SetContext(value, exc_value); 113 } else { 114 Py_DECREF(exc_value); 115 } 116 } 117 if (value != NULL && PyExceptionInstance_Check(value)) 118 tb = PyException_GetTraceback(value); 119 Py_XINCREF(exception); 120 PyErr_Restore(exception, value, tb); 121} 122 123/* Set a key error with the specified argument, wrapping it in a 124 * tuple automatically so that tuple keys are not unpacked as the 125 * exception arguments. */ 126void 127_PyErr_SetKeyError(PyObject *arg) 128{ 129 PyObject *tup; 130 tup = PyTuple_Pack(1, arg); 131 if (!tup) 132 return; /* caller will expect error to be set anyway */ 133 PyErr_SetObject(PyExc_KeyError, tup); 134 Py_DECREF(tup); 135} 136 137void 138PyErr_SetNone(PyObject *exception) 139{ 140 PyErr_SetObject(exception, (PyObject *)NULL); 141} 142 143void 144PyErr_SetString(PyObject *exception, const char *string) 145{ 146 PyObject *value = PyUnicode_FromString(string); 147 PyErr_SetObject(exception, value); 148 Py_XDECREF(value); 149} 150 151 152PyObject * 153PyErr_Occurred(void) 154{ 155 PyThreadState *tstate = _PyThreadState_UncheckedGet(); 156 return tstate == NULL ? NULL : tstate->curexc_type; 157} 158 159 160int 161PyErr_GivenExceptionMatches(PyObject *err, PyObject *exc) 162{ 163 if (err == NULL || exc == NULL) { 164 /* maybe caused by "import exceptions" that failed early on */ 165 return 0; 166 } 167 if (PyTuple_Check(exc)) { 168 Py_ssize_t i, n; 169 n = PyTuple_Size(exc); 170 for (i = 0; i < n; i++) { 171 /* Test recursively */ 172 if (PyErr_GivenExceptionMatches( 173 err, PyTuple_GET_ITEM(exc, i))) 174 { 175 return 1; 176 } 177 } 178 return 0; 179 } 180 /* err might be an instance, so check its class. */ 181 if (PyExceptionInstance_Check(err)) 182 err = PyExceptionInstance_Class(err); 183 184 if (PyExceptionClass_Check(err) && PyExceptionClass_Check(exc)) { 185 int res = 0; 186 PyObject *exception, *value, *tb; 187 PyErr_Fetch(&exception, &value, &tb); 188 /* PyObject_IsSubclass() can recurse and therefore is 189 not safe (see test_bad_getattr in test.pickletester). */ 190 res = PyType_IsSubtype((PyTypeObject *)err, (PyTypeObject *)exc); 191 /* This function must not fail, so print the error here */ 192 if (res == -1) { 193 PyErr_WriteUnraisable(err); 194 res = 0; 195 } 196 PyErr_Restore(exception, value, tb); 197 return res; 198 } 199 200 return err == exc; 201} 202 203 204int 205PyErr_ExceptionMatches(PyObject *exc) 206{ 207 return PyErr_GivenExceptionMatches(PyErr_Occurred(), exc); 208} 209 210 211/* Used in many places to normalize a raised exception, including in 212 eval_code2(), do_raise(), and PyErr_Print() 213 214 XXX: should PyErr_NormalizeException() also call 215 PyException_SetTraceback() with the resulting value and tb? 216*/ 217void 218PyErr_NormalizeException(PyObject **exc, PyObject **val, PyObject **tb) 219{ 220 PyObject *type = *exc; 221 PyObject *value = *val; 222 PyObject *inclass = NULL; 223 PyObject *initial_tb = NULL; 224 PyThreadState *tstate = NULL; 225 226 if (type == NULL) { 227 /* There was no exception, so nothing to do. */ 228 return; 229 } 230 231 /* If PyErr_SetNone() was used, the value will have been actually 232 set to NULL. 233 */ 234 if (!value) { 235 value = Py_None; 236 Py_INCREF(value); 237 } 238 239 if (PyExceptionInstance_Check(value)) 240 inclass = PyExceptionInstance_Class(value); 241 242 /* Normalize the exception so that if the type is a class, the 243 value will be an instance. 244 */ 245 if (PyExceptionClass_Check(type)) { 246 int is_subclass; 247 if (inclass) { 248 is_subclass = PyObject_IsSubclass(inclass, type); 249 if (is_subclass < 0) 250 goto finally; 251 } 252 else 253 is_subclass = 0; 254 255 /* if the value was not an instance, or is not an instance 256 whose class is (or is derived from) type, then use the 257 value as an argument to instantiation of the type 258 class. 259 */ 260 if (!inclass || !is_subclass) { 261 PyObject *args, *res; 262 263 if (value == Py_None) 264 args = PyTuple_New(0); 265 else if (PyTuple_Check(value)) { 266 Py_INCREF(value); 267 args = value; 268 } 269 else 270 args = PyTuple_Pack(1, value); 271 272 if (args == NULL) 273 goto finally; 274 res = PyEval_CallObject(type, args); 275 Py_DECREF(args); 276 if (res == NULL) 277 goto finally; 278 Py_DECREF(value); 279 value = res; 280 } 281 /* if the class of the instance doesn't exactly match the 282 class of the type, believe the instance 283 */ 284 else if (inclass != type) { 285 Py_DECREF(type); 286 type = inclass; 287 Py_INCREF(type); 288 } 289 } 290 *exc = type; 291 *val = value; 292 return; 293finally: 294 Py_DECREF(type); 295 Py_DECREF(value); 296 /* If the new exception doesn't set a traceback and the old 297 exception had a traceback, use the old traceback for the 298 new exception. It's better than nothing. 299 */ 300 initial_tb = *tb; 301 PyErr_Fetch(exc, val, tb); 302 if (initial_tb != NULL) { 303 if (*tb == NULL) 304 *tb = initial_tb; 305 else 306 Py_DECREF(initial_tb); 307 } 308 /* normalize recursively */ 309 tstate = PyThreadState_GET(); 310 if (++tstate->recursion_depth > Py_GetRecursionLimit()) { 311 --tstate->recursion_depth; 312 /* throw away the old exception and use the recursion error instead */ 313 Py_INCREF(PyExc_RecursionError); 314 Py_SETREF(*exc, PyExc_RecursionError); 315 Py_INCREF(PyExc_RecursionErrorInst); 316 Py_SETREF(*val, PyExc_RecursionErrorInst); 317 /* just keeping the old traceback */ 318 return; 319 } 320 PyErr_NormalizeException(exc, val, tb); 321 --tstate->recursion_depth; 322} 323 324 325void 326PyErr_Fetch(PyObject **p_type, PyObject **p_value, PyObject **p_traceback) 327{ 328 PyThreadState *tstate = PyThreadState_GET(); 329 330 *p_type = tstate->curexc_type; 331 *p_value = tstate->curexc_value; 332 *p_traceback = tstate->curexc_traceback; 333 334 tstate->curexc_type = NULL; 335 tstate->curexc_value = NULL; 336 tstate->curexc_traceback = NULL; 337} 338 339void 340PyErr_Clear(void) 341{ 342 PyErr_Restore(NULL, NULL, NULL); 343} 344 345void 346PyErr_GetExcInfo(PyObject **p_type, PyObject **p_value, PyObject **p_traceback) 347{ 348 PyThreadState *tstate = PyThreadState_GET(); 349 350 *p_type = tstate->exc_type; 351 *p_value = tstate->exc_value; 352 *p_traceback = tstate->exc_traceback; 353 354 Py_XINCREF(*p_type); 355 Py_XINCREF(*p_value); 356 Py_XINCREF(*p_traceback); 357} 358 359void 360PyErr_SetExcInfo(PyObject *p_type, PyObject *p_value, PyObject *p_traceback) 361{ 362 PyObject *oldtype, *oldvalue, *oldtraceback; 363 PyThreadState *tstate = PyThreadState_GET(); 364 365 oldtype = tstate->exc_type; 366 oldvalue = tstate->exc_value; 367 oldtraceback = tstate->exc_traceback; 368 369 tstate->exc_type = p_type; 370 tstate->exc_value = p_value; 371 tstate->exc_traceback = p_traceback; 372 373 Py_XDECREF(oldtype); 374 Py_XDECREF(oldvalue); 375 Py_XDECREF(oldtraceback); 376} 377 378/* Like PyErr_Restore(), but if an exception is already set, 379 set the context associated with it. 380 */ 381void 382_PyErr_ChainExceptions(PyObject *exc, PyObject *val, PyObject *tb) 383{ 384 if (exc == NULL) 385 return; 386 387 if (PyErr_Occurred()) { 388 PyObject *exc2, *val2, *tb2; 389 PyErr_Fetch(&exc2, &val2, &tb2); 390 PyErr_NormalizeException(&exc, &val, &tb); 391 Py_DECREF(exc); 392 Py_XDECREF(tb); 393 PyErr_NormalizeException(&exc2, &val2, &tb2); 394 PyException_SetContext(val2, val); 395 PyErr_Restore(exc2, val2, tb2); 396 } 397 else { 398 PyErr_Restore(exc, val, tb); 399 } 400} 401 402/* Convenience functions to set a type error exception and return 0 */ 403 404int 405PyErr_BadArgument(void) 406{ 407 PyErr_SetString(PyExc_TypeError, 408 "bad argument type for built-in operation"); 409 return 0; 410} 411 412PyObject * 413PyErr_NoMemory(void) 414{ 415 if (Py_TYPE(PyExc_MemoryError) == NULL) { 416 /* PyErr_NoMemory() has been called before PyExc_MemoryError has been 417 initialized by _PyExc_Init() */ 418 Py_FatalError("Out of memory and PyExc_MemoryError is not " 419 "initialized yet"); 420 } 421 PyErr_SetNone(PyExc_MemoryError); 422 return NULL; 423} 424 425PyObject * 426PyErr_SetFromErrnoWithFilenameObject(PyObject *exc, PyObject *filenameObject) 427{ 428 return PyErr_SetFromErrnoWithFilenameObjects(exc, filenameObject, NULL); 429} 430 431PyObject * 432PyErr_SetFromErrnoWithFilenameObjects(PyObject *exc, PyObject *filenameObject, PyObject *filenameObject2) 433{ 434 PyObject *message; 435 PyObject *v, *args; 436 int i = errno; 437#ifdef MS_WINDOWS 438 WCHAR *s_buf = NULL; 439#endif /* Unix/Windows */ 440 441#ifdef EINTR 442 if (i == EINTR && PyErr_CheckSignals()) 443 return NULL; 444#endif 445 446#ifndef MS_WINDOWS 447 if (i != 0) { 448 char *s = strerror(i); 449 message = PyUnicode_DecodeLocale(s, "surrogateescape"); 450 } 451 else { 452 /* Sometimes errno didn't get set */ 453 message = PyUnicode_FromString("Error"); 454 } 455#else 456 if (i == 0) 457 message = PyUnicode_FromString("Error"); /* Sometimes errno didn't get set */ 458 else 459 { 460 /* Note that the Win32 errors do not lineup with the 461 errno error. So if the error is in the MSVC error 462 table, we use it, otherwise we assume it really _is_ 463 a Win32 error code 464 */ 465 if (i > 0 && i < _sys_nerr) { 466 message = PyUnicode_FromString(_sys_errlist[i]); 467 } 468 else { 469 int len = FormatMessageW( 470 FORMAT_MESSAGE_ALLOCATE_BUFFER | 471 FORMAT_MESSAGE_FROM_SYSTEM | 472 FORMAT_MESSAGE_IGNORE_INSERTS, 473 NULL, /* no message source */ 474 i, 475 MAKELANGID(LANG_NEUTRAL, 476 SUBLANG_DEFAULT), 477 /* Default language */ 478 (LPWSTR) &s_buf, 479 0, /* size not used */ 480 NULL); /* no args */ 481 if (len==0) { 482 /* Only ever seen this in out-of-mem 483 situations */ 484 s_buf = NULL; 485 message = PyUnicode_FromFormat("Windows Error 0x%x", i); 486 } else { 487 /* remove trailing cr/lf and dots */ 488 while (len > 0 && (s_buf[len-1] <= L' ' || s_buf[len-1] == L'.')) 489 s_buf[--len] = L'\0'; 490 message = PyUnicode_FromWideChar(s_buf, len); 491 } 492 } 493 } 494#endif /* Unix/Windows */ 495 496 if (message == NULL) 497 { 498#ifdef MS_WINDOWS 499 LocalFree(s_buf); 500#endif 501 return NULL; 502 } 503 504 if (filenameObject != NULL) { 505 if (filenameObject2 != NULL) 506 args = Py_BuildValue("(iOOiO)", i, message, filenameObject, 0, filenameObject2); 507 else 508 args = Py_BuildValue("(iOO)", i, message, filenameObject); 509 } else { 510 assert(filenameObject2 == NULL); 511 args = Py_BuildValue("(iO)", i, message); 512 } 513 Py_DECREF(message); 514 515 if (args != NULL) { 516 v = PyObject_Call(exc, args, NULL); 517 Py_DECREF(args); 518 if (v != NULL) { 519 PyErr_SetObject((PyObject *) Py_TYPE(v), v); 520 Py_DECREF(v); 521 } 522 } 523#ifdef MS_WINDOWS 524 LocalFree(s_buf); 525#endif 526 return NULL; 527} 528 529PyObject * 530PyErr_SetFromErrnoWithFilename(PyObject *exc, const char *filename) 531{ 532 PyObject *name = filename ? PyUnicode_DecodeFSDefault(filename) : NULL; 533 PyObject *result = PyErr_SetFromErrnoWithFilenameObjects(exc, name, NULL); 534 Py_XDECREF(name); 535 return result; 536} 537 538#ifdef MS_WINDOWS 539PyObject * 540PyErr_SetFromErrnoWithUnicodeFilename(PyObject *exc, const Py_UNICODE *filename) 541{ 542 PyObject *name = filename ? 543 PyUnicode_FromUnicode(filename, wcslen(filename)) : 544 NULL; 545 PyObject *result = PyErr_SetFromErrnoWithFilenameObjects(exc, name, NULL); 546 Py_XDECREF(name); 547 return result; 548} 549#endif /* MS_WINDOWS */ 550 551PyObject * 552PyErr_SetFromErrno(PyObject *exc) 553{ 554 return PyErr_SetFromErrnoWithFilenameObjects(exc, NULL, NULL); 555} 556 557#ifdef MS_WINDOWS 558/* Windows specific error code handling */ 559PyObject *PyErr_SetExcFromWindowsErrWithFilenameObject( 560 PyObject *exc, 561 int ierr, 562 PyObject *filenameObject) 563{ 564 return PyErr_SetExcFromWindowsErrWithFilenameObjects(exc, ierr, 565 filenameObject, NULL); 566} 567 568PyObject *PyErr_SetExcFromWindowsErrWithFilenameObjects( 569 PyObject *exc, 570 int ierr, 571 PyObject *filenameObject, 572 PyObject *filenameObject2) 573{ 574 int len; 575 WCHAR *s_buf = NULL; /* Free via LocalFree */ 576 PyObject *message; 577 PyObject *args, *v; 578 DWORD err = (DWORD)ierr; 579 if (err==0) err = GetLastError(); 580 len = FormatMessageW( 581 /* Error API error */ 582 FORMAT_MESSAGE_ALLOCATE_BUFFER | 583 FORMAT_MESSAGE_FROM_SYSTEM | 584 FORMAT_MESSAGE_IGNORE_INSERTS, 585 NULL, /* no message source */ 586 err, 587 MAKELANGID(LANG_NEUTRAL, 588 SUBLANG_DEFAULT), /* Default language */ 589 (LPWSTR) &s_buf, 590 0, /* size not used */ 591 NULL); /* no args */ 592 if (len==0) { 593 /* Only seen this in out of mem situations */ 594 message = PyUnicode_FromFormat("Windows Error 0x%x", err); 595 s_buf = NULL; 596 } else { 597 /* remove trailing cr/lf and dots */ 598 while (len > 0 && (s_buf[len-1] <= L' ' || s_buf[len-1] == L'.')) 599 s_buf[--len] = L'\0'; 600 message = PyUnicode_FromWideChar(s_buf, len); 601 } 602 603 if (message == NULL) 604 { 605 LocalFree(s_buf); 606 return NULL; 607 } 608 609 if (filenameObject == NULL) { 610 assert(filenameObject2 == NULL); 611 filenameObject = filenameObject2 = Py_None; 612 } 613 else if (filenameObject2 == NULL) 614 filenameObject2 = Py_None; 615 /* This is the constructor signature for OSError. 616 The POSIX translation will be figured out by the constructor. */ 617 args = Py_BuildValue("(iOOiO)", 0, message, filenameObject, err, filenameObject2); 618 Py_DECREF(message); 619 620 if (args != NULL) { 621 v = PyObject_Call(exc, args, NULL); 622 Py_DECREF(args); 623 if (v != NULL) { 624 PyErr_SetObject((PyObject *) Py_TYPE(v), v); 625 Py_DECREF(v); 626 } 627 } 628 LocalFree(s_buf); 629 return NULL; 630} 631 632PyObject *PyErr_SetExcFromWindowsErrWithFilename( 633 PyObject *exc, 634 int ierr, 635 const char *filename) 636{ 637 PyObject *name = filename ? PyUnicode_DecodeFSDefault(filename) : NULL; 638 PyObject *ret = PyErr_SetExcFromWindowsErrWithFilenameObjects(exc, 639 ierr, 640 name, 641 NULL); 642 Py_XDECREF(name); 643 return ret; 644} 645 646PyObject *PyErr_SetExcFromWindowsErrWithUnicodeFilename( 647 PyObject *exc, 648 int ierr, 649 const Py_UNICODE *filename) 650{ 651 PyObject *name = filename ? 652 PyUnicode_FromUnicode(filename, wcslen(filename)) : 653 NULL; 654 PyObject *ret = PyErr_SetExcFromWindowsErrWithFilenameObjects(exc, 655 ierr, 656 name, 657 NULL); 658 Py_XDECREF(name); 659 return ret; 660} 661 662PyObject *PyErr_SetExcFromWindowsErr(PyObject *exc, int ierr) 663{ 664 return PyErr_SetExcFromWindowsErrWithFilename(exc, ierr, NULL); 665} 666 667PyObject *PyErr_SetFromWindowsErr(int ierr) 668{ 669 return PyErr_SetExcFromWindowsErrWithFilename(PyExc_OSError, 670 ierr, NULL); 671} 672 673PyObject *PyErr_SetFromWindowsErrWithFilename( 674 int ierr, 675 const char *filename) 676{ 677 PyObject *name = filename ? PyUnicode_DecodeFSDefault(filename) : NULL; 678 PyObject *result = PyErr_SetExcFromWindowsErrWithFilenameObjects( 679 PyExc_OSError, 680 ierr, name, NULL); 681 Py_XDECREF(name); 682 return result; 683} 684 685PyObject *PyErr_SetFromWindowsErrWithUnicodeFilename( 686 int ierr, 687 const Py_UNICODE *filename) 688{ 689 PyObject *name = filename ? 690 PyUnicode_FromUnicode(filename, wcslen(filename)) : 691 NULL; 692 PyObject *result = PyErr_SetExcFromWindowsErrWithFilenameObjects( 693 PyExc_OSError, 694 ierr, name, NULL); 695 Py_XDECREF(name); 696 return result; 697} 698#endif /* MS_WINDOWS */ 699 700PyObject * 701PyErr_SetImportError(PyObject *msg, PyObject *name, PyObject *path) 702{ 703 PyObject *args, *kwargs, *error; 704 705 if (msg == NULL) 706 return NULL; 707 708 args = PyTuple_New(1); 709 if (args == NULL) 710 return NULL; 711 712 kwargs = PyDict_New(); 713 if (kwargs == NULL) { 714 Py_DECREF(args); 715 return NULL; 716 } 717 718 if (name == NULL) { 719 name = Py_None; 720 } 721 722 if (path == NULL) { 723 path = Py_None; 724 } 725 726 Py_INCREF(msg); 727 PyTuple_SET_ITEM(args, 0, msg); 728 729 if (PyDict_SetItemString(kwargs, "name", name) < 0) 730 goto done; 731 if (PyDict_SetItemString(kwargs, "path", path) < 0) 732 goto done; 733 734 error = PyObject_Call(PyExc_ImportError, args, kwargs); 735 if (error != NULL) { 736 PyErr_SetObject((PyObject *)Py_TYPE(error), error); 737 Py_DECREF(error); 738 } 739 740done: 741 Py_DECREF(args); 742 Py_DECREF(kwargs); 743 return NULL; 744} 745 746void 747_PyErr_BadInternalCall(const char *filename, int lineno) 748{ 749 PyErr_Format(PyExc_SystemError, 750 "%s:%d: bad argument to internal function", 751 filename, lineno); 752} 753 754/* Remove the preprocessor macro for PyErr_BadInternalCall() so that we can 755 export the entry point for existing object code: */ 756#undef PyErr_BadInternalCall 757void 758PyErr_BadInternalCall(void) 759{ 760 assert(0 && "bad argument to internal function"); 761 PyErr_Format(PyExc_SystemError, 762 "bad argument to internal function"); 763} 764#define PyErr_BadInternalCall() _PyErr_BadInternalCall(__FILE__, __LINE__) 765 766 767PyObject * 768PyErr_FormatV(PyObject *exception, const char *format, va_list vargs) 769{ 770 PyObject* string; 771 772 /* Issue #23571: PyUnicode_FromFormatV() must not be called with an 773 exception set, it calls arbitrary Python code like PyObject_Repr() */ 774 PyErr_Clear(); 775 776 string = PyUnicode_FromFormatV(format, vargs); 777 778 PyErr_SetObject(exception, string); 779 Py_XDECREF(string); 780 return NULL; 781} 782 783 784PyObject * 785PyErr_Format(PyObject *exception, const char *format, ...) 786{ 787 va_list vargs; 788#ifdef HAVE_STDARG_PROTOTYPES 789 va_start(vargs, format); 790#else 791 va_start(vargs); 792#endif 793 PyErr_FormatV(exception, format, vargs); 794 va_end(vargs); 795 return NULL; 796} 797 798 799PyObject * 800PyErr_NewException(const char *name, PyObject *base, PyObject *dict) 801{ 802 const char *dot; 803 PyObject *modulename = NULL; 804 PyObject *classname = NULL; 805 PyObject *mydict = NULL; 806 PyObject *bases = NULL; 807 PyObject *result = NULL; 808 dot = strrchr(name, '.'); 809 if (dot == NULL) { 810 PyErr_SetString(PyExc_SystemError, 811 "PyErr_NewException: name must be module.class"); 812 return NULL; 813 } 814 if (base == NULL) 815 base = PyExc_Exception; 816 if (dict == NULL) { 817 dict = mydict = PyDict_New(); 818 if (dict == NULL) 819 goto failure; 820 } 821 if (PyDict_GetItemString(dict, "__module__") == NULL) { 822 modulename = PyUnicode_FromStringAndSize(name, 823 (Py_ssize_t)(dot-name)); 824 if (modulename == NULL) 825 goto failure; 826 if (PyDict_SetItemString(dict, "__module__", modulename) != 0) 827 goto failure; 828 } 829 if (PyTuple_Check(base)) { 830 bases = base; 831 /* INCREF as we create a new ref in the else branch */ 832 Py_INCREF(bases); 833 } else { 834 bases = PyTuple_Pack(1, base); 835 if (bases == NULL) 836 goto failure; 837 } 838 /* Create a real class. */ 839 result = PyObject_CallFunction((PyObject *)&PyType_Type, "sOO", 840 dot+1, bases, dict); 841 failure: 842 Py_XDECREF(bases); 843 Py_XDECREF(mydict); 844 Py_XDECREF(classname); 845 Py_XDECREF(modulename); 846 return result; 847} 848 849 850/* Create an exception with docstring */ 851PyObject * 852PyErr_NewExceptionWithDoc(const char *name, const char *doc, 853 PyObject *base, PyObject *dict) 854{ 855 int result; 856 PyObject *ret = NULL; 857 PyObject *mydict = NULL; /* points to the dict only if we create it */ 858 PyObject *docobj; 859 860 if (dict == NULL) { 861 dict = mydict = PyDict_New(); 862 if (dict == NULL) { 863 return NULL; 864 } 865 } 866 867 if (doc != NULL) { 868 docobj = PyUnicode_FromString(doc); 869 if (docobj == NULL) 870 goto failure; 871 result = PyDict_SetItemString(dict, "__doc__", docobj); 872 Py_DECREF(docobj); 873 if (result < 0) 874 goto failure; 875 } 876 877 ret = PyErr_NewException(name, base, dict); 878 failure: 879 Py_XDECREF(mydict); 880 return ret; 881} 882 883 884/* Call when an exception has occurred but there is no way for Python 885 to handle it. Examples: exception in __del__ or during GC. */ 886void 887PyErr_WriteUnraisable(PyObject *obj) 888{ 889 _Py_IDENTIFIER(__module__); 890 PyObject *f, *t, *v, *tb; 891 PyObject *moduleName = NULL; 892 char* className; 893 894 PyErr_Fetch(&t, &v, &tb); 895 896 f = _PySys_GetObjectId(&PyId_stderr); 897 if (f == NULL || f == Py_None) 898 goto done; 899 900 if (obj) { 901 if (PyFile_WriteString("Exception ignored in: ", f) < 0) 902 goto done; 903 if (PyFile_WriteObject(obj, f, 0) < 0) { 904 PyErr_Clear(); 905 if (PyFile_WriteString("<object repr() failed>", f) < 0) { 906 goto done; 907 } 908 } 909 if (PyFile_WriteString("\n", f) < 0) 910 goto done; 911 } 912 913 if (PyTraceBack_Print(tb, f) < 0) 914 goto done; 915 916 if (!t) 917 goto done; 918 919 assert(PyExceptionClass_Check(t)); 920 className = PyExceptionClass_Name(t); 921 if (className != NULL) { 922 char *dot = strrchr(className, '.'); 923 if (dot != NULL) 924 className = dot+1; 925 } 926 927 moduleName = _PyObject_GetAttrId(t, &PyId___module__); 928 if (moduleName == NULL) { 929 PyErr_Clear(); 930 if (PyFile_WriteString("<unknown>", f) < 0) 931 goto done; 932 } 933 else { 934 if (_PyUnicode_CompareWithId(moduleName, &PyId_builtins) != 0) { 935 if (PyFile_WriteObject(moduleName, f, Py_PRINT_RAW) < 0) 936 goto done; 937 if (PyFile_WriteString(".", f) < 0) 938 goto done; 939 } 940 } 941 if (className == NULL) { 942 if (PyFile_WriteString("<unknown>", f) < 0) 943 goto done; 944 } 945 else { 946 if (PyFile_WriteString(className, f) < 0) 947 goto done; 948 } 949 950 if (v && v != Py_None) { 951 if (PyFile_WriteString(": ", f) < 0) 952 goto done; 953 if (PyFile_WriteObject(v, f, Py_PRINT_RAW) < 0) { 954 PyErr_Clear(); 955 if (PyFile_WriteString("<exception str() failed>", f) < 0) { 956 goto done; 957 } 958 } 959 } 960 if (PyFile_WriteString("\n", f) < 0) 961 goto done; 962 963done: 964 Py_XDECREF(moduleName); 965 Py_XDECREF(t); 966 Py_XDECREF(v); 967 Py_XDECREF(tb); 968 PyErr_Clear(); /* Just in case */ 969} 970 971extern PyObject *PyModule_GetWarningsModule(void); 972 973 974void 975PyErr_SyntaxLocation(const char *filename, int lineno) 976{ 977 PyErr_SyntaxLocationEx(filename, lineno, -1); 978} 979 980 981/* Set file and line information for the current exception. 982 If the exception is not a SyntaxError, also sets additional attributes 983 to make printing of exceptions believe it is a syntax error. */ 984 985void 986PyErr_SyntaxLocationObject(PyObject *filename, int lineno, int col_offset) 987{ 988 PyObject *exc, *v, *tb, *tmp; 989 _Py_IDENTIFIER(filename); 990 _Py_IDENTIFIER(lineno); 991 _Py_IDENTIFIER(msg); 992 _Py_IDENTIFIER(offset); 993 _Py_IDENTIFIER(print_file_and_line); 994 _Py_IDENTIFIER(text); 995 996 /* add attributes for the line number and filename for the error */ 997 PyErr_Fetch(&exc, &v, &tb); 998 PyErr_NormalizeException(&exc, &v, &tb); 999 /* XXX check that it is, indeed, a syntax error. It might not 1000 * be, though. */ 1001 tmp = PyLong_FromLong(lineno); 1002 if (tmp == NULL) 1003 PyErr_Clear(); 1004 else { 1005 if (_PyObject_SetAttrId(v, &PyId_lineno, tmp)) 1006 PyErr_Clear(); 1007 Py_DECREF(tmp); 1008 } 1009 if (col_offset >= 0) { 1010 tmp = PyLong_FromLong(col_offset); 1011 if (tmp == NULL) 1012 PyErr_Clear(); 1013 else { 1014 if (_PyObject_SetAttrId(v, &PyId_offset, tmp)) 1015 PyErr_Clear(); 1016 Py_DECREF(tmp); 1017 } 1018 } 1019 if (filename != NULL) { 1020 if (_PyObject_SetAttrId(v, &PyId_filename, filename)) 1021 PyErr_Clear(); 1022 1023 tmp = PyErr_ProgramTextObject(filename, lineno); 1024 if (tmp) { 1025 if (_PyObject_SetAttrId(v, &PyId_text, tmp)) 1026 PyErr_Clear(); 1027 Py_DECREF(tmp); 1028 } 1029 } 1030 if (_PyObject_SetAttrId(v, &PyId_offset, Py_None)) { 1031 PyErr_Clear(); 1032 } 1033 if (exc != PyExc_SyntaxError) { 1034 if (!_PyObject_HasAttrId(v, &PyId_msg)) { 1035 tmp = PyObject_Str(v); 1036 if (tmp) { 1037 if (_PyObject_SetAttrId(v, &PyId_msg, tmp)) 1038 PyErr_Clear(); 1039 Py_DECREF(tmp); 1040 } else { 1041 PyErr_Clear(); 1042 } 1043 } 1044 if (!_PyObject_HasAttrId(v, &PyId_print_file_and_line)) { 1045 if (_PyObject_SetAttrId(v, &PyId_print_file_and_line, 1046 Py_None)) 1047 PyErr_Clear(); 1048 } 1049 } 1050 PyErr_Restore(exc, v, tb); 1051} 1052 1053void 1054PyErr_SyntaxLocationEx(const char *filename, int lineno, int col_offset) 1055{ 1056 PyObject *fileobj; 1057 if (filename != NULL) { 1058 fileobj = PyUnicode_DecodeFSDefault(filename); 1059 if (fileobj == NULL) 1060 PyErr_Clear(); 1061 } 1062 else 1063 fileobj = NULL; 1064 PyErr_SyntaxLocationObject(fileobj, lineno, col_offset); 1065 Py_XDECREF(fileobj); 1066} 1067 1068/* Attempt to load the line of text that the exception refers to. If it 1069 fails, it will return NULL but will not set an exception. 1070 1071 XXX The functionality of this function is quite similar to the 1072 functionality in tb_displayline() in traceback.c. */ 1073 1074static PyObject * 1075err_programtext(FILE *fp, int lineno) 1076{ 1077 int i; 1078 char linebuf[1000]; 1079 1080 if (fp == NULL) 1081 return NULL; 1082 for (i = 0; i < lineno; i++) { 1083 char *pLastChar = &linebuf[sizeof(linebuf) - 2]; 1084 do { 1085 *pLastChar = '\0'; 1086 if (Py_UniversalNewlineFgets(linebuf, sizeof linebuf, 1087 fp, NULL) == NULL) 1088 break; 1089 /* fgets read *something*; if it didn't get as 1090 far as pLastChar, it must have found a newline 1091 or hit the end of the file; if pLastChar is \n, 1092 it obviously found a newline; else we haven't 1093 yet seen a newline, so must continue */ 1094 } while (*pLastChar != '\0' && *pLastChar != '\n'); 1095 } 1096 fclose(fp); 1097 if (i == lineno) { 1098 char *p = linebuf; 1099 PyObject *res; 1100 while (*p == ' ' || *p == '\t' || *p == '\014') 1101 p++; 1102 res = PyUnicode_FromString(p); 1103 if (res == NULL) 1104 PyErr_Clear(); 1105 return res; 1106 } 1107 return NULL; 1108} 1109 1110PyObject * 1111PyErr_ProgramText(const char *filename, int lineno) 1112{ 1113 FILE *fp; 1114 if (filename == NULL || *filename == '\0' || lineno <= 0) 1115 return NULL; 1116 fp = _Py_fopen(filename, "r" PY_STDIOTEXTMODE); 1117 return err_programtext(fp, lineno); 1118} 1119 1120PyObject * 1121PyErr_ProgramTextObject(PyObject *filename, int lineno) 1122{ 1123 FILE *fp; 1124 if (filename == NULL || lineno <= 0) 1125 return NULL; 1126 fp = _Py_fopen_obj(filename, "r" PY_STDIOTEXTMODE); 1127 if (fp == NULL) { 1128 PyErr_Clear(); 1129 return NULL; 1130 } 1131 return err_programtext(fp, lineno); 1132} 1133 1134#ifdef __cplusplus 1135} 1136#endif 1137