#include "Python.h"

#include "pycore_initconfig.h"

#include "pycore_object.h" // _PyType_GetQualName

#include "pycore_pyerrors.h"

#include "pycore_pystate.h" // _PyThreadState_GET()

#include "pycore_sysmodule.h"

#include "pycore_traceback.h"

#ifndef __STDC__

#ifndef MS_WINDOWS

extern char *strerror(int);

#ifdef MS_WINDOWS

#include <windows.h>

#include <winbase.h>

#include <ctype.h>

#ifdef __cplusplus

extern "C" {

_Py_IDENTIFIER(__module__);

_Py_IDENTIFIER(builtins);

_Py_IDENTIFIER(stderr);

_Py_IDENTIFIER(flush);

static PyObject *

_PyErr_FormatV(PyThreadState *tstate, PyObject *exception,

const char *format, va_list vargs);

_PyErr_Restore(PyThreadState *tstate, PyObject *type, PyObject *value,

PyObject *traceback)

{

PyObject *oldtype, *oldvalue, *oldtraceback;

if (traceback != NULL && !PyTraceBack_Check(traceback)) {

/* XXX Should never happen -- fatal error instead? */

/* Well, it could be None. */

Py_DECREF(traceback);

traceback = NULL;

}

/* Save these in locals to safeguard against recursive

oldtype = tstate->curexc_type;

oldvalue = tstate->curexc_value;

oldtraceback = tstate->curexc_traceback;

tstate->curexc_type = type;

tstate->curexc_value = value;

tstate->curexc_traceback = traceback;

Py_XDECREF(oldtype);

Py_XDECREF(oldvalue);

Py_XDECREF(oldtraceback);

}

PyErr_Restore(PyObject *type, PyObject *value, PyObject *traceback)

{

PyThreadState *tstate = _PyThreadState_GET();

_PyErr_Restore(tstate, type, value, traceback);

}

_PyErr_StackItem *

_PyErr_GetTopmostException(PyThreadState *tstate)

{

_PyErr_StackItem *exc_info = tstate->exc_info;

while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) &&

exc_info->previous_item != NULL)

{

exc_info = exc_info->previous_item;

}

return exc_info;

}

static PyObject*

_PyErr_CreateException(PyObject *exception_type, PyObject *value)

{

PyObject *exc;

if (value == NULL || value == Py_None) {

exc = _PyObject_CallNoArg(exception_type);

}

else if (PyTuple_Check(value)) {

exc = PyObject_Call(exception_type, value, NULL);

}

else {

exc = PyObject_CallOneArg(exception_type, value);

}

if (exc != NULL && !PyExceptionInstance_Check(exc)) {

PyErr_Format(PyExc_TypeError,

"calling %R should have returned an instance of "

"BaseException, not %s",

exception_type, Py_TYPE(exc)->tp_name);

Py_CLEAR(exc);

}

return exc;

}

_PyErr_SetObject(PyThreadState *tstate, PyObject *exception, PyObject *value)

{

PyObject *exc_value;

PyObject *tb = NULL;

if (exception != NULL &&

!PyExceptionClass_Check(exception)) {

_PyErr_Format(tstate, PyExc_SystemError,

"_PyErr_SetObject: "

"exception %R is not a BaseException subclass",

exception);

return;

}

Py_XINCREF(value);

exc_value = _PyErr_GetTopmostException(tstate)->exc_value;

if (exc_value != NULL && exc_value != Py_None) {

/* Implicit exception chaining */

Py_INCREF(exc_value);

if (value == NULL || !PyExceptionInstance_Check(value)) {

/* We must normalize the value right now */

PyObject *fixed_value;

/* Issue #23571: functions must not be called with an

_PyErr_Clear(tstate);

fixed_value = _PyErr_CreateException(exception, value);

Py_XDECREF(value);

if (fixed_value == NULL) {

Py_DECREF(exc_value);

return;

}

value = fixed_value;

}

/* Avoid creating new reference cycles through the

if (exc_value != value) {

PyObject *o = exc_value, *context;

PyObject *slow_o = o; /* Floyd's cycle detection algo */

int slow_update_toggle = 0;

while ((context = PyException_GetContext(o))) {

Py_DECREF(context);

if (context == value) {

PyException_SetContext(o, NULL);

break;

}

o = context;

if (o == slow_o) {

/* pre-existing cycle - all exceptions on the

break;

}

if (slow_update_toggle) {

slow_o = PyException_GetContext(slow_o);

Py_DECREF(slow_o);

}

slow_update_toggle = !slow_update_toggle;

}

PyException_SetContext(value, exc_value);

}

else {

Py_DECREF(exc_value);

}

}

if (value != NULL && PyExceptionInstance_Check(value))

tb = PyException_GetTraceback(value);

Py_XINCREF(exception);

_PyErr_Restore(tstate, exception, value, tb);

}

PyErr_SetObject(PyObject *exception, PyObject *value)

{

PyThreadState *tstate = _PyThreadState_GET();

_PyErr_SetObject(tstate, exception, value);

}

_PyErr_SetKeyError(PyObject *arg)

{

PyThreadState *tstate = _PyThreadState_GET();

PyObject *tup = PyTuple_Pack(1, arg);

if (!tup) {

/* caller will expect error to be set anyway */

return;

}

_PyErr_SetObject(tstate, PyExc_KeyError, tup);

Py_DECREF(tup);

}

_PyErr_SetNone(PyThreadState *tstate, PyObject *exception)

{

_PyErr_SetObject(tstate, exception, (PyObject *)NULL);

}

PyErr_SetNone(PyObject *exception)

{

PyThreadState *tstate = _PyThreadState_GET();

_PyErr_SetNone(tstate, exception);

}

_PyErr_SetString(PyThreadState *tstate, PyObject *exception,

const char *string)

{

PyObject *value = PyUnicode_FromString(string);

_PyErr_SetObject(tstate, exception, value);

Py_XDECREF(value);

}

PyErr_SetString(PyObject *exception, const char *string)

{

PyThreadState *tstate = _PyThreadState_GET();

_PyErr_SetString(tstate, exception, string);

}

PyObject* _Py_HOT_FUNCTION

PyErr_Occurred(void)

{

/* The caller must hold the GIL. */

assert(PyGILState_Check());

PyThreadState *tstate = _PyThreadState_GET();

return _PyErr_Occurred(tstate);

}

PyErr_GivenExceptionMatches(PyObject *err, PyObject *exc)

{

if (err == NULL || exc == NULL) {

/* maybe caused by "import exceptions" that failed early on */

return 0;

}

if (PyTuple_Check(exc)) {

Py_ssize_t i, n;

n = PyTuple_Size(exc);

for (i = 0; i < n; i++) {

/* Test recursively */

if (PyErr_GivenExceptionMatches(

err, PyTuple_GET_ITEM(exc, i)))

{

return 1;

}

}

return 0;

}

/* err might be an instance, so check its class. */

if (PyExceptionInstance_Check(err))

err = PyExceptionInstance_Class(err);

if (PyExceptionClass_Check(err) && PyExceptionClass_Check(exc)) {

return PyType_IsSubtype((PyTypeObject *)err, (PyTypeObject *)exc);

}

return err == exc;

}

_PyErr_ExceptionMatches(PyThreadState *tstate, PyObject *exc)

{

return PyErr_GivenExceptionMatches(_PyErr_Occurred(tstate), exc);

}

PyErr_ExceptionMatches(PyObject *exc)

{

PyThreadState *tstate = _PyThreadState_GET();

return _PyErr_ExceptionMatches(tstate, exc);

}

#ifndef Py_NORMALIZE_RECURSION_LIMIT

#define Py_NORMALIZE_RECURSION_LIMIT 32

_PyErr_NormalizeException(PyThreadState *tstate, PyObject **exc,

PyObject **val, PyObject **tb)

{

int recursion_depth = 0;

tstate->overflowed++;

PyObject *type, *value, *initial_tb;

restart:

type = *exc;

if (type == NULL) {

/* There was no exception, so nothing to do. */

tstate->overflowed--;

return;

}

value = *val;

/* If PyErr_SetNone() was used, the value will have been actually

if (!value) {

value = Py_None;

Py_INCREF(value);

}

/* Normalize the exception so that if the type is a class, the

if (PyExceptionClass_Check(type)) {

PyObject *inclass = NULL;

int is_subclass = 0;

if (PyExceptionInstance_Check(value)) {

inclass = PyExceptionInstance_Class(value);

is_subclass = PyObject_IsSubclass(inclass, type);

if (is_subclass < 0) {

goto error;

}

}

/* If the value was not an instance, or is not an instance

if (!is_subclass) {

PyObject *fixed_value = _PyErr_CreateException(type, value);

if (fixed_value == NULL) {

goto error;

}

Py_DECREF(value);

value = fixed_value;

}

/* If the class of the instance doesn't exactly match the

else if (inclass != type) {

Py_INCREF(inclass);

Py_DECREF(type);

type = inclass;

}

}

*exc = type;

*val = value;

tstate->overflowed--;

return;

error:

Py_DECREF(type);

Py_DECREF(value);

recursion_depth++;

if (recursion_depth == Py_NORMALIZE_RECURSION_LIMIT) {

_PyErr_SetString(tstate, PyExc_RecursionError,

"maximum recursion depth exceeded "

"while normalizing an exception");

}

/* If the new exception doesn't set a traceback and the old

initial_tb = *tb;

_PyErr_Fetch(tstate, exc, val, tb);

assert(*exc != NULL);

if (initial_tb != NULL) {

if (*tb == NULL)

*tb = initial_tb;

else

Py_DECREF(initial_tb);

}

/* Abort when Py_NORMALIZE_RECURSION_LIMIT has been exceeded, and the

if (recursion_depth >= Py_NORMALIZE_RECURSION_LIMIT + 2) {

if (PyErr_GivenExceptionMatches(*exc, PyExc_MemoryError)) {

Py_FatalError("Cannot recover from MemoryErrors "

"while normalizing exceptions.");

}

else {

Py_FatalError("Cannot recover from the recursive normalization "

"of an exception.");

}

}

goto restart;

}

PyErr_NormalizeException(PyObject **exc, PyObject **val, PyObject **tb)

{

PyThreadState *tstate = _PyThreadState_GET();

_PyErr_NormalizeException(tstate, exc, val, tb);

}

_PyErr_Fetch(PyThreadState *tstate, PyObject **p_type, PyObject **p_value,

PyObject **p_traceback)

{

*p_type = tstate->curexc_type;

*p_value = tstate->curexc_value;

*p_traceback = tstate->curexc_traceback;

tstate->curexc_type = NULL;

tstate->curexc_value = NULL;

tstate->curexc_traceback = NULL;

}

PyErr_Fetch(PyObject **p_type, PyObject **p_value, PyObject **p_traceback)

{

PyThreadState *tstate = _PyThreadState_GET();

_PyErr_Fetch(tstate, p_type, p_value, p_traceback);

}

_PyErr_Clear(PyThreadState *tstate)

{

_PyErr_Restore(tstate, NULL, NULL, NULL);

}

PyErr_Clear(void)

{

PyThreadState *tstate = _PyThreadState_GET();

_PyErr_Clear(tstate);

}

_PyErr_GetExcInfo(PyThreadState *tstate,

PyObject **p_type, PyObject **p_value, PyObject **p_traceback)

{

_PyErr_StackItem *exc_info = _PyErr_GetTopmostException(tstate);

*p_type = exc_info->exc_type;

*p_value = exc_info->exc_value;

*p_traceback = exc_info->exc_traceback;

Py_XINCREF(*p_type);

Py_XINCREF(*p_value);

Py_XINCREF(*p_traceback);

}

PyErr_GetExcInfo(PyObject **p_type, PyObject **p_value, PyObject **p_traceback)

{

PyThreadState *tstate = _PyThreadState_GET();

_PyErr_GetExcInfo(tstate, p_type, p_value, p_traceback);

}

PyErr_SetExcInfo(PyObject *p_type, PyObject *p_value, PyObject *p_traceback)

{

PyObject *oldtype, *oldvalue, *oldtraceback;

PyThreadState *tstate = _PyThreadState_GET();

oldtype = tstate->exc_info->exc_type;

oldvalue = tstate->exc_info->exc_value;

oldtraceback = tstate->exc_info->exc_traceback;

tstate->exc_info->exc_type = p_type;

tstate->exc_info->exc_value = p_value;

tstate->exc_info->exc_traceback = p_traceback;

Py_XDECREF(oldtype);

Py_XDECREF(oldvalue);

Py_XDECREF(oldtraceback);

}

_PyErr_ChainExceptions(PyObject *exc, PyObject *val, PyObject *tb)

{

if (exc == NULL)

return;

PyThreadState *tstate = _PyThreadState_GET();

if (!PyExceptionClass_Check(exc)) {

_PyErr_Format(tstate, PyExc_SystemError,

"_PyErr_ChainExceptions: "

"exception %R is not a BaseException subclass",

exc);

return;

}

if (_PyErr_Occurred(tstate)) {

PyObject *exc2, *val2, *tb2;

_PyErr_Fetch(tstate, &exc2, &val2, &tb2);

_PyErr_NormalizeException(tstate, &exc, &val, &tb);

if (tb != NULL) {

PyException_SetTraceback(val, tb);

Py_DECREF(tb);

}

Py_DECREF(exc);

_PyErr_NormalizeException(tstate, &exc2, &val2, &tb2);

PyException_SetContext(val2, val);

_PyErr_Restore(tstate, exc2, val2, tb2);

}

else {

_PyErr_Restore(tstate, exc, val, tb);

}

}

_PyErr_ChainStackItem(_PyErr_StackItem *exc_info)

{

PyThreadState *tstate = _PyThreadState_GET();

assert(_PyErr_Occurred(tstate));

int exc_info_given;

if (exc_info == NULL) {

exc_info_given = 0;

exc_info = tstate->exc_info;

} else {

exc_info_given = 1;

}

if (exc_info->exc_type == NULL || exc_info->exc_type == Py_None) {

return;

}

_PyErr_StackItem *saved_exc_info;

if (exc_info_given) {

/* Temporarily set the thread state's exc_info since this is what

saved_exc_info = tstate->exc_info;

tstate->exc_info = exc_info;

}

PyObject *exc, *val, *tb;

_PyErr_Fetch(tstate, &exc, &val, &tb);

PyObject *exc2, *val2, *tb2;

exc2 = exc_info->exc_type;

val2 = exc_info->exc_value;

tb2 = exc_info->exc_traceback;

_PyErr_NormalizeException(tstate, &exc2, &val2, &tb2);

if (tb2 != NULL) {

PyException_SetTraceback(val2, tb2);

}

/* _PyErr_SetObject sets the context from PyThreadState. */

_PyErr_SetObject(tstate, exc, val);

Py_DECREF(exc); // since _PyErr_Occurred was true

Py_XDECREF(val);

Py_XDECREF(tb);

if (exc_info_given) {

tstate->exc_info = saved_exc_info;

}

}

static PyObject *

_PyErr_FormatVFromCause(PyThreadState *tstate, PyObject *exception,

const char *format, va_list vargs)

{

PyObject *exc, *val, *val2, *tb;

assert(_PyErr_Occurred(tstate));

_PyErr_Fetch(tstate, &exc, &val, &tb);

_PyErr_NormalizeException(tstate, &exc, &val, &tb);

if (tb != NULL) {

PyException_SetTraceback(val, tb);

Py_DECREF(tb);

}

Py_DECREF(exc);

assert(!_PyErr_Occurred(tstate));

_PyErr_FormatV(tstate, exception, format, vargs);

_PyErr_Fetch(tstate, &exc, &val2, &tb);

_PyErr_NormalizeException(tstate, &exc, &val2, &tb);

Py_INCREF(val);

PyException_SetCause(val2, val);

PyException_SetContext(val2, val);

_PyErr_Restore(tstate, exc, val2, tb);

return NULL;

}

PyObject *

_PyErr_FormatFromCauseTstate(PyThreadState *tstate, PyObject *exception,

const char *format, ...)

{

va_list vargs;

#ifdef HAVE_STDARG_PROTOTYPES

va_start(vargs, format);

va_start(vargs);

_PyErr_FormatVFromCause(tstate, exception, format, vargs);

va_end(vargs);

return NULL;

}

PyObject *

_PyErr_FormatFromCause(PyObject *exception, const char *format, ...)

{

PyThreadState *tstate = _PyThreadState_GET();

va_list vargs;

#ifdef HAVE_STDARG_PROTOTYPES

va_start(vargs, format);

va_start(vargs);

_PyErr_FormatVFromCause(tstate, exception, format, vargs);

va_end(vargs);

return NULL;

}

PyErr_BadArgument(void)

{

PyThreadState *tstate = _PyThreadState_GET();

_PyErr_SetString(tstate, PyExc_TypeError,

"bad argument type for built-in operation");

return 0;

}

PyObject *

_PyErr_NoMemory(PyThreadState *tstate)

{

if (Py_IS_TYPE(PyExc_MemoryError, NULL)) {

/* PyErr_NoMemory() has been called before PyExc_MemoryError has been

Py_FatalError("Out of memory and PyExc_MemoryError is not "

"initialized yet");

}

_PyErr_SetNone(tstate, PyExc_MemoryError);

return NULL;

}

PyObject *

PyErr_NoMemory(void)

{

PyThreadState *tstate = _PyThreadState_GET();

return _PyErr_NoMemory(tstate);

}

PyObject *

PyErr_SetFromErrnoWithFilenameObject(PyObject *exc, PyObject *filenameObject)

{

return PyErr_SetFromErrnoWithFilenameObjects(exc, filenameObject, NULL);

}

PyObject *

PyErr_SetFromErrnoWithFilenameObjects(PyObject *exc, PyObject *filenameObject, PyObject *filenameObject2)

{

PyThreadState *tstate = _PyThreadState_GET();

PyObject *message;

PyObject *v, *args;

int i = errno;

#ifdef MS_WINDOWS

WCHAR *s_buf = NULL;

#endif /* Unix/Windows */

#ifdef EINTR

if (i == EINTR && PyErr_CheckSignals())

return NULL;

#ifndef MS_WINDOWS

if (i != 0) {

const char *s = strerror(i);

message = PyUnicode_DecodeLocale(s, "surrogateescape");

}

else {

/* Sometimes errno didn't get set */

message = PyUnicode_FromString("Error");

}

if (i == 0)

message = PyUnicode_FromString("Error"); /* Sometimes errno didn't get set */

else

{

/* Note that the Win32 errors do not lineup with the

if (i > 0 && i < _sys_nerr) {

message = PyUnicode_FromString(_sys_errlist[i]);

}

else {

int len = FormatMessageW(

FORMAT_MESSAGE_ALLOCATE_BUFFER |

FORMAT_MESSAGE_FROM_SYSTEM |

FORMAT_MESSAGE_IGNORE_INSERTS,

NULL, /* no message source */

i,

MAKELANGID(LANG_NEUTRAL,

SUBLANG_DEFAULT),

/* Default language */

(LPWSTR) &s_buf,

0, /* size not used */

NULL); /* no args */

if (len==0) {

/* Only ever seen this in out-of-mem

s_buf = NULL;

message = PyUnicode_FromFormat("Windows Error 0x%x", i);

} else {

/* remove trailing cr/lf and dots */

while (len > 0 && (s_buf[len-1] <= L' ' || s_buf[len-1] == L'.'))

s_buf[--len] = L'\0';

message = PyUnicode_FromWideChar(s_buf, len);

}

}

}

#endif /* Unix/Windows */

if (message == NULL)

{

#ifdef MS_WINDOWS

LocalFree(s_buf);

return NULL;

}

if (filenameObject != NULL) {

if (filenameObject2 != NULL)

args = Py_BuildValue("(iOOiO)", i, message, filenameObject, 0, filenameObject2);

else

args = Py_BuildValue("(iOO)", i, message, filenameObject);

} else {

assert(filenameObject2 == NULL);

args = Py_BuildValue("(iO)", i, message);

}

Py_DECREF(message);

if (args != NULL) {

v = PyObject_Call(exc, args, NULL);

Py_DECREF(args);

if (v != NULL) {

_PyErr_SetObject(tstate, (PyObject *) Py_TYPE(v), v);

Py_DECREF(v);

}

}

#ifdef MS_WINDOWS

LocalFree(s_buf);

return NULL;

}

PyObject *

PyErr_SetFromErrnoWithFilename(PyObject *exc, const char *filename)

{

PyObject *name = filename ? PyUnicode_DecodeFSDefault(filename) : NULL;

PyObject *result = PyErr_SetFromErrnoWithFilenameObjects(exc, name, NULL);

Py_XDECREF(name);

return result;

}

#ifdef MS_WINDOWS

PyObject *

PyErr_SetFromErrnoWithUnicodeFilename(PyObject *exc, const Py_UNICODE *filename)

{

PyObject *name = filename ? PyUnicode_FromWideChar(filename, -1) : NULL;

PyObject *result = PyErr_SetFromErrnoWithFilenameObjects(exc, name, NULL);

Py_XDECREF(name);

return result;

}

#endif /* MS_WINDOWS */

PyObject *

PyErr_SetFromErrno(PyObject *exc)

{

return PyErr_SetFromErrnoWithFilenameObjects(exc, NULL, NULL);

}

#ifdef MS_WINDOWS

PyObject *PyErr_SetExcFromWindowsErrWithFilenameObject(

PyObject *exc,

int ierr,

PyObject *filenameObject)

{

return PyErr_SetExcFromWindowsErrWithFilenameObjects(exc, ierr,

filenameObject, NULL);

}

PyObject *PyErr_SetExcFromWindowsErrWithFilenameObjects(

PyObject *filenameObject2)

{

PyThreadState *tstate = _PyThreadState_GET();

int len;

WCHAR *s_buf = NULL; /* Free via LocalFree */

PyObject *message;

PyObject *args, *v;

DWORD err = (DWORD)ierr;

if (err==0) {

err = GetLastError();

}

len = FormatMessageW(

/* Error API error */

FORMAT_MESSAGE_ALLOCATE_BUFFER |

FORMAT_MESSAGE_FROM_SYSTEM |

FORMAT_MESSAGE_IGNORE_INSERTS,

NULL, /* no message source */

err,

MAKELANGID(LANG_NEUTRAL,

SUBLANG_DEFAULT), /* Default language */

(LPWSTR) &s_buf,

0, /* size not used */

NULL); /* no args */

if (len==0) {

/* Only seen this in out of mem situations */

message = PyUnicode_FromFormat("Windows Error 0x%x", err);

s_buf = NULL;

} else {

/* remove trailing cr/lf and dots */

while (len > 0 && (s_buf[len-1] <= L' ' || s_buf[len-1] == L'.'))

s_buf[--len] = L'\0';

message = PyUnicode_FromWideChar(s_buf, len);

}

if (message == NULL)

{

LocalFree(s_buf);

return NULL;

}

if (filenameObject == NULL) {

assert(filenameObject2 == NULL);

filenameObject = filenameObject2 = Py_None;

}

else if (filenameObject2 == NULL)

filenameObject2 = Py_None;

/* This is the constructor signature for OSError.

args = Py_BuildValue("(iOOiO)", 0, message, filenameObject, err, filenameObject2);

Py_DECREF(message);

if (args != NULL) {

v = PyObject_Call(exc, args, NULL);

Py_DECREF(args);

if (v != NULL) {

_PyErr_SetObject(tstate, (PyObject *) Py_TYPE(v), v);

Py_DECREF(v);

}

}

LocalFree(s_buf);

return NULL;

}

PyObject *PyErr_SetExcFromWindowsErrWithFilename(

PyObject *exc,

int ierr,

const char *filename)

{

PyObject *name = filename ? PyUnicode_DecodeFSDefault(filename) : NULL;

PyObject *ret = PyErr_SetExcFromWindowsErrWithFilenameObjects(exc,

ierr,

name,

NULL);

Py_XDECREF(name);

return ret;

}

PyObject *PyErr_SetExcFromWindowsErrWithUnicodeFilename(

PyObject *exc,

int ierr,

const Py_UNICODE *filename)

{

PyObject *name = filename ? PyUnicode_FromWideChar(filename, -1) : NULL;

PyObject *ret = PyErr_SetExcFromWindowsErrWithFilenameObjects(exc,

ierr,

name,

NULL);

Py_XDECREF(name);

return ret;

}

PyObject *PyErr_SetExcFromWindowsErr(PyObject *exc, int ierr)

{

return PyErr_SetExcFromWindowsErrWithFilename(exc, ierr, NULL);

}

PyObject *PyErr_SetFromWindowsErr(int ierr)

{

return PyErr_SetExcFromWindowsErrWithFilename(PyExc_OSError,

ierr, NULL);

}

PyObject *PyErr_SetFromWindowsErrWithFilename(

int ierr,

const char *filename)

{

PyObject *name = filename ? PyUnicode_DecodeFSDefault(filename) : NULL;

PyObject *result = PyErr_SetExcFromWindowsErrWithFilenameObjects(

PyExc_OSError,

ierr, name, NULL);

Py_XDECREF(name);

return result;

}

PyObject *PyErr_SetFromWindowsErrWithUnicodeFilename(

int ierr,

const Py_UNICODE *filename)

{

PyObject *name = filename ? PyUnicode_FromWideChar(filename, -1) : NULL;

PyObject *result = PyErr_SetExcFromWindowsErrWithFilenameObjects(

PyExc_OSError,

ierr, name, NULL);

Py_XDECREF(name);

return result;

}

#endif /* MS_WINDOWS */

PyObject *

PyErr_SetImportErrorSubclass(PyObject *exception, PyObject *msg,

PyObject *name, PyObject *path)

{

PyThreadState *tstate = _PyThreadState_GET();

int issubclass;

PyObject *kwargs, *error;

issubclass = PyObject_IsSubclass(exception, PyExc_ImportError);

if (issubclass < 0) {

return NULL;

}

else if (!issubclass) {

_PyErr_SetString(tstate, PyExc_TypeError,

"expected a subclass of ImportError");

return NULL;

}

if (msg == NULL) {

_PyErr_SetString(tstate, PyExc_TypeError,

"expected a message argument");

return NULL;

}

if (name == NULL) {

name = Py_None;

}

if (path == NULL) {

path = Py_None;

}

kwargs = PyDict_New();

if (kwargs == NULL) {

return NULL;