#include "Python.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" {

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

{

PyThreadState *tstate = PyThreadState_GET();

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_SetObject(PyObject *exception, PyObject *value)

{

PyThreadState *tstate = PyThreadState_GET();

PyObject *exc_value;

PyObject *tb = NULL;

if (exception != NULL &&

!PyExceptionClass_Check(exception)) {

PyErr_Format(PyExc_SystemError,

"exception %R not a BaseException subclass",

exception);

return;

}

Py_XINCREF(value);

exc_value = 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 *args, *fixed_value;

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

args = PyTuple_New(0);

else if (PyTuple_Check(value)) {

Py_INCREF(value);

args = value;

}

else

args = PyTuple_Pack(1, value);

fixed_value = args ?

PyEval_CallObject(exception, args) : NULL;

Py_XDECREF(args);

Py_XDECREF(value);

if (fixed_value == NULL)

return;

value = fixed_value;

}

/* Avoid reference cycles through the context chain.

if (exc_value != value) {

PyObject *o = exc_value, *context;

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

Py_DECREF(context);

if (context == value) {

PyException_SetContext(o, NULL);

break;

}

o = context;

}

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(exception, value, tb);

}

PyErr_SetNone(PyObject *exception)

{

PyErr_SetObject(exception, (PyObject *)NULL);

}

PyErr_SetString(PyObject *exception, const char *string)

{

PyObject *value = PyUnicode_FromString(string);

PyErr_SetObject(exception, value);

Py_XDECREF(value);

}

PyObject *

PyErr_Occurred(void)

{

/* If there is no thread state, PyThreadState_GET calls

PyThreadState *tstate =

((PyThreadState*)_Py_atomic_load_relaxed(&_PyThreadState_Current));

return tstate == NULL ? NULL : tstate->curexc_type;

}

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)) {

int res = 0;

PyObject *exception, *value, *tb;

PyErr_Fetch(&exception, &value, &tb);

/* PyObject_IsSubclass() can recurse and therefore is

res = PyType_IsSubtype((PyTypeObject *)err, (PyTypeObject *)exc);

/* This function must not fail, so print the error here */

if (res == -1) {

PyErr_WriteUnraisable(err);

res = 0;

}

PyErr_Restore(exception, value, tb);

return res;

}

return err == exc;

}

PyErr_ExceptionMatches(PyObject *exc)

{

return PyErr_GivenExceptionMatches(PyErr_Occurred(), exc);

}

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

{

PyObject *type = *exc;

PyObject *value = *val;

PyObject *inclass = NULL;

PyObject *initial_tb = NULL;

PyThreadState *tstate = NULL;

if (type == NULL) {

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

return;

}

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

if (!value) {

value = Py_None;

Py_INCREF(value);

}

if (PyExceptionInstance_Check(value))

inclass = PyExceptionInstance_Class(value);

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

if (PyExceptionClass_Check(type)) {

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

if (!inclass || !PyObject_IsSubclass(inclass, type)) {

PyObject *args, *res;

if (value == Py_None)

args = PyTuple_New(0);

else if (PyTuple_Check(value)) {

Py_INCREF(value);

args = value;

}

else

args = PyTuple_Pack(1, value);

if (args == NULL)

goto finally;

res = PyEval_CallObject(type, args);

Py_DECREF(args);

if (res == NULL)

goto finally;

Py_DECREF(value);

value = res;

}

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

else if (inclass != type) {

Py_DECREF(type);

type = inclass;

Py_INCREF(type);

}

}

*exc = type;

*val = value;

return;

finally:

Py_DECREF(type);

Py_DECREF(value);

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

initial_tb = *tb;

PyErr_Fetch(exc, val, tb);

if (initial_tb != NULL) {

if (*tb == NULL)

*tb = initial_tb;

else

Py_DECREF(initial_tb);

}

/* normalize recursively */

tstate = PyThreadState_GET();

if (++tstate->recursion_depth > Py_GetRecursionLimit()) {

--tstate->recursion_depth;

/* throw away the old exception... */

Py_DECREF(*exc);

Py_DECREF(*val);

/* ... and use the recursion error instead */

*exc = PyExc_RuntimeError;

*val = PyExc_RecursionErrorInst;

Py_INCREF(*exc);

Py_INCREF(*val);

/* just keeping the old traceback */

return;

}

PyErr_NormalizeException(exc, val, tb);

--tstate->recursion_depth;

}

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

