summaryrefslogtreecommitdiff
path: root/plugins/pychrysalide/format
diff options
context:
space:
mode:
authorCyrille Bagard <nocbos@gmail.com>2018-01-16 19:02:56 (GMT)
committerCyrille Bagard <nocbos@gmail.com>2018-01-16 19:02:56 (GMT)
commit9da8f8b37e3edebc917b4e223dd2447cd7cbc818 (patch)
tree3f330b13e7ca2a0a163882be3043ca9571f25211 /plugins/pychrysalide/format
parenteb9b7fd76451db5c9f07a800c0394480e4b88c9c (diff)
Changed the Python bindings source directory and updated code.
Diffstat (limited to 'plugins/pychrysalide/format')
-rw-r--r--plugins/pychrysalide/format/Makefile.am21
-rw-r--r--plugins/pychrysalide/format/executable.c215
-rw-r--r--plugins/pychrysalide/format/executable.h42
-rw-r--r--plugins/pychrysalide/format/format.c680
-rw-r--r--plugins/pychrysalide/format/format.h56
-rw-r--r--plugins/pychrysalide/format/module.c99
-rw-r--r--plugins/pychrysalide/format/module.h39
-rw-r--r--plugins/pychrysalide/format/symbol.c446
-rw-r--r--plugins/pychrysalide/format/symbol.h42
-rw-r--r--plugins/pychrysalide/format/symiter.c276
-rw-r--r--plugins/pychrysalide/format/symiter.h42
11 files changed, 1958 insertions, 0 deletions
diff --git a/plugins/pychrysalide/format/Makefile.am b/plugins/pychrysalide/format/Makefile.am
new file mode 100644
index 0000000..325206c
--- /dev/null
+++ b/plugins/pychrysalide/format/Makefile.am
@@ -0,0 +1,21 @@
+
+noinst_LTLIBRARIES = libpychrysaformat.la
+
+libpychrysaformat_la_SOURCES = \
+ executable.h executable.c \
+ format.h format.c \
+ module.h module.c \
+ symbol.h symbol.c \
+ symiter.h symiter.c
+
+libpychrysaformat_la_LIBADD =
+
+libpychrysaformat_la_LDFLAGS =
+
+
+AM_CPPFLAGS = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS) $(LIBPYTHON_CFLAGS) $(LIBPYGOBJECT_CFLAGS) \
+ -I../../../src
+
+AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS)
+
+SUBDIRS =
diff --git a/plugins/pychrysalide/format/executable.c b/plugins/pychrysalide/format/executable.c
new file mode 100644
index 0000000..1b1bfe8
--- /dev/null
+++ b/plugins/pychrysalide/format/executable.c
@@ -0,0 +1,215 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * executable.c - équivalent Python du fichier "format/executable.h"
+ *
+ * Copyright (C) 2012-2017 Cyrille Bagard
+ *
+ * This file is part of Chrysalide.
+ *
+ * Chrysalide 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.
+ *
+ * Chrysalide 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
+ */
+
+
+#include "executable.h"
+
+
+#include <pygobject.h>
+
+
+#include <format/format.h>
+
+
+#include "format.h"
+#include "../helpers.h"
+#include "../arch/vmpa.h"
+
+
+
+/* Fournit l'emplacement correspondant à une position physique. */
+static PyObject *py_exe_format_translate_offset_into_vmpa(PyObject *, PyObject *);
+
+/* Fournit l'emplacement correspondant à une adresse virtuelle. */
+static PyObject *py_exe_format_translate_address_into_vmpa(PyObject *, PyObject *);
+
+
+
+/******************************************************************************
+* *
+* Paramètres : self = description de l'exécutable à consulter. *
+* args = arguments accompagnant l'appel. *
+* *
+* Description : Fournit l'emplacement correspondant à une position physique. *
+* *
+* Retour : Position correspondante ou None. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_exe_format_translate_offset_into_vmpa(PyObject *self, PyObject *args)
+{
+ PyObject *result; /* Instance à retourner */
+ GExeFormat *format; /* Version GLib du format */
+ unsigned long long off; /* Adresse en mémoire virtuelle*/
+ int ret; /* Bilan de lecture des args. */
+ vmpa2t pos; /* Position complète déterminée*/
+ bool status; /* Bilan de l'opération */
+
+ format = G_EXE_FORMAT(pygobject_get(self));
+ assert(format != NULL);
+
+ ret = PyArg_ParseTuple(args, "K", &off);
+ if (!ret) return NULL;
+
+ status = g_exe_format_translate_offset_into_vmpa(format, off, &pos);
+
+ if (status)
+ result = build_from_internal_vmpa(&pos);
+
+ else
+ {
+ result = Py_None;
+ Py_INCREF(result);
+ }
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = description de l'exécutable à consulter. *
+* args = arguments accompagnant l'appel. *
+* *
+* Description : Fournit l'emplacement correspondant à une adresse virtuelle. *
+* *
+* Retour : Position correspondante ou None. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_exe_format_translate_address_into_vmpa(PyObject *self, PyObject *args)
+{
+ PyObject *result; /* Instance à retourner */
+ GExeFormat *format; /* Version GLib du format */
+ unsigned long long addr; /* Adresse en mémoire virtuelle*/
+ int ret; /* Bilan de lecture des args. */
+ vmpa2t pos; /* Position complète déterminée*/
+ bool status; /* Bilan de l'opération */
+
+ format = G_EXE_FORMAT(pygobject_get(self));
+ assert(format != NULL);
+
+ ret = PyArg_ParseTuple(args, "K", &addr);
+ if (!ret) return NULL;
+
+ status = g_exe_format_translate_address_into_vmpa(format, addr, &pos);
+
+ if (status)
+ result = build_from_internal_vmpa(&pos);
+
+ else
+ {
+ result = Py_None;
+ Py_INCREF(result);
+ }
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : - *
+* *
+* Description : Fournit un accès à une définition de type à diffuser. *
+* *
+* Retour : Définition d'objet pour Python. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+PyTypeObject *get_python_executable_format_type(void)
+{
+ static PyMethodDef py_exe_format_methods[] = {
+ {
+ "translate_offset_into_vmpa", py_exe_format_translate_offset_into_vmpa,
+ METH_VARARGS,
+ "translate_offset_into_vmpa($self, off, /)\n--\n\nTranslate a physical offset to a full location.."
+ },
+ {
+ "translate_address_into_vmpa", py_exe_format_translate_address_into_vmpa,
+ METH_VARARGS,
+ "translate_address_into_vmpa($self, addr, /)\n--\n\nTranslate a physical offset to a full location.."
+ },
+ { NULL }
+ };
+
+ static PyGetSetDef py_exe_format_getseters[] = {
+ { NULL }
+ };
+
+ static PyTypeObject py_exe_format_type = {
+
+ PyVarObject_HEAD_INIT(NULL, 0)
+
+ .tp_name = "pychrysalide.format.ExeFormat",
+ .tp_basicsize = sizeof(PyGObject),
+
+ .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+
+ .tp_doc = "PyChrysalide executable format",
+
+ .tp_methods = py_exe_format_methods,
+ .tp_getset = py_exe_format_getseters,
+
+ };
+
+ return &py_exe_format_type;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : module = module dont la définition est à compléter. *
+* *
+* Description : Prend en charge l'objet 'pychrysalide.format.ExeFormat'. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool register_python_executable_format(PyObject *module)
+{
+ PyTypeObject *py_exe_format_type; /* Type Python 'ExeFormat' */
+ PyObject *dict; /* Dictionnaire du module */
+
+ py_exe_format_type = get_python_executable_format_type();
+
+ dict = PyModule_GetDict(module);
+
+ if (!register_class_for_pygobject(dict, G_TYPE_EXE_FORMAT, py_exe_format_type, get_python_binary_format_type()))
+ return false;
+
+ return true;
+
+}
diff --git a/plugins/pychrysalide/format/executable.h b/plugins/pychrysalide/format/executable.h
new file mode 100644
index 0000000..2157b93
--- /dev/null
+++ b/plugins/pychrysalide/format/executable.h
@@ -0,0 +1,42 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * executable.h - prototypes pour l'équivalent Python du fichier "format/executable.h"
+ *
+ * Copyright (C) 2012-2017 Cyrille Bagard
+ *
+ * This file is part of Chrysalide.
+ *
+ * Chrysalide 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.
+ *
+ * Chrysalide 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
+ */
+
+
+#ifndef _PLUGINS_PYCHRYSALIDE_FORMAT_EXECUTABLE_H
+#define _PLUGINS_PYCHRYSALIDE_FORMAT_EXECUTABLE_H
+
+
+#include <Python.h>
+#include <stdbool.h>
+
+
+
+/* Fournit un accès à une définition de type à diffuser. */
+PyTypeObject *get_python_executable_format_type(void);
+
+/* Prend en charge l'objet 'pychrysalide.format.ExeFormat'. */
+bool register_python_executable_format(PyObject *);
+
+
+
+#endif /* _PLUGINS_PYCHRYSALIDE_FORMAT_EXECUTABLE_H */
diff --git a/plugins/pychrysalide/format/format.c b/plugins/pychrysalide/format/format.c
new file mode 100644
index 0000000..3bfc705
--- /dev/null
+++ b/plugins/pychrysalide/format/format.c
@@ -0,0 +1,680 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * format.c - équivalent Python du fichier "format/format.c"
+ *
+ * Copyright (C) 2012-2017 Cyrille Bagard
+ *
+ * This file is part of Chrysalide.
+ *
+ * Chrysalide 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.
+ *
+ * Chrysalide 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
+ */
+
+
+#include "format.h"
+
+
+#include <pygobject.h>
+
+
+#include <format/format.h>
+
+
+#include "symbol.h"
+#include "symiter.h"
+#include "../helpers.h"
+#include "../arch/vmpa.h"
+
+
+
+/* ---------------------------- FORMAT BINAIRE GENERIQUE ---------------------------- */
+
+
+
+/* Ajoute un symbole à la collection du format binaire. */
+static PyObject *py_binary_format_add_symbol(PyObject *, PyObject *);
+
+/* Retire un symbole de la collection du format binaire. */
+static PyObject *py_binary_format_remove_symbol(PyObject *, PyObject *);
+
+/* Recherche le symbole correspondant à une étiquette. */
+static PyObject *py_binary_format_find_symbol_by_label(PyObject *, PyObject *);
+
+/* Recherche le symbole suivant celui lié à une adresse. */
+static PyObject *py_binary_format_find_symbol_at(PyObject *, PyObject *);
+
+/* Recherche le symbole suivant celui lié à une adresse. */
+static PyObject *py_binary_format_find_next_symbol_at(PyObject *, PyObject *);
+
+/* Recherche le symbole correspondant à une adresse. */
+static PyObject *py_binary_format_resolve_symbol(PyObject *, PyObject *);
+
+/* Fournit une référence vers le contenu binaire analysé. */
+static PyObject *py_binary_format_get_content(PyObject *, void *);
+
+/* Fournit la liste de tous les symboles détectés. */
+static PyObject *py_binary_format_get_symbols(PyObject *, void *);
+
+
+
+/* ------------------ CONSERVATION DES SOUCIS DURANT LE CHARGEMENT ------------------ */
+
+
+/* Etend la liste des soucis détectés avec de nouvelles infos. */
+static PyObject *py_binary_format_add_error(PyObject *, PyObject *);
+
+/* Fournit les éléments concernant tous les soucis détectés. */
+static PyObject *py_binary_format_get_errors(PyObject *, void *);
+
+
+
+
+
+
+/* Définit les constantes pour les types d'erreurs. */
+static bool define_python_binary_format_constants(PyTypeObject *);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* FORMAT BINAIRE GENERIQUE */
+/* ---------------------------------------------------------------------------------- */
+
+
+
+
+
+/******************************************************************************
+* *
+* Paramètres : self = classe représentant un format. *
+* args = arguments fournis à l'appel. *
+* *
+* Description : Ajoute un symbole à la collection du format binaire. *
+* *
+* Retour : True si le symbole était bien localisé et a été inséré. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_binary_format_add_symbol(PyObject *self, PyObject *args)
+{
+ PyObject *result; /* Valeur à retourner */
+ PyObject *symbol_obj; /* Version Python d'un symbole */
+ int ret; /* Bilan de lecture des args. */
+ GBinFormat *format; /* Format de binaire manipulé */
+ GBinSymbol *symbol; /* Enventuel symbole trouvé */
+ bool added; /* Bilan de l'appel interne */
+
+ ret = PyArg_ParseTuple(args, "O!", get_python_binary_symbol_type(), &symbol_obj);
+ if (!ret) return NULL;
+
+ format = G_BIN_FORMAT(pygobject_get(self));
+ symbol = G_BIN_SYMBOL(pygobject_get(symbol_obj));
+
+ added = g_binary_format_add_symbol(format, symbol);
+
+ result = added ? Py_True : Py_False;
+ Py_INCREF(result);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = classe représentant un format. *
+* args = arguments fournis à l'appel. *
+* *
+* Description : Retire un symbole de la collection du format binaire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_binary_format_remove_symbol(PyObject *self, PyObject *args)
+{
+ PyObject *result; /* Valeur à retourner */
+ PyObject *symbol_obj; /* Version Python d'un symbole */
+ int ret; /* Bilan de lecture des args. */
+ GBinFormat *format; /* Format de binaire manipulé */
+ GBinSymbol *symbol; /* Enventuel symbole trouvé */
+
+ ret = PyArg_ParseTuple(args, "O!", get_python_binary_symbol_type(), &symbol_obj);
+ if (!ret) return NULL;
+
+ format = G_BIN_FORMAT(pygobject_get(self));
+ symbol = G_BIN_SYMBOL(pygobject_get(symbol_obj));
+
+ g_binary_format_remove_symbol(format, symbol);
+
+ result = Py_None;
+ Py_INCREF(result);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = classe représentant un binaire. *
+* args = arguments fournis à l'appel. *
+* *
+* Description : Recherche le symbole correspondant à une étiquette. *
+* *
+* Retour : Symbol trouvé si l'opération a été un succès, None sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_binary_format_find_symbol_by_label(PyObject *self, PyObject *args)
+{
+ PyObject *result; /* Valeur à retourner */
+ PyObject *label; /* Etiquette à retrouver */
+ int ret; /* Bilan de lecture des args. */
+ GBinFormat *format; /* Format de binaire manipulé */
+ GBinSymbol *symbol; /* Enventuel symbole trouvé */
+ bool found; /* Bilan de la recherche */
+
+ ret = PyArg_ParseTuple(args, "O", &label);
+ if (!ret) return NULL;
+
+ ret = PyUnicode_Check(label);
+ if (!ret) return NULL;
+
+ format = G_BIN_FORMAT(pygobject_get(self));
+
+ found = g_binary_format_find_symbol_by_label(format, PyUnicode_DATA(label), &symbol);
+
+ if (found)
+ result = pygobject_new(G_OBJECT(symbol));
+ else
+ {
+ result = Py_None;
+ Py_INCREF(result);
+ }
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = classe représentant un binaire. *
+* args = arguments fournis à l'appel. *
+* *
+* Description : Recherche le symbole suivant celui lié à une adresse. *
+* *
+* Retour : Symbol trouvé si l'opération a été un succès, None sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_binary_format_find_symbol_at(PyObject *self, PyObject *args)
+{
+ PyObject *result; /* Valeur à retourner */
+ PyObject *py_vmpa; /* Localisation version Python */
+ int ret; /* Bilan de lecture des args. */
+ GBinFormat *format; /* Format de binaire manipulé */
+ GBinSymbol *symbol; /* Enventuel symbole trouvé */
+ bool found; /* Bilan de la recherche */
+
+ ret = PyArg_ParseTuple(args, "O", &py_vmpa);
+ if (!ret) return NULL;
+
+ ret = PyObject_IsInstance(py_vmpa, (PyObject *)get_python_vmpa_type());
+ if (!ret) return NULL;
+
+ format = G_BIN_FORMAT(pygobject_get(self));
+
+ found = g_binary_format_find_symbol_at(format, get_internal_vmpa(py_vmpa), &symbol);
+
+ if (found)
+ {
+ result = pygobject_new(G_OBJECT(symbol));
+ g_object_unref(G_OBJECT(symbol));
+ }
+ else
+ {
+ result = Py_None;
+ Py_INCREF(result);
+ }
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = classe représentant un binaire. *
+* args = arguments fournis à l'appel. *
+* *
+* Description : Recherche le symbole suivant celui lié à une adresse. *
+* *
+* Retour : Symbol trouvé si l'opération a été un succès, None sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_binary_format_find_next_symbol_at(PyObject *self, PyObject *args)
+{
+ PyObject *result; /* Valeur à retourner */
+ PyObject *py_vmpa; /* Localisation version Python */
+ int ret; /* Bilan de lecture des args. */
+ GBinFormat *format; /* Format de binaire manipulé */
+ GBinSymbol *symbol; /* Enventuel symbole trouvé */
+ bool found; /* Bilan de la recherche */
+
+ ret = PyArg_ParseTuple(args, "O", &py_vmpa);
+ if (!ret) return NULL;
+
+ ret = PyObject_IsInstance(py_vmpa, (PyObject *)get_python_vmpa_type());
+ if (!ret) return NULL;
+
+ format = G_BIN_FORMAT(pygobject_get(self));
+
+ found = g_binary_format_find_next_symbol_at(format, get_internal_vmpa(py_vmpa), &symbol);
+
+ if (found)
+ {
+ result = pygobject_new(G_OBJECT(symbol));
+ g_object_unref(G_OBJECT(symbol));
+ }
+ else
+ {
+ result = Py_None;
+ Py_INCREF(result);
+ }
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = classe représentant un format binaire. *
+* args = arguments fournis à l'appel. *
+* *
+* Description : Recherche le symbole correspondant à une adresse. *
+* *
+* Retour : Tuple (nom, décallage) ou Py_None. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_binary_format_resolve_symbol(PyObject *self, PyObject *args)
+{
+ PyObject *result; /* Valeur à retourner */
+ PyObject *py_vmpa; /* Localisation version Python */
+ int strict; /* Tolérance acceptée */
+ int ret; /* Bilan de lecture des args. */
+ GBinFormat *format; /* Format de binaire manipulé */
+ GBinSymbol *symbol; /* Enventuel symbole trouvé */
+ phys_t diff; /* Décallage éventuel mesuré */
+ bool found; /* Bilan de la recherche */
+
+ ret = PyArg_ParseTuple(args, "Op", &py_vmpa, &strict);
+ if (!ret) return NULL;
+
+ ret = PyObject_IsInstance(py_vmpa, (PyObject *)get_python_vmpa_type());
+ if (!ret) return NULL;
+
+ format = G_BIN_FORMAT(pygobject_get(self));
+
+ found = g_binary_format_resolve_symbol(format, get_internal_vmpa(py_vmpa), strict, &symbol, &diff);
+
+ if (found)
+ {
+ result = PyTuple_New(2);
+ PyTuple_SetItem(result, 0, pygobject_new(G_OBJECT(symbol)));
+ PyTuple_SetItem(result, 1, PyLong_FromUnsignedLongLong(diff));
+
+ g_object_unref(G_OBJECT(symbol));
+
+ }
+ else
+ {
+ result = Py_None;
+ Py_INCREF(result);
+ }
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = objet Python concerné par l'appel. *
+* closure = non utilisé ici. *
+* *
+* Description : Fournit une référence vers le contenu binaire analysé. *
+* *
+* Retour : Gestionnaire de contenu binaire en place. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_binary_format_get_content(PyObject *self, void *closure)
+{
+ PyObject *result; /* Trouvailles à retourner */
+ GBinFormat *format; /* Format de binaire manipulé */
+ GBinContent *content; /* Instance GLib correspondante*/
+
+ format = G_BIN_FORMAT(pygobject_get(self));
+
+ content = g_binary_format_get_content(format);
+
+ result = pygobject_new(G_OBJECT(content));
+
+ g_object_unref(content);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = classe représentant un format binaire. *
+* closure = adresse non utilisée ici. *
+* *
+* Description : Fournit la liste de tous les symboles détectés. *
+* *
+* Retour : Tableau créé ou NULL si aucun symbole trouvé. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_binary_format_get_symbols(PyObject *self, void *closure)
+{
+ PyObject *result; /* Instance Python à retourner */
+ PyTypeObject *iterator_type; /* Type Python de l'itérateur */
+ PyObject *args; /* Liste des arguments d'appel */
+
+ iterator_type = get_python_sym_iterator_type();
+
+ args = Py_BuildValue("On", self, 0);
+
+ result = PyObject_CallObject((PyObject *)iterator_type, args);
+
+ Py_DECREF(args);
+
+ return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* CONSERVATION DES SOUCIS DURANT LE CHARGEMENT */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+* *
+* Paramètres : self = architecture concernée par la procédure. *
+* args = instruction représentant le point de départ. *
+* *
+* Description : Etend la liste des soucis détectés avec de nouvelles infos. *
+* *
+* Retour : None. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_binary_format_add_error(PyObject *self, PyObject *args)
+{
+ BinaryFormatError type; /* Type d'erreur détectée */
+ vmpa2t addr; /* Position d'une erreur */
+ const char *desc; /* Description d'une erreur */
+ int ret; /* Bilan de lecture des args. */
+ GBinFormat *format; /* Format binaire manipulé */
+
+ ret = PyArg_ParseTuple(args, "IO&s", &type, convert_any_to_vmpa, &addr, &desc);
+ if (!ret) return NULL;
+
+ format = G_BIN_FORMAT(pygobject_get(self));
+
+ g_binary_format_add_error(format, type, &addr, desc);
+
+ Py_RETURN_NONE;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = objet Python concerné par l'appel. *
+* closure = non utilisé ici. *
+* *
+* Description : Fournit les éléments concernant tous les soucis détectés. *
+* *
+* Retour : Liste des erreurs relevées au niveau de l'assembleur. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_binary_format_get_errors(PyObject *self, void *closure)
+{
+ PyObject *result; /* Instance Python à retourner */
+ GBinFormat *format; /* Format binaire manipulé */
+ size_t count; /* Nombre d'éléments à traiter */
+ size_t i; /* Boucle de parcours */
+#ifndef NDEBUG
+ bool status; /* Bilan d'un appel */
+#endif
+ BinaryFormatError type; /* Type d'erreur détectée */
+ vmpa2t addr; /* Position d'une erreur */
+ char *desc; /* Description d'une erreur */
+ PyObject *error; /* Nouvelle erreur à rajouter */
+
+ format = G_BIN_FORMAT(pygobject_get(self));
+
+ g_binary_format_lock_errors(format);
+
+ count = g_binary_format_count_errors(format);
+
+ result = PyTuple_New(count);
+
+ for (i = 0; i < count; i++)
+ {
+#ifndef NDEBUG
+ status = g_binary_format_get_error(format, i, &type, &addr, &desc);
+ assert(status);
+#else
+ g_binary_format_get_error(format, i, &type, &addr, &desc);
+#endif
+
+ error = Py_BuildValue("IO&s", type, build_from_internal_vmpa, &addr, desc);
+
+ PyTuple_SetItem(result, i, error);
+
+ }
+
+ g_binary_format_unlock_errors(format);
+
+ return result;
+
+}
+
+
+
+
+
+
+
+/******************************************************************************
+* *
+* Paramètres : obj_type = type dont le dictionnaire est à compléter. *
+* *
+* Description : Définit les constantes pour les types d'erreurs. *
+* *
+* Retour : true en cas de succès de l'opération, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool define_python_binary_format_constants(PyTypeObject *obj_type)
+{
+ bool result; /* Bilan à retourner */
+
+ result = true;
+
+ result &= PyDict_AddIntMacro(obj_type, BFE_SPECIFICATION);
+ result &= PyDict_AddIntMacro(obj_type, BFE_STRUCTURE);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : - *
+* *
+* Description : Fournit un accès à une définition de type à diffuser. *
+* *
+* Retour : Définition d'objet pour Python. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+PyTypeObject *get_python_binary_format_type(void)
+{
+ static PyMethodDef py_bin_format_methods[] = {
+ {
+ "add_symbol", py_binary_format_add_symbol,
+ METH_VARARGS,
+ "add_symbol($self, symbol, /)\n--\n\nRegister a new symbol for the format."
+ },
+ {
+ "remove_symbol", py_binary_format_remove_symbol,
+ METH_VARARGS,
+ "remove_symbol($self, symbol, /)\n--\n\nUnregister a symbol from the format."
+ },
+ {
+ "find_symbol_by_label", py_binary_format_find_symbol_by_label,
+ METH_VARARGS,
+ "find_symbol_by_label($self, label, /)\n--\n\nFind a symbol by its label."
+ },
+ {
+ "find_symbol_at", py_binary_format_find_symbol_at,
+ METH_VARARGS,
+ "find_symbol_at($self, addr, /)\n--\n\nFind a symbol at a given address."
+ },
+ {
+ "find_next_symbol_at", py_binary_format_find_next_symbol_at,
+ METH_VARARGS,
+ "find_next_symbol_at($self, addr, /)\n--\n\nFind the symbol next to the one found at a given address."
+ },
+ {
+ "resolve_symbol", py_binary_format_resolve_symbol,
+ METH_VARARGS,
+ "resolve_symbol($self, addr, strict, /)\n--\n\nSearch a position inside a routine by a given address."
+ },
+ {
+ "add_error", py_binary_format_add_error,
+ METH_VARARGS,
+ "add_error($self, type, addr, desc, /)\n--\n\nExtend the list of detected disassembling errors."
+ },
+ { NULL }
+ };
+
+ static PyGetSetDef py_bin_format_getseters[] = {
+ {
+ "content", py_binary_format_get_content, NULL,
+ "Content of the binary format.", NULL
+ },
+ {
+ "symbols", py_binary_format_get_symbols, NULL,
+ "Iterable list of all symbols found in the binary format.", NULL
+ },
+ {
+ "errors", py_binary_format_get_errors, NULL,
+ "List of all detected errors which occurred while loading the binary.", NULL
+ },
+ { NULL }
+ };
+
+ static PyTypeObject py_bin_format_type = {
+
+ PyVarObject_HEAD_INIT(NULL, 0)
+
+ .tp_name = "pychrysalide.format.BinFormat",
+ .tp_basicsize = sizeof(PyGObject),
+
+ .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_BASETYPE,
+
+ .tp_doc = "PyChrysalide binary format",
+
+ .tp_methods = py_bin_format_methods,
+ .tp_getset = py_bin_format_getseters
+
+ };
+
+ return &py_bin_format_type;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : module = module dont la définition est à compléter. *
+* *
+* Description : Prend en charge l'objet 'pychrysalide.format.BinFormat'. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool register_python_binary_format(PyObject *module)
+{
+ PyTypeObject *py_bin_format_type; /* Type Python 'BinFormat' */
+ PyObject *dict; /* Dictionnaire du module */
+
+ py_bin_format_type = get_python_binary_format_type();
+
+ APPLY_ABSTRACT_FLAG(py_bin_format_type);
+
+ dict = PyModule_GetDict(module);
+
+ if (!register_class_for_pygobject(dict, G_TYPE_BIN_FORMAT, py_bin_format_type, &PyGObject_Type))
+ return false;
+
+ if (!define_python_binary_format_constants(py_bin_format_type))
+ return false;
+
+ return true;
+
+}
diff --git a/plugins/pychrysalide/format/format.h b/plugins/pychrysalide/format/format.h
new file mode 100644
index 0000000..a8dfbf0
--- /dev/null
+++ b/plugins/pychrysalide/format/format.h
@@ -0,0 +1,56 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * format.h - prototypes pour l'équivalent Python du fichier "format/format.h"
+ *
+ * Copyright (C) 2012-2017 Cyrille Bagard
+ *
+ * This file is part of Chrysalide.
+ *
+ * Chrysalide 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.
+ *
+ * Chrysalide 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
+ */
+
+
+#ifndef _PLUGINS_PYCHRYSALIDE_FORMAT_FORMAT_H
+#define _PLUGINS_PYCHRYSALIDE_FORMAT_FORMAT_H
+
+
+#include <Python.h>
+#include <stdbool.h>
+
+
+
+/* ------------------------ PARCOURS DE SYMBOLES DE BINAIRES ------------------------ */
+
+
+/* Fournit un accès à une définition de type à diffuser. */
+PyTypeObject *get_python_binary_symbol_iterator_type(void);
+
+/* Prend en charge l'objet 'pychrysalide...BinSymbolIterator'. */
+bool register_python_binary_symbol_iterator(PyObject *);
+
+
+
+/* ---------------------------- FORMAT BINAIRE GENERIQUE ---------------------------- */
+
+
+/* Fournit un accès à une définition de type à diffuser. */
+PyTypeObject *get_python_binary_format_type(void);
+
+/* Prend en charge l'objet 'pychrysalide.format.BinFormat'. */
+bool register_python_binary_format(PyObject *);
+
+
+
+#endif /* _PLUGINS_PYCHRYSALIDE_FORMAT_FORMAT_H */
diff --git a/plugins/pychrysalide/format/module.c b/plugins/pychrysalide/format/module.c
new file mode 100644
index 0000000..1daeb3f
--- /dev/null
+++ b/plugins/pychrysalide/format/module.c
@@ -0,0 +1,99 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * module.c - intégration du répertoire format en tant que module
+ *
+ * Copyright (C) 2012-2017 Cyrille Bagard
+ *
+ * This file is part of Chrysalide.
+ *
+ * Chrysalide 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.
+ *
+ * Chrysalide 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
+ */
+
+
+#include "module.h"
+
+
+#include <assert.h>
+
+
+#include "executable.h"
+#include "format.h"
+#include "symbol.h"
+#include "symiter.h"
+#include "../access.h"
+
+
+
+/******************************************************************************
+* *
+* Paramètres : module = module dont la définition est à compléter. *
+* *
+* Description : Ajoute le module 'format' au module Python. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool add_format_module_to_python_module(PyObject *super)
+{
+ bool result; /* Bilan à retourner */
+ PyObject *module; /* Sous-module mis en place */
+ int ret; /* Bilan d'un appel */
+
+ static PyModuleDef py_chrysalide_format_module = {
+
+ .m_base = PyModuleDef_HEAD_INIT,
+
+ .m_name = "pychrysalide.format",
+ .m_doc = "Python module for Chrysalide.format",
+
+ .m_size = -1,
+
+ };
+
+ result = false;
+
+ module = PyModule_Create(&py_chrysalide_format_module);
+ if (module == NULL) return false;
+
+ ret = PyState_AddModule(super, &py_chrysalide_format_module);
+ if (ret != 0) goto loading_failed;
+
+ ret = _PyImport_FixupBuiltin(module, "pychrysalide.format");
+ if (ret != 0) goto loading_failed;
+
+ Py_INCREF(module);
+ ret = PyModule_AddObject(super, "format", module);
+ if (ret != 0) goto loading_failed;
+
+ result = true;
+
+ result &= register_python_binary_format(module);
+ result &= register_python_executable_format(module);
+ result &= register_python_binary_symbol(module);
+ result &= register_python_sym_iterator(module);
+
+ if (result)
+ register_access_to_python_module("pychrysalide.format", module);
+
+ loading_failed:
+
+ assert(result);
+
+ return result;
+
+}
diff --git a/plugins/pychrysalide/format/module.h b/plugins/pychrysalide/format/module.h
new file mode 100644
index 0000000..0557722
--- /dev/null
+++ b/plugins/pychrysalide/format/module.h
@@ -0,0 +1,39 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * module.h - prototypes pour l'intégration du répertoire format en tant que module
+ *
+ * Copyright (C) 2012-2017 Cyrille Bagard
+ *
+ * This file is part of Chrysalide.
+ *
+ * Chrysalide 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.
+ *
+ * Chrysalide 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
+ */
+
+
+#ifndef _PLUGINS_PYOIDA_FORMAT_MODULE_H
+#define _PLUGINS_PYOIDA_FORMAT_MODULE_H
+
+
+#include <Python.h>
+#include <stdbool.h>
+
+
+
+/* Ajoute le module 'format' au module Python. */
+bool add_format_module_to_python_module(PyObject *);
+
+
+
+#endif /* _PLUGINS_PYOIDA_FORMAT_MODULE_H */
diff --git a/plugins/pychrysalide/format/symbol.c b/plugins/pychrysalide/format/symbol.c
new file mode 100644
index 0000000..5ddaca2
--- /dev/null
+++ b/plugins/pychrysalide/format/symbol.c
@@ -0,0 +1,446 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * symbol.c - équivalent Python du fichier "format/symbol.h"
+ *
+ * Copyright (C) 2015-2017 Cyrille Bagard
+ *
+ * This file is part of Chrysalide.
+ *
+ * Chrysalide 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.
+ *
+ * Chrysalide 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
+ */
+
+
+#include "symbol.h"
+
+
+#include <pygobject.h>
+
+
+#include <i18n.h>
+
+
+#include <format/symbol.h>
+
+
+#include "../helpers.h"
+#include "../analysis/routine.h"
+#include "../analysis/db/items/comment.h"
+#include "../arch/instruction.h"
+#include "../arch/vmpa.h"
+
+
+
+/* Effectue une comparaison avec un objet Python 'BinSymbol'. */
+static PyObject *py_binary_symbol_richcompare(PyObject *, PyObject *, int);
+
+/* Définit un autre nom pour le symbole. */
+static PyObject *py_binary_symbol_set_alt_label(PyObject *, PyObject *);
+
+/* Fournit le type du symbole. */
+static PyObject *py_binary_symbol_get_target_type(PyObject *, void *);
+
+/* Fournit un étiquette pour viser un symbole. */
+static PyObject *py_binary_symbol_get_label(PyObject *, void *);
+
+/* Fournit l'emplacement où se situe un symbole. */
+static PyObject *py_binary_symbol_get_range(PyObject *, void *);
+
+/* Fournit la visibilité du symbole. */
+static PyObject *py_binary_symbol_get_status(PyObject *, void *);
+
+/* Définit les constantes pour les symboles binaires. */
+static bool py_binary_symbol_define_constants(PyTypeObject *);
+
+
+
+/******************************************************************************
+* *
+* Paramètres : a = premier object Python à consulter. *
+* b = second object Python à consulter. *
+* op = type de comparaison menée. *
+* *
+* Description : Effectue une comparaison avec un objet Python 'BinSymbol'. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_binary_symbol_richcompare(PyObject *a, PyObject *b, int op)
+{
+ PyObject *result; /* Bilan à retourner */
+ int ret; /* Bilan de lecture des args. */
+ const GBinSymbol *sym_a; /* Premier élément à traiter */
+ const GBinSymbol *sym_b; /* Second élément à traiter */
+ int status; /* Résultat d'une comparaison */
+
+ ret = PyObject_IsInstance(b, (PyObject *)get_python_binary_symbol_type());
+ if (!ret)
+ {
+ result = Py_NotImplemented;
+ goto cmp_done;
+ }
+
+ sym_a = G_BIN_SYMBOL(pygobject_get(a));
+ sym_a = G_BIN_SYMBOL(pygobject_get(b));
+
+ status = g_binary_symbol_cmp(&sym_a, &sym_b);
+
+ result = status_to_rich_cmp_state(status, op);
+
+ cmp_done:
+
+ Py_INCREF(result);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : type = type de l'objet à instancier. *
+* args = arguments fournis à l'appel. *
+* kwds = arguments de type key=val fournis. *
+* *
+* Description : Crée un nouvel objet Python de type 'DbComment'. *
+* *
+* Retour : Instance Python mise en place. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_binary_symbol_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+ PyObject *result; /* Bilan à retourner */
+ SymbolType stype; /* Type prévu pour le symbole */
+ PyObject *range_obj; /* Objet pour la couverture */
+ int ret; /* Bilan de lecture des args. */
+ mrange_t *range; /* Version native d'un espace */
+ GBinSymbol *symbol; /* Version GLib du symble */
+
+ ret = PyArg_ParseTuple(args, "lO", &stype, &range_obj);
+ if (!ret) return NULL;
+
+ if (stype >= STP_COUNT)
+ {
+ PyErr_SetString(PyExc_ValueError, _("Invalid type of symbol."));
+ return NULL;
+ }
+
+ ret = PyObject_IsInstance(range_obj, (PyObject *)get_python_mrange_type());
+ if (!ret)
+ {
+ PyErr_SetString(PyExc_TypeError, _("The second argument must be an instance of mrange."));
+ return NULL;
+ }
+
+ range = get_internal_mrange(range_obj);
+
+ symbol = g_binary_symbol_new(range, stype);
+
+ result = pygobject_new(G_OBJECT(symbol));
+ g_object_unref(symbol);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = classe représentant un binaire. *
+* args = arguments fournis à l'appel. *
+* *
+* Description : Définit un autre nom pour le symbole. *
+* *
+* Retour : None. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_binary_symbol_set_alt_label(PyObject *self, PyObject *args)
+{
+ const char *alt; /* Etiquette alternative */
+ int ret; /* Bilan de lecture des args. */
+ GBinSymbol *symbol; /* Elément à consulter */
+
+ ret = PyArg_ParseTuple(args, "s", &alt);
+ if (!ret) return NULL;
+
+ symbol = G_BIN_SYMBOL(pygobject_get(self));
+
+ g_binary_symbol_set_alt_label(symbol, alt);
+
+ Py_RETURN_NONE;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = objet Python concerné par l'appel. *
+* closure = non utilisé ici. *
+* *
+* Description : Fournit le type du symbole. *
+* *
+* Retour : Type de symbole représenté. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_binary_symbol_get_target_type(PyObject *self, void *closure)
+{
+ PyObject *result; /* Valeur à retourner */
+ GBinSymbol *symbol; /* Elément à consulter */
+ SymbolType type; /* Type de symbole représenté */
+
+ symbol = G_BIN_SYMBOL(pygobject_get(self));
+ type = g_binary_symbol_get_target_type(symbol);
+
+ result = PyLong_FromLong(type);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = objet Python concerné par l'appel. *
+* closure = non utilisé ici. *
+* *
+* Description : Fournit un étiquette pour viser un symbole. *
+* *
+* Retour : Chaîne de caractères renvoyant au symbole. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_binary_symbol_get_label(PyObject *self, void *closure)
+{
+ PyObject *result; /* Valeur à retourner */
+ GBinSymbol *symbol; /* Elément à consulter */
+ const char *label; /* Désignation courante */
+
+ symbol = G_BIN_SYMBOL(pygobject_get(self));
+ label = g_binary_symbol_get_label(symbol);
+
+ if (label != NULL)
+ result = PyUnicode_FromString(label);
+
+ else
+ {
+ result = Py_None;
+ Py_INCREF(result);
+ }
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = objet Python concerné par l'appel. *
+* closure = non utilisé ici. *
+* *
+* Description : Fournit l'emplacement où se situe un symbole. *
+* *
+* Retour : Zone mémoire couverte par le symbole. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_binary_symbol_get_range(PyObject *self, void *closure)
+{
+ PyObject *result; /* Valeur à retourner */
+ GBinSymbol *symbol; /* Elément à consulter */
+ const mrange_t *range; /* Couverture courante */
+
+ symbol = G_BIN_SYMBOL(pygobject_get(self));
+ range = g_binary_symbol_get_range(symbol);
+
+ result = build_from_internal_mrange(range);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = objet Python concerné par l'appel. *
+* closure = non utilisé ici. *
+* *
+* Description : Fournit la visibilité du symbole. *
+* *
+* Retour : Etat de la visibilité du symbole représenté. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_binary_symbol_get_status(PyObject *self, void *closure)
+{
+ PyObject *result; /* Valeur à retourner */
+ GBinSymbol *symbol; /* Elément à consulter */
+ SymbolStatus status; /* Visibilité du symbole fourni*/
+
+ symbol = G_BIN_SYMBOL(pygobject_get(self));
+ status = g_binary_symbol_get_status(symbol);
+
+ result = PyLong_FromLong(status);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : obj_type = type dont le dictionnaire est à compléter. *
+* *
+* Description : Définit les constantes pour les symboles binaires. *
+* *
+* Retour : true en cas de succès de l'opération, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool py_binary_symbol_define_constants(PyTypeObject *obj_type)
+{
+ bool result; /* Bilan à retourner */
+
+ result = true;
+
+ result &= PyDict_AddIntMacro(obj_type, STP_DATA);
+ result &= PyDict_AddIntMacro(obj_type, STP_ROUTINE);
+ result &= PyDict_AddIntMacro(obj_type, STP_CODE_LABEL);
+ result &= PyDict_AddIntMacro(obj_type, STP_OBJECT);
+ result &= PyDict_AddIntMacro(obj_type, STP_ENTRY_POINT);
+ result &= PyDict_AddIntMacro(obj_type, STP_STRING);
+ result &= PyDict_AddIntMacro(obj_type, STP_RO_STRING);
+ result &= PyDict_AddIntMacro(obj_type, STP_COUNT);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : - *
+* *
+* Description : Fournit un accès à une définition de type à diffuser. *
+* *
+* Retour : Définition d'objet pour Python. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+PyTypeObject *get_python_binary_symbol_type(void)
+{
+ static PyMethodDef py_bin_symbol_methods[] = {
+ {
+ "set_alt_label", py_binary_symbol_set_alt_label,
+ METH_VARARGS,
+ "set_alt_label($self, alt, /)\n--\n\nSet an alternative label for the symbol."
+ },
+ { NULL }
+ };
+
+ static PyGetSetDef py_bin_symbol_getseters[] = {
+ {
+ "target_type", py_binary_symbol_get_target_type, NULL,
+ "Type of the current symbol.", NULL
+ },
+ {
+ "label", py_binary_symbol_get_label, NULL,
+ "Label of the symbol, provided by the internal component or by an alternative label.", NULL
+ },
+ {
+ "range", py_binary_symbol_get_range, NULL,
+ "Range covered by the symbol.", NULL
+ },
+ {
+ "status", py_binary_symbol_get_status, NULL,
+ "Status of the symbol's visibility.", NULL
+ },
+ { NULL }
+ };
+
+ static PyTypeObject py_bin_symbol_type = {
+
+ PyVarObject_HEAD_INIT(NULL, 0)
+
+ .tp_name = "pychrysalide.format.BinSymbol",
+ .tp_basicsize = sizeof(PyGObject),
+
+ .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+
+ .tp_doc = "PyChrysalide binary symbol",
+
+ .tp_richcompare = py_binary_symbol_richcompare,
+
+ .tp_methods = py_bin_symbol_methods,
+ .tp_getset = py_bin_symbol_getseters,
+ .tp_new = (newfunc)py_binary_symbol_new
+
+ };
+
+ return &py_bin_symbol_type;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : module = module dont la définition est à compléter. *
+* *
+* Description : Prend en charge l'objet 'pychrysalide.format.BinSymbol'. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool register_python_binary_symbol(PyObject *module)
+{
+ PyTypeObject *py_bin_symbol_type; /* Type Python 'BinSymbol' */
+ PyObject *dict; /* Dictionnaire du module */
+
+ py_bin_symbol_type = get_python_binary_symbol_type();
+
+ dict = PyModule_GetDict(module);
+
+ if (!register_class_for_pygobject(dict, G_TYPE_BIN_SYMBOL, py_bin_symbol_type, &PyGObject_Type))
+ return false;
+
+ if (!py_binary_symbol_define_constants(py_bin_symbol_type))
+ return false;
+
+ return true;
+
+}
diff --git a/plugins/pychrysalide/format/symbol.h b/plugins/pychrysalide/format/symbol.h
new file mode 100644
index 0000000..913da74
--- /dev/null
+++ b/plugins/pychrysalide/format/symbol.h
@@ -0,0 +1,42 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * symbol.h - prototypes pour l'équivalent Python du fichier "format/symbol.h"
+ *
+ * Copyright (C) 2015-2017 Cyrille Bagard
+ *
+ * This file is part of Chrysalide.
+ *
+ * Chrysalide 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.
+ *
+ * Chrysalide 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
+ */
+
+
+#ifndef _PLUGINS_PYCHRYSALIDE_FORMAT_SYMBOL_H
+#define _PLUGINS_PYCHRYSALIDE_FORMAT_SYMBOL_H
+
+
+#include <Python.h>
+#include <stdbool.h>
+
+
+
+/* Fournit un accès à une définition de type à diffuser. */
+PyTypeObject *get_python_binary_symbol_type(void);
+
+/* Prend en charge l'objet 'pychrysalide.format.BinSymbol'. */
+bool register_python_binary_symbol(PyObject *);
+
+
+
+#endif /* _PLUGINS_PYCHRYSALIDE_FORMAT_EXECUTABLE_H */
diff --git a/plugins/pychrysalide/format/symiter.c b/plugins/pychrysalide/format/symiter.c
new file mode 100644
index 0000000..db0b744
--- /dev/null
+++ b/plugins/pychrysalide/format/symiter.c
@@ -0,0 +1,276 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * symiter.c - équivalent Python du fichier "format/symiter.c"
+ *
+ * Copyright (C) 2017 Cyrille Bagard
+ *
+ * This file is part of Chrysalide.
+ *
+ * Chrysalide 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.
+ *
+ * Chrysalide 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
+ */
+
+
+#include "symiter.h"
+
+
+#include <pygobject.h>
+
+
+#include <format/symiter.h>
+
+
+#include "format.h"
+
+
+
+/* Transcription d'un itérateur en Python */
+typedef struct _PySymIterator
+{
+ PyObject_HEAD; /* A laisser en premier */
+
+ sym_iter_t *native; /* Version native de l'objet */
+ bool first_time; /* Premier élément retourné ? */
+
+} PySymIterator;
+
+
+/* Libère de la mémoire un itérateur sur des symboles. */
+static void py_sym_iterator_dealloc(PySymIterator *);
+
+/* Fournit le symbole qui en suit un autr. */
+static PyObject *py_sym_iterator_next(PySymIterator *);
+
+/* Initialise un nouvel itérateur. */
+static int py_sym_iterator_init(PySymIterator *, PyObject *, PyObject *);
+
+/* Construit un nouvel itérateur. */
+static PyObject *py_sym_iterator_new(PyTypeObject *, PyObject *, PyObject *);
+
+
+
+/******************************************************************************
+* *
+* Paramètres : self = itérateur à supprimer. *
+* *
+* Description : Libère de la mémoire un itérateur sur des symboles. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void py_sym_iterator_dealloc(PySymIterator *self)
+{
+ delete_symbol_iterator(self->native);
+
+ Py_TYPE(self)->tp_free((PyObject *)self);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = itérateur à manipuler. *
+* *
+* Description : Fournit le symbole qui en suit un autre. *
+* *
+* Retour : Symbole suivant trouvé, ou NULL. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_sym_iterator_next(PySymIterator *self)
+{
+ PyObject *result; /* Résultat à retourner */
+ GBinSymbol *next; /* Symbole suivant */
+
+ if (self->first_time)
+ {
+ next = get_symbol_iterator_current(self->native);
+ self->first_time = false;
+ }
+
+ else
+ next = get_symbol_iterator_next(self->native);
+
+ if (next != NULL)
+ {
+ result = pygobject_new(G_OBJECT(next));
+ g_object_unref(G_OBJECT(next));
+ }
+
+ else
+ {
+ PyErr_SetNone(PyExc_StopIteration);
+ result = NULL;
+ }
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = instance d'objet à initialiser. *
+* args = arguments passés pour l'appel. *
+* kwds = mots clefs éventuellement fournis en complément. *
+* *
+* Description : Initialise un nouvel itérateur. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static int py_sym_iterator_init(PySymIterator *self, PyObject *args, PyObject *kwds)
+{
+ int result; /* Bilan à retourner */
+ PyObject *fmt_obj; /* Format version Python */
+ unsigned long index; /* Indice de premier symbole */
+ int ret; /* Bilan de lecture des args. */
+ GBinFormat *format; /* Version native du format */
+
+ result = -1;
+
+ ret = PyArg_ParseTuple(args, "Ok", &fmt_obj, &index);
+ if (ret == 0) goto psii_exit;
+
+ ret = PyObject_IsInstance(fmt_obj, (PyObject *)get_python_binary_format_type());
+ if (!ret) goto psii_exit;
+
+ format = G_BIN_FORMAT(pygobject_get(fmt_obj));
+
+ self->native = create_symbol_iterator(format, index);
+ self->first_time = true;
+
+ result = 0;
+
+ psii_exit:
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : type = type d'objet à mettre en place. *
+* args = arguments passés pour l'appel. *
+* kwds = mots clefs éventuellement fournis en complément. *
+* *
+* Description : Construit un nouvel itérateur. *
+* *
+* Retour : Définition d'objet pour Python. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_sym_iterator_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+ PySymIterator *result; /* Nouvelle instance à renvoyer*/
+ int ret; /* Bilan de l'initialisation */
+
+ result = (PySymIterator *)type->tp_alloc(type, 0);
+
+ if (result != NULL)
+ {
+ ret = py_sym_iterator_init(result, args, kwds);
+
+ if (ret != 0)
+ {
+ Py_DECREF(result);
+ result = NULL;
+ }
+
+ }
+
+ return (PyObject *)result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : - *
+* *
+* Description : Fournit un accès à une définition de type à diffuser. *
+* *
+* Retour : Définition d'objet pour Python. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+PyTypeObject *get_python_sym_iterator_type(void)
+{
+ static PyTypeObject py_sym_iterator_type = {
+
+ PyVarObject_HEAD_INIT(NULL, 0)
+
+ .tp_name = "pychrysalide.format.SymIterator",
+ .tp_basicsize = sizeof(PySymIterator),
+
+ .tp_dealloc = (destructor)py_sym_iterator_dealloc,
+
+ .tp_flags = Py_TPFLAGS_DEFAULT,
+
+ .tp_doc = "Iterator for Chrysalide symbols registered in a given format.",
+
+ .tp_iter = PyObject_SelfIter,
+ .tp_iternext = (iternextfunc)py_sym_iterator_next,
+
+ .tp_init = (initproc)py_sym_iterator_init,
+ .tp_new = py_sym_iterator_new,
+
+ };
+
+ return &py_sym_iterator_type;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : module = module dont la définition est à compléter. *
+* *
+* Description : Prend en charge l'objet 'pychrysalide.format.SymIterator'. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool register_python_sym_iterator(PyObject *module)
+{
+ PyTypeObject *py_sym_iterator_type; /* Type Python 'BinContent' */
+ int ret; /* Bilan d'un appel */
+
+ py_sym_iterator_type = get_python_sym_iterator_type();
+
+ if (PyType_Ready(py_sym_iterator_type) < 0)
+ return false;
+
+ Py_INCREF(py_sym_iterator_type);
+ ret = PyModule_AddObject(module, "SymIterator", (PyObject *)py_sym_iterator_type);
+
+ return (ret == 0);
+
+}
diff --git a/plugins/pychrysalide/format/symiter.h b/plugins/pychrysalide/format/symiter.h
new file mode 100644
index 0000000..6cc1d29
--- /dev/null
+++ b/plugins/pychrysalide/format/symiter.h
@@ -0,0 +1,42 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * symiter.h - prototypes pour l'équivalent Python du fichier "format/symiter.h"
+ *
+ * Copyright (C) 2017 Cyrille Bagard
+ *
+ * This file is part of Chrysalide.
+ *
+ * Chrysalide 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.
+ *
+ * Chrysalide 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
+ */
+
+
+#ifndef _PLUGINS_PYCHRYSALIDE_FORMAT_SYMITER_H
+#define _PLUGINS_PYCHRYSALIDE_FORMAT_SYMITER_H
+
+
+#include <Python.h>
+#include <stdbool.h>
+
+
+
+/* Fournit un accès à une définition de type à diffuser. */
+PyTypeObject *get_python_sym_iterator_type(void);
+
+/* Prend en charge l'objet 'pychrysalide.format.SymIterator'. */
+bool register_python_sym_iterator(PyObject *);
+
+
+
+#endif /* _PLUGINS_PYCHRYSALIDE_FORMAT_SYMITER_H */