HG_REPOSITORIES/LPP/INSTRUMENTATION/SocExplorer Commit - r37:b04e90691097

ElfFile classes WIP.

jeandet -

r37:b04e90691097 default

parent child

Context file:

r37:b04e90691097

Collapse all files

src/common/PySocExplorer.h +5 0

+            #include <QObject>
+            #include <QWidget>
             #include "qhexspinbox.h"
             #include "memsizewdgt.h"
             #include "qhexedit/qhexedit.h"
             #include "SocExplorerPlot.h"
             #include "tcp_terminal_client.h"
             #include "elf/elfparser.h"
+            #include "elf/abstractexecfile.h"
+            #include "elf/elffile.h"
+            #include "elf/elffilewidget.h"

src/common/abstractexecfile.cpp +2 -3

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2014, Plasma Physics Laboratory - CNRS
             --
             --  This program 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 program 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 General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "abstractexecfile.h"
-            abstractExecFile::abstractExecFile(QObject *parent) :
+            abstractExecFile::abstractExecFile()
-                QObject(parent)
             {
             }
-            abstractExecFile::abstractExecFile(const QString &File, QObject *parent)
+            abstractExecFile::abstractExecFile(const QString &File)
             {
             }
             codeFragment::codeFragment()
             {
             }

src/common/abstractexecfile.h +3 -7

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2014, Plasma Physics Laboratory - CNRS
             --
             --  This program 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 program 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 General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #ifndef ABSTRACTEXECFILE_H
             #define ABSTRACTEXECFILE_H
             #include <QObject>
             class codeFragment
             {
             public:
                 codeFragment();
                 char* data;
                 quint32 size;
                 quint32 address;
             };
-            class abstractExecFile : public QObject
+            class abstractExecFile
             {
-                Q_OBJECT
             public:
-                abstractExecFile(QObject *parent = 0);
+                abstractExecFile();
-                abstractExecFile(const QString& File,QObject *parent = 0);
+                abstractExecFile(const QString& File);
                 virtual bool openFile(const QString& File)=0;
                 virtual bool isopened()=0;
                 virtual int closeFile()=0;
                 virtual QList<codeFragment> getFragments()=0;
-            signals:
-            public slots:
             protected:
                 QString p_fileName;
             };
             #endif // ABSTRACTEXECFILE_H