{

PyThreadState *tstate = PyThreadState_GET();

*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_Clear(void)

{

PyErr_Restore(NULL, NULL, NULL);

}

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

{

PyThreadState *tstate = PyThreadState_GET();

*p_type = tstate->exc_type;

*p_value = tstate->exc_value;

*p_traceback = tstate->exc_traceback;

Py_XINCREF(*p_type);

Py_XINCREF(*p_value);

Py_XINCREF(*p_traceback);

}

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

{

PyObject *oldtype, *oldvalue, *oldtraceback;

PyThreadState *tstate = PyThreadState_GET();

oldtype = tstate->exc_type;

oldvalue = tstate->exc_value;

oldtraceback = tstate->exc_traceback;

tstate->exc_type = p_type;

tstate->exc_value = p_value;

tstate->exc_traceback = p_traceback;

Py_XDECREF(oldtype);

Py_XDECREF(oldvalue);

Py_XDECREF(oldtraceback);

}

PyErr_BadArgument(void)

{

PyErr_SetString(PyExc_TypeError,

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

return 0;

}

PyObject *

PyErr_NoMemory(void)

{

PyErr_SetNone(PyExc_MemoryError);

return NULL;

}

PyObject *

PyErr_SetFromErrnoWithFilenameObject(PyObject *exc, PyObject *filenameObject)

{

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) {

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)

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

else

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((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_SetFromErrnoWithFilenameObject(exc, name);

Py_XDECREF(name);

return result;

}

#ifdef MS_WINDOWS

PyObject *

PyErr_SetFromErrnoWithUnicodeFilename(PyObject *exc, const Py_UNICODE *filename)

{

PyObject *name = filename ?

PyUnicode_FromUnicode(filename, wcslen(filename)) :

NULL;

PyObject *result = PyErr_SetFromErrnoWithFilenameObject(exc, name);

Py_XDECREF(name);

return result;

}

#endif /* MS_WINDOWS */

PyObject *

PyErr_SetFromErrno(PyObject *exc)

{

return PyErr_SetFromErrnoWithFilenameObject(exc, NULL);

}

#ifdef MS_WINDOWS

PyObject *PyErr_SetExcFromWindowsErrWithFilenameObject(

PyObject *exc,

int ierr,

PyObject *filenameObject)

{

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)

filenameObject = Py_None;

/* This is the constructor signature for passing a Windows error code.

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

Py_DECREF(message);

if (args != NULL) {

v = PyObject_Call(exc, args, NULL);

Py_DECREF(args);

if (v != NULL) {

PyErr_SetObject((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_SetExcFromWindowsErrWithFilenameObject(exc,

ierr,

name);

Py_XDECREF(name);

return ret;

}

PyObject *PyErr_SetExcFromWindowsErrWithUnicodeFilename(

PyObject *exc,

int ierr,

const Py_UNICODE *filename)

{

PyObject *name = filename ?

PyUnicode_FromUnicode(filename, wcslen(filename)) :

NULL;

PyObject *ret = PyErr_SetExcFromWindowsErrWithFilenameObject(exc,

ierr,

name);

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_WindowsError,

ierr, NULL);

}

PyObject *PyErr_SetFromWindowsErrWithFilename(

int ierr,

const char *filename)

{

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

PyObject *result = PyErr_SetExcFromWindowsErrWithFilenameObject(

PyExc_WindowsError,

ierr, name);

Py_XDECREF(name);

return result;

}

PyObject *PyErr_SetFromWindowsErrWithUnicodeFilename(

int ierr,

const Py_UNICODE *filename)

{

PyObject *name = filename ?

PyUnicode_FromUnicode(filename, wcslen(filename)) :

NULL;

PyObject *result = PyErr_SetExcFromWindowsErrWithFilenameObject(

PyExc_WindowsError,

ierr, name);

Py_XDECREF(name);

return result;

}

#endif /* MS_WINDOWS */

PyObject *

PyErr_SetImportError(PyObject *msg, PyObject *name, PyObject *path)

{

PyObject *args, *kwargs, *error;

if (msg == NULL)

return NULL;

args = PyTuple_New(1);

if (args == NULL)

return NULL;

kwargs = PyDict_New();

if (kwargs == NULL) {

Py_DECREF(args);

return NULL;

}

if (name == NULL) {

name = Py_None;

}

if (path == NULL) {

path = Py_None;

}

Py_INCREF(msg);

PyTuple_SET_ITEM(args, 0, msg);

PyDict_SetItemString(kwargs, "name", name);

PyDict_SetItemString(kwargs, "path", path);

error = PyObject_Call(PyExc_ImportError, args, kwargs);

if (error != NULL) {

PyErr_SetObject((PyObject *)Py_TYPE(error), error);

Py_DECREF(error);

}

Py_DECREF(args);

Py_DECREF(kwargs);

return NULL;

}

_PyErr_BadInternalCall(const char *filename, int lineno)

{

PyErr_Format(PyExc_SystemError,

"%s:%d: bad argument to internal function",

filename, lineno);

}

#undef PyErr_BadInternalCall

PyErr_BadInternalCall(void)

{

PyErr_Format(PyExc_SystemError,

"bad argument to internal function");

}

#define PyErr_BadInternalCall() _PyErr_BadInternalCall(__FILE__, __LINE__)

PyObject *

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

{

va_list vargs;

PyObject* string;

#ifdef HAVE_STDARG_PROTOTYPES

va_start(vargs, format);

va_start(vargs);

string = PyUnicode_FromFormatV(format, vargs);

PyErr_SetObject(exception, string);

Py_XDECREF(string);

va_end(vargs);

return NULL;

}

PyObject *

PyErr_NewException(const char *name, PyObject *base, PyObject *dict)

{

const char *dot;

PyObject *modulename = NULL;

PyObject *classname = NULL;

PyObject *mydict = NULL;

PyObject *bases = NULL;

PyObject *result = NULL;

dot = strrchr(name, '.');

if (dot == NULL) {

PyErr_SetString(PyExc_SystemError,

"PyErr_NewException: name must be module.class");

return NULL;

}

if (base == NULL)

base = PyExc_Exception;

if (dict == NULL) {

dict = mydict = PyDict_New();

if (dict == NULL)

goto failure;

}

if (PyDict_GetItemString(dict, "__module__") == NULL) {

modulename = PyUnicode_FromStringAndSize(name,

(Py_ssize_t)(dot-name));

if (modulename == NULL)

goto failure;

if (PyDict_SetItemString(dict, "__module__", modulename) != 0)

goto failure;

}

if (PyTuple_Check(base)) {

bases = base;

/* INCREF as we create a new ref in the else branch */

Py_INCREF(bases);

} else {

bases = PyTuple_Pack(1, base);

if (bases == NULL)

goto failure;

}

/* Create a real class. */

result = PyObject_CallFunction((PyObject *)&PyType_Type, "sOO",

dot+1, bases, dict);

failure:

Py_XDECREF(bases);

Py_XDECREF(mydict);

Py_XDECREF(classname);

Py_XDECREF(modulename);

return result;

}

PyObject *

PyErr_NewExceptionWithDoc(const char *name, const char *doc,

PyObject *base, PyObject *dict)

{

int result;

PyObject *ret = NULL;

PyObject *mydict = NULL; /* points to the dict only if we create it */

PyObject *docobj;

if (dict == NULL) {

dict = mydict = PyDict_New();

if (dict == NULL) {

return NULL;

}

}

if (doc != NULL) {

docobj = PyUnicode_FromString(doc);

if (docobj == NULL)

goto failure;

result = PyDict_SetItemString(dict, "__doc__", docobj);

Py_DECREF(docobj);

if (result < 0)

goto failure;

}

ret = PyErr_NewException(name, base, dict);

failure:

Py_XDECREF(mydict);

return ret;

}

PyErr_WriteUnraisable(PyObject *obj)

{

_Py_IDENTIFIER(__module__);

PyObject *f, *t, *v, *tb;

PyErr_Fetch(&t, &v, &tb);

f = PySys_GetObject("stderr");

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

PyFile_WriteString("Exception ", f);

if (t) {

PyObject* moduleName;

char* className;

assert(PyExceptionClass_Check(t));

className = PyExceptionClass_Name(t);

if (className != NULL) {

char *dot = strrchr(className, '.');

if (dot != NULL)

className = dot+1;

}

moduleName = _PyObject_GetAttrId(t, &PyId___module__);

if (moduleName == NULL)

PyFile_WriteString("<unknown>", f);

else {

char* modstr = _PyUnicode_AsString(moduleName);

if (modstr &&

strcmp(modstr, "builtins") != 0)

{

PyFile_WriteString(modstr, f);

PyFile_WriteString(".", f);

}

}

if (className == NULL)

PyFile_WriteString("<unknown>", f);

else

PyFile_WriteString(className, f);

if (v && v != Py_None) {

PyFile_WriteString(": ", f);

PyFile_WriteObject(v, f, 0);

}

Py_XDECREF(moduleName);

}

if (obj) {

PyFile_WriteString(" in ", f);

PyFile_WriteObject(obj, f, 0);

}

PyFile_WriteString(" ignored\n", f);

PyErr_Clear(); /* Just in case */

}

Py_XDECREF(t);

Py_XDECREF(v);

Py_XDECREF(tb);

}

extern PyObject *PyModule_GetWarningsModule(void);

PyErr_SyntaxLocation(const char *filename, int lineno) {

PyErr_SyntaxLocationEx(filename, lineno, -1);

}

PyErr_SyntaxLocationEx(const char *filename, int lineno, int col_offset)

{

PyObject *exc, *v, *tb, *tmp;

_Py_IDENTIFIER(filename);

_Py_IDENTIFIER(lineno);

_Py_IDENTIFIER(msg);

_Py_IDENTIFIER(offset);

_Py_IDENTIFIER(print_file_and_line);

_Py_IDENTIFIER(text);

/* add attributes for the line number and filename for the error */

PyErr_Fetch(&exc, &v, &tb);

PyErr_NormalizeException(&exc, &v, &tb);

/* XXX check that it is, indeed, a syntax error. It might not

tmp = PyLong_FromLong(lineno);

if (tmp == NULL)

PyErr_Clear();

else {

if (_PyObject_SetAttrId(v, &PyId_lineno, tmp))

PyErr_Clear();

Py_DECREF(tmp);

}

if (col_offset >= 0) {

tmp = PyLong_FromLong(col_offset);

if (tmp == NULL)

PyErr_Clear();

else {

if (_PyObject_SetAttrId(v, &PyId_offset, tmp))

PyErr_Clear();

Py_DECREF(tmp);

}

}

if (filename != NULL) {

tmp = PyUnicode_DecodeFSDefault(filename);

if (tmp == NULL)

PyErr_Clear();

else {

if (_PyObject_SetAttrId(v, &PyId_filename, tmp))

PyErr_Clear();

Py_DECREF(tmp);

}

tmp = PyErr_ProgramText(filename, lineno);

if (tmp) {

if (_PyObject_SetAttrId(v, &PyId_text, tmp))

PyErr_Clear();

Py_DECREF(tmp);

}

}

if (_PyObject_SetAttrId(v, &PyId_offset, Py_None)) {

PyErr_Clear();

}

if (exc != PyExc_SyntaxError) {

if (!_PyObject_HasAttrId(v, &PyId_msg)) {

tmp = PyObject_Str(v);

if (tmp) {

if (_PyObject_SetAttrId(v, &PyId_msg, tmp))

PyErr_Clear();

Py_DECREF(tmp);

} else {

PyErr_Clear();

}

}

if (!_PyObject_HasAttrId(v, &PyId_print_file_and_line)) {

if (_PyObject_SetAttrId(v, &PyId_print_file_and_line,

Py_None))

PyErr_Clear();

}

}

PyErr_Restore(exc, v, tb);

}

PyObject *

PyErr_ProgramText(const char *filename, int lineno)

{

FILE *fp;

int i;

char linebuf[1000];

if (filename == NULL || *filename == '\0' || lineno <= 0)

return NULL;

fp = fopen(filename, "r" PY_STDIOTEXTMODE);

if (fp == NULL)

return NULL;

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

char *pLastChar = &linebuf[sizeof(linebuf) - 2];

do {

*pLastChar = '\0';

if (Py_UniversalNewlineFgets(linebuf, sizeof linebuf,

fp, NULL) == NULL)

break;

/* fgets read *something*; if it didn't get as

} while (*pLastChar != '\0' && *pLastChar != '\n');

}

fclose(fp);

if (i == lineno) {

char *p = linebuf;

PyObject *res;

while (*p == ' ' || *p == '\t' || *p == '\014')

p++;

res = PyUnicode_FromString(p);

if (res == NULL)

PyErr_Clear();

return res;

}

return NULL;

}

#ifdef __cplusplus

}