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