src/common/common.pro +1 0

             SOCEXPLORER_ROOT = \"$${PWD}/../..\"
             include($${PWD}/../../build_cfg/socexplorer.pri)
             include($${PWD}/lppserial/lppserial.pri)
             TEMPLATE = lib
             TARGET = socexplorercommon$${DEBUG_EXT}
             win32:CONFIG += dll
             win32:CONFIG -= static
             win32:INCLUDEPATH += $${PWD}/elf/libelfWin32/include
             win32:INCLUDEPATH += $${PWD}/elf/libelfWin32/include/libelf
             win32:DEFINES+=_ELF_WINDOWS_
             DEFINES+=RS232_debug
             win32:LIBS += $${PWD}/elf/libelfWin32/bin/libelf.a
             unix:LIBS += -lelf
             QMAKE_LFLAGS_RELEASE += --enable-auto-import
             QMAKE_LFLAGS_DEBUG += --enable-auto-import
             target.path = $$[QT_INSTALL_LIBS]
             isEmpty(target.path) {
                error(can\'t get QT_INSTALL_LIBS)
             }
             header.path = $$[QT_INSTALL_HEADERS]/SocExplorer/common
             header.files = \
                 memsizewdgt.h \
                 qhexspinbox.h \
                 qsvgicon.h \
                 qhexedit/qhexedit_p.h \
                 qhexedit/qhexedit.h \
                 qhexedit/xbytearray.h \
                 QCustomPlot/qcustomplot.h \
                 SocExplorerPlot.h \
                 tcp_terminal_client.h \
                 elf/elfinfowdgt.h \
                 elf/elfparser.h \
                 elf/elffile.h \
+                elf/elffilewidget.h \
                 qipdialogbox.h \
                 lppserial/src/RS232.h
             win32{
                 elfheader.path = $$[QT_INSTALL_HEADERS]/SocExplorer/common/libelf
                 elfheader.files += \
                     elf/libelfWin32/include/libelf/byteswap.h  \
                     elf/libelfWin32/include/libelf/errors.h     \
                     elf/libelfWin32/include/libelf/gelf.h    \
                     elf/libelfWin32/include/libelf/nlist.h    \
                     elf/libelfWin32/include/libelf/sys_elf.h  \
                     elf/libelfWin32/include/libelf/verneed.h \
                     elf/libelfWin32/include/libelf/elf_repl.h \
                     elf/libelfWin32/include/libelf/ext_types.h \
                     elf/libelfWin32/include/libelf/libelf.h  \
                     elf/libelfWin32/include/libelf/private.h  \
                     elf/libelfWin32/include/libelf/verdef.h
                 INSTALLS += elfheader
             }
             isEmpty(header.path) {
                error(can\'t get QT_INSTALL_HEADERS)
             }
             INSTALLS += target header
             INCLUDEPATH += QCustomPlot qhexedit
             HEADERS += \
                 memsizewdgt.h \
                 qhexspinbox.h \
                 qsvgicon.h \
                 qhexedit/qhexedit_p.h \
                 qhexedit/qhexedit.h \
                 qhexedit/xbytearray.h \
                 qhexedit/commands.h \
                 QCustomPlot/qcustomplot.h \
                 tcp_terminal_client.h \
                 elf/elfinfowdgt.h \
                 elf/elfparser.h \
                 abstractexecfile.h \
                 elf/elffile.h \
                 qipdialogbox.h \
                 PySocExplorer.h \
                 SocExplorerPlot.h \
                 elf/elffilewidget.h
             SOURCES += \
                 memsizewdgt.cpp \
                 qhexspinbox.cpp \
                 qsvgicon.cpp \
                 qhexedit/qhexedit_p.cpp \
                 qhexedit/qhexedit.cpp \
                 qhexedit/xbytearray.cpp \
                 qhexedit/commands.cpp \
                 QCustomPlot/qcustomplot.cpp \
                 tcp_terminal_client.cpp \
                 elf/elfinfowdgt.cpp \
                 elf/elfparser.cpp \
                 abstractexecfile.cpp \
                 elf/elffile.cpp \
                 qipdialogbox.cpp \
                 SocExplorerPlot.cpp \
                 elf/elffilewidget.cpp
             FORMS += \
                 elf/elffilewidget.ui

src/common/elf/elffile.cpp +3 -3

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2014, Plasma Physics Laboratory - CNRS
             --
             --  This program 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 program 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 General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author :
                     Alexis Jeandet
             --                     Mail :
                     alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "elffile.h"
-            ElfFile::ElfFile(QObject *parent) :
+            ElfFile::ElfFile(QObject *parent)
-                abstractExecFile(parent)
+                :QObject(parent),abstractExecFile(),elfparser()
             {
             }
             ElfFile::ElfFile(const QString &File, QObject *parent)
-                :abstractExecFile(parent),elfparser()
+                :QObject(parent),abstractExecFile(),elfparser()
             {
                 this->p_fileName = File;
                 setFilename(File);
             }
             bool ElfFile::openFile(const QString &File)
             {
                 this->p_fileName = File;
                 return setFilename(File);
             }
             bool ElfFile::isopened()
             {
                 return elfparser::isopened();
             }
             int ElfFile::closeFile()
             {
                 return elfparser::closeFile();
             }
             QList<codeFragment> ElfFile::getFragments(QStringList fragmentList)
             {
                 QList<codeFragment> fragments;
                 if (isopened())
                 {
                     for(int i =0;i<fragmentList.count();i++)
                     {
                         fragments.append(getFragment(fragmentList.at(i)));
                     }
                 }
                 return fragments;
             }
             QList<codeFragment> ElfFile::getFragments()
             {
                 return getFragments(QStringList()<<".data"<<".text");
             }
             codeFragment ElfFile::getFragment(const QString &name)
             {
                 codeFragment fragment;
                 for(int i=0;i<getSectioncount();i++)
                 {
                     if(getSectionName(i) == name)
                     {
                         fragment.data =NULL;
                         fragment.size = getSectionDatasz(i);
                         fragment.address = getSectionPaddr(i);
                         getSectionData(i,&fragment.data);
                     }
                 }
             }

src/common/elf/elffile.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2014, Plasma Physics Laboratory - CNRS
             --
             --  This program 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 program 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 General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include <abstractexecfile.h>
             #include <elf.h>
             #include "elfparser.h"
             #include <QStringList>
             #ifndef ELFFILE_H
             #define ELFFILE_H
-            class ElfFile : public abstractExecFile, public elfparser
+            class ElfFile :public QObject, public abstractExecFile, public elfparser
             {
                 Q_OBJECT
             public:
                 ElfFile(QObject *parent = 0);
                 ElfFile(const QString& File,QObject *parent = 0);
                 bool openFile(const QString& File);
                 bool isopened();
                 int closeFile();
                 QList<codeFragment> getFragments();
                 QList<codeFragment> getFragments(QStringList fragmentList);
             //    elfparser parser;
             signals:
             public slots:
             private:
                 codeFragment getFragment(const QString& name);
             };
             #endif // ELFFILE_H

src/common/elf/elffilewidget.cpp +18 0

             #include "elffilewidget.h"
             #include "ui_elffilewidget.h"
             elfFileWidget::elfFileWidget(QWidget *parent) :
                 QWidget(parent),
                 ui(new Ui::elfFileWidget)
             {
                 ui->setupUi(this);
             }
             elfFileWidget::~elfFileWidget()
             {
                 delete ui;
             }
             void elfFileWidget::updateElfFile(ElfFile *file)
             {
                 this->p_elf = file;
                 if(p_elf->isopened() && p_elf->iself())
                 {
                     this->ui->classLabel->setText(p_elf->getClass());
                     this->ui->VersionLabel->setText(QString::number(p_elf->getVersion()));
                     this->ui->machineLabel->setText(p_elf->getArchitecture());
                     this->ui->endiannesLabel->setText(p_elf->getEndianness());
+                    this->ui->abiLabel->setText(p_elf->getABI());
+                    this->ui->entryPointLabel->setText("0x"+QString::number(p_elf->getEntryPointAddress(),16,8));
+                    this->ui->sectionCountLabel->setText(QString::number(p_elf->getSectioncount()));
                 }
             }

src/common/elf/elfparser.cpp +32 0

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2013, Plasma Physics Laboratory - CNRS
             --
             --  This program 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 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program 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 General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "elfparser.h"
             #include <sys/types.h>
             #include <sys/stat.h>
             #include <fcntl.h>
             #include <unistd.h>
             QString elfresolveMachine(Elf64_Half	e_machine)
             {
                 QString machineName;
                 //Update from with bash script don't write it by yourself!
                 switch(e_machine)
                 {
                 case EM_NONE:
                     machineName = " No machine ";
                     break;
                 case EM_M32:
                     machineName = " AT&T WE 32100 ";
                     break;
                 case EM_SPARC:
                     machineName = " SUN SPARC ";
                     break;
                 case EM_386:
                     machineName = " Intel 80386 ";
                     break;
                 case EM_68K:
                     machineName = " Motorola m68k family ";
                     break;
                 case EM_88K:
                     machineName = " Motorola m88k family ";
                     break;
                 case EM_860:
                     machineName = " Intel 80860 ";
                     break;
                 case EM_MIPS:
                     machineName = " MIPS R3000 big-endian ";
                     break;
                 case EM_S370:
                     machineName = " IBM System/370 ";
                     break;
                 case EM_MIPS_RS3_LE:
                     machineName = " MIPS R3000 little-endian ";
                     break;
                 case EM_PARISC:
                     machineName = " HPPA ";
                     break;
                 case EM_VPP500:
                     machineName = " Fujitsu VPP500 ";
                     break;
                 case EM_SPARC32PLUS:
                     machineName = " Sun's \"v8plus\" ";
                     break;
                 case EM_960:
                     machineName = " Intel 80960 ";
                     break;
                 case EM_PPC:
                     machineName = " PowerPC ";
                     break;
                 case EM_PPC64:
                     machineName = " PowerPC 64-bit ";
                     break;
                 case EM_S390:
                     machineName = " IBM S390 ";
                     break;
                 case EM_V800:
                     machineName = " NEC V800 series ";
                     break;
                 case EM_FR20:
                     machineName = " Fujitsu FR20 ";
                     break;
                 case EM_RH32:
                     machineName = " TRW RH-32 ";
                     break;
                 case EM_RCE:
                     machineName = " Motorola RCE ";
                     break;
                 case EM_ARM:
                     machineName = " ARM ";
                     break;
                 case EM_FAKE_ALPHA:
                     machineName = " Digital Alpha ";
                     break;
                 case EM_SH:
                     machineName = " Hitachi SH ";
                     break;
                 case EM_SPARCV9:
                     machineName = " SPARC v9 64-bit ";
                     break;
                 case EM_TRICORE:
                     machineName = " Siemens Tricore ";
                     break;
                 case EM_ARC:
                     machineName = " Argonaut RISC Core ";
                     break;
                 case EM_H8_300:
                     machineName = " Hitachi H8/300 ";
                     break;
                 case EM_H8_300H:
                     machineName = " Hitachi H8/300H ";
                     break;
                 case EM_H8S:
                     machineName = " Hitachi H8S ";
                     break;
                 case EM_H8_500:
                     machineName = " Hitachi H8/500 ";
                     break;
                 case EM_IA_64:
                     machineName = " Intel Merced ";
                     break;
                 case EM_MIPS_X:
                     machineName = " Stanford MIPS-X ";
                     break;
                 case EM_COLDFIRE:
                     machineName = " Motorola Coldfire ";
                     break;
                 case EM_68HC12:
                     machineName = " Motorola M68HC12 ";
                     break;
                 case EM_MMA:
                     machineName = " Fujitsu MMA Multimedia Accelerator";
                     break;
                 case EM_PCP:
                     machineName = " Siemens PCP ";
                     break;
                 case EM_NCPU:
                     machineName = " Sony nCPU embeeded RISC ";
                     break;
                 case EM_NDR1:
                     machineName = " Denso NDR1 microprocessor ";
                     break;
                 case EM_STARCORE:
                     machineName = " Motorola Start*Core processor ";
                     break;
                 case EM_ME16:
                     machineName = " Toyota ME16 processor ";
                     break;
                 case EM_ST100:
                     machineName = " STMicroelectronic ST100 processor ";
                     break;
                 case EM_TINYJ:
                     machineName = " Advanced Logic Corp. Tinyj emb.fam";
                     break;
                 case EM_X86_64:
                     machineName = " AMD x86-64 architecture ";
                     break;
                 case EM_PDSP:
                     machineName = " Sony DSP Processor ";
                     break;
                 case EM_FX66:
                     machineName = " Siemens FX66 microcontroller ";
                     break;
                 case EM_ST9PLUS:
                     machineName = " STMicroelectronics ST9+ 8/16 mc ";
                     break;
                 case EM_ST7:
                     machineName = " STmicroelectronics ST7 8 bit mc ";
                     break;
                 case EM_68HC16:
                     machineName = " Motorola MC68HC16 microcontroller ";
                     break;
                 case EM_68HC11:
                     machineName = " Motorola MC68HC11 microcontroller ";
                     break;
                 case EM_68HC08:
                     machineName = " Motorola MC68HC08 microcontroller ";
                     break;
                 case EM_68HC05:
                     machineName = " Motorola MC68HC05 microcontroller ";
                     break;
                 case EM_SVX:
                     machineName = " Silicon Graphics SVx ";
                     break;
                 case EM_ST19:
                     machineName = " STMicroelectronics ST19 8 bit mc ";
                     break;
                 case EM_VAX:
                     machineName = " Digital VAX ";
                     break;
                 case EM_CRIS:
                     machineName = " Axis Communications 32-bit embedded processor ";
                     break;
                 case EM_JAVELIN:
                     machineName = " Infineon Technologies 32-bit embedded processor ";
                     break;
                 case EM_FIREPATH:
                     machineName = " Element 14 64-bit DSP Processor ";
                     break;
                 case EM_ZSP:
                     machineName = " LSI Logic 16-bit DSP Processor ";
                     break;
                 case EM_MMIX:
                     machineName = " Donald Knuth's educational 64-bit processor ";
                     break;
                 case EM_HUANY:
                     machineName = " Harvard University machine-independent object files ";
                     break;
                 case EM_PRISM:
                     machineName = " SiTera Prism ";
                     break;
                 case EM_AVR:
                     machineName = " Atmel AVR 8-bit microcontroller ";
                     break;
                 case EM_FR30:
                     machineName = " Fujitsu FR30 ";
                     break;
                 case EM_D10V:
                     machineName = " Mitsubishi D10V ";
                     break;
                 case EM_D30V:
                     machineName = " Mitsubishi D30V ";
                     break;
                 case EM_V850:
                     machineName = " NEC v850 ";
                     break;
                 case EM_M32R:
                     machineName = " Mitsubishi M32R ";
                     break;
                 case EM_MN10300:
                     machineName = " Matsushita MN10300 ";
                     break;
                 case EM_MN10200:
                     machineName = " Matsushita MN10200 ";
                     break;
                 case EM_PJ:
                     machineName = " picoJava ";
                     break;
                 case EM_OPENRISC:
                     machineName = " OpenRISC 32-bit embedded processor ";
                     break;
                 case EM_ARC_A5:
                     machineName = " ARC Cores Tangent-A5 ";
                     break;
                 case EM_XTENSA:
                     machineName = " Tensilica Xtensa Architecture ";
                     break;
                 case EM_AARCH64:
                     machineName = " ARM AARCH64 ";
                     break;
                 case EM_TILEPRO:
                     machineName = " Tilera TILEPro ";
                     break;
                 case EM_MICROBLAZE:
                     machineName = " Xilinx MicroBlaze ";
                     break;
                 case EM_TILEGX:
                     machineName = " Tilera TILE-Gx ";
                     break;
                 case EM_NUM:
                     machineName = "";
                     break;
                 default:
                     machineName ="Unknow Machine";
                     break;
                 }
                 return machineName;
             }
             elfparser::elfparser()
             {
                 this->opened = false;
                 this->type_elf = false;
                 this->elfFile = NULL;
                 this->e = NULL;
             }
             int elfparser::setFilename(const QString &name)
             {
                 this->closeFile();
                 if(elf_version(EV_CURRENT)==EV_NONE)return 0;
             #ifdef _ELF_WINDOWS_
                 this->elfFile = open(name.toStdString().c_str(),O_RDONLY|O_BINARY ,0);
             #else
                 this->elfFile = open(name.toStdString().c_str(),O_RDONLY ,0);
             #endif
                 if(this->elfFile==NULL)return 0;
                 this->e = elf_begin(this->elfFile,ELF_C_READ,NULL);
                 if(this->e==NULL)return 0;
                 this->ek = elf_kind(this->e);
                 gelf_getehdr (this->e, &this->ehdr );
                 elf_getshdrstrndx (this->e, &this->shstrndx);
                 this->updateSegments();
                 this->updateSections();
                 return 1;
             }
             int elfparser::closeFile()
             {
                 if(this->elfFile!=NULL)
                 {
                     if(this->e!=NULL)
                     {
                         elf_end(this->e);
                         this->e = NULL;
                     }
                     close(this->elfFile);
                     this->elfFile = NULL;
                 }
                 return 0;
             }
             QString elfparser::getClass()
             {
                 if(this->e!=NULL)
                 {
                     int eclass = gelf_getclass(this->e);
                     if(eclass==ELFCLASS32)return "ELF32";
                     if(eclass==ELFCLASS64)return "ELF64";
                 }
                 return "none";
             }
             bool elfparser::isopened()
             {
                 return this->opened;
             }
             bool elfparser::iself()
             {
                 return this->type_elf;
             }
             QString elfparser::getArchitecture()
             {
                 if(this->e!=NULL)
                 {
                     return elfresolveMachine(this->ehdr.e_machine);
                 }
                 return "";
             }
             QString elfparser::getType()
             {
                 QString kind("");
                 if(this->e!=NULL)
                 {
                     switch(this->ek)
                     {
                     case ELF_K_AR:
                         kind = "Archive";
                         break;
                     case ELF_K_ELF:
                         kind = "Elf";
                         break;
                     case ELF_K_COFF:
                         kind = "COFF";
                         break;
                     case ELF_K_NUM:
                         kind = "NUM";
                         break;
                     case ELF_K_NONE:
                         kind = "Data";
                         break;
                     default:
                         kind = "Unknow";
                         break;
                     }
                 }
                 return kind;
             }
             QString elfparser::getEndianness()
             {
                 if(this->e!=NULL)
                 {
                     if(this->ehdr.e_ident[EI_DATA]==ELFDATA2LSB)return "2's complement, little endian";
                     if(this->ehdr.e_ident[EI_DATA]==ELFDATA2MSB)return "2's complement, big endian";
                 }
                 return "none";
             }
+            QString elfparser::getABI()
+            {
+                if(this->e!=NULL)
+                {
+                    if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_NONE)return "UNIX System V ABI";
+                    if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_SYSV)return "Alias";
+                    if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_HPUX)return "HP-UX";
+                    if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_NETBSD)return "NetBSD";
+                    if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_GNU)return "Object uses GNU ELF extensions";
+                    if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_LINUX)return "Compatibility alias";
+                    if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_SOLARIS)return "Sun Solaris";
+                    if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_AIX)return "IBM AIX";
+                    if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_IRIX)return "SGI Irix";
+                    if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_FREEBSD)return "FreeBSD";
+                    if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_TRU64)return "Compaq TRU64 UNIX";
+                    if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_MODESTO)return " Novell Modesto";
+                    if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_OPENBSD)return "OpenBSD";
+                    if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_ARM_AEABI)return "ARM EABI";
+                    if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_ARM)return "ARM";
+                    if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_STANDALONE)return "Standalone (embedded) application";
+                }
+                return "none";
+            }
             int32_t  elfparser::getVersion()
             {
                 if(this->e!=NULL)
                 {
                     return this->ehdr.e_version;
                 }
             }
