pythonize.h

Go to the documentation of this file.

/*
copyright 2003 Jim Bublitz <jbublitz@nwinternet.com>

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of
the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Library General Public License for more details.

You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB.  If not, write to
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.
*/

#ifndef __pythonize_h__
#define __pythonize_h__

// Pythonize is a general purpose library that wraps the Python
// interpreter with an interface to a set of common operations
// used when embedding the interpreter.

#ifdef slots
#undef slots
#endif

#include <Python.h>

#ifndef signals
#define signals Q_SIGNALS
#endif

#ifndef slots
#define slots Q_SLOTS
#endif

#include <Base/String.h>

namespace Core
{
struct ObjectRef
{
    ObjectRef(ObjectRef* oi, PyObject* o);
    ~ObjectRef();

    PyObject* object = nullptr;       // pointer to an object we created
    ObjectRef* prevObject = nullptr;  // pointer to next object on the stack
};

class CORE_EXPORT Pythonize
{
public:
    explicit Pythonize(const Base::String& pythonHome);
    ~Pythonize();

    // adds a path to sys.path
    bool appendToSysPath(const Base::String& newPath) const;

    // insert a path to sys.path
    bool insertToSysPath(int pos, const Base::String& newPath) const;

    // imports a module into the interpreter
    // or gets a PyObject for an already loaded module
    PyObject* importModule(char* moduleName);

    // returns an object from a loaded module
    // you must decref the object returned when done with it (new reference returned)
    PyObject* getNewObjectRef(PyObject* module, char* object) const;
    PyObject* getSysModule() const;
    PyObject* getMainModule() const;

    void setMainModule();
    bool getPythonInit() const;

    // runs a script on the current sys.path
    bool runScript(const Base::String& scr) const;
    bool runScript2(const Base::String& scr, Base::String& err) const;

    // executes a string of Python in the interpreter
    bool runString(const Base::String& str) const;
    bool runString2(const Base::String& str, Base::String& err) const;
    bool runString3(std::string input, std::string resultname, bool& result) const;
    bool runStringWithNameSpace(char* str, char* ns) const;

    std::string getPythonErrorString() const;

    // runs a callable Python object
    PyObject* runFunction(PyObject* object, PyObject* args) const;

    // handle the thread state and global interpreter lock
    void releaseLock() const;
    void acquireLock() const;
    PyThreadState* getThreadState() const;
    PyThreadState* setThreadState(PyThreadState* tstate) const;

    int runExpression(const Base::String& command, double& val) const;

private:
    bool _pythonInit = false;         // status of Py_Initialize
    PyObject* _sysModule = nullptr;   // a pointer to the sys module which is always loaded first
    PyObject* _mainModule = nullptr;  // a pointer to __main__
    ObjectRef* _objects = nullptr;    // a stack of PyObjects (used in destructor)
};
}  // namespace Core

#endif