diff --git a/from_cpython/CMakeLists.txt b/from_cpython/CMakeLists.txt index d49fcb501..e6c0d5b34 100644 --- a/from_cpython/CMakeLists.txt +++ b/from_cpython/CMakeLists.txt @@ -87,6 +87,7 @@ file(GLOB_RECURSE STDOBJECT_SRCS Objects complexobject.c dictobject.c dictproxy.c + errors.c exceptions.c floatobject.c fileobject.c diff --git a/from_cpython/Python/errors.c b/from_cpython/Python/errors.c new file mode 100644 index 000000000..c5698b80e --- /dev/null +++ b/from_cpython/Python/errors.c @@ -0,0 +1,801 @@ + +/* Error handling */ + +#include "Python.h" + +#ifndef __STDC__ +#ifndef MS_WINDOWS +extern char *strerror(int); +#endif +#endif + +#ifdef MS_WINDOWS +#include "windows.h" +#include "winbase.h" +#endif + +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +void +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 + invocation through Py_XDECREF */ + 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); +} + +void +PyErr_SetObject(PyObject *exception, PyObject *value) +{ + Py_XINCREF(exception); + Py_XINCREF(value); + PyErr_Restore(exception, value, (PyObject *)NULL); +} + +void +PyErr_SetNone(PyObject *exception) +{ + PyErr_SetObject(exception, (PyObject *)NULL); +} + +void +PyErr_SetString(PyObject *exception, const char *string) +{ + PyObject *value = PyString_FromString(string); + PyErr_SetObject(exception, value); + Py_XDECREF(value); +} + + +PyObject * +PyErr_Occurred(void) +{ + PyThreadState *tstate = PyThreadState_GET(); + + return tstate->curexc_type; +} + + +int +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, reclimit; + PyObject *exception, *value, *tb; + PyErr_Fetch(&exception, &value, &tb); + /* Temporarily bump the recursion limit, so that in the most + common case PyObject_IsSubclass will not raise a recursion + error we have to ignore anyway. Don't do it when the limit + is already insanely high, to avoid overflow */ + reclimit = Py_GetRecursionLimit(); + if (reclimit < (1 << 30)) + Py_SetRecursionLimit(reclimit + 5); + res = PyObject_IsSubclass(err, exc); + Py_SetRecursionLimit(reclimit); + /* 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; +} + + +int +PyErr_ExceptionMatches(PyObject *exc) +{ + return PyErr_GivenExceptionMatches(PyErr_Occurred(), exc); +} + + +/* pyston changed */ +void +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 + set to NULL. + */ + 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 + value will be an instance. + */ + if (PyExceptionClass_Check(type)) { + /* if the value was not an instance, or is not an instance + whose class is (or is derived from) type, then use the + value as an argument to instantiation of the type + class. + */ + if (!inclass || !PyObject_IsSubclass(inclass, type)) { + // Pyston change: rewrote this section + + PyObject* res; + if (!PyTuple_Check(value)) { + res = PyErr_CreateExceptionInstance(type, value == Py_None ? NULL : value); + } else { + PyObject* args = value; + + // Pyston change: + // res = PyEval_CallObject(type, args); + res = PyObject_Call(type, args, NULL); + } + + if (res == NULL) + goto finally; + value = res; + } + /* if the class of the instance doesn't exactly match the + class of the type, believe the instance + */ + 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 + exception had a traceback, use the old traceback for the + new exception. It's better than nothing. + */ + 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; +} + +void +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; +} + +void +PyErr_Clear(void) +{ + PyErr_Restore(NULL, NULL, NULL); +} + +/* Convenience functions to set a type error exception and return 0 */ + +int +PyErr_BadArgument(void) +{ + PyErr_SetString(PyExc_TypeError, + "bad argument type for built-in operation"); + return 0; +} + +PyObject * +PyErr_NoMemory(void) +{ + if (PyErr_ExceptionMatches(PyExc_MemoryError)) + /* already current */ + return NULL; + + /* raise the pre-allocated instance if it still exists */ + if (PyExc_MemoryErrorInst) + PyErr_SetObject(PyExc_MemoryError, PyExc_MemoryErrorInst); + else + /* this will probably fail since there's no memory and hee, + hee, we have to instantiate this class + */ + PyErr_SetNone(PyExc_MemoryError); + + return NULL; +} + +PyObject * +PyErr_SetFromErrnoWithFilenameObject(PyObject *exc, PyObject *filenameObject) +{ + PyObject *v; + char *s; + int i = errno; +#ifdef PLAN9 + char errbuf[ERRMAX]; +#endif +#ifdef MS_WINDOWS + char *s_buf = NULL; + char s_small_buf[28]; /* Room for "Windows Error 0xFFFFFFFF" */ +#endif +#ifdef EINTR + if (i == EINTR && PyErr_CheckSignals()) + return NULL; +#endif +#ifdef PLAN9 + rerrstr(errbuf, sizeof errbuf); + s = errbuf; +#else + if (i == 0) + s = "Error"; /* Sometimes errno didn't get set */ + else +#ifndef MS_WINDOWS + s = strerror(i); +#else + { + /* Note that the Win32 errors do not lineup with the + errno error. So if the error is in the MSVC error + table, we use it, otherwise we assume it really _is_ + a Win32 error code + */ + if (i > 0 && i < _sys_nerr) { + s = _sys_errlist[i]; + } + else { + int len = FormatMessage( + FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, /* no message source */ + i, + MAKELANGID(LANG_NEUTRAL, + SUBLANG_DEFAULT), + /* Default language */ + (LPTSTR) &s_buf, + 0, /* size not used */ + NULL); /* no args */ + if (len==0) { + /* Only ever seen this in out-of-mem + situations */ + sprintf(s_small_buf, "Windows Error 0x%X", i); + s = s_small_buf; + s_buf = NULL; + } else { + s = s_buf; + /* remove trailing cr/lf and dots */ + while (len > 0 && (s[len-1] <= ' ' || s[len-1] == '.')) + s[--len] = '\0'; + } + } + } +#endif /* Unix/Windows */ +#endif /* PLAN 9*/ + if (filenameObject != NULL) + v = Py_BuildValue("(isO)", i, s, filenameObject); + else + v = Py_BuildValue("(is)", i, s); + if (v != NULL) { + PyErr_SetObject(exc, v); + Py_DECREF(v); + } +#ifdef MS_WINDOWS + LocalFree(s_buf); +#endif + return NULL; +} + + +PyObject * +PyErr_SetFromErrnoWithFilename(PyObject *exc, const char *filename) +{ + PyObject *name = filename ? PyString_FromString(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 +/* Windows specific error code handling */ +PyObject *PyErr_SetExcFromWindowsErrWithFilenameObject( + PyObject *exc, + int ierr, + PyObject *filenameObject) +{ + int len; + char *s; + char *s_buf = NULL; /* Free via LocalFree */ + char s_small_buf[28]; /* Room for "Windows Error 0xFFFFFFFF" */ + PyObject *v; + DWORD err = (DWORD)ierr; + if (err==0) err = GetLastError(); + len = FormatMessage( + /* 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 */ + (LPTSTR) &s_buf, + 0, /* size not used */ + NULL); /* no args */ + if (len==0) { + /* Only seen this in out of mem situations */ + sprintf(s_small_buf, "Windows Error 0x%X", err); + s = s_small_buf; + s_buf = NULL; + } else { + s = s_buf; + /* remove trailing cr/lf and dots */ + while (len > 0 && (s[len-1] <= ' ' || s[len-1] == '.')) + s[--len] = '\0'; + } + if (filenameObject != NULL) + v = Py_BuildValue("(isO)", err, s, filenameObject); + else + v = Py_BuildValue("(is)", err, s); + if (v != NULL) { + PyErr_SetObject(exc, v); + Py_DECREF(v); + } + LocalFree(s_buf); + return NULL; +} + +PyObject *PyErr_SetExcFromWindowsErrWithFilename( + PyObject *exc, + int ierr, + const char *filename) +{ + PyObject *name = filename ? PyString_FromString(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 ? PyString_FromString(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 */ + +void +_PyErr_BadInternalCall(const char *filename, int lineno) +{ + PyErr_Format(PyExc_SystemError, + "%s:%d: bad argument to internal function", + filename, lineno); +} + +/* Remove the preprocessor macro for PyErr_BadInternalCall() so that we can + export the entry point for existing object code: */ +#undef PyErr_BadInternalCall +void +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); +#else + va_start(vargs); +#endif + + string = PyString_FromFormatV(format, vargs); + PyErr_SetObject(exception, string); + Py_XDECREF(string); + va_end(vargs); + return NULL; +} + + + +PyObject * +PyErr_NewException(char *name, PyObject *base, PyObject *dict) +{ + 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 = PyString_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 new-style 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; +} + + +/* Create an exception with docstring */ +PyObject * +PyErr_NewExceptionWithDoc(char *name, 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 = PyString_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; +} + + +/* Call when an exception has occurred but there is no way for Python + to handle it. Examples: exception in __del__ or during GC. */ +void +PyErr_WriteUnraisable(PyObject *obj) +{ + PyObject *f, *t, *v, *tb; + PyErr_Fetch(&t, &v, &tb); + f = PySys_GetObject("stderr"); + if (f != NULL) { + PyFile_WriteString("Exception ", f); + if (t) { + PyObject* moduleName; + char* className; + assert(PyExceptionClass_Check(t)); + className = (char*)PyExceptionClass_Name(t); + if (className != NULL) { + char *dot = strrchr(className, '.'); + if (dot != NULL) + className = dot+1; + } + + moduleName = PyObject_GetAttrString(t, "__module__"); + if (moduleName == NULL) + PyFile_WriteString("", f); + else { + char* modstr = PyString_AsString(moduleName); + if (modstr && + strcmp(modstr, "exceptions") != 0) + { + PyFile_WriteString(modstr, f); + PyFile_WriteString(".", f); + } + } + if (className == NULL) + PyFile_WriteString("", f); + else + PyFile_WriteString(className, f); + if (v && v != Py_None) { + PyFile_WriteString(": ", f); + PyFile_WriteObject(v, f, 0); + } + Py_XDECREF(moduleName); + } + 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); + + +/* Set file and line information for the current exception. + If the exception is not a SyntaxError, also sets additional attributes + to make printing of exceptions believe it is a syntax error. */ + +void +PyErr_SyntaxLocation(const char *filename, int lineno) +{ + PyObject *exc, *v, *tb, *tmp; + + /* 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 + * be, though. */ + tmp = PyInt_FromLong(lineno); + if (tmp == NULL) + PyErr_Clear(); + else { + if (PyObject_SetAttrString(v, "lineno", tmp)) + PyErr_Clear(); + Py_DECREF(tmp); + } + if (filename != NULL) { + tmp = PyString_FromString(filename); + if (tmp == NULL) + PyErr_Clear(); + else { + if (PyObject_SetAttrString(v, "filename", tmp)) + PyErr_Clear(); + Py_DECREF(tmp); + } + + tmp = PyErr_ProgramText(filename, lineno); + if (tmp) { + if (PyObject_SetAttrString(v, "text", tmp)) + PyErr_Clear(); + Py_DECREF(tmp); + } + } + if (PyObject_SetAttrString(v, "offset", Py_None)) { + PyErr_Clear(); + } + if (exc != PyExc_SyntaxError) { + if (!PyObject_HasAttrString(v, "msg")) { + tmp = PyObject_Str(v); + if (tmp) { + if (PyObject_SetAttrString(v, "msg", tmp)) + PyErr_Clear(); + Py_DECREF(tmp); + } else { + PyErr_Clear(); + } + } + if (!PyObject_HasAttrString(v, "print_file_and_line")) { + if (PyObject_SetAttrString(v, "print_file_and_line", + Py_None)) + PyErr_Clear(); + } + } + PyErr_Restore(exc, v, tb); +} + +/* com_fetch_program_text will attempt to load the line of text that + the exception refers to. If it fails, it will return NULL but will + not set an exception. + + XXX The functionality of this function is quite similar to the + functionality in tb_displayline() in traceback.c. +*/ + +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 + far as pLastChar, it must have found a newline + or hit the end of the file; if pLastChar is \n, + it obviously found a newline; else we haven't + yet seen a newline, so must continue */ + } while (*pLastChar != '\0' && *pLastChar != '\n'); + } + fclose(fp); + if (i == lineno) { + char *p = linebuf; + while (*p == ' ' || *p == '\t' || *p == '\014') + p++; + return PyString_FromString(p); + } + return NULL; +} + +#ifdef __cplusplus +} +#endif + diff --git a/src/capi/errors.cpp b/src/capi/errors.cpp index 0e51b1dd9..3dd445890 100644 --- a/src/capi/errors.cpp +++ b/src/capi/errors.cpp @@ -27,85 +27,6 @@ namespace pyston { -extern "C" PyObject* PyErr_SetFromErrnoWithFilenameObject(PyObject* exc, PyObject* filenameObject) noexcept { - PyObject* v; - // Pyston change: made const - const char* s; - int i = errno; -#ifdef PLAN9 - char errbuf[ERRMAX]; -#endif -#ifdef MS_WINDOWS - char* s_buf = NULL; - char s_small_buf[28]; /* Room for "Windows Error 0xFFFFFFFF" */ -#endif -#ifdef EINTR - if (i == EINTR && PyErr_CheckSignals()) - return NULL; -#endif -#ifdef PLAN9 - rerrstr(errbuf, sizeof errbuf); - s = errbuf; -#else - if (i == 0) - s = "Error"; /* Sometimes errno didn't get set */ - else -#ifndef MS_WINDOWS - s = strerror(i); -#else - { - /* Note that the Win32 errors do not lineup with the - errno error. So if the error is in the MSVC error - table, we use it, otherwise we assume it really _is_ - a Win32 error code - */ - if (i > 0 && i < _sys_nerr) { - s = _sys_errlist[i]; - } else { - int len = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM - | FORMAT_MESSAGE_IGNORE_INSERTS, - NULL, /* no message source */ - i, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), - /* Default language */ - (LPTSTR)&s_buf, 0, /* size not used */ - NULL); /* no args */ - if (len == 0) { - /* Only ever seen this in out-of-mem - situations */ - sprintf(s_small_buf, "Windows Error 0x%X", i); - s = s_small_buf; - s_buf = NULL; - } else { - s = s_buf; - /* remove trailing cr/lf and dots */ - while (len > 0 && (s[len - 1] <= ' ' || s[len - 1] == '.')) - s[--len] = '\0'; - } - } - } -#endif /* Unix/Windows */ -#endif /* PLAN 9*/ - if (filenameObject != NULL) - v = Py_BuildValue("(isO)", i, s, filenameObject); - else - v = Py_BuildValue("(is)", i, s); - if (v != NULL) { - PyErr_SetObject(exc, v); - Py_DECREF(v); - } -#ifdef MS_WINDOWS - LocalFree(s_buf); -#endif - return NULL; -} - -extern "C" PyObject* PyErr_SetFromErrnoWithFilename(PyObject* exc, const char* filename) noexcept { - PyObject* name = filename ? PyString_FromString(filename) : NULL; - PyObject* result = PyErr_SetFromErrnoWithFilenameObject(exc, name); - Py_XDECREF(name); - return result; -} - #ifdef MS_WINDOWS extern "C" PyObject* PyErr_SetFromErrnoWithUnicodeFilename(PyObject* exc, const Py_UNICODE* filename) noexcept { PyObject* name = filename ? PyUnicode_FromUnicode(filename, wcslen(filename)) : NULL; @@ -115,75 +36,6 @@ extern "C" PyObject* PyErr_SetFromErrnoWithUnicodeFilename(PyObject* exc, const } #endif /* MS_WINDOWS */ -extern "C" void PyErr_Fetch(PyObject** p_type, PyObject** p_value, PyObject** p_traceback) noexcept { - 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; -} - -extern "C" PyObject* PyErr_SetFromErrno(PyObject* exc) noexcept { - return PyErr_SetFromErrnoWithFilenameObject(exc, NULL); -} - -extern "C" void PyErr_SetNone(PyObject* exception) noexcept { - PyErr_SetObject(exception, (PyObject*)NULL); -} - -/* Call when an exception has occurred but there is no way for Python - to handle it. Examples: exception in __del__ or during GC. */ -extern "C" void PyErr_WriteUnraisable(PyObject* obj) noexcept { - PyObject* f, *t, *v, *tb; - PyErr_Fetch(&t, &v, &tb); - f = PySys_GetObject("stderr"); - if (f != NULL) { - PyFile_WriteString("Exception ", f); - if (t) { - PyObject* moduleName; - const char* className; - assert(PyExceptionClass_Check(t)); - className = PyExceptionClass_Name(t); - if (className != NULL) { - const char* dot = strrchr(className, '.'); - if (dot != NULL) - className = dot + 1; - } - - moduleName = PyObject_GetAttrString(t, "__module__"); - if (moduleName == NULL) - PyFile_WriteString("", f); - else { - char* modstr = PyString_AsString(moduleName); - if (modstr && strcmp(modstr, "exceptions") != 0) { - PyFile_WriteString(modstr, f); - PyFile_WriteString(".", f); - } - } - if (className == NULL) - PyFile_WriteString("", f); - else - PyFile_WriteString(className, f); - if (v && v != Py_None) { - PyFile_WriteString(": ", f); - PyFile_WriteObject(v, f, 0); - } - Py_XDECREF(moduleName); - } - 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); -} - static int parse_syntax_error(PyObject* err, PyObject** message, const char** filename, int* lineno, int* offset, const char** text) noexcept { long hold; @@ -493,108 +345,7 @@ extern "C" void PyErr_PrintEx(int set_sys_last_vars) noexcept { Py_XDECREF(tb); } - extern "C" void PyErr_Print() noexcept { PyErr_PrintEx(1); } - -/* com_fetch_program_text will attempt to load the line of text that - the exception refers to. If it fails, it will return NULL but will - not set an exception. - - XXX The functionality of this function is quite similar to the - functionality in tb_displayline() in traceback.c. -*/ - -extern "C" PyObject* PyErr_ProgramText(const char* filename, int lineno) noexcept { - 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 - far as pLastChar, it must have found a newline - or hit the end of the file; if pLastChar is \n, - it obviously found a newline; else we haven't - yet seen a newline, so must continue */ - } while (*pLastChar != '\0' && *pLastChar != '\n'); - } - fclose(fp); - if (i == lineno) { - char* p = linebuf; - while (*p == ' ' || *p == '\t' || *p == '\014') - p++; - return PyString_FromString(p); - } - return NULL; -} - -/* Set file and line information for the current exception. - If the exception is not a SyntaxError, also sets additional attributes - to make printing of exceptions believe it is a syntax error. */ - -extern "C" void PyErr_SyntaxLocation(const char* filename, int lineno) noexcept { - PyObject* exc, *v, *tb, *tmp; - - /* 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 - * be, though. */ - tmp = PyInt_FromLong(lineno); - if (tmp == NULL) - PyErr_Clear(); - else { - if (PyObject_SetAttrString(v, "lineno", tmp)) - PyErr_Clear(); - Py_DECREF(tmp); - } - if (filename != NULL) { - tmp = PyString_FromString(filename); - if (tmp == NULL) - PyErr_Clear(); - else { - if (PyObject_SetAttrString(v, "filename", tmp)) - PyErr_Clear(); - Py_DECREF(tmp); - } - - tmp = PyErr_ProgramText(filename, lineno); - if (tmp) { - if (PyObject_SetAttrString(v, "text", tmp)) - PyErr_Clear(); - Py_DECREF(tmp); - } - } - if (PyObject_SetAttrString(v, "offset", Py_None)) { - PyErr_Clear(); - } - if (exc != PyExc_SyntaxError) { - if (!PyObject_HasAttrString(v, "msg")) { - tmp = PyObject_Str(v); - if (tmp) { - if (PyObject_SetAttrString(v, "msg", tmp)) - PyErr_Clear(); - Py_DECREF(tmp); - } else { - PyErr_Clear(); - } - } - if (!PyObject_HasAttrString(v, "print_file_and_line")) { - if (PyObject_SetAttrString(v, "print_file_and_line", Py_None)) - PyErr_Clear(); - } - } - PyErr_Restore(exc, v, tb); -} } diff --git a/src/runtime/builtin_modules/builtins.cpp b/src/runtime/builtin_modules/builtins.cpp index 99abe8c06..8a1a61cbe 100644 --- a/src/runtime/builtin_modules/builtins.cpp +++ b/src/runtime/builtin_modules/builtins.cpp @@ -1132,42 +1132,6 @@ static BoxedClass* makeBuiltinException(BoxedClass* base, const char* name, int return cls; } -extern "C" PyObject* PyErr_NewException(char* name, PyObject* _base, PyObject* dict) noexcept { - if (_base == NULL) - _base = Exception; - if (dict == NULL) - dict = new BoxedDict(); - - try { - char* dot_pos = strchr(name, '.'); - RELEASE_ASSERT(dot_pos, ""); - int n = strlen(name); - BoxedString* boxedName = boxString(llvm::StringRef(dot_pos + 1, n - (dot_pos - name) - 1)); - - // It can also be a tuple of bases - RELEASE_ASSERT(PyType_Check(_base), ""); - BoxedClass* base = static_cast(_base); - - if (PyDict_GetItemString(dict, "__module__") == NULL) { - PyDict_SetItemString(dict, "__module__", boxString(llvm::StringRef(name, dot_pos - name))); - } - checkAndThrowCAPIException(); - - Box* cls = runtimeCall(type_cls, ArgPassSpec(3), boxedName, BoxedTuple::create({ base }), dict, NULL, NULL); - return cls; - } catch (ExcInfo e) { - // PyErr_NewException isn't supposed to fail, and callers sometimes take advantage of that - // by not checking the return value. Since failing probably indicates a bug anyway, - // to be safe just print the traceback and die. - e.printExcAndTraceback(); - RELEASE_ASSERT(0, "PyErr_NewException failed"); - - // The proper way of handling it: - setCAPIException(e); - return NULL; - } -} - BoxedClass* enumerate_cls; class BoxedEnumerate : public Box { private: diff --git a/src/runtime/capi.cpp b/src/runtime/capi.cpp index d091b5838..61424cb88 100644 --- a/src/runtime/capi.cpp +++ b/src/runtime/capi.cpp @@ -65,10 +65,6 @@ int Py_Py3kWarningFlag; BoxedClass* capifunc_cls; } -extern "C" void _PyErr_BadInternalCall(const char* filename, int lineno) noexcept { - PyErr_Format(PyExc_SystemError, "%s:%d: bad argument to internal function", filename, lineno); -} - extern "C" PyObject* PyObject_Format(PyObject* obj, PyObject* format_spec) noexcept { PyObject* empty = NULL; PyObject* result = NULL; @@ -684,102 +680,6 @@ extern "C" int Py_FlushLine(void) noexcept { return PyFile_WriteString("\n", f); } -extern "C" void PyErr_NormalizeException(PyObject** exc, PyObject** val, PyObject** tb) noexcept { - 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 - set to NULL. - */ - 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 - value will be an instance. - */ - if (PyExceptionClass_Check(type)) { - /* if the value was not an instance, or is not an instance - whose class is (or is derived from) type, then use the - value as an argument to instantiation of the type - class. - */ - if (!inclass || !PyObject_IsSubclass(inclass, type)) { - // Pyston change: rewrote this section - - PyObject* res; - if (!PyTuple_Check(value)) { - res = PyErr_CreateExceptionInstance(type, value == Py_None ? NULL : value); - } else { - PyObject* args = value; - - // Pyston change: - // res = PyEval_CallObject(type, args); - res = PyObject_Call(type, args, NULL); - } - - if (res == NULL) - goto finally; - value = res; - } - /* if the class of the instance doesn't exactly match the - class of the type, believe the instance - */ - 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 - exception had a traceback, use the old traceback for the - new exception. It's better than nothing. - */ - 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; -} - void setCAPIException(const ExcInfo& e) { cur_thread_state.curexc_type = e.type; cur_thread_state.curexc_value = e.value; @@ -849,16 +749,6 @@ extern "C" void Py_Exit(int sts) noexcept { exit(sts); } -extern "C" void PyErr_Restore(PyObject* type, PyObject* value, PyObject* traceback) noexcept { - cur_thread_state.curexc_type = type; - cur_thread_state.curexc_value = value; - cur_thread_state.curexc_traceback = traceback; -} - -extern "C" void PyErr_Clear() noexcept { - PyErr_Restore(NULL, NULL, NULL); -} - extern "C" void PyErr_GetExcInfo(PyObject** ptype, PyObject** pvalue, PyObject** ptraceback) noexcept { ExcInfo* exc = getFrameExcInfo(); *ptype = exc->type; @@ -873,54 +763,6 @@ extern "C" void PyErr_SetExcInfo(PyObject* type, PyObject* value, PyObject* trac exc->traceback = traceback ? traceback : None; } -extern "C" void PyErr_SetString(PyObject* exception, const char* string) noexcept { - PyErr_SetObject(exception, boxString(string)); -} - -extern "C" void PyErr_SetObject(PyObject* exception, PyObject* value) noexcept { - PyErr_Restore(exception, value, NULL); -} - -extern "C" PyObject* PyErr_Format(PyObject* exception, const char* format, ...) noexcept { - va_list vargs; - PyObject* string; - -#ifdef HAVE_STDARG_PROTOTYPES - va_start(vargs, format); -#else - va_start(vargs); -#endif - - string = PyString_FromFormatV(format, vargs); - PyErr_SetObject(exception, string); - Py_XDECREF(string); - va_end(vargs); - return NULL; -} - -extern "C" int PyErr_BadArgument() noexcept { - // TODO this is untested - PyErr_SetString(PyExc_TypeError, "bad argument type for built-in operation"); - return 0; -} - -extern "C" PyObject* PyErr_NoMemory() noexcept { - if (PyErr_ExceptionMatches(PyExc_MemoryError)) - /* already current */ - return NULL; - - /* raise the pre-allocated instance if it still exists */ - if (PyExc_MemoryErrorInst) - PyErr_SetObject(PyExc_MemoryError, PyExc_MemoryErrorInst); - else - /* this will probably fail since there's no memory and hee, - hee, we have to instantiate this class - */ - PyErr_SetNone(PyExc_MemoryError); - - return NULL; -} - extern "C" const char* PyExceptionClass_Name(PyObject* o) noexcept { return PyClass_Check(o) ? PyString_AS_STRING(static_cast(o)->name) : static_cast(o)->tp_name; @@ -969,66 +811,6 @@ extern "C" void Py_SetRecursionLimit(int new_limit) noexcept { _Py_CheckRecursionLimit = recursion_limit; } -extern "C" int PyErr_GivenExceptionMatches(PyObject* err, PyObject* exc) noexcept { - 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)) { - // Pyston addition: fast-path the check for if the exception exactly-matches the specifier. - // Note that we have to check that the exception specifier doesn't have a custom metaclass - // (ie it's cls is type_cls), since otherwise we would have to check for subclasscheck overloading. - // (TODO actually, that should be fast now) - if (exc->cls == type_cls && exc == err) - return 1; - - int res = 0, reclimit; - PyObject* exception, *value, *tb; - PyErr_Fetch(&exception, &value, &tb); - /* Temporarily bump the recursion limit, so that in the most - common case PyObject_IsSubclass will not raise a recursion - error we have to ignore anyway. Don't do it when the limit - is already insanely high, to avoid overflow */ - reclimit = Py_GetRecursionLimit(); - if (reclimit < (1 << 30)) - Py_SetRecursionLimit(reclimit + 5); - res = PyObject_IsSubclass(err, exc); - Py_SetRecursionLimit(reclimit); - /* 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; -} - -extern "C" int PyErr_ExceptionMatches(PyObject* exc) noexcept { - return PyErr_GivenExceptionMatches(PyErr_Occurred(), exc); -} - -extern "C" PyObject* PyErr_Occurred() noexcept { - return cur_thread_state.curexc_type; -} - extern "C" void* PyObject_Malloc(size_t sz) noexcept { return gc_compat_malloc(sz); }