+            int64_t elfparser::getEntryPointAddress()
+            {
+                if(this->e!=NULL)
+                {
+                    return this->ehdr.e_entry;
+                }
+            }
             int elfparser::getSectioncount()
             {
                 return (int)this->SectionCount;
             }
             int elfparser::getSegmentcount()
             {
                 return (int)this->SegmentCount;
             }
             QString elfparser::getSegmentType(int index)
             {
                 QString type("");
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
                         switch(this->Segments.at(index)->p_type)
                         {
                         case PT_NULL:
                             type = "Program header table entry unused";
                             break;
                         case PT_LOAD:
                             type = "Loadable program segment";
                             break;
                         case PT_DYNAMIC	:
                             type = "Dynamic linking information";
                             break;
                         case PT_INTERP:
                             type ="Program interpreter";
                             break;
                         case PT_NOTE:
                             type = "Auxiliary information";
                             break;
                         case PT_SHLIB:
                             type = "Reserved";
                             break;
                         case PT_PHDR:
                             type =	"Entry for header table itself";
                             break;
                         case PT_TLS:
                             type = "Thread-local storage segment";
                             break;
                         case PT_NUM:
                             type = "Number of defined types";
                             break;
                         case PT_LOOS:
                             type =	"Start of OS-specific";
                             break;
                         case PT_SUNWSTACK:
                             type = "Stack segment";
                             break;
                         case PT_LOPROC:
                             type = "Start of processor-specific";
                             break;
                         case PT_HIPROC:
                             type = "End of processor-specific";
                             break;
                         default:
                             type = "Unknow Section Type";
                             break;
                         }
                     }
                 }
                 return type;
             }
             int64_t elfparser::getSegmentOffset(int index)
             {
                 int64_t Offset;
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
                         Offset =  (int64_t)this->Segments.at(index)->p_offset;
                     }
                 }
                 return Offset;
             }
             int64_t elfparser::getSegmentVaddr(int index)
             {
                 int64_t Vaddr = 0;
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
                         Vaddr =  (int64_t)this->Segments.at(index)->p_vaddr;
                     }
                 }
                 return Vaddr;
             }
             int64_t elfparser::getSegmentPaddr(int index)
             {
                 int64_t Paddr=0;
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
                         Paddr = (int64_t)this->Segments.at(index)->p_paddr;
                     }
                 }
                 return Paddr;
             }
             int64_t elfparser::getSectionPaddr(int index)
             {
                 int64_t Paddr=0;
                 if(this->e!=NULL)
                 {
                     if(index < this->sections.count())
                     {
                         Paddr = (int64_t)this->sections.at(index)->section_header->sh_addr;
                     }
                 }
                 return Paddr;
             }
             int64_t elfparser::getSegmentFilesz(int index)
             {
                 int64_t FileSz=0;
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
                         FileSz = (int64_t)this->Segments.at(index)->p_filesz;
                     }
                 }
                 return FileSz;
             }
             int64_t elfparser::getSectionDatasz(int index)
             {
                 int64_t DataSz=0;
                 if(this->e!=NULL)
                 {
                     if(index < this->sections.count())
                     {
                         DataSz = (int64_t)this->sections.at(index)->data->d_size;
                     }
                 }
                 return DataSz;
             }
             bool elfparser::getSectionData(int index, char **buffer)
             {
                 if(this->e!=NULL)
                 {
                     if(index < this->sections.count())
                     {
                         *buffer = (char *)this->sections.at(index)->data->d_buf;
                         return true;
                     }
                 }
                 return false;
             }
             int64_t elfparser::getSegmentMemsz(int index)
             {
                 int64_t MemSz=0;
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
                         MemSz = (int64_t)this->Segments.at(index)->p_memsz;
                     }
                 }
                 return MemSz;
             }
             int64_t elfparser::getSectionMemsz(int index)
             {
                 int64_t MemSz=0;
                 if(this->e!=NULL)
                 {
                     if(index < this->sections.count())
                     {
                         MemSz = (int64_t)this->sections.at(index)->section_header->sh_size;
                     }
                 }
                 return MemSz;
             }
             QString elfparser::getSegmentFlags(int index)
             {
                 QString flags("");
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
                         if((this->Segments.at(index)->p_flags&PF_X) == PF_X)flags+="x";
                         if((this->Segments.at(index)->p_flags&PF_W) == PF_W)flags+="w";
                         if((this->Segments.at(index)->p_flags&PF_R) == PF_R)flags+="r";
                         if((this->Segments.at(index)->p_flags&PF_MASKOS) == PF_MASKOS)flags+=" OS-specific";
                         if((this->Segments.at(index)->p_flags&PF_MASKPROC) == PF_MASKPROC)flags+=" Processor-specific";
                     }
                 }
                 return flags;
             }
             QString elfparser::getSectionName(int index)
             {
                 char* nameChr = elf_strptr(this->e , this->shstrndx , this->sections.at(index)->section_header->sh_name);
                 return QString(nameChr);
             }
             void elfparser::updateSections()
             {
                 for(int i=0;i<this->sections.count();i++)
                 {
                     delete this->sections.at(i);
                 }
                 this->sections.clear();
                 this->scn = elf_nextscn (this->e , NULL );
                 this->SectionCount = 0;
                 while( this->scn != NULL )
                 {
                     GElf_Shdr* shdr = (GElf_Shdr*)malloc(sizeof(GElf_Shdr));
                     gelf_getshdr ( this->scn , shdr );
                     Elf_Data*  data = elf_getdata(this->scn, NULL);
                     this->sections.append(new Elf_Section(data,shdr));
                     this->SectionCount+=1;
                     this->scn = elf_nextscn(e , scn);
                 }
             }
             void elfparser::updateSegments()
             {
                 elf_getphdrnum (this->e , &this->SegmentCount);
                 for(int i=0;i<this->Segments.count();i++)
                 {
                     free(this->Segments.at(i));
                 }
                 this->Segments.clear();
                 for(int i=0;i<this->SegmentCount;i++)
                 {
                     GElf_Phdr* header=(GElf_Phdr*)malloc(sizeof(GElf_Phdr));
                     gelf_getphdr (this->e , i , header );
                     this->Segments.append(header);
                 }
             }
             QString elfparser::getSectionType(int index)
             {
                 QString type("");
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
                         switch(this->Segments.at(index)->p_type)
                         {
                         case SHT_NULL	 :	type = "Section header table entry unused"; break;
                         case SHT_PROGBITS	  :		type = "Program data"; break;
                         case SHT_SYMTAB	  :		type = "Symbol table"; break;
                         case SHT_STRTAB	  :		type = "String table"; break;
                         case SHT_RELA	  :		type = "Relocation entries with addends"; break;
                         case SHT_HASH	  :		type = "Symbol hash table"; break;
                         case SHT_DYNAMIC	 :		type = "Dynamic linking information"; break;
                         case SHT_NOTE	  :		type = "Notes"; break;
                         case SHT_NOBITS    :type = "Program space with no data (bss)"; break;
                         case SHT_REL    :type = "Relocation entries, no addends"; break;
                         case SHT_SHLIB	 :		type = "Reserved"; break;
                         case SHT_DYNSYM	  :		type = "Dynamic linker symbol table"; break;
                         case SHT_INIT_ARRAY	  :		type = "Array of constructors"; break;
                         case SHT_FINI_ARRAY	  :		type = "Array of destructors"; break;
                         case SHT_PREINIT_ARRAY :		type = "Array of pre-constructors"; break;
                         case SHT_GROUP	  :		type = "Section group"; break;
                         case SHT_SYMTAB_SHNDX  :		type = "Extended section indeces"; break;
                         case SHT_NUM		  :		type = "Number of defined types. "; break;
                         case SHT_LOOS	  :	type = "Start OS-specific. "; break;
                         case SHT_LOSUNW	  :	type = "Sun-specific low bound. "; break;
                         case SHT_SUNW_COMDAT  : type = " "; break;
                         case SHT_SUNW_syminfo  : type = " "; break;
                         case SHT_GNU_verdef	  :	type = "Version definition section. "; break;
                         case SHT_GNU_verneed	  :	type = "Version needs section. "; break;
                         case SHT_GNU_versym	  :	type = "Version symbol table. "; break;
                         case SHT_LOPROC	  :	type = "Start of processor-specific"; break;
                         case SHT_HIPROC	 :	type = "End of processor-specific"; break;
                         case SHT_HIUSER	 :	type = "End of application-specific"; break;
                         }
                     }
                 }
                 return type;
             }
             bool elfparser::isElf(const QString &File)
             {
                 int file =0;
             #ifdef _ELF_WINDOWS_
                 file = open(File.toStdString().c_str(),O_RDONLY|O_BINARY ,0);
             #else
                 file = open(File.toStdString().c_str(),O_RDONLY ,0);
             #endif
                 char Magic[4];
                 if(file!=-1)
                 {
                     read(file,Magic,4);
                     close(file);
                     if(Magic[0]==0x7f && Magic[1]==0x45 && Magic[2]==0x4c && Magic[3]==0x46)
                     {
                         return true;
                     }
                 }
                 return false;
             }

