GIT_REPOSITORIES/LPP/PythonQt Commit - r201:4443fddf8142

integrated changes from https://github.com/commontk/PythonQt#patched-2...

florianlink -

r201:4443fddf8142

parent child

Context file:

r201:4443fddf8142

Collapse all files

src/PythonQt.cpp +96 0

              QVariant PythonQt::evalCode(PyObject* object, PyObject* pycode) {
                QVariant result;
+               clearError();
                if (pycode) {
                  PyObject* dict = NULL;
                  PyObject* globals = NULL;
                QVariant result;
                PythonQtObjectPtr p;
                PyObject* dict = NULL;
+               clearError();
                if (PyModule_Check(object)) {
                  dict = PyModule_GetDict(object);
                } else if (PyDict_Check(object)) {
              void PythonQt::evalFile(PyObject* module, const QString& filename)
              {
                PythonQtObjectPtr code = parseFile(filename);
+               clearError();
                if (code) {
                  evalCode(module, code);
                } else {
              {
                PythonQtObjectPtr p;
                p.setNewRef(PythonQtImport::getCodeFromPyc(filename));
+               clearError();
                if (!p) {
                  handleError();
                }
                QVariant r;
                PythonQtObjectPtr result;
                result.setNewRef(callAndReturnPyObject(callable, args, kwargs));
+               clearError();
                if (result) {
                  r = PythonQtConv::PyObjToQVariant(result);
                } else {
                _wrappedCB = NULL;
                _currentClassInfoForClassWrapperCreation = NULL;
                _profilingCB = NULL;
+               _hadError = false;
+               _systemExitExceptionHandlerEnabled = false;
              }
              void PythonQtPrivate::setupSharedLibrarySuffixes()
                _signalReceivers.remove(obj);
              }
+             namespace
+             {
+             //! adapted from python source file "pythonrun.c", function "handle_system_exit"
+             //! return the exitcode instead of calling "Py_Exit".
+             //! it gives the application an opportunity to properly terminate.
+             int custom_system_exit_exception_handler()
+             {
+               PyObject *exception, *value, *tb;
+               int exitcode = 0;
+             //  if (Py_InspectFlag)
+             //    /* Don't exit if -i flag was given. This flag is set to 0
+             //     * when entering interactive mode for inspecting. */
+             //    return exitcode;
+               PyErr_Fetch(&exception, &value, &tb);
+               if (Py_FlushLine())
+                 PyErr_Clear();
+               fflush(stdout);
+               if (value == NULL || value == Py_None)
+                 goto done;
+               if (PyExceptionInstance_Check(value)) {
+                 /* The error code should be in the `code' attribute. */
+                 PyObject *code = PyObject_GetAttrString(value, "code");
+                 if (code) {
+                   Py_DECREF(value);
+                   value = code;
+                   if (value == Py_None)
+                     goto done;
+                 }
+                 /* If we failed to dig out the 'code' attribute,
+                    just let the else clause below print the error. */
+               }
+               if (PyInt_Check(value))
+                 exitcode = (int)PyInt_AsLong(value);
+               else {
+                 PyObject *sys_stderr = PySys_GetObject(const_cast<char*>("stderr"));
+                 if (sys_stderr != NULL && sys_stderr != Py_None) {
+                   PyFile_WriteObject(value, sys_stderr, Py_PRINT_RAW);
+                 } else {
+                   PyObject_Print(value, stderr, Py_PRINT_RAW);
+                   fflush(stderr);
+                 }
+                 PySys_WriteStderr("\n");
+                 exitcode = 1;
+               }
+               done:
+                 /* Restore and clear the exception info, in order to properly decref
+                  * the exception, value, and traceback.      If we just exit instead,
+                  * these leak, which confuses PYTHONDUMPREFS output, and may prevent
+                  * some finalizers from running.
+                  */
+                 PyErr_Restore(exception, value, tb);
+                 PyErr_Clear();
+                 return exitcode;
+                 //Py_Exit(exitcode);
+             }
+             }
              bool PythonQt::handleError()
              {
                bool flag = false;
                if (PyErr_Occurred()) {
+                 if (_p->_systemExitExceptionHandlerEnabled &&
+                     PyErr_ExceptionMatches(PyExc_SystemExit)) {
+                   int exitcode = custom_system_exit_exception_handler();
+                   emit PythonQt::self()->systemExitExceptionRaised(exitcode);
+                   }
+                 else
+                   {
                  // currently we just print the error and the stderr handler parses the errors
                  PyErr_Print();
                    Py_XDECREF(ptraceback);
                  */
                  PyErr_Clear();
+                   }
                  flag = true;
                }
+               _p->_hadError = flag;
                return flag;
              }
+             bool PythonQt::hadError()const
+             {
+               return _p->_hadError;
+             }
+             void PythonQt::clearError()
+             {
+               _p->_hadError = false;
+             }
+             void PythonQt::setSystemExitExceptionHandlerEnabled(bool value)
+             {
+               _p->_systemExitExceptionHandlerEnabled = value;
+             }
+             bool PythonQt::systemExitExceptionHandlerEnabled() const
+             {
+               return _p->_systemExitExceptionHandlerEnabled;
+             }
              void PythonQt::addSysPath(const QString& path)
              {
                PythonQtObjectPtr sys;
              PythonQtObjectPtr PythonQtPrivate::createModule(const QString& name, PyObject* pycode)
              {
                PythonQtObjectPtr result;
+               PythonQt::self()->clearError();
                if (pycode) {
                  result.setNewRef(PyImport_ExecCodeModule((char*)name.toLatin1().data(), pycode));
                } else {

src/PythonQt.h +28 -5

                //! get access to internal data (should not be used on the public API, but is used by some C functions)
                static PythonQtPrivate* priv() { return _self->_p; }
+               //! clear all NotFound entries on all class infos, to ensure that
+               //! newly loaded wrappers can add methods even when the object was wrapped by PythonQt before the wrapper was loaded
+               void clearNotFoundCachedMembers();
                //! handle a python error, call this when a python function fails. If no error occurred, it returns false.
                //! The error is currently just output to the python stderr, future version might implement better trace printing
                bool handleError();
-               //! clear all NotFound entries on all class infos, to ensure that
-               //! newly loaded wrappers can add methods even when the object was wrapped by PythonQt before the wrapper was loaded
-               void clearNotFoundCachedMembers();
+               //! return \a true if \a handleError() has been called and an error occured.
+               bool hadError()const;
+               //! reset error flag. After calling this, hadError() will return false.
+               //! \sa hadError()
+               void clearError();
+               //! if set to true, the systemExitExceptionRaised signal will be emitted if exception SystemExit is caught
+               //! \sa handleError()
+               void setSystemExitExceptionHandlerEnabled(bool value);
-               //! set a callback that is called when a QObject with parent == NULL is wrapped by pythonqt
+               //! return \a true if SystemExit exception is handled by PythonQt
+               //! \sa setSystemExitExceptionHandlerEnabled()
+               bool systemExitExceptionHandlerEnabled() const;
+               //! set a callback that is called when a QObject with parent == NULL is wrapped by PythonQt
                void setQObjectWrappedCallback(PythonQtQObjectWrappedCB* cb);
-               //! set a callback that is called when a QObject with parent == NULL is no longer wrapped by pythonqt
+               //! set a callback that is called when a QObject with parent == NULL is no longer wrapped by PythonQt
                void setQObjectNoLongerWrappedCallback(PythonQtQObjectNoLongerWrappedCB* cb);
                //! call the callback if it is set
                //! emitted when help() is called on a PythonQt object and \c ExternalHelp is enabled
                void pythonHelpRequest(const QByteArray& cppClassName);
+               //! emitted when both custom SystemExit exception handler is enabled and a SystemExit
+               //! exception is raised.
+               //! \sa setSystemExitExceptionHandlerEnabled(bool)
+               void systemExitExceptionRaised(int exitCode);
              private:
                void initPythonQtModule(bool redirectStdOut, const QByteArray& pythonQtModuleName);
                int _initFlags;
                int _PythonQtObjectPtr_metaId;
+               bool _hadError;
+               bool _systemExitExceptionHandlerEnabled;
                friend class PythonQt;
              };

src/PythonQtPythonInclude.h +1 0

              #undef _DEBUG
              #if defined(_MSC_VER) && _MSC_VER >= 1400
              #define _CRT_NOFORCE_MANIFEST 1
+             #define _STL_NOFORCE_MANIFEST 1
              #endif
              #include <Python.h>
              #define _DEBUG

src/PythonQtStdOut.cpp +8 -1

                return Py_BuildValue("");
              }
+             static PyObject *PythonQtStdOutRedirect_isatty(PyObject * /*self*/, PyObject * /*args*/)
+             {
+               Py_INCREF(Py_False);
+               return Py_False;
+             }
              static PyMethodDef PythonQtStdOutRedirect_methods[] = {
                {"write", (PyCFunction)PythonQtStdOutRedirect_write, METH_VARARGS,
                {"flush", (PyCFunction)PythonQtStdOutRedirect_flush, METH_VARARGS,
                "flush the output, currently not implemented but needed for logging framework"
                },
+               {"isatty", (PyCFunction)PythonQtStdOutRedirect_isatty,   METH_NOARGS,
+               "return False since this object is not a tty-like device. Needed for logging framework"
+               },
                {NULL,    NULL, 0 , NULL} /* sentinel */
              };

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages