MapType CyPy_Element::dictAsElement(const Py::Dict& dict)
{
MapType map;
for (auto key : dict.keys()) {
map.emplace(key.str(), asElement(dict.getItem(key)));
}
return map;
}
PyObject* Application::sAddCommand(PyObject * /*self*/, PyObject *args,PyObject * /*kwd*/)
{
char* pName;
char* pSource=0;
PyObject* pcCmdObj;
if (!PyArg_ParseTuple(args, "sO|s", &pName,&pcCmdObj,&pSource)) // convert args: Python->C
return NULL; // NULL triggers exception
#if 0
std::string source = (pSource ? pSource : "");
if (source.empty()) {
try {
Py::Module module(PyImport_ImportModule("inspect"),true);
Py::Dict dict = module.getDict();
Py::Callable call(dict.getItem("getsourcelines"));
Py::Tuple arg(1);
arg.setItem(0, Py::Object(pcCmdObj).getAttr("Activated"));
Py::Tuple tuple(call.apply(arg));
Py::List lines(tuple[0]);
int pos=0;
std::string code = (std::string)(Py::String(lines[1]));
while (code[pos] == ' ' || code[pos] == '\t')
pos++;
for (Py::List::iterator it = lines.begin()+1; it != lines.end(); ++it) {
Py::String str(*it);
source += ((std::string)str).substr(pos);
}
}
catch (Py::Exception& e) {
e.clear();
}
}
Application::Instance->commandManager().addCommand(new PythonCommand(pName,pcCmdObj,source.c_str()));
#else
try {
Application::Instance->commandManager().addCommand(new PythonCommand(pName,pcCmdObj,pSource));
}
catch (const Base::Exception& e) {
PyErr_SetString(Base::BaseExceptionFreeCADError, e.what());
return 0;
}
catch (...) {
PyErr_SetString(Base::BaseExceptionFreeCADError, "Unknown C++ exception raised in Application::sAddCommand()");
return 0;
}
#endif
Py_INCREF(Py_None);
return Py_None;
}
MeshObject* MeshObject::createSphere(float radius, int sampling)
{
// load the 'BuildRegularGeoms' module
Base::PyGILStateLocker lock;
try {
Py::Module module(PyImport_ImportModule("BuildRegularGeoms"),true);
Py::Dict dict = module.getDict();
Py::Callable call(dict.getItem("Sphere"));
Py::Tuple args(2);
args.setItem(0, Py::Float(radius));
args.setItem(1, Py::Int(sampling));
Py::List list(call.apply(args));
return createMeshFromList(list);
}
catch (Py::Exception& e) {
e.clear();
}
return 0;
}
MeshObject* MeshObject::createCube(float length, float width, float height)
{
// load the 'BuildRegularGeoms' module
Base::PyGILStateLocker lock;
try {
Py::Module module(PyImport_ImportModule("BuildRegularGeoms"),true);
Py::Dict dict = module.getDict();
Py::Callable call(dict.getItem("Cube"));
Py::Tuple args(3);
args.setItem(0, Py::Float(length));
args.setItem(1, Py::Float(width));
args.setItem(2, Py::Float(height));
Py::List list(call.apply(args));
return createMeshFromList(list);
}
catch (Py::Exception& e) {
e.clear();
}
return 0;
}
MeshObject* MeshObject::createCylinder(float radius, float length, int closed, float edgelen, int sampling)
{
// load the 'BuildRegularGeoms' module
Base::PyGILStateLocker lock;
try {
Py::Module module(PyImport_ImportModule("BuildRegularGeoms"),true);
Py::Dict dict = module.getDict();
Py::Callable call(dict.getItem("Cylinder"));
Py::Tuple args(5);
args.setItem(0, Py::Float(radius));
args.setItem(1, Py::Float(length));
args.setItem(2, Py::Int(closed));
args.setItem(3, Py::Float(edgelen));
args.setItem(4, Py::Int(sampling));
Py::List list(call.apply(args));
return createMeshFromList(list);
}
catch (Py::Exception& e) {
e.clear();
}
return 0;
}
QMap<QString, CallTip> CallTipsList::extractTips(const QString& context) const
{
Base::PyGILStateLocker lock;
QMap<QString, CallTip> tips;
if (context.isEmpty())
return tips;
try {
Py::Module module("__main__");
Py::Dict dict = module.getDict();
#if 0
QStringList items = context.split(QLatin1Char('.'));
QString modname = items.front();
items.pop_front();
if (!dict.hasKey(std::string(modname.toLatin1())))
return tips; // unknown object
// get the Python object we need
Py::Object obj = dict.getItem(std::string(modname.toLatin1()));
while (!items.isEmpty()) {
QByteArray name = items.front().toLatin1();
std::string attr = name.constData();
items.pop_front();
if (obj.hasAttr(attr))
obj = obj.getAttr(attr);
else
return tips;
}
#else
// Don't use hasattr & getattr because if a property is bound to a method this will be executed twice.
PyObject* code = Py_CompileString(static_cast<const char*>(context.toLatin1()), "<CallTipsList>", Py_eval_input);
if (!code) {
PyErr_Clear();
return tips;
}
PyObject* eval = 0;
if (PyCode_Check(code)) {
eval = PyEval_EvalCode(reinterpret_cast<PyCodeObject*>(code), dict.ptr(), dict.ptr());
}
Py_DECREF(code);
if (!eval) {
PyErr_Clear();
return tips;
}
Py::Object obj(eval, true);
#endif
// Checks whether the type is a subclass of PyObjectBase because to get the doc string
// of a member we must get it by its type instead of its instance otherwise we get the
// wrong string, namely that of the type of the member.
// Note: 3rd party libraries may use their own type object classes so that we cannot
// reliably use Py::Type. To be on the safe side we should use Py::Object to assign
// the used type object to.
//Py::Object type = obj.type();
Py::Object type(PyObject_Type(obj.ptr()), true);
Py::Object inst = obj; // the object instance
union PyType_Object typeobj = {&Base::PyObjectBase::Type};
union PyType_Object typedoc = {&App::DocumentObjectPy::Type};
union PyType_Object basetype = {&PyBaseObject_Type};
if (PyObject_IsSubclass(type.ptr(), typedoc.o) == 1) {
// From the template Python object we don't query its type object because there we keep
// a list of additional methods that we won't see otherwise. But to get the correct doc
// strings we query the type's dict in the class itself.
// To see if we have a template Python object we check for the existence of supportedProperties
if (!type.hasAttr("supportedProperties")) {
obj = type;
}
}
else if (PyObject_IsSubclass(type.ptr(), typeobj.o) == 1) {
obj = type;
}
else if (PyInstance_Check(obj.ptr())) {
// instances of old style classes
PyInstanceObject* inst = reinterpret_cast<PyInstanceObject*>(obj.ptr());
PyObject* classobj = reinterpret_cast<PyObject*>(inst->in_class);
obj = Py::Object(classobj);
}
else if (PyObject_IsInstance(obj.ptr(), basetype.o) == 1) {
// New style class which can be a module, type, list, tuple, int, float, ...
// Make sure it's not a type objec
union PyType_Object typetype = {&PyType_Type};
if (PyObject_IsInstance(obj.ptr(), typetype.o) != 1) {
// this should be now a user-defined Python class
// http://stackoverflow.com/questions/12233103/in-python-at-runtime-determine-if-an-object-is-a-class-old-and-new-type-instan
if (Py_TYPE(obj.ptr())->tp_flags & Py_TPFLAGS_HEAPTYPE) {
obj = type;
}
}
}
// If we have an instance of PyObjectBase then determine whether it's valid or not
if (PyObject_IsInstance(inst.ptr(), typeobj.o) == 1) {
Base::PyObjectBase* baseobj = static_cast<Base::PyObjectBase*>(inst.ptr());
const_cast<CallTipsList*>(this)->validObject = baseobj->isValid();
}
else {
// PyObject_IsInstance might set an exception
PyErr_Clear();
}
Py::List list(obj.dir());
// If we derive from PropertyContainerPy we can search for the properties in the
// C++ twin class.
union PyType_Object proptypeobj = {&App::PropertyContainerPy::Type};
if (PyObject_IsSubclass(type.ptr(), proptypeobj.o) == 1) {
// These are the attributes of the instance itself which are NOT accessible by
// its type object
extractTipsFromProperties(inst, tips);
}
// If we derive from App::DocumentPy we have direct access to the objects by their internal
// names. So, we add these names to the list, too.
union PyType_Object appdoctypeobj = {&App::DocumentPy::Type};
if (PyObject_IsSubclass(type.ptr(), appdoctypeobj.o) == 1) {
App::DocumentPy* docpy = (App::DocumentPy*)(inst.ptr());
App::Document* document = docpy->getDocumentPtr();
// Make sure that the C++ object is alive
if (document) {
std::vector<App::DocumentObject*> objects = document->getObjects();
Py::List list;
for (std::vector<App::DocumentObject*>::iterator it = objects.begin(); it != objects.end(); ++it)
list.append(Py::String((*it)->getNameInDocument()));
extractTipsFromObject(inst, list, tips);
}
}
// If we derive from Gui::DocumentPy we have direct access to the objects by their internal
// names. So, we add these names to the list, too.
union PyType_Object guidoctypeobj = {&Gui::DocumentPy::Type};
if (PyObject_IsSubclass(type.ptr(), guidoctypeobj.o) == 1) {
Gui::DocumentPy* docpy = (Gui::DocumentPy*)(inst.ptr());
if (docpy->getDocumentPtr()) {
App::Document* document = docpy->getDocumentPtr()->getDocument();
// Make sure that the C++ object is alive
if (document) {
std::vector<App::DocumentObject*> objects = document->getObjects();
Py::List list;
for (std::vector<App::DocumentObject*>::iterator it = objects.begin(); it != objects.end(); ++it)
list.append(Py::String((*it)->getNameInDocument()));
extractTipsFromObject(inst, list, tips);
}
}
}
// These are the attributes from the type object
extractTipsFromObject(obj, list, tips);
}
catch (Py::Exception& e) {
// Just clear the Python exception
e.clear();
}
return tips;
}
QMap<QString, CallTip> CallTipsList::extractTips(const QString& context) const
{
Base::PyGILStateLocker lock;
QMap<QString, CallTip> tips;
if (context.isEmpty())
return tips;
try {
QStringList items = context.split(QLatin1Char('.'));
Py::Module module("__main__");
Py::Dict dict = module.getDict();
QString modname = items.front();
items.pop_front();
if (!dict.hasKey(std::string(modname.toAscii())))
return tips; // unknown object
// get the Python object we need
Py::Object obj = dict.getItem(std::string(modname.toAscii()));
while (!items.isEmpty()) {
QByteArray name = items.front().toAscii();
std::string attr = name.constData();
items.pop_front();
if (obj.hasAttr(attr))
obj = obj.getAttr(attr);
else
return tips;
}
// Checks whether the type is a subclass of PyObjectBase because to get the doc string
// of a member we must get it by its type instead of its instance otherwise we get the
// wrong string, namely that of the type of the member.
// Note: 3rd party libraries may use their own type object classes so that we cannot
// reliably use Py::Type. To be on the safe side we should use Py::Object to assign
// the used type object to.
//Py::Object type = obj.type();
Py::Object type(PyObject_Type(obj.ptr()), true);
Py::Object inst = obj; // the object instance
union PyType_Object typeobj = {&Base::PyObjectBase::Type};
union PyType_Object typedoc = {&App::DocumentObjectPy::Type};
if (PyObject_IsSubclass(type.ptr(), typedoc.o) == 1) {
// From the template Python object we don't query its type object because there we keep
// a list of additional methods that we won't see otherwise. But to get the correct doc
// strings we query the type's dict in the class itself.
// To see if we have a template Python object we check for the existence of supportedProperties
if (!type.hasAttr("supportedProperties")) {
obj = type;
}
}
else if (PyObject_IsSubclass(type.ptr(), typeobj.o) == 1) {
obj = type;
}
// If we have an instance of PyObjectBase then determine whether it's valid or not
if (PyObject_IsInstance(inst.ptr(), typeobj.o) == 1) {
Base::PyObjectBase* baseobj = static_cast<Base::PyObjectBase*>(inst.ptr());
const_cast<CallTipsList*>(this)->validObject = baseobj->isValid();
}
else {
// PyObject_IsInstance might set an exception
PyErr_Clear();
}
Py::List list(PyObject_Dir(obj.ptr()), true);
// If we derive from PropertyContainerPy we can search for the properties in the
// C++ twin class.
union PyType_Object proptypeobj = {&App::PropertyContainerPy::Type};
if (PyObject_IsSubclass(type.ptr(), proptypeobj.o) == 1) {
// These are the attributes of the instance itself which are NOT accessible by
// its type object
extractTipsFromProperties(inst, tips);
}
// If we derive from App::DocumentPy we have direct access to the objects by their internal
// names. So, we add these names to the list, too.
union PyType_Object appdoctypeobj = {&App::DocumentPy::Type};
if (PyObject_IsSubclass(type.ptr(), appdoctypeobj.o) == 1) {
App::DocumentPy* docpy = (App::DocumentPy*)(inst.ptr());
App::Document* document = docpy->getDocumentPtr();
// Make sure that the C++ object is alive
if (document) {
std::vector<App::DocumentObject*> objects = document->getObjects();
Py::List list;
for (std::vector<App::DocumentObject*>::iterator it = objects.begin(); it != objects.end(); ++it)
list.append(Py::String((*it)->getNameInDocument()));
extractTipsFromObject(inst, list, tips);
}
}
// If we derive from Gui::DocumentPy we have direct access to the objects by their internal
// names. So, we add these names to the list, too.
union PyType_Object guidoctypeobj = {&Gui::DocumentPy::Type};
if (PyObject_IsSubclass(type.ptr(), guidoctypeobj.o) == 1) {
Gui::DocumentPy* docpy = (Gui::DocumentPy*)(inst.ptr());
if (docpy->getDocumentPtr()) {
App::Document* document = docpy->getDocumentPtr()->getDocument();
// Make sure that the C++ object is alive
if (document) {
std::vector<App::DocumentObject*> objects = document->getObjects();
Py::List list;
for (std::vector<App::DocumentObject*>::iterator it = objects.begin(); it != objects.end(); ++it)
list.append(Py::String((*it)->getNameInDocument()));
extractTipsFromObject(inst, list, tips);
}
}
}
// These are the attributes from the type object
extractTipsFromObject(obj, list, tips);
}
catch (Py::Exception& e) {
// Just clear the Python exception
e.clear();
}
return tips;
}
PythonInterpreter::PythonInterpreter(Kross::InterpreterInfo* info)
: Kross::Interpreter(info)
, d(new PythonInterpreterPrivate())
{
// Initialize the python interpreter.
initialize();
// Set name of the program.
Py_SetProgramName(const_cast<char*>("Kross"));
/*
// Set arguments.
//char* comm[0];
const char* comm = const_cast<char*>("kross"); // name.
PySys_SetArgv(1, comm);
*/
// In the python sys.path are all module-directories are
// listed in.
QString path;
// First import the sys-module to remember it's sys.path
// list in our path QString.
Py::Module sysmod( PyImport_ImportModule( (char*)"sys" ), true );
Py::Dict sysmoddict = sysmod.getDict();
Py::Object syspath = sysmoddict.getItem("path");
if(syspath.isList()) {
Py::List syspathlist = syspath;
for(Py::List::iterator it = syspathlist.begin(); it != syspathlist.end(); ++it) {
if( ! (*it).isString() ) continue;
QString s = PythonType<QString>::toVariant(*it);
path.append( s + PYPATHDELIMITER );
}
}
else
path = Py_GetPath();
#if 0
// Determinate additional module-paths we like to add.
// First add the global Kross modules-path.
QStringList krossdirs = KGlobal::dirs()->findDirs("data", "kross/python");
for(QStringList::Iterator krossit = krossdirs.begin(); krossit != krossdirs.end(); ++krossit)
path.append(*krossit + PYPATHDELIMITER);
// Then add the application modules-path.
QStringList appdirs = KGlobal::dirs()->findDirs("appdata", "kross/python");
for(QStringList::Iterator appit = appdirs.begin(); appit != appdirs.end(); ++appit)
path.append(*appit + PYPATHDELIMITER);
#endif
// Set the extended sys.path.
PySys_SetPath( (char*) path.toLatin1().data() );
#ifdef KROSS_PYTHON_INTERPRETER_DEBUG
krossdebug(QString("Python ProgramName: %1").arg(Py_GetProgramName()));
krossdebug(QString("Python ProgramFullPath: %1").arg(Py_GetProgramFullPath()));
krossdebug(QString("Python Version: %1").arg(Py_GetVersion()));
krossdebug(QString("Python Platform: %1").arg(Py_GetPlatform()));
krossdebug(QString("Python Prefix: %1").arg(Py_GetPrefix()));
krossdebug(QString("Python ExecPrefix: %1").arg(Py_GetExecPrefix()));
//krossdebug(QString("Python Path: %1").arg(Py_GetPath()));
//krossdebug(QString("Python System Path: %1").arg(path));
#endif
// Initialize the main module.
d->mainmodule = new PythonModule(this);
// The main dictonary.
Py::Dict moduledict = d->mainmodule->getDict();
//TODO moduledict["KrossPythonVersion"] = Py::Int(KROSS_PYTHON_VERSION);
// Prepare the interpreter.
QString s =
//"# -*- coding: iso-8859-1 -*-\n"
//"import locale\n"
//"locale.setlocale(locale.LC_ALL, '')\n"
//"# -*- coding: latin-1 -*\n"
//"# -*- coding: utf-8 -*-\n"
//"import locale\n"
//"locale.setlocale(locale.LC_ALL, '')\n"
//"from __future__ import absolute_import\n"
"import sys\n"
//"import os, os.path\n"
//"sys.setdefaultencoding('latin-1')\n"
// Dirty hack to get sys.argv defined. Needed for e.g. TKinter.
"sys.argv = ['']\n"
// On the try to read something from stdin always return an empty
// string. That way such reads don't block our script.
// Deactivated since sys.stdin has the encoding attribute needed
// by e.g. LiquidWeather and those attr is missing in StringIO
// and cause it's buildin we can't just add it but would need to
// implement our own class. Grrrr, what a stupid design :-/
//"try:\n"
//" import cStringIO\n"
//" sys.stdin = cStringIO.StringIO()\n"
//"except:\n"
//" pass\n"
// Class to redirect something. We use this class e.g. to redirect
// <stdout> and <stderr> to a c++ event.
//"class Redirect:\n"
//" def __init__(self, target):\n"
//" self.target = target\n"
//" def write(self, s):\n"
//" self.target.call(s)\n"
// Wrap builtin __import__ method. All import requests are
// first redirected to our PythonModule.import method and
// if the call returns None, then we call the original
// python import mechanism.
"import __builtin__\n"
"import __main__\n"
"import traceback\n"
"sys.modules['_oldmain'] = sys.modules['__main__']\n"
"_main_builtin_import_ = __main__.__builtin__.__import__\n"
"class _Importer:\n"
" def __init__(self, script):\n"
" self.script = script\n"
" self.realImporter = __main__.__builtin__.__import__\n"
" __main__.__builtin__.__import__ = self._import\n"
" def _import(self, name, globals=None, locals=None, fromlist=[], level = -1):\n"
//" try:\n"
//" print \"1===========> _Importer name=%s fromlist=%s\" % (name,fromlist)\n"
#if PY_MAJOR_VERSION >= 3 || (PY_MAJOR_VERSION >= 2 && PY_MINOR_VERSION >= 5)
" mod = __main__._import(self.script, name, globals, locals, fromlist, level)\n"
#else
" mod = __main__._import(self.script, name, globals, locals, fromlist)\n"
#endif
" if mod == None:\n"
" if name == 'qt':\n"
" raise ImportError('Import of the PyQt3 module is not allowed. Please use PyQt4 instead.')\n"
" if name == 'dcop':\n"
" raise ImportError('Import of the KDE3 DCOP module is not allowed. Please use PyQt4 DBUS instead.')\n"
#if PY_MAJOR_VERSION >= 3 || (PY_MAJOR_VERSION >= 2 && PY_MINOR_VERSION >= 5)
" mod = self.realImporter(name, globals, locals, fromlist, level)\n"
#else
" mod = self.realImporter(name, globals, locals, fromlist)\n"
#endif
" if mod != None:\n"
//" print \"3===========> _Importer name=%s fromlist=%s\" % (name,fromlist)\n"
" if globals != None and (not fromlist or len(fromlist)==0 or '*' in fromlist):\n"
" globals[name] = mod\n"
" return mod\n"
//" except ImportError:\n"
//" except:\n"
//" print \"9===========> _Importer Trying ImportError with name=%s fromlist=%s insysmodules=%s\" % (name,fromlist,name in sys.modules)\n"
//" print \" \".join( traceback.format_exception(sys.exc_info()[0],sys.exc_info()[1],sys.exc_info()[2]) )\n"
//" return None\n"
/*
" print \"_Importer name=%s fromlist=%s\" % (name,fromlist)\n"
" if fromlist == None:\n"
" mod = __main__._import(self.script, name, globals, locals, fromlist)\n"
" if mod != None:\n"
" print \"2===========> _Importer name=%s fromlist=%s\" % (name,fromlist)\n"
" globals[name] = mod\n"
" return mod\n"
//" if name in sys.modules:\n" // hack to preserve module paths, needed e.g. for "import os.path"
//" print \"3===========> _Importer name=%s fromlist=%s\" % (name,fromlist)\n"
//" return sys.modules[name]\n"
" print \"3===========> _Importer Trying realImporter with name=%s fromlist=%s insysmodules=%s\" % (name,fromlist,name in sys.modules)\n"
" try:\n"
" mod = self.realImporter(name, globals, locals, fromlist)\n"
" print \"4===========> _Importer Trying realImporter with name=%s fromlist=%s insysmodules=%s module=%s\" % (name,fromlist,name in sys.modules,mod)\n"
//" mod.__init__(name)\n"
//" globals[name] = mod\n"
//" sys.modules[name] = mod\n"
" print \"5===========> _Importer Trying realImporter with name=%s fromlist=%s insysmodules=%s module=%s\" % (name,fromlist,name in sys.modules,mod)\n"
" return mod\n"
" except ImportError:\n"
" print \"6===========> _Importer Trying ImportError with name=%s fromlist=%s insysmodules=%s\" % (name,fromlist,name in sys.modules)\n"
" n = name.split('.')\n"
" if len(n) >= 2:\n"
" print \"7===========> _Importer Trying ImportError with name=%s fromlist=%s insysmodules=%s\" % (name,fromlist,name in sys.modules)\n"
" m = self._import(\".\".join(n[:-1]),globals,locals,[n[-1],])\n"
" print \"8===========> _Importer Trying ImportError with name=%s fromlist=%s insysmodules=%s\" % (name,fromlist,name in sys.modules)\n"
" return self.realImporter(name, globals, locals, fromlist)\n"
" print \"9===========> _Importer Trying ImportError with name=%s fromlist=%s insysmodules=%s\" % (name,fromlist,name in sys.modules)\n"
" raise\n"
*/
;
PyObject* pyrun = PyRun_String(s.toLatin1().data(), Py_file_input, moduledict.ptr(), moduledict.ptr());
if(! pyrun) {
Py::Object errobj = Py::value(Py::Exception()); // get last error
setError( QString("Failed to prepare the __main__ module: %1").arg(errobj.as_string().c_str()) );
}
Py_XDECREF(pyrun); // free the reference.
}
void PythonInterpreter::extractException(QStringList& errorlist, int& lineno)
{
lineno = -1;
PyObject *type, *value, *traceback;
PyErr_Fetch(&type, &value, &traceback);
Py_FlushLine();
PyErr_NormalizeException(&type, &value, &traceback);
if(traceback) {
Py::List tblist;
try {
Py::Module tbmodule( PyImport_Import(Py::String("traceback").ptr()), true );
Py::Dict tbdict = tbmodule.getDict();
Py::Callable tbfunc(tbdict.getItem("format_tb"));
Py::Tuple args(1);
args.setItem(0, Py::Object(traceback));
tblist = tbfunc.apply(args);
uint length = tblist.length();
for(Py::List::size_type i = 0; i < length; ++i)
errorlist.append( Py::Object(tblist[i]).as_string().c_str() );
}
catch(Py::Exception& e) {
QString err = Py::value(e).as_string().c_str();
e.clear(); // exception is handled. clear it now.
#ifdef KROSS_PYTHON_EXCEPTION_DEBUG
krosswarning( QString("Kross::PythonScript::toException() Failed to fetch a traceback: %1").arg(err) );
#endif
}
PyObject *next;
while (traceback && traceback != Py_None) {
PyFrameObject *frame = (PyFrameObject*)PyObject_GetAttrString(traceback, const_cast< char* >("tb_frame"));
{
PyObject *getobj = PyObject_GetAttrString(traceback, const_cast< char* >("tb_lineno") );
lineno = PyInt_AsLong(getobj);
Py_DECREF(getobj);
}
if(Py_OptimizeFlag) {
PyObject *getobj = PyObject_GetAttrString(traceback, const_cast< char* >("tb_lasti") );
int lasti = PyInt_AsLong(getobj);
Py_DECREF(getobj);
lineno = PyCode_Addr2Line(frame->f_code, lasti);
}
//const char* filename = PyString_AsString(frame->f_code->co_filename);
//const char* name = PyString_AsString(frame->f_code->co_name);
//errorlist.append( QString("%1#%2: \"%3\"").arg(filename).arg(lineno).arg(name) );
//Py_DECREF(frame); // don't free cause we don't own it.
next = PyObject_GetAttrString(traceback, const_cast< char* >("tb_next") );
Py_DECREF(traceback);
traceback = next;
}
}
if(lineno < 0 && value && PyObject_HasAttrString(value, const_cast< char* >("lineno"))) {
PyObject *getobj = PyObject_GetAttrString(value, const_cast< char* >("lineno") );
if(getobj) {
lineno = PyInt_AsLong(getobj);
Py_DECREF(getobj);
}
}
#ifdef KROSS_PYTHON_EXCEPTION_DEBUG
//krossdebug( QString("PythonInterpreter::extractException: %1").arg( Py::Object(value).as_string().c_str() ) );
krossdebug( QString("PythonInterpreter::extractException:\n%1").arg( errorlist.join("\n") ) );
#endif
PyErr_Restore(type, value, traceback);
}