src/common/elf/elfparser.h +2 0

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2013, Plasma Physics Laboratory - CNRS
             --
             --  This program 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 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program 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 General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef ELFPARSER_H
             #define ELFPARSER_H
             #include <libelf.h>
             #include <gelf.h>
             #include <QString>
             #include <stdio.h>
             #include <QList>
             #include <stdint.h>
             class Elf_Section
             {
             public:
                 Elf_Section(){}
                 Elf_Section(Elf_Data*  data,GElf_Shdr* section_header)
                 {
                     this->data = data;
                     this->section_header = section_header;
                 }
                 Elf_Data*  data;
                 GElf_Shdr* section_header;
             };
             class elfparser
             {
             public:
                 elfparser();
                 bool iself();
                 bool isopened();
                 int setFilename(const QString& name);
                 int closeFile();
                 QString getClass();
                 QString getArchitecture();
                 QString getType();
                 QString getEndianness();
+                QString getABI();
                 int32_t getVersion();
+                int64_t getEntryPointAddress();
                 int getSectioncount();
                 int getSegmentcount();
                 QString getSegmentType(int index);
                 int64_t getSegmentOffset(int index);
                 int64_t getSegmentVaddr(int index);
                 int64_t getSegmentPaddr(int index);
                 int64_t getSectionPaddr(int index);
                 int64_t getSegmentFilesz(int index);
                 int64_t getSectionDatasz(int index);
                 bool getSectionData(int index, char **buffer);
                 int64_t getSegmentMemsz(int index);
                 int64_t getSectionMemsz(int index);
                 QString getSegmentFlags(int index);
                 QString getSectionName(int index);
                 QString getSectionType(int index);
                 static bool isElf(const QString& File);
             private:
                 void updateSections();
                 void updateSegments();
                 int elfFile;
                 bool opened;
                 bool type_elf;
                 Elf* e;
                 Elf_Kind ek;
                 GElf_Ehdr ehdr;
                 Elf_Scn * scn;
                 Elf_Data * data;
                 size_t SectionCount,SegmentCount, shstrndx;
                 QList<GElf_Phdr*> Segments;
                 QList<Elf_Section*> sections;
             };
             #endif // ELFPARSER_H

src/common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer0.cpp +47 0

             #include "PySocExplorer0.h"
             #include <PythonQtConversion.h>
             #include <PythonQtMethodInfo.h>
             #include <PythonQtSignalReceiver.h>
             #include <QVariant>
+            #include <elffile.h>
+            ElfFile* PythonQtWrapper_ElfFile::new_ElfFile(QObject*  parent)
+            {
+            return new ElfFile(parent); }
+            ElfFile* PythonQtWrapper_ElfFile::new_ElfFile(const QString&  File, QObject*  parent)
+            {
+            return new ElfFile(File, parent); }
+            int  PythonQtWrapper_ElfFile::closeFile(ElfFile* theWrappedObject)
+            {
+              return ( theWrappedObject->closeFile());
+            }
+            bool  PythonQtWrapper_ElfFile::isopened(ElfFile* theWrappedObject)
+            {
+              return ( theWrappedObject->isopened());
+            }
+            bool  PythonQtWrapper_ElfFile::openFile(ElfFile* theWrappedObject, const QString&  File)
+            {
+              return ( theWrappedObject->openFile(File));
+            }
             MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(QWidget*  parent)
             {
             return new MemSizeWdgt(parent); }
             MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(int  defaultSize, QWidget*  parent)
             {
             return new MemSizeWdgt(defaultSize, parent); }
             int  PythonQtWrapper_MemSizeWdgt::getsize(MemSizeWdgt* theWrappedObject)
             {
               return ( theWrappedObject->getsize());
             }
             void PythonQtWrapper_MemSizeWdgt::setMaximum(MemSizeWdgt* theWrappedObject, unsigned int  max)
             {
               ( theWrappedObject->setMaximum(max));
             }
             void PythonQtWrapper_MemSizeWdgt::show(MemSizeWdgt* theWrappedObject)
             {
               ( theWrappedObject->show());
             }
             void PythonQtWrapper_MemSizeWdgt::updateSizeValue(MemSizeWdgt* theWrappedObject)
             {
               ( theWrappedObject->updateSizeValue());
             }
             PythonQtShell_QHexEdit::~PythonQtShell_QHexEdit() {
               PythonQtPrivate* priv = PythonQt::priv();
               if (priv) { priv->shellClassDeleted(this); }
             }
             QHexEdit* PythonQtWrapper_QHexEdit::new_QHexEdit(QWidget*  parent)
             {
             return new PythonQtShell_QHexEdit(parent); }
             QColor  PythonQtWrapper_QHexEdit::addressAreaColor(QHexEdit* theWrappedObject)
             {
               return ( theWrappedObject->addressAreaColor());
             }
             int  PythonQtWrapper_QHexEdit::addressOffset(QHexEdit* theWrappedObject)
             {
               return ( theWrappedObject->addressOffset());
             }
             int  PythonQtWrapper_QHexEdit::cursorPosition(QHexEdit* theWrappedObject)
             {
               return ( theWrappedObject->cursorPosition());
             }
             QByteArray  PythonQtWrapper_QHexEdit::data(QHexEdit* theWrappedObject)
             {
               return ( theWrappedObject->data());
             }
             const QFont*  PythonQtWrapper_QHexEdit::font(QHexEdit* theWrappedObject) const
             {
               return &( theWrappedObject->font());
             }
             QColor  PythonQtWrapper_QHexEdit::highlightingColor(QHexEdit* theWrappedObject)
             {
               return ( theWrappedObject->highlightingColor());
             }
             int  PythonQtWrapper_QHexEdit::indexOf(QHexEdit* theWrappedObject, const QByteArray&  ba, int  from) const
             {
               return ( theWrappedObject->indexOf(ba, from));
             }
             void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int  i, char  ch)
             {
               ( theWrappedObject->insert(i, ch));
             }
             void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int  i, const QByteArray&  ba)
             {
               ( theWrappedObject->insert(i, ba));
             }
             bool  PythonQtWrapper_QHexEdit::isReadOnly(QHexEdit* theWrappedObject)
             {
               return ( theWrappedObject->isReadOnly());
             }
             int  PythonQtWrapper_QHexEdit::lastIndexOf(QHexEdit* theWrappedObject, const QByteArray&  ba, int  from) const
             {
               return ( theWrappedObject->lastIndexOf(ba, from));
             }
             bool  PythonQtWrapper_QHexEdit::overwriteMode(QHexEdit* theWrappedObject)
             {
               return ( theWrappedObject->overwriteMode());
             }
             void PythonQtWrapper_QHexEdit::remove(QHexEdit* theWrappedObject, int  pos, int  len)
             {
               ( theWrappedObject->remove(pos, len));
             }
             void PythonQtWrapper_QHexEdit::replace(QHexEdit* theWrappedObject, int  pos, int  len, const QByteArray&  after)
             {
               ( theWrappedObject->replace(pos, len, after));
             }
             QColor  PythonQtWrapper_QHexEdit::selectionColor(QHexEdit* theWrappedObject)
             {
               return ( theWrappedObject->selectionColor());
             }
             QString  PythonQtWrapper_QHexEdit::selectionToReadableString(QHexEdit* theWrappedObject)
             {
               return ( theWrappedObject->selectionToReadableString());
             }
             void PythonQtWrapper_QHexEdit::setAddressAreaColor(QHexEdit* theWrappedObject, const QColor&  color)
             {
               ( theWrappedObject->setAddressAreaColor(color));
             }
             void PythonQtWrapper_QHexEdit::setAddressOffset(QHexEdit* theWrappedObject, int  offset)
             {
               ( theWrappedObject->setAddressOffset(offset));
             }
             void PythonQtWrapper_QHexEdit::setCursorPosition(QHexEdit* theWrappedObject, int  cusorPos)
             {
               ( theWrappedObject->setCursorPosition(cusorPos));
             }
             void PythonQtWrapper_QHexEdit::setData(QHexEdit* theWrappedObject, const QByteArray&  data)
             {
               ( theWrappedObject->setData(data));
             }
             void PythonQtWrapper_QHexEdit::setFont(QHexEdit* theWrappedObject, const QFont&  arg__1)
             {
               ( theWrappedObject->setFont(arg__1));
             }
             void PythonQtWrapper_QHexEdit::setHighlightingColor(QHexEdit* theWrappedObject, const QColor&  color)
             {
               ( theWrappedObject->setHighlightingColor(color));
             }
             void PythonQtWrapper_QHexEdit::setOverwriteMode(QHexEdit* theWrappedObject, bool  arg__1)
             {
               ( theWrappedObject->setOverwriteMode(arg__1));
             }
             void PythonQtWrapper_QHexEdit::setReadOnly(QHexEdit* theWrappedObject, bool  arg__1)
             {
               ( theWrappedObject->setReadOnly(arg__1));
             }
             void PythonQtWrapper_QHexEdit::setSelectionColor(QHexEdit* theWrappedObject, const QColor&  color)
             {
               ( theWrappedObject->setSelectionColor(color));
             }
             QString  PythonQtWrapper_QHexEdit::toReadableString(QHexEdit* theWrappedObject)
             {
               return ( theWrappedObject->toReadableString());
             }
             QHexSpinBox* PythonQtWrapper_QHexSpinBox::new_QHexSpinBox(QWidget*  parent)
             {
             return new QHexSpinBox(parent); }
             void PythonQtWrapper_QHexSpinBox::show(QHexSpinBox* theWrappedObject)
             {
               ( theWrappedObject->show());
             }
             QString  PythonQtWrapper_QHexSpinBox::textFromValue(QHexSpinBox* theWrappedObject, int  value) const
             {
               return ( theWrappedObject->textFromValue(value));
             }
             QValidator::State  PythonQtWrapper_QHexSpinBox::validate(QHexSpinBox* theWrappedObject, QString&  input, int&  pos) const
             {
               return ( theWrappedObject->validate(input, pos));
             }
             int  PythonQtWrapper_QHexSpinBox::valueFromText(QHexSpinBox* theWrappedObject, const QString&  text) const
             {
               return ( theWrappedObject->valueFromText(text));
             }
             PythonQtShell_SocExplorerPlot::~PythonQtShell_SocExplorerPlot() {
               PythonQtPrivate* priv = PythonQt::priv();
               if (priv) { priv->shellClassDeleted(this); }
             }
             SocExplorerPlot* PythonQtWrapper_SocExplorerPlot::new_SocExplorerPlot(QWidget*  parent)
             {
             return new PythonQtShell_SocExplorerPlot(parent); }
             int  PythonQtWrapper_SocExplorerPlot::addGraph(SocExplorerPlot* theWrappedObject)
             {
               return ( theWrappedObject->addGraph());
             }
             void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int  graphIndex, QList<QVariant >  x, QList<QVariant >  y)
             {
               ( theWrappedObject->addGraphData(graphIndex, x, y));
             }
             void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int  graphIndex, QVariant  x, QVariant  y)
             {
               ( theWrappedObject->addGraphData(graphIndex, x, y));
             }
             QPen  PythonQtWrapper_SocExplorerPlot::getGraphPen(SocExplorerPlot* theWrappedObject, int  graphIndex)
             {
               return ( theWrappedObject->getGraphPen(graphIndex));
             }
             void PythonQtWrapper_SocExplorerPlot::rescaleAxis(SocExplorerPlot* theWrappedObject)
             {
               ( theWrappedObject->rescaleAxis());
             }
             void PythonQtWrapper_SocExplorerPlot::setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int  graphIndex, bool  enable)
             {
               ( theWrappedObject->setAdaptativeSampling(graphIndex, enable));
             }
             void PythonQtWrapper_SocExplorerPlot::setGraphData(SocExplorerPlot* theWrappedObject, int  graphIndex, QList<QVariant >  x, QList<QVariant >  y)
             {
               ( theWrappedObject->setGraphData(graphIndex, x, y));
             }
             void PythonQtWrapper_SocExplorerPlot::setGraphLineStyle(SocExplorerPlot* theWrappedObject, int  graphIndex, QString  lineStyle)
             {
               ( theWrappedObject->setGraphLineStyle(graphIndex, lineStyle));
             }
             void PythonQtWrapper_SocExplorerPlot::setGraphName(SocExplorerPlot* theWrappedObject, int  graphIndex, QString  name)
             {
               ( theWrappedObject->setGraphName(graphIndex, name));
             }
             void PythonQtWrapper_SocExplorerPlot::setGraphPen(SocExplorerPlot* theWrappedObject, int  graphIndex, QPen  pen)
             {
               ( theWrappedObject->setGraphPen(graphIndex, pen));
             }
             void PythonQtWrapper_SocExplorerPlot::setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int  graphIndex, QString  scatterStyle)
             {
               ( theWrappedObject->setGraphScatterStyle(graphIndex, scatterStyle));
             }
             void PythonQtWrapper_SocExplorerPlot::setLegendFont(SocExplorerPlot* theWrappedObject, QFont  font)
             {
               ( theWrappedObject->setLegendFont(font));
             }
             void PythonQtWrapper_SocExplorerPlot::setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont  font)
             {
               ( theWrappedObject->setLegendSelectedFont(font));
             }
             void PythonQtWrapper_SocExplorerPlot::setTitle(SocExplorerPlot* theWrappedObject, QString  title)
             {
               ( theWrappedObject->setTitle(title));
             }
             void PythonQtWrapper_SocExplorerPlot::setXaxisLabel(SocExplorerPlot* theWrappedObject, QString  label)
             {
               ( theWrappedObject->setXaxisLabel(label));
             }
             void PythonQtWrapper_SocExplorerPlot::setXaxisRange(SocExplorerPlot* theWrappedObject, double  lower, double  upper)
             {
               ( theWrappedObject->setXaxisRange(lower, upper));
             }
             void PythonQtWrapper_SocExplorerPlot::setYaxisLabel(SocExplorerPlot* theWrappedObject, QString  label)
             {
               ( theWrappedObject->setYaxisLabel(label));
             }
             void PythonQtWrapper_SocExplorerPlot::setYaxisRange(SocExplorerPlot* theWrappedObject, double  lower, double  upper)
             {
               ( theWrappedObject->setYaxisRange(lower, upper));
             }
             void PythonQtWrapper_SocExplorerPlot::show(SocExplorerPlot* theWrappedObject)
             {
               ( theWrappedObject->show());
             }
             TCP_Terminal_Client* PythonQtWrapper_TCP_Terminal_Client::new_TCP_Terminal_Client(QObject*  parent)
             {
             return new TCP_Terminal_Client(parent); }
             void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject)
             {
               ( theWrappedObject->connectToServer());
             }
             void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject, const QString&  IP, int  port)
             {
               ( theWrappedObject->connectToServer(IP, port));
             }
             bool  PythonQtWrapper_TCP_Terminal_Client::isConnected(TCP_Terminal_Client* theWrappedObject)
             {
               return ( theWrappedObject->isConnected());
             }
             void PythonQtWrapper_TCP_Terminal_Client::sendText(TCP_Terminal_Client* theWrappedObject, const QString&  text)
             {
               ( theWrappedObject->sendText(text));
             }
             void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject)
             {
               ( theWrappedObject->startServer());
             }
             void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject, int  port)
             {
               ( theWrappedObject->startServer(port));
             }
             XByteArray* PythonQtWrapper_XByteArray::new_XByteArray()
             {
             return new XByteArray(); }
             int  PythonQtWrapper_XByteArray::addressOffset(XByteArray* theWrappedObject)
             {
               return ( theWrappedObject->addressOffset());
             }
             int  PythonQtWrapper_XByteArray::addressWidth(XByteArray* theWrappedObject)
             {
               return ( theWrappedObject->addressWidth());
             }
             QChar  PythonQtWrapper_XByteArray::asciiChar(XByteArray* theWrappedObject, int  index)
             {
               return ( theWrappedObject->asciiChar(index));
             }
             QByteArray*  PythonQtWrapper_XByteArray::data(XByteArray* theWrappedObject)
             {
               return &( theWrappedObject->data());
             }
             bool  PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int  i)
             {
               return ( theWrappedObject->dataChanged(i));
             }
             QByteArray  PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int  i, int  len)
             {
               return ( theWrappedObject->dataChanged(i, len));
             }
             QByteArray*  PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int  i, char  ch)
             {
               return &( theWrappedObject->insert(i, ch));
             }
             QByteArray*  PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int  i, const QByteArray&  ba)
             {
               return &( theWrappedObject->insert(i, ba));
             }
             int  PythonQtWrapper_XByteArray::realAddressNumbers(XByteArray* theWrappedObject)
             {
               return ( theWrappedObject->realAddressNumbers());
             }
             QByteArray*  PythonQtWrapper_XByteArray::remove(XByteArray* theWrappedObject, int  pos, int  len)
             {
               return &( theWrappedObject->remove(pos, len));
             }
             QByteArray*  PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int  index, char  ch)
             {
               return &( theWrappedObject->replace(index, ch));
             }
             QByteArray*  PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int  index, const QByteArray&  ba)
             {
               return &( theWrappedObject->replace(index, ba));
             }
             QByteArray*  PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int  index, int  length, const QByteArray&  ba)
             {
               return &( theWrappedObject->replace(index, length, ba));
             }
             void PythonQtWrapper_XByteArray::setAddressOffset(XByteArray* theWrappedObject, int  offset)
             {
               ( theWrappedObject->setAddressOffset(offset));
             }
             void PythonQtWrapper_XByteArray::setAddressWidth(XByteArray* theWrappedObject, int  width)
             {
               ( theWrappedObject->setAddressWidth(width));
             }
             void PythonQtWrapper_XByteArray::setData(XByteArray* theWrappedObject, QByteArray  data)
             {
               ( theWrappedObject->setData(data));
             }
             void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int  i, bool  state)
             {
               ( theWrappedObject->setDataChanged(i, state));
             }
             void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int  i, const QByteArray&  state)
             {
               ( theWrappedObject->setDataChanged(i, state));
             }
             int  PythonQtWrapper_XByteArray::size(XByteArray* theWrappedObject)
             {
               return ( theWrappedObject->size());
             }
             QString  PythonQtWrapper_XByteArray::toRedableString(XByteArray* theWrappedObject, int  start, int  end)
             {
               return ( theWrappedObject->toRedableString(start, end));
             }
+            elfFileWidget* PythonQtWrapper_elfFileWidget::new_elfFileWidget(QWidget*  parent)
+            {
+            return new elfFileWidget(parent); }
             elfparser* PythonQtWrapper_elfparser::new_elfparser()
             {
             return new elfparser(); }
             int  PythonQtWrapper_elfparser::closeFile(elfparser* theWrappedObject)
             {
               return ( theWrappedObject->closeFile());
             }
+            QString  PythonQtWrapper_elfparser::getABI(elfparser* theWrappedObject)
+            {
+              return ( theWrappedObject->getABI());
+            }
             QString  PythonQtWrapper_elfparser::getArchitecture(elfparser* theWrappedObject)
             {
               return ( theWrappedObject->getArchitecture());
             }
+            QString  PythonQtWrapper_elfparser::getClass(elfparser* theWrappedObject)
+            {
+              return ( theWrappedObject->getClass());
+            }
+            QString  PythonQtWrapper_elfparser::getEndianness(elfparser* theWrappedObject)
+            {
+              return ( theWrappedObject->getEndianness());
+            }
             bool  PythonQtWrapper_elfparser::getSectionData(elfparser* theWrappedObject, int  index, char**  buffer)
             {
               return ( theWrappedObject->getSectionData(index, buffer));
             }
             QString  PythonQtWrapper_elfparser::getSectionName(elfparser* theWrappedObject, int  index)
             {
               return ( theWrappedObject->getSectionName(index));
             }
             QString  PythonQtWrapper_elfparser::getSectionType(elfparser* theWrappedObject, int  index)
             {
               return ( theWrappedObject->getSectionType(index));
             }
             int  PythonQtWrapper_elfparser::getSectioncount(elfparser* theWrappedObject)
             {
               return ( theWrappedObject->getSectioncount());
             }
             QString  PythonQtWrapper_elfparser::getSegmentFlags(elfparser* theWrappedObject, int  index)
             {
               return ( theWrappedObject->getSegmentFlags(index));
             }
             QString  PythonQtWrapper_elfparser::getSegmentType(elfparser* theWrappedObject, int  index)
             {
               return ( theWrappedObject->getSegmentType(index));
             }
             int  PythonQtWrapper_elfparser::getSegmentcount(elfparser* theWrappedObject)
             {
               return ( theWrappedObject->getSegmentcount());
             }
             QString  PythonQtWrapper_elfparser::getType(elfparser* theWrappedObject)
             {
               return ( theWrappedObject->getType());
             }
             bool  PythonQtWrapper_elfparser::static_elfparser_isElf(const QString&  File)
             {
               return (elfparser::isElf(File));
             }
             bool  PythonQtWrapper_elfparser::iself(elfparser* theWrappedObject)
             {
               return ( theWrappedObject->iself());
             }
             bool  PythonQtWrapper_elfparser::isopened(elfparser* theWrappedObject)
             {
               return ( theWrappedObject->isopened());
             }
             int  PythonQtWrapper_elfparser::setFilename(elfparser* theWrappedObject, const QString&  name)
             {
               return ( theWrappedObject->setFilename(name));
             }

src/common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer0.h +33 0

             #include <PythonQt.h>
             #include <QObject>
             #include <QVariant>
             #include <SocExplorerPlot.h>
+            #include <elffile.h>
+            #include <elffilewidget.h>
             #include <elfparser.h>
             #include <memsizewdgt.h>
             #include <qhexedit.h>
             #include <qhexspinbox.h>
             #include <tcp_terminal_client.h>
             #include <xbytearray.h>
+            class PythonQtWrapper_ElfFile : public QObject
+            { Q_OBJECT
+            public:
+            public slots:
+            ElfFile* new_ElfFile(QObject*  parent = 0);
+            ElfFile* new_ElfFile(const QString&  File, QObject*  parent = 0);
+            void delete_ElfFile(ElfFile* obj) { delete obj; }
+               int  closeFile(ElfFile* theWrappedObject);
+               bool  isopened(ElfFile* theWrappedObject);
+               bool  openFile(ElfFile* theWrappedObject, const QString&  File);
+            };
             class PythonQtWrapper_MemSizeWdgt : public QObject
             { Q_OBJECT
             public:
             public slots:
             MemSizeWdgt* new_MemSizeWdgt(QWidget*  parent = 0);
             MemSizeWdgt* new_MemSizeWdgt(int  defaultSize, QWidget*  parent = 0);
             void delete_MemSizeWdgt(MemSizeWdgt* obj) { delete obj; }
                int  getsize(MemSizeWdgt* theWrappedObject);
                void setMaximum(MemSizeWdgt* theWrappedObject, unsigned int  max);
                void show(MemSizeWdgt* theWrappedObject);
                void updateSizeValue(MemSizeWdgt* theWrappedObject);
             };
             class PythonQtShell_QHexEdit : public QHexEdit
             {
             public:
                 PythonQtShell_QHexEdit(QWidget*  parent = 0):QHexEdit(parent),_wrapper(NULL) {};
                ~PythonQtShell_QHexEdit();
               PythonQtInstanceWrapper* _wrapper;
             };
             class PythonQtWrapper_QHexEdit : public QObject
             { Q_OBJECT
             public:
             public slots:
             QHexEdit* new_QHexEdit(QWidget*  parent = 0);
             void delete_QHexEdit(QHexEdit* obj) { delete obj; }
                QColor  addressAreaColor(QHexEdit* theWrappedObject);
                int  addressOffset(QHexEdit* theWrappedObject);
                int  cursorPosition(QHexEdit* theWrappedObject);
                QByteArray  data(QHexEdit* theWrappedObject);
                const QFont*  font(QHexEdit* theWrappedObject) const;
                QColor  highlightingColor(QHexEdit* theWrappedObject);
                int  indexOf(QHexEdit* theWrappedObject, const QByteArray&  ba, int  from = 0) const;
                void insert(QHexEdit* theWrappedObject, int  i, char  ch);
                void insert(QHexEdit* theWrappedObject, int  i, const QByteArray&  ba);
                bool  isReadOnly(QHexEdit* theWrappedObject);
                int  lastIndexOf(QHexEdit* theWrappedObject, const QByteArray&  ba, int  from = 0) const;
                bool  overwriteMode(QHexEdit* theWrappedObject);
                void remove(QHexEdit* theWrappedObject, int  pos, int  len = 1);
                void replace(QHexEdit* theWrappedObject, int  pos, int  len, const QByteArray&  after);
                QColor  selectionColor(QHexEdit* theWrappedObject);
                QString  selectionToReadableString(QHexEdit* theWrappedObject);
                void setAddressAreaColor(QHexEdit* theWrappedObject, const QColor&  color);
                void setAddressOffset(QHexEdit* theWrappedObject, int  offset);
                void setCursorPosition(QHexEdit* theWrappedObject, int  cusorPos);
                void setData(QHexEdit* theWrappedObject, const QByteArray&  data);
                void setFont(QHexEdit* theWrappedObject, const QFont&  arg__1);
                void setHighlightingColor(QHexEdit* theWrappedObject, const QColor&  color);
                void setOverwriteMode(QHexEdit* theWrappedObject, bool  arg__1);
                void setReadOnly(QHexEdit* theWrappedObject, bool  arg__1);
                void setSelectionColor(QHexEdit* theWrappedObject, const QColor&  color);
                QString  toReadableString(QHexEdit* theWrappedObject);
             };
             class PythonQtWrapper_QHexSpinBox : public QObject
             { Q_OBJECT
             public:
             public slots:
             QHexSpinBox* new_QHexSpinBox(QWidget*  parent = 0);
             void delete_QHexSpinBox(QHexSpinBox* obj) { delete obj; }
                void show(QHexSpinBox* theWrappedObject);
                QString  textFromValue(QHexSpinBox* theWrappedObject, int  value) const;
                QValidator::State  validate(QHexSpinBox* theWrappedObject, QString&  input, int&  pos) const;
                int  valueFromText(QHexSpinBox* theWrappedObject, const QString&  text) const;
             };
             class PythonQtShell_SocExplorerPlot : public SocExplorerPlot
             {
             public:
                 PythonQtShell_SocExplorerPlot(QWidget*  parent = 0):SocExplorerPlot(parent),_wrapper(NULL) {};
                ~PythonQtShell_SocExplorerPlot();
               PythonQtInstanceWrapper* _wrapper;
             };
             class PythonQtWrapper_SocExplorerPlot : public QObject
             { Q_OBJECT
             public:
             public slots:
             SocExplorerPlot* new_SocExplorerPlot(QWidget*  parent = 0);
             void delete_SocExplorerPlot(SocExplorerPlot* obj) { delete obj; }
                int  addGraph(SocExplorerPlot* theWrappedObject);
                void addGraphData(SocExplorerPlot* theWrappedObject, int  graphIndex, QList<QVariant >  x, QList<QVariant >  y);
                void addGraphData(SocExplorerPlot* theWrappedObject, int  graphIndex, QVariant  x, QVariant  y);
                QPen  getGraphPen(SocExplorerPlot* theWrappedObject, int  graphIndex);
                void rescaleAxis(SocExplorerPlot* theWrappedObject);
                void setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int  graphIndex, bool  enable);
                void setGraphData(SocExplorerPlot* theWrappedObject, int  graphIndex, QList<QVariant >  x, QList<QVariant >  y);
                void setGraphLineStyle(SocExplorerPlot* theWrappedObject, int  graphIndex, QString  lineStyle);
                void setGraphName(SocExplorerPlot* theWrappedObject, int  graphIndex, QString  name);
                void setGraphPen(SocExplorerPlot* theWrappedObject, int  graphIndex, QPen  pen);
                void setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int  graphIndex, QString  scatterStyle);
                void setLegendFont(SocExplorerPlot* theWrappedObject, QFont  font);
                void setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont  font);
                void setTitle(SocExplorerPlot* theWrappedObject, QString  title);
                void setXaxisLabel(SocExplorerPlot* theWrappedObject, QString  label);
                void setXaxisRange(SocExplorerPlot* theWrappedObject, double  lower, double  upper);
                void setYaxisLabel(SocExplorerPlot* theWrappedObject, QString  label);
                void setYaxisRange(SocExplorerPlot* theWrappedObject, double  lower, double  upper);
                void show(SocExplorerPlot* theWrappedObject);
             };
             class PythonQtWrapper_TCP_Terminal_Client : public QObject
             { Q_OBJECT
             public:
             public slots:
             TCP_Terminal_Client* new_TCP_Terminal_Client(QObject*  parent = 0);
             void delete_TCP_Terminal_Client(TCP_Terminal_Client* obj) { delete obj; }
                void connectToServer(TCP_Terminal_Client* theWrappedObject);
                void connectToServer(TCP_Terminal_Client* theWrappedObject, const QString&  IP, int  port);
                bool  isConnected(TCP_Terminal_Client* theWrappedObject);
                void sendText(TCP_Terminal_Client* theWrappedObject, const QString&  text);
                void startServer(TCP_Terminal_Client* theWrappedObject);
                void startServer(TCP_Terminal_Client* theWrappedObject, int  port);
             };
             class PythonQtWrapper_XByteArray : public QObject
             { Q_OBJECT
             public:
             public slots:
             XByteArray* new_XByteArray();
             void delete_XByteArray(XByteArray* obj) { delete obj; }
                int  addressOffset(XByteArray* theWrappedObject);
                int  addressWidth(XByteArray* theWrappedObject);
                QChar  asciiChar(XByteArray* theWrappedObject, int  index);
                QByteArray*  data(XByteArray* theWrappedObject);
                bool  dataChanged(XByteArray* theWrappedObject, int  i);
                QByteArray  dataChanged(XByteArray* theWrappedObject, int  i, int  len);
                QByteArray*  insert(XByteArray* theWrappedObject, int  i, char  ch);
                QByteArray*  insert(XByteArray* theWrappedObject, int  i, const QByteArray&  ba);
                int  realAddressNumbers(XByteArray* theWrappedObject);
                QByteArray*  remove(XByteArray* theWrappedObject, int  pos, int  len);
                QByteArray*  replace(XByteArray* theWrappedObject, int  index, char  ch);
                QByteArray*  replace(XByteArray* theWrappedObject, int  index, const QByteArray&  ba);
                QByteArray*  replace(XByteArray* theWrappedObject, int  index, int  length, const QByteArray&  ba);
                void setAddressOffset(XByteArray* theWrappedObject, int  offset);
                void setAddressWidth(XByteArray* theWrappedObject, int  width);
                void setData(XByteArray* theWrappedObject, QByteArray  data);
                void setDataChanged(XByteArray* theWrappedObject, int  i, bool  state);
                void setDataChanged(XByteArray* theWrappedObject, int  i, const QByteArray&  state);
                int  size(XByteArray* theWrappedObject);
                QString  toRedableString(XByteArray* theWrappedObject, int  start = 0, int  end = -1);
             };
+            class PythonQtWrapper_elfFileWidget : public QObject
+            { Q_OBJECT
+            public:
+            public slots:
+            elfFileWidget* new_elfFileWidget(QWidget*  parent = 0);
+            void delete_elfFileWidget(elfFileWidget* obj) { delete obj; }
+            };
             class PythonQtWrapper_elfparser : public QObject
             { Q_OBJECT
             public:
             public slots:
             elfparser* new_elfparser();
             void delete_elfparser(elfparser* obj) { delete obj; }
                int  closeFile(elfparser* theWrappedObject);
+               QString  getABI(elfparser* theWrappedObject);
                QString  getArchitecture(elfparser* theWrappedObject);
+               QString  getClass(elfparser* theWrappedObject);
+               QString  getEndianness(elfparser* theWrappedObject);
                bool  getSectionData(elfparser* theWrappedObject, int  index, char**  buffer);
                QString  getSectionName(elfparser* theWrappedObject, int  index);
                QString  getSectionType(elfparser* theWrappedObject, int  index);
                int  getSectioncount(elfparser* theWrappedObject);
                QString  getSegmentFlags(elfparser* theWrappedObject, int  index);
                QString  getSegmentType(elfparser* theWrappedObject, int  index);
                int  getSegmentcount(elfparser* theWrappedObject);
                QString  getType(elfparser* theWrappedObject);
                bool  static_elfparser_isElf(const QString&  File);
                bool  iself(elfparser* theWrappedObject);
                bool  isopened(elfparser* theWrappedObject);
                int  setFilename(elfparser* theWrappedObject, const QString&  name);
             };

src/common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer_init.cpp +2 0

             #include <PythonQt.h>
             #include "PySocExplorer0.h"
             void PythonQt_init_PySocExplorer(PyObject* module) {
+            PythonQt::priv()->registerClass(&ElfFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_ElfFile>, NULL, module, 0);
             PythonQt::priv()->registerCPPClass("MemSizeWdgt", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_MemSizeWdgt>, NULL, module, 0);
             PythonQt::priv()->registerCPPClass("QHexEdit", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_QHexEdit>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QHexEdit>, module, 0);
             PythonQt::priv()->registerCPPClass("QHexSpinBox", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_QHexSpinBox>, NULL, module, 0);
             PythonQt::priv()->registerCPPClass("SocExplorerPlot", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_SocExplorerPlot>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_SocExplorerPlot>, module, 0);
             PythonQt::priv()->registerClass(&TCP_Terminal_Client::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_TCP_Terminal_Client>, NULL, module, 0);
             PythonQt::priv()->registerCPPClass("XByteArray", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_XByteArray>, NULL, module, 0);
+            PythonQt::priv()->registerCPPClass("elfFileWidget", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfFileWidget>, NULL, module, 0);
             PythonQt::priv()->registerCPPClass("elfparser", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfparser>, NULL, module, 0);
             }

src/common/pythonQtgeneratorCfg.txt +7 -3

             <typesystem package="PySocExplorer" default-superclass="com.trolltech.qt.QtJambiObject">
-                <load-typesystem name=":/trolltech/generator/typesystem_core.txt" generate="no" />
+                <load-typesystem name=":/trolltech/generator/typesystem_core.txt" generate="yes" />
-                <load-typesystem name=":/trolltech/generator/typesystem_gui.txt" generate="no" />
+                <load-typesystem name=":/trolltech/generator/typesystem_gui.txt" generate="yes" />
                 <load-typesystem name=":/trolltech/generator/typesystem_sql.txt" generate="no" />
                 <load-typesystem name=":/trolltech/generator/typesystem_opengl.txt" generate="no" />
                 <load-typesystem name=":/trolltech/generator/typesystem_svg.txt" generate="no" />
                 <load-typesystem name=":/trolltech/generator/typesystem_network.txt" generate="no" />
                 <load-typesystem name=":/trolltech/generator/typesystem_xml.txt" generate="no" />
                 <load-typesystem name=":/trolltech/generator/typesystem_xmlpatterns.txt" generate="no" />
                 <load-typesystem name=":/trolltech/generator/typesystem_webkit.txt" generate="no" />
                 <load-typesystem name=":/trolltech/generator/typesystem_phonon.txt" generate="no" />
+                <rejection class="abstractExecFile" />
                 <object-type name="QHexSpinBox" />
                 <object-type name="MemSizeWdgt" />
                 <object-type name="QHexEdit" />
                 <object-type name="XByteArray" />
                 <object-type name="SocExplorerPlot" />
                 <object-type name="TCP_Terminal_Client" />
                 <object-type name="elfparser" />
+                <object-type name="abstractExecFile" />
+                <object-type name="ElfFile" />
+                <object-type name="elfFileWidget" />
             </typesystem>

src/common/pythongenerator.sh +1 -1

             #!/bin/bash
             #export QTDIR=/usr/include
             export QTDIR=/usr/include/qt5
-            pythonqt_generator --output-directory=pythonQtOut PySocExplorer.h pythonQtgeneratorCfg.txt
+            pythonqt_generator --dump-object-tree --output-directory=pythonQtOut PySocExplorer.h pythonQtgeneratorCfg.txt

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