diff options
Diffstat (limited to 'plugins')
| -rw-r--r-- | plugins/pychrysalide/Makefile.am | 6 | ||||
| -rw-r--r-- | plugins/pychrysalide/core.c | 6 | ||||
| -rw-r--r-- | plugins/pychrysalide/format/Makefile.am | 21 | ||||
| -rw-r--r-- | plugins/pychrysalide/format/executable.c | 273 | ||||
| -rw-r--r-- | plugins/pychrysalide/format/executable.h | 4 | ||||
| -rw-r--r-- | plugins/pychrysalide/format/flat.c | 64 | ||||
| -rw-r--r-- | plugins/pychrysalide/format/known.c | 185 | ||||
| -rw-r--r-- | plugins/pychrysalide/format/module.c | 20 | ||||
| -rw-r--r-- | plugins/pychrysalide/format/program.c | 445 | ||||
| -rw-r--r-- | plugins/pychrysalide/format/program.h | 29 |
10 files changed, 613 insertions, 440 deletions
diff --git a/plugins/pychrysalide/Makefile.am b/plugins/pychrysalide/Makefile.am index 8408c96..183a4ef 100644 --- a/plugins/pychrysalide/Makefile.am +++ b/plugins/pychrysalide/Makefile.am @@ -48,7 +48,6 @@ AM_CFLAGS = $(LIBPYTHON_INTERPRETER_CFLAGS) $(LIBPYGOBJECT_CFLAGS) $(TOOLKIT_CFL # common/libpychrysacommon.la \ # core/libpychrysacore.la \ # debug/libpychrysadebug.la \ -# format/libpychrysaformat.la \ # $(GTKEXT_LIBADD) \ # $(GUI_LIBADD) \ # mangling/libpychrysamangling.la \ @@ -59,6 +58,7 @@ pychrysalide_la_LIBADD = \ arch/libpychrysaarch4.la \ common/libpychrysacommon.la \ core/libpychrysacore.la \ + format/libpychrysaformat.la \ glibext/libpychrysaglibext.la \ plugins/libpychrysaplugins.la @@ -76,5 +76,5 @@ devdir = $(includedir)/chrysalide/$(subdir) dev_HEADERS = $(pychrysalide_la_SOURCES:%c=) -#SUBDIRS = analysis arch common core debug format glibext $(GTKEXT_SUBDIR) $(GUI_SUBDIR) mangling plugins -SUBDIRS = analysis arch common core glibext plugins +#SUBDIRS = analysis arch common core debug $(GTKEXT_SUBDIR) $(GUI_SUBDIR) mangling plugins +SUBDIRS = analysis arch common core format glibext plugins diff --git a/plugins/pychrysalide/core.c b/plugins/pychrysalide/core.c index 6842c34..c76fae4 100644 --- a/plugins/pychrysalide/core.c +++ b/plugins/pychrysalide/core.c @@ -64,7 +64,7 @@ #include "core/module.h" #include "glibext/module.h" /* #include "debug/module.h" */ -/* #include "format/module.h" */ +#include "format/module.h" /* #ifdef INCLUDE_GTK_SUPPORT */ /* # include "gtkext/module.h" */ /* # include "gui/module.h" */ @@ -648,7 +648,9 @@ PyMODINIT_FUNC PyInit_pychrysalide(void) if (status) status = add_core_module(result); /* if (status) status = add_debug_module(result); + */ if (status) status = add_format_module(result); + /* #ifdef INCLUDE_GTK_SUPPORT if (status) status = add_gtkext_module(result); if (status) status = add_gui_module(result); @@ -671,7 +673,9 @@ PyMODINIT_FUNC PyInit_pychrysalide(void) if (status) status = populate_core_module(); /* if (status) status = populate_debug_module(); + */ if (status) status = populate_format_module(); + /* #ifdef INCLUDE_GTK_SUPPORT if (status) status = populate_gtkext_module(); if (status) status = populate_gui_module(); diff --git a/plugins/pychrysalide/format/Makefile.am b/plugins/pychrysalide/format/Makefile.am index 02f0a6e..efe58f3 100644 --- a/plugins/pychrysalide/format/Makefile.am +++ b/plugins/pychrysalide/format/Makefile.am @@ -1,19 +1,26 @@ noinst_LTLIBRARIES = libpychrysaformat.la +# libpychrysaformat_la_SOURCES = \ +# constants.h constants.c \ +# executable.h executable.c \ +# flat.h flat.c \ +# program.h program.c \ +# known.h known.c \ +# module.h module.c \ +# preload.h preload.c \ +# strsym.h strsym.c \ +# symbol.h symbol.c \ +# symiter.h symiter.c + libpychrysaformat_la_SOURCES = \ - constants.h constants.c \ executable.h executable.c \ flat.h flat.c \ - program.h program.c \ known.h known.c \ module.h module.c \ - preload.h preload.c \ - strsym.h strsym.c \ - symbol.h symbol.c \ - symiter.h symiter.c + program.h program.c -libpychrysaformat_la_CFLAGS = $(TOOLKIT_CFLAGS) $(LIBXML_CFLAGS) $(LIBPYTHON_INTERPRETER_CFLAGS) $(LIBPYGOBJECT_CFLAGS) \ +libpychrysaformat_la_CFLAGS = $(TOOLKIT_CFLAGS) $(LIBPYTHON_INTERPRETER_CFLAGS) $(LIBPYGOBJECT_CFLAGS) \ -I$(top_srcdir)/src -DNO_IMPORT_PYGOBJECT diff --git a/plugins/pychrysalide/format/executable.c b/plugins/pychrysalide/format/executable.c index ff2d14a..d886e9a 100644 --- a/plugins/pychrysalide/format/executable.c +++ b/plugins/pychrysalide/format/executable.c @@ -2,7 +2,7 @@ /* Chrysalide - Outil d'analyse de fichiers binaires * executable.c - équivalent Python du fichier "format/executable.c" * - * Copyright (C) 2018-2019 Cyrille Bagard + * Copyright (C) 2018-2024 Cyrille Bagard * * This file is part of Chrysalide. * @@ -30,15 +30,31 @@ #include <i18n.h> -#include <core/processors.h> +#include <format/executable-int.h> -#include "format.h" +#include "program.h" #include "../access.h" #include "../helpers.h" -#include "../arch/processor.h" -#include "../arch/vmpa.h" -#include "../glibext/binportion.h" +//#include "../arch/processor.h" +//#include "../arch/vmpa.h" +//#include "../glibext/binportion.h" + + + +/* ------------------------ GLUE POUR CREATION DEPUIS PYTHON ------------------------ */ + + +/* Initialise la classe des formats exécutables. */ +static void py_executable_format_init_gclass(GExecutableFormatClass *, gpointer); + +CREATE_DYN_ABSTRACT_CONSTRUCTOR(executable_format, G_TYPE_EXECUTABLE_FORMAT, py_executable_format_init_gclass); + +/* Initialise une instance sur la base du dérivé de GObject. */ +static int py_executable_format_init(PyObject *, PyObject *, PyObject *); + +/* Indique le type d'architecture visée par le format. */ +static char *py_executable_format_get_target_machine_wrapper(const GExecutableFormat *); @@ -46,13 +62,145 @@ /* Enregistre une portion artificielle pour le format. */ -static PyObject *py_exe_format_register_user_portion(PyObject *, PyObject *); +//static PyObject *py_executable_format_register_user_portion(PyObject *, PyObject *); /* Fournit l'emplacement correspondant à une position physique. */ -static PyObject *py_exe_format_translate_offset_into_vmpa(PyObject *, PyObject *); +//static PyObject *py_executable_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 *); +//static PyObject *py_executable_format_translate_address_into_vmpa(PyObject *, PyObject *); + +/* Indique le type d'architecture visée par le format. */ +static PyObject *py_executable_format_get_target_machine(PyObject *, void *); + + + +/* ---------------------------------------------------------------------------------- */ +/* GLUE POUR CREATION DEPUIS PYTHON */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : class = classe à initialiser. * +* unused = données non utilisées ici. * +* * +* Description : Initialise la classe des formats exécutables. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void py_executable_format_init_gclass(GExecutableFormatClass *class, gpointer unused) +{ + class->get_machine = py_executable_format_get_target_machine_wrapper; + +} + + +/****************************************************************************** +* * +* Paramètres : self = objet à initialiser (théoriquement). * +* args = arguments fournis à l'appel. * +* kwds = arguments de type key=val fournis. * +* * +* Description : Initialise une instance sur la base du dérivé de GObject. * +* * +* Retour : 0. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static int py_executable_format_init(PyObject *self, PyObject *args, PyObject *kwds) +{ + int ret; /* Bilan de lecture des args. */ + +#define EXECUTABLE_FORMAT_DOC \ + "The ExecutableFormat class provides support for formats containing"\ + " code to run.\n" \ + "\n" \ + "The following method has to be defined for new classes:\n" \ + "* pychrysalide.format.ExecutableFormat._get_target_machine();\n" \ + "\n" \ + "\n" \ + "Calls to the *__init__* constructor of this abstract object expect"\ + " no particular argument." + + /* Initialisation d'un objet GLib */ + + ret = forward_pygobjet_init(self); + if (ret == -1) return -1; + + return 0; + +} + + +/****************************************************************************** +* * +* Paramètres : format = description du format exécutable à consulter. * +* * +* Description : Indique le type d'architecture visée par le format. * +* * +* Retour : Identifiant de l'architecture ciblée par le format. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static char *py_executable_format_get_target_machine_wrapper(const GExecutableFormat *format) +{ + char *result; /* Désignation à renvoyer */ + PyGILState_STATE gstate; /* Sauvegarde d'environnement */ + PyObject *pyobj; /* Objet Python concerné */ + PyObject *pyret; /* Valeur retournée */ + int ret; /* Bilan d'une conversion */ + +#define EXECUTABLE_FORMAT_GET_TARGET_MACHINE_WRAPPER PYTHON_WRAPPER_DEF \ +( \ + _get_target_machine, "$self", \ + METH_NOARGS, \ + "Abstract method used to define the identifier of the architecture" \ + " suitable for the executable format.\n" \ + "\n" \ + "The return value has to be a (tiny) string." \ +) + + result = NULL; + + gstate = PyGILState_Ensure(); + + pyobj = pygobject_new(G_OBJECT(format)); + + if (has_python_method(pyobj, "_get_target_machine")) + { + pyret = run_python_method(pyobj, "_get_target_machine", NULL); + + if (pyret != NULL) + { + ret = PyUnicode_Check(pyret); + + if (ret) + result = strdup(PyUnicode_AsUTF8(pyret)); + else + PyErr_SetString(PyExc_ValueError, _("unexpected value type for executable format target machine")); + + Py_DECREF(pyret); + + } + + } + + Py_DECREF(pyobj); + + PyGILState_Release(gstate); + + return result; + +} @@ -61,6 +209,7 @@ static PyObject *py_exe_format_translate_address_into_vmpa(PyObject *, PyObject /* ---------------------------------------------------------------------------------- */ +#if 0 /****************************************************************************** * * * Paramètres : self = description de l'exécutable à consulter. * @@ -74,16 +223,16 @@ static PyObject *py_exe_format_translate_address_into_vmpa(PyObject *, PyObject * * ******************************************************************************/ -static PyObject *py_exe_format_register_user_portion(PyObject *self, PyObject *args) +static PyObject *py_executable_format_register_user_portion(PyObject *self, PyObject *args) { GBinPortion *portion; /* Portion binaire à conserver */ int ret; /* Bilan de lecture des args. */ - GExeFormat *format; /* Version GLib du format */ + GExecutableFormat *format; /* Version GLib du format */ ret = PyArg_ParseTuple(args, "O&", convert_to_binary_portion, &portion); if (!ret) return NULL; - format = G_EXE_FORMAT(pygobject_get(self)); + format = G_EXECUTABLE_FORMAT(pygobject_get(self)); g_object_ref(G_OBJECT(portion)); g_exe_format_register_user_portion(format, portion); @@ -106,16 +255,16 @@ static PyObject *py_exe_format_register_user_portion(PyObject *self, PyObject *a * * ******************************************************************************/ -static PyObject *py_exe_format_translate_offset_into_vmpa(PyObject *self, PyObject *args) +static PyObject *py_executable_format_translate_offset_into_vmpa(PyObject *self, PyObject *args) { PyObject *result; /* Instance à retourner */ - GExeFormat *format; /* Version GLib du format */ + GExecutableFormat *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)); + format = G_EXECUTABLE_FORMAT(pygobject_get(self)); assert(format != NULL); ret = PyArg_ParseTuple(args, "K", &off); @@ -150,16 +299,16 @@ static PyObject *py_exe_format_translate_offset_into_vmpa(PyObject *self, PyObje * * ******************************************************************************/ -static PyObject *py_exe_format_translate_address_into_vmpa(PyObject *self, PyObject *args) +static PyObject *py_executable_format_translate_address_into_vmpa(PyObject *self, PyObject *args) { PyObject *result; /* Instance à retourner */ - GExeFormat *format; /* Version GLib du format */ + GExecutableFormat *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)); + format = G_EXECUTABLE_FORMAT(pygobject_get(self)); assert(format != NULL); ret = PyArg_ParseTuple(args, "K", &addr); @@ -179,6 +328,56 @@ static PyObject *py_exe_format_translate_address_into_vmpa(PyObject *self, PyObj return result; } +#endif + + +/****************************************************************************** +* * +* Paramètres : self = objet Python concerné par l'appel. * +* closure = non utilisé ici. * +* * +* Description : Indique le type d'architecture visée par le format. * +* * +* Retour : Identifiant de l'architecture ciblée par le format. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_executable_format_get_target_machine(PyObject *self, void *closure) +{ + PyObject *result; /* Trouvailles à retourner */ + GExecutableFormat *format; /* Format exécutable manipulé */ + char *machine; /* Désignation machine ciblée */ + +#define EXECUTABLE_FORMAT_TARGET_MACHINE_ATTRIB PYTHON_GET_DEF_FULL \ +( \ + target_machine, py_executable_format, \ + "Identifier of the architecture suitable for the executable format,"\ + " provided as a (tiny) string." \ +) + + format = G_EXECUTABLE_FORMAT(pygobject_get(self)); + + machine = g_executable_format_get_target_machine(format); + + if (machine != NULL) + { + result = PyUnicode_FromString(machine); + free(machine); + } + else + { + result = NULL; + + if (PyErr_Occurred() == NULL) + PyErr_SetString(PyExc_ValueError, _("unexpected NULL value for executable format target machine")); + + } + + return result; + +} /****************************************************************************** @@ -195,46 +394,53 @@ static PyObject *py_exe_format_translate_address_into_vmpa(PyObject *self, PyObj PyTypeObject *get_python_executable_format_type(void) { - static PyMethodDef py_exe_format_methods[] = { + static PyMethodDef py_executable_format_methods[] = { + EXECUTABLE_FORMAT_GET_TARGET_MACHINE_WRAPPER, +#if 0 { - "register_user_portion", py_exe_format_register_user_portion, + "register_user_portion", py_executable_format_register_user_portion, METH_VARARGS, "register_user_portion($self, portion, /)\n--\n\nRemember a given user-defined binary portion as part of the executable format content." }, { - "translate_offset_into_vmpa", py_exe_format_translate_offset_into_vmpa, + "translate_offset_into_vmpa", py_executable_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, + "translate_address_into_vmpa", py_executable_format_translate_address_into_vmpa, METH_VARARGS, "translate_address_into_vmpa($self, addr, /)\n--\n\nTranslate a physical offset to a full location." }, +#endif { NULL } }; - static PyGetSetDef py_exe_format_getseters[] = { + static PyGetSetDef py_executable_format_getseters[] = { + EXECUTABLE_FORMAT_TARGET_MACHINE_ATTRIB, { NULL } }; - static PyTypeObject py_exe_format_type = { + static PyTypeObject py_executable_format_type = { PyVarObject_HEAD_INIT(NULL, 0) - .tp_name = "pychrysalide.format.ExeFormat", + .tp_name = "pychrysalide.format.ExecutableFormat", .tp_basicsize = sizeof(PyGObject), .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, - .tp_doc = "PyChrysalide executable format", + .tp_doc = EXECUTABLE_FORMAT_DOC, + + .tp_methods = py_executable_format_methods, + .tp_getset = py_executable_format_getseters, - .tp_methods = py_exe_format_methods, - .tp_getset = py_exe_format_getseters, + .tp_init = py_executable_format_init, + .tp_new = py_executable_format_new, }; - return &py_exe_format_type; + return &py_executable_format_type; } @@ -265,10 +471,10 @@ bool ensure_python_executable_format_is_registered(void) dict = PyModule_GetDict(module); - if (!ensure_python_binary_format_is_registered()) + if (!ensure_python_program_format_is_registered()) return false; - if (!register_class_for_pygobject(dict, G_TYPE_EXE_FORMAT, type)) + if (!register_class_for_pygobject(dict, G_TYPE_EXECUTABLE_FORMAT, type)) return false; } @@ -309,7 +515,7 @@ int convert_to_executable_format(PyObject *arg, void *dst) break; case 1: - *((GExeFormat **)dst) = G_EXE_FORMAT(pygobject_get(arg)); + *((GExecutableFormat **)dst) = G_EXECUTABLE_FORMAT(pygobject_get(arg)); break; default: @@ -328,7 +534,7 @@ int convert_to_executable_format(PyObject *arg, void *dst) /* TRADUCTION D'EMPLACEMENT */ /* ---------------------------------------------------------------------------------- */ - +#if 0 /****************************************************************************** * * * Paramètres : obj = objet Python à convertir en emplacement. * @@ -391,3 +597,4 @@ int convert_to_vmpa_using_executable(PyObject *obj, exe_cv_info_t *info) return result; } +#endif diff --git a/plugins/pychrysalide/format/executable.h b/plugins/pychrysalide/format/executable.h index 9ef1fe5..1b305a4 100644 --- a/plugins/pychrysalide/format/executable.h +++ b/plugins/pychrysalide/format/executable.h @@ -50,7 +50,7 @@ int convert_to_executable_format(PyObject *, void *); /* ---------------------------- TRADUCTION D'EMPLACEMENT ---------------------------- */ - +#if 0 /* Informations utiles à une traduction */ typedef struct _exe_cv_info_t { @@ -64,7 +64,7 @@ typedef struct _exe_cv_info_t /* Réalise une conversion d'un objet Python en localisation. */ int convert_to_vmpa_using_executable(PyObject *, exe_cv_info_t *); - +#endif #endif /* _PLUGINS_PYCHRYSALIDE_FORMAT_EXECUTABLE_H */ diff --git a/plugins/pychrysalide/format/flat.c b/plugins/pychrysalide/format/flat.c index 4df3646..a115c57 100644 --- a/plugins/pychrysalide/format/flat.c +++ b/plugins/pychrysalide/format/flat.c @@ -2,7 +2,7 @@ /* Chrysalide - Outil d'analyse de fichiers binaires * flat.c - équivalent Python du fichier "format/flat.c" * - * Copyright (C) 2018-2019 Cyrille Bagard + * Copyright (C) 2018-2024 Cyrille Bagard * * This file is part of Chrysalide. * @@ -28,43 +28,46 @@ #include <pygobject.h> -#include <format/flat.h> +#include <format/flat-int.h> #include "executable.h" #include "../access.h" +#include "../constants.h" #include "../helpers.h" #include "../analysis/content.h" -/* Crée un nouvel objet Python de type 'FlatFormat'. */ -static PyObject *py_flat_format_new(PyTypeObject *, PyObject *, PyObject *); +CREATE_DYN_CONSTRUCTOR(flat_format, G_TYPE_FLAT_FORMAT); + + +/* Initialise une instance sur la base du dérivé de GObject. */ +static int py_flat_format_init(PyObject *, PyObject *, PyObject *); /****************************************************************************** * * -* Paramètres : type = type de l'objet à instancier. * +* Paramètres : self = objet à initialiser (théoriquement). * * args = arguments fournis à l'appel. * * kwds = arguments de type key=val fournis. * * * -* Description : Crée un nouvel objet Python de type 'FlatFormat'. * +* Description : Initialise une instance sur la base du dérivé de GObject. * * * -* Retour : Instance Python mise en place. * +* Retour : 0. * * * * Remarques : - * * * ******************************************************************************/ -static PyObject *py_flat_format_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +static int py_flat_format_init(PyObject *self, PyObject *args, PyObject *kwds) { - PyObject *result; /* Instance à retourner */ GBinContent *content; /* Instance GLib du contenu */ const char *machine; /* Identifiant d'architecture */ - unsigned int endian; /* Boutisme de l'architecture */ + SourceEndian endian; /* Boutisme de l'architecture */ int ret; /* Bilan de lecture des args. */ - GExeFormat *format; /* Création GLib à transmettre */ + GFlatFormat *format; /* Création GLib à transmettre */ #define FLAT_FORMAT_DOC \ "FlatFormat is suitable for all executable contents without a proper" \ @@ -75,27 +78,30 @@ static PyObject *py_flat_format_new(PyTypeObject *type, PyObject *args, PyObject " FlatFormat(content, machine, endian)" \ "\n" \ "Where content is a pychrysalide.analysis.BinContent object, machine" \ - " defines the target architecture and endian provides the right" \ - " endianness of the data." + " defines the target architecture as a string value and endian provides"\ + " the right endianness of the data, as pychrysalide.SourceEndian value." - ret = PyArg_ParseTuple(args, "O&sI", convert_to_binary_content, &content, &machine, &endian); - if (!ret) return NULL; + /* Récupération des paramètres */ - format = g_flat_format_new(content, machine, endian); + ret = PyArg_ParseTuple(args, "O&sO&", + convert_to_binary_content, &content, + &machine, + convert_to_source_endian, &endian); + if (!ret) return -1; - if (format == NULL) - { - result = Py_None; - Py_INCREF(result); - } + /* Initialisation d'un objet GLib */ - else - { - result = pygobject_new(G_OBJECT(format)); - g_object_unref(format); - } + ret = forward_pygobjet_init(self); + if (ret == -1) return -1; - return result; + /* Eléments de base */ + + format = G_FLAT_FORMAT(pygobject_get(self)); + + if (!g_flat_format_create(format, content, machine, endian)) + return -1; + + return 0; } @@ -135,7 +141,9 @@ PyTypeObject *get_python_flat_format_type(void) .tp_methods = py_flat_format_methods, .tp_getset = py_flat_format_getseters, - .tp_new = py_flat_format_new + + .tp_init = py_flat_format_init, + .tp_new = py_flat_format_new, }; diff --git a/plugins/pychrysalide/format/known.c b/plugins/pychrysalide/format/known.c index 3167ba2..e38c975 100644 --- a/plugins/pychrysalide/format/known.c +++ b/plugins/pychrysalide/format/known.c @@ -2,7 +2,7 @@ /* Chrysalide - Outil d'analyse de fichiers binaires * known.c - équivalent Python du fichier "format/known.c" * - * Copyright (C) 2019 Cyrille Bagard + * Copyright (C) 2019-2024 Cyrille Bagard * * This file is part of Chrysalide. * @@ -30,7 +30,6 @@ #include <i18n.h> #include <format/known-int.h> -#include <plugins/dt.h> #include "../access.h" @@ -42,12 +41,11 @@ /* ------------------------ GLUE POUR CREATION DEPUIS PYTHON ------------------------ */ -/* Accompagne la création d'une instance dérivée en Python. */ -static PyObject *py_known_format_new(PyTypeObject *, PyObject *, PyObject *); - /* Initialise la classe des descriptions de fichier binaire. */ static void py_known_format_init_gclass(GKnownFormatClass *, gpointer); +CREATE_DYN_ABSTRACT_CONSTRUCTOR(known_format, G_TYPE_KNOWN_FORMAT, py_known_format_init_gclass); + /* Initialise une instance sur la base du dérivé de GObject. */ static int py_known_format_init(PyObject *, PyObject *, PyObject *); @@ -57,11 +55,13 @@ static char *py_known_format_get_key_wrapper(const GKnownFormat *); /* Fournit une description humaine du format. */ static char *py_known_format_get_description_wrapper(const GKnownFormat *); +#if 0 /* Assure l'interprétation d'un format en différé. */ static bool py_known_format_analyze_wrapper(GKnownFormat *, wgroup_id_t, GtkStatusStack *); /* Réalise un traitement post-désassemblage. */ static void py_known_format_complete_analysis_wrapper(GKnownFormat *, wgroup_id_t, GtkStatusStack *); +#endif @@ -69,10 +69,10 @@ static void py_known_format_complete_analysis_wrapper(GKnownFormat *, wgroup_id_ /* Assure l'interprétation d'un format en différé. */ -static PyObject *py_known_format_analyze(PyObject *, PyObject *); +//static PyObject *py_known_format_analyze(PyObject *, PyObject *); /* Réalise un traitement post-désassemblage. */ -static PyObject *py_known_format_complete_analysis(PyObject *, PyObject *); +//static PyObject *py_known_format_complete_analysis(PyObject *, PyObject *); /* Indique la désignation interne du format. */ static PyObject *py_known_format_get_key(PyObject *, void *); @@ -92,73 +92,10 @@ static PyObject *py_known_format_get_content(PyObject *, void *); /****************************************************************************** * * -* Paramètres : type = type du nouvel objet à mettre en place. * -* args = éventuelle liste d'arguments. * -* kwds = éventuel dictionnaire de valeurs mises à disposition. * -* * -* Description : Accompagne la création d'une instance dérivée en Python. * -* * -* Retour : Nouvel objet Python mis en place ou NULL en cas d'échec. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static PyObject *py_known_format_new(PyTypeObject *type, PyObject *args, PyObject *kwds) -{ - PyObject *result; /* Objet à retourner */ - PyTypeObject *base; /* Type de base à dériver */ - bool first_time; /* Evite les multiples passages*/ - GType gtype; /* Nouveau type de processeur */ - bool status; /* Bilan d'un enregistrement */ - - /* Validations diverses */ - - base = get_python_known_format_type(); - - if (type == base) - { - result = NULL; - PyErr_Format(PyExc_RuntimeError, _("%s is an abstract class"), type->tp_name); - goto exit; - } - - /* Mise en place d'un type dédié */ - - first_time = (g_type_from_name(type->tp_name) == 0); - - gtype = build_dynamic_type(G_TYPE_KNOWN_FORMAT, type->tp_name, - (GClassInitFunc)py_known_format_init_gclass, NULL, NULL); - - if (first_time) - { - status = register_class_for_dynamic_pygobject(gtype, type); - - if (!status) - { - result = NULL; - goto exit; - } - - } - - /* On crée, et on laisse ensuite la main à PyGObject_Type.tp_init() */ - - result = PyType_GenericNew(type, args, kwds); - - exit: - - return result; - -} - - -/****************************************************************************** -* * * Paramètres : class = classe à initialiser. * * unused = données non utilisées ici. * * * -* Description : Initialise la classe générique des processeurs. * +* Description : Initialise la classe des formats connus. * * * * Retour : - * * * @@ -171,8 +108,8 @@ static void py_known_format_init_gclass(GKnownFormatClass *class, gpointer unuse class->get_key = py_known_format_get_key_wrapper; class->get_desc = py_known_format_get_description_wrapper; - class->analyze = py_known_format_analyze_wrapper; - class->complete = py_known_format_complete_analysis_wrapper; + //class->analyze = py_known_format_analyze_wrapper; + //class->complete = py_known_format_complete_analysis_wrapper; } @@ -201,12 +138,8 @@ static int py_known_format_init(PyObject *self, PyObject *args, PyObject *kwds) "KnownFormat is a small class providing basic features for" \ " recognized formats.\n" \ "\n" \ - "One item has to be defined as class attribute in the final" \ - " class:\n" \ - "* *_key*: a string providing a small name used to identify the" \ - " format.\n" \ - "\n" \ "The following methods have to be defined for new classes:\n" \ + "* pychrysalide.format.KnownFormat._get_key();\n" \ "* pychrysalide.format.KnownFormat._get_description();\n" \ "* pychrysalide.format.KnownFormat._analyze().\n" \ "\n" \ @@ -231,7 +164,8 @@ static int py_known_format_init(PyObject *self, PyObject *args, PyObject *kwds) format = G_KNOWN_FORMAT(pygobject_get(self)); - g_known_format_set_content(format, content); + if (!g_known_format_create(format, content)) + return -1; return 0; @@ -255,27 +189,39 @@ static char *py_known_format_get_key_wrapper(const GKnownFormat *format) char *result; /* Désignation à renvoyer */ PyGILState_STATE gstate; /* Sauvegarde d'environnement */ PyObject *pyobj; /* Objet Python concerné */ - PyObject *pykey; /* Clef en objet Python */ + PyObject *pyret; /* Valeur retournée */ int ret; /* Bilan d'une conversion */ +#define KNOWN_FORMAT_GET_KEY_WRAPPER PYTHON_WRAPPER_DEF \ +( \ + _get_key, "$self", \ + METH_NOARGS, \ + "Abstract method used to define the internal name" \ + " of the known format.\n" \ + "\n" \ + "The return value has to be a (tiny) string." \ +) + result = NULL; gstate = PyGILState_Ensure(); pyobj = pygobject_new(G_OBJECT(format)); - if (PyObject_HasAttrString(pyobj, "_key")) + if (has_python_method(pyobj, "_get_key")) { - pykey = PyObject_GetAttrString(pyobj, "_key"); + pyret = run_python_method(pyobj, "_get_key", NULL); - if (pykey != NULL) + if (pyret != NULL) { - ret = PyUnicode_Check(pykey); + ret = PyUnicode_Check(pyret); if (ret) - result = strdup(PyUnicode_AsUTF8(pykey)); + result = strdup(PyUnicode_AsUTF8(pyret)); + else + PyErr_SetString(PyExc_ValueError, _("unexpected value type for known format key")); - Py_DECREF(pykey); + Py_DECREF(pyret); } @@ -335,6 +281,8 @@ static char *py_known_format_get_description_wrapper(const GKnownFormat *format) if (ret) result = strdup(PyUnicode_AsUTF8(pyret)); + else + PyErr_SetString(PyExc_ValueError, _("unexpected value type for known format description")); Py_DECREF(pyret); @@ -350,7 +298,7 @@ static char *py_known_format_get_description_wrapper(const GKnownFormat *format) } - +#if 0 /****************************************************************************** * * * Paramètres : format = format chargé dont l'analyse est lancée. * @@ -475,7 +423,7 @@ static void py_known_format_complete_analysis_wrapper(GKnownFormat *format, wgro PyGILState_Release(gstate); } - +#endif /* ---------------------------------------------------------------------------------- */ @@ -483,6 +431,7 @@ static void py_known_format_complete_analysis_wrapper(GKnownFormat *format, wgro /* ---------------------------------------------------------------------------------- */ +#if 0 /****************************************************************************** * * * Paramètres : self = objet représentant un format connu. * @@ -584,6 +533,7 @@ static PyObject *py_known_format_complete_analysis(PyObject *self, PyObject *arg return result; } +#endif /****************************************************************************** @@ -615,9 +565,30 @@ static PyObject *py_known_format_get_key(PyObject *self, void *closure) key = g_known_format_get_key(format); - result = PyUnicode_FromString(key); + if (key != NULL) + { + result = PyUnicode_FromString(key); + free(key); + } + else + { + result = NULL; - free(key); + /** + * Si l'absence de retour vient d'une instance implémentée en Python, + * une exception peut (et doit dans ce cas) avoir été définie dans la + * fonction py_known_format_get_key_wrapper(). + * + * Aucun traitement supplémntaire n'est alors nécessaire. + * + * Une action est cependant nécessaire pour assurer un traitement + * des extensions purement natives offrant une mauvaise implémentation. + */ + + if (PyErr_Occurred() == NULL) + PyErr_SetString(PyExc_ValueError, _("unexpected NULL value for known format key")); + + } return result; @@ -653,9 +624,30 @@ static PyObject *py_known_format_get_description(PyObject *self, void *closure) desc = g_known_format_get_description(format); - result = PyUnicode_FromString(desc); + if (desc != NULL) + { + result = PyUnicode_FromString(desc); + free(desc); + } + else + { + result = NULL; - free(desc); + /** + * Si l'absence de retour vient d'une instance implémentée en Python, + * une exception peut (et doit dans ce cas) avoir été définie dans la + * fonction py_known_format_get_description_wrapper(). + * + * Aucun traitement supplémntaire n'est alors nécessaire. + * + * Une action est cependant nécessaire pour assurer un traitement + * des extensions purement natives offrant une mauvaise implémentation. + */ + + if (PyErr_Occurred() == NULL) + PyErr_SetString(PyExc_ValueError, _("unexpected NULL value for known format description")); + + } return result; @@ -724,11 +716,12 @@ static PyObject *py_known_format_get_content(PyObject *self, void *closure) PyTypeObject *get_python_known_format_type(void) { static PyMethodDef py_known_format_methods[] = { + KNOWN_FORMAT_GET_KEY_WRAPPER, KNOWN_FORMAT_GET_DESCRIPTION_WRAPPER, - KNOWN_FORMAT_ANALYZE_WRAPPER, - KNOWN_FORMAT_COMPLETE_ANALYSIS_WRAPPER, - KNOWN_FORMAT_ANALYZE_METHOD, - KNOWN_FORMAT_COMPLETE_ANALYSIS_METHOD, + //KNOWN_FORMAT_ANALYZE_WRAPPER, + //KNOWN_FORMAT_COMPLETE_ANALYSIS_WRAPPER, + //KNOWN_FORMAT_ANALYZE_METHOD, + //KNOWN_FORMAT_COMPLETE_ANALYSIS_METHOD, { NULL } }; diff --git a/plugins/pychrysalide/format/module.c b/plugins/pychrysalide/format/module.c index 62c15ed..95d4172 100644 --- a/plugins/pychrysalide/format/module.c +++ b/plugins/pychrysalide/format/module.c @@ -30,12 +30,12 @@ #include "executable.h" #include "flat.h" -#include "format.h" #include "known.h" -#include "preload.h" -#include "strsym.h" -#include "symbol.h" -#include "symiter.h" +//#include "preload.h" +#include "program.h" +//#include "strsym.h" +//#include "symbol.h" +//#include "symiter.h" #include "../helpers.h" @@ -105,11 +105,11 @@ bool populate_format_module(void) if (result) result = ensure_python_executable_format_is_registered(); if (result) result = ensure_python_flat_format_is_registered(); if (result) result = ensure_python_known_format_is_registered(); - if (result) result = ensure_python_binary_format_is_registered(); - if (result) result = ensure_python_preload_info_is_registered(); - if (result) result = ensure_python_string_symbol_is_registered(); - if (result) result = ensure_python_binary_symbol_is_registered(); - if (result) result = ensure_python_sym_iterator_is_registered(); + //if (result) result = ensure_python_preload_info_is_registered(); + if (result) result = ensure_python_program_format_is_registered(); + //if (result) result = ensure_python_string_symbol_is_registered(); + //if (result) result = ensure_python_binary_symbol_is_registered(); + //if (result) result = ensure_python_sym_iterator_is_registered(); assert(result); diff --git a/plugins/pychrysalide/format/program.c b/plugins/pychrysalide/format/program.c index 82c6c33..d96c2db 100644 --- a/plugins/pychrysalide/format/program.c +++ b/plugins/pychrysalide/format/program.c @@ -1,8 +1,8 @@ /* Chrysalide - Outil d'analyse de fichiers binaires - * format.c - équivalent Python du fichier "format/format.c" + * program.c - équivalent Python du fichier "format/program.c" * - * Copyright (C) 2018-2020 Cyrille Bagard + * Copyright (C) 2018-2024 Cyrille Bagard * * This file is part of Chrysalide. * @@ -22,101 +22,104 @@ */ -#include "format.h" +#include "program.h" #include <pygobject.h> -#include <i18n.h> -#include <format/format-int.h> -#include <plugins/dt.h> +#include <format/program-int.h> +#include "known.h" +#include "../access.h" +#include "../constants.h" +#include "../helpers.h" + + +/* #include "constants.h" #include "executable.h" -#include "known.h" #include "symbol.h" #include "symiter.h" -#include "../access.h" -#include "../helpers.h" #include "../analysis/constants.h" #include "../analysis/content.h" #include "../arch/vmpa.h" #include "../arch/constants.h" +*/ /* ------------------------ GLUE POUR CREATION DEPUIS PYTHON ------------------------ */ -/* Accompagne la création d'une instance dérivée en Python. */ -static PyObject *py_binary_format_new(PyTypeObject *, PyObject *, PyObject *); +/* Initialise la classe des formats de programmes. */ +static void py_program_format_init_gclass(GProgramFormatClass *, gpointer); -/* Initialise la classe des descriptions de fichier binaire. */ -static void py_binary_format_init_gclass(GBinFormatClass *, gpointer); +CREATE_DYN_ABSTRACT_CONSTRUCTOR(program_format, G_TYPE_PROGRAM_FORMAT, py_program_format_init_gclass); /* Initialise une instance sur la base du dérivé de GObject. */ -static int py_binary_format_init(PyObject *, PyObject *, PyObject *); +static int py_program_format_init(PyObject *, PyObject *, PyObject *); /* Indique le boutisme employé par le format binaire analysé. */ -static SourceEndian py_binary_format_get_endianness_wrapper(const GBinFormat *); +static SourceEndian py_program_format_get_endianness_wrapper(const GProgramFormat *); /* ---------------------------- FORMAT BINAIRE GENERIQUE ---------------------------- */ +#if 0 /* Ajoute une information complémentaire à un format. */ -static PyObject *py_binary_format_set_flag(PyObject *, PyObject *); +static PyObject *py_program_format_set_flag(PyObject *, PyObject *); /* Retire une information complémentaire à un format. */ -static PyObject *py_binary_format_unset_flag(PyObject *, PyObject *); +static PyObject *py_program_format_unset_flag(PyObject *, PyObject *); /* Détermine si un format possède un fanion particulier. */ -static PyObject *py_binary_format_has_flag(PyObject *, PyObject *); +static PyObject *py_program_format_has_flag(PyObject *, PyObject *); /* Enregistre une adresse comme début d'une zone de code. */ -static PyObject *py_binary_format_register_code_point(PyObject *, PyObject *); +static PyObject *py_program_format_register_code_point(PyObject *, PyObject *); /* Ajoute un symbole à la collection du format binaire. */ -static PyObject *py_binary_format_add_symbol(PyObject *, PyObject *); +static PyObject *py_program_format_add_symbol(PyObject *, PyObject *); /* Retire un symbole de la collection du format binaire. */ -static PyObject *py_binary_format_remove_symbol(PyObject *, PyObject *); +static PyObject *py_program_format_remove_symbol(PyObject *, PyObject *); /* Recherche le symbole correspondant à une étiquette. */ -static PyObject *py_binary_format_find_symbol_by_label(PyObject *, PyObject *); +static PyObject *py_program_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 *); +static PyObject *py_program_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 *); +static PyObject *py_program_format_find_next_symbol_at(PyObject *, PyObject *); /* Recherche le symbole correspondant à une adresse. */ -static PyObject *py_binary_format_resolve_symbol(PyObject *, PyObject *); +static PyObject *py_program_format_resolve_symbol(PyObject *, PyObject *); /* Fournit les particularités du format. */ -static PyObject *py_binary_format_get_flags(PyObject *, void *); +static PyObject *py_program_format_get_flags(PyObject *, void *); /* Indique le boutisme employé par le format binaire analysé. */ -static PyObject *py_binary_format_get_endianness(PyObject *, void *); +static PyObject *py_program_format_get_endianness(PyObject *, void *); /* Fournit la liste de tous les symboles détectés. */ -static PyObject *py_binary_format_get_symbols(PyObject *, void *); - +static PyObject *py_program_format_get_symbols(PyObject *, void *); +#endif /* ------------------ CONSERVATION DES SOUCIS DURANT LE CHARGEMENT ------------------ */ - +#if 0 /* Etend la liste des soucis détectés avec de nouvelles infos. */ -static PyObject *py_binary_format_add_error(PyObject *, PyObject *); +static PyObject *py_program_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 *); - +static PyObject *py_program_format_get_errors(PyObject *, void *); +#endif /* ---------------------------------------------------------------------------------- */ @@ -126,73 +129,10 @@ static PyObject *py_binary_format_get_errors(PyObject *, void *); /****************************************************************************** * * -* Paramètres : type = type du nouvel objet à mettre en place. * -* args = éventuelle liste d'arguments. * -* kwds = éventuel dictionnaire de valeurs mises à disposition. * -* * -* Description : Accompagne la création d'une instance dérivée en Python. * -* * -* Retour : Nouvel objet Python mis en place ou NULL en cas d'échec. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static PyObject *py_binary_format_new(PyTypeObject *type, PyObject *args, PyObject *kwds) -{ - PyObject *result; /* Objet à retourner */ - PyTypeObject *base; /* Type de base à dériver */ - bool first_time; /* Evite les multiples passages*/ - GType gtype; /* Nouveau type de processeur */ - bool status; /* Bilan d'un enregistrement */ - - /* Validations diverses */ - - base = get_python_known_format_type(); - - if (type == base) - { - result = NULL; - PyErr_Format(PyExc_RuntimeError, _("%s is an abstract class"), type->tp_name); - goto exit; - } - - /* Mise en place d'un type dédié */ - - first_time = (g_type_from_name(type->tp_name) == 0); - - gtype = build_dynamic_type(G_TYPE_BIN_FORMAT, type->tp_name, - (GClassInitFunc)py_binary_format_init_gclass, NULL, NULL); - - if (first_time) - { - status = register_class_for_dynamic_pygobject(gtype, type); - - if (!status) - { - result = NULL; - goto exit; - } - - } - - /* On crée, et on laisse ensuite la main à PyGObject_Type.tp_init() */ - - result = PyType_GenericNew(type, args, kwds); - - exit: - - return result; - -} - - -/****************************************************************************** -* * * Paramètres : class = classe à initialiser. * * unused = données non utilisées ici. * * * -* Description : Initialise la classe générique des processeurs. * +* Description : Initialise la classe des formats de programmes. * * * * Retour : - * * * @@ -200,9 +140,9 @@ static PyObject *py_binary_format_new(PyTypeObject *type, PyObject *args, PyObje * * ******************************************************************************/ -static void py_binary_format_init_gclass(GBinFormatClass *class, gpointer unused) +static void py_program_format_init_gclass(GProgramFormatClass *class, gpointer unused) { - class->get_endian = py_binary_format_get_endianness_wrapper; + class->get_endian = py_program_format_get_endianness_wrapper; } @@ -221,18 +161,18 @@ static void py_binary_format_init_gclass(GBinFormatClass *class, gpointer unused * * ******************************************************************************/ -static int py_binary_format_init(PyObject *self, PyObject *args, PyObject *kwds) +static int py_program_format_init(PyObject *self, PyObject *args, PyObject *kwds) { int ret; /* Bilan de lecture des args. */ -#define BINARY_FORMAT_DOC \ - "The BinFormat class is the major poart of binary format support." \ - " It is the core class used by loading most of the binary files.\n" \ +#define PROGRAM_FORMAT_DOC \ + "The ProgramFormat class is the major part of binary format" \ + " support. It is the core class used by loading most of the binary" \ + " files.\n" \ + "\n" \ "\n" \ - "One item has to be defined as class attribute in the final" \ - " class:\n" \ - "* *_endianness*: a pychrysalide.analysis.BinContent.SourceEndian" \ - " value indicating the endianness of the format.\n" \ + "The following method has to be defined for new classes:\n" \ + "* pychrysalide.format.ProgramFormat._get_endianness().\n" \ "\n" \ "Calls to the *__init__* constructor of this abstract object expect"\ " no particular argument." @@ -259,7 +199,7 @@ static int py_binary_format_init(PyObject *self, PyObject *args, PyObject *kwds) * * ******************************************************************************/ -static SourceEndian py_binary_format_get_endianness_wrapper(const GBinFormat *format) +static SourceEndian py_program_format_get_endianness_wrapper(const GProgramFormat *format) { SourceEndian result; /* Boutisme à retourner */ PyGILState_STATE gstate; /* Sauvegarde d'environnement */ @@ -267,22 +207,35 @@ static SourceEndian py_binary_format_get_endianness_wrapper(const GBinFormat *fo PyObject *pyret; /* Valeur retournée */ int ret; /* Bilan d'une conversion */ +#define PROGRAM_FORMAT_GET_ENDIANNESS_WRAPPER PYTHON_WRAPPER_DEF \ +( \ + _get_endianness_wrapper, "$self", \ + METH_NOARGS, \ + "Abstract method used to define the endianness of the format.\n"\ + "\n" \ + "The return value is of type pychrysalide.SourceEndian," \ + " pychrysalide.SourceEndian.LITTLE by default." \ +) + result = SRE_LITTLE; gstate = PyGILState_Ensure(); pyobj = pygobject_new(G_OBJECT(format)); - if (PyObject_HasAttrString(pyobj, "_endianness")) + if (has_python_method(pyobj, "_get_endianness")) { - pyret = PyObject_GetAttrString(pyobj, "_endianness"); + pyret = run_python_method(pyobj, "_get_endianness", NULL); if (pyret != NULL) { ret = convert_to_source_endian(pyret, &result); if (ret != 1) + { + PyErr_Clear(); result = SRE_LITTLE; + } Py_DECREF(pyret); @@ -304,6 +257,7 @@ static SourceEndian py_binary_format_get_endianness_wrapper(const GBinFormat *fo /* ---------------------------------------------------------------------------------- */ +#if 0 /****************************************************************************** * * * Paramètres : self = serveur à manipuler. * @@ -317,18 +271,18 @@ static SourceEndian py_binary_format_get_endianness_wrapper(const GBinFormat *fo * * ******************************************************************************/ -static PyObject *py_binary_format_set_flag(PyObject *self, PyObject *args) +static PyObject *py_program_format_set_flag(PyObject *self, PyObject *args) { PyObject *result; /* Bilan à retourner */ unsigned int flag; /* Propriété à traiter */ int ret; /* Bilan de lecture des args. */ - GBinFormat *format; /* Elément à manipuler */ + GProgramFormat *format; /* Elément à manipuler */ bool status; /* Bilan de l'opération */ -#define BINARY_FORMAT_SET_FLAG_METHOD PYTHON_METHOD_DEF \ +#define PROGRAM_FORMAT_SET_FLAG_METHOD PYTHON_METHOD_DEF \ ( \ set_flag, "$self, flag, /", \ - METH_VARARGS, py_binary_format, \ + METH_VARARGS, py_program_format, \ "Add a property from a binary format.\n" \ "\n" \ "This property is one of the values listed in the" \ @@ -341,9 +295,9 @@ static PyObject *py_binary_format_set_flag(PyObject *self, PyObject *args) ret = PyArg_ParseTuple(args, "I", &flag); if (!ret) return NULL; - format = G_BIN_FORMAT(pygobject_get(self)); + format = G_PROGRAM_FORMAT(pygobject_get(self)); - status = g_binary_format_set_flag(format, flag); + status = g_program_format_set_flag(format, flag); result = status ? Py_True : Py_False; Py_INCREF(result); @@ -366,18 +320,18 @@ static PyObject *py_binary_format_set_flag(PyObject *self, PyObject *args) * * ******************************************************************************/ -static PyObject *py_binary_format_unset_flag(PyObject *self, PyObject *args) +static PyObject *py_program_format_unset_flag(PyObject *self, PyObject *args) { PyObject *result; /* Bilan à retourner */ unsigned int flag; /* Propriété à traiter */ int ret; /* Bilan de lecture des args. */ - GBinFormat *format; /* Elément à manipuler */ + GProgramFormat *format; /* Elément à manipuler */ bool status; /* Bilan de l'opération */ -#define BINARY_FORMAT_UNSET_FLAG_METHOD PYTHON_METHOD_DEF \ +#define PROGRAM_FORMAT_UNSET_FLAG_METHOD PYTHON_METHOD_DEF \ ( \ unset_flag, "$self, flag, /", \ - METH_VARARGS, py_binary_format, \ + METH_VARARGS, py_program_format, \ "Remove a property from a binary format.\n" \ "\n" \ "This property is one of the values listed in the" \ @@ -390,9 +344,9 @@ static PyObject *py_binary_format_unset_flag(PyObject *self, PyObject *args) ret = PyArg_ParseTuple(args, "I", &flag); if (!ret) return NULL; - format = G_BIN_FORMAT(pygobject_get(self)); + format = G_PROGRAM_FORMAT(pygobject_get(self)); - status = g_binary_format_unset_flag(format, flag); + status = g_program_format_unset_flag(format, flag); result = status ? Py_True : Py_False; Py_INCREF(result); @@ -415,18 +369,18 @@ static PyObject *py_binary_format_unset_flag(PyObject *self, PyObject *args) * * ******************************************************************************/ -static PyObject *py_binary_format_has_flag(PyObject *self, PyObject *args) +static PyObject *py_program_format_has_flag(PyObject *self, PyObject *args) { PyObject *result; /* Bilan à retourner */ unsigned int flag; /* Propriété à traiter */ int ret; /* Bilan de lecture des args. */ - GBinFormat *format; /* Elément à manipuler */ + GProgramFormat *format; /* Elément à manipuler */ bool status; /* Bilan de l'opération */ -#define BINARY_FORMAT_HAS_FLAG_METHOD PYTHON_METHOD_DEF \ +#define PROGRAM_FORMAT_HAS_FLAG_METHOD PYTHON_METHOD_DEF \ ( \ has_flag, "$self, flag, /", \ - METH_VARARGS, py_binary_format, \ + METH_VARARGS, py_program_format, \ "Test if a binary format has a given property.\n" \ "\n" \ "This property is one of the values listed in the" \ @@ -438,9 +392,9 @@ static PyObject *py_binary_format_has_flag(PyObject *self, PyObject *args) ret = PyArg_ParseTuple(args, "I", &flag); if (!ret) return NULL; - format = G_BIN_FORMAT(pygobject_get(self)); + format = G_PROGRAM_FORMAT(pygobject_get(self)); - status = g_binary_format_has_flag(format, flag); + status = g_program_format_has_flag(format, flag); result = status ? Py_True : Py_False; Py_INCREF(result); @@ -463,17 +417,17 @@ static PyObject *py_binary_format_has_flag(PyObject *self, PyObject *args) * * ******************************************************************************/ -static PyObject *py_binary_format_register_code_point(PyObject *self, PyObject *args) +static PyObject *py_program_format_register_code_point(PyObject *self, PyObject *args) { unsigned long long pt; /* Adresse virtuelle du point */ DisassPriorityLevel level; /* Nature du point fourni */ int ret; /* Bilan de lecture des args. */ - GBinFormat *format; /* Format de binaire manipulé */ + GProgramFormat *format; /* Format de binaire manipulé */ -#define BINARY_FORMAT_REGISTER_CODE_POINT_METHOD PYTHON_METHOD_DEF \ +#define PROGRAM_FORMAT_REGISTER_CODE_POINT_METHOD PYTHON_METHOD_DEF \ ( \ register_code_point, "$self, point, level, /", \ - METH_VARARGS, py_binary_format, \ + METH_VARARGS, py_program_format, \ "Register a virtual address as entry point or basic point.\n" \ "\n" \ "The point is an integer value for the virtual memory location" \ @@ -484,9 +438,9 @@ static PyObject *py_binary_format_register_code_point(PyObject *self, PyObject * ret = PyArg_ParseTuple(args, "kO&", &pt, convert_to_disass_priority_level, &level); if (!ret) return NULL; - format = G_BIN_FORMAT(pygobject_get(self)); + format = G_PROGRAM_FORMAT(pygobject_get(self)); - g_binary_format_register_code_point(format, pt, level); + g_program_format_register_code_point(format, pt, level); Py_RETURN_NONE; @@ -506,18 +460,18 @@ static PyObject *py_binary_format_register_code_point(PyObject *self, PyObject * * * ******************************************************************************/ -static PyObject *py_binary_format_add_symbol(PyObject *self, PyObject *args) +static PyObject *py_program_format_add_symbol(PyObject *self, PyObject *args) { PyObject *result; /* Valeur à retourner */ GBinSymbol *symbol; /* Enventuel symbole trouvé */ int ret; /* Bilan de lecture des args. */ - GBinFormat *format; /* Format de binaire manipulé */ + GProgramFormat *format; /* Format de binaire manipulé */ bool added; /* Bilan de l'appel interne */ -#define BINARY_FORMAT_ADD_SYMBOL_METHOD PYTHON_METHOD_DEF \ +#define PROGRAM_FORMAT_ADD_SYMBOL_METHOD PYTHON_METHOD_DEF \ ( \ add_symbol, "$self, symbol, /", \ - METH_VARARGS, py_binary_format, \ + METH_VARARGS, py_program_format, \ "Register a new symbol for the format.\n" \ "\n" \ "The symbol has to be a pychrysalide.format.BinSymbol instance." \ @@ -526,10 +480,10 @@ static PyObject *py_binary_format_add_symbol(PyObject *self, PyObject *args) ret = PyArg_ParseTuple(args, "O&", convert_to_binary_symbol, &symbol); if (!ret) return NULL; - format = G_BIN_FORMAT(pygobject_get(self)); + format = G_PROGRAM_FORMAT(pygobject_get(self)); g_object_ref(G_OBJECT(symbol)); - added = g_binary_format_add_symbol(format, symbol); + added = g_program_format_add_symbol(format, symbol); result = added ? Py_True : Py_False; Py_INCREF(result); @@ -552,17 +506,17 @@ static PyObject *py_binary_format_add_symbol(PyObject *self, PyObject *args) * * ******************************************************************************/ -static PyObject *py_binary_format_remove_symbol(PyObject *self, PyObject *args) +static PyObject *py_program_format_remove_symbol(PyObject *self, PyObject *args) { PyObject *result; /* Valeur à retourner */ GBinSymbol *symbol; /* Enventuel symbole trouvé */ int ret; /* Bilan de lecture des args. */ - GBinFormat *format; /* Format de binaire manipulé */ + GProgramFormat *format; /* Format de binaire manipulé */ -#define BINARY_FORMAT_REMOVE_SYMBOL_METHOD PYTHON_METHOD_DEF \ +#define PROGRAM_FORMAT_REMOVE_SYMBOL_METHOD PYTHON_METHOD_DEF \ ( \ remove_symbol, "$self, symbol, /", \ - METH_VARARGS, py_binary_format, \ + METH_VARARGS, py_program_format, \ "Unregister a symbol from the format.\n" \ "\n" \ "The symbol has to be a pychrysalide.format.BinSymbol instance." \ @@ -571,9 +525,9 @@ static PyObject *py_binary_format_remove_symbol(PyObject *self, PyObject *args) ret = PyArg_ParseTuple(args, "O&", convert_to_binary_symbol, &symbol); if (!ret) return NULL; - format = G_BIN_FORMAT(pygobject_get(self)); + format = G_PROGRAM_FORMAT(pygobject_get(self)); - g_binary_format_remove_symbol(format, symbol); + g_program_format_remove_symbol(format, symbol); result = Py_None; Py_INCREF(result); @@ -596,19 +550,19 @@ static PyObject *py_binary_format_remove_symbol(PyObject *self, PyObject *args) * * ******************************************************************************/ -static PyObject *py_binary_format_find_symbol_by_label(PyObject *self, PyObject *args) +static PyObject *py_program_format_find_symbol_by_label(PyObject *self, PyObject *args) { PyObject *result; /* Valeur à retourner */ const char *label; /* Etiquette à retrouver */ int ret; /* Bilan de lecture des args. */ - GBinFormat *format; /* Format de binaire manipulé */ + GProgramFormat *format; /* Format de binaire manipulé */ GBinSymbol *symbol; /* Enventuel symbole trouvé */ bool found; /* Bilan de la recherche */ -#define BINARY_FORMAT_FIND_SYMBOL_BY_LABEL_METHOD PYTHON_METHOD_DEF \ +#define PROGRAM_FORMAT_FIND_SYMBOL_BY_LABEL_METHOD PYTHON_METHOD_DEF \ ( \ find_symbol_by_label, "$self, label, /", \ - METH_VARARGS, py_binary_format, \ + METH_VARARGS, py_program_format, \ "Find the symbol with a given label, provided as a string.\n" \ "\n" \ "The result is a pychrysalide.format.BinSymbol instance, or None" \ @@ -618,9 +572,9 @@ static PyObject *py_binary_format_find_symbol_by_label(PyObject *self, PyObject ret = PyArg_ParseTuple(args, "s", &label); if (!ret) return NULL; - format = G_BIN_FORMAT(pygobject_get(self)); + format = G_PROGRAM_FORMAT(pygobject_get(self)); - found = g_binary_format_find_symbol_by_label(format, label, &symbol); + found = g_program_format_find_symbol_by_label(format, label, &symbol); if (found) { @@ -651,19 +605,19 @@ static PyObject *py_binary_format_find_symbol_by_label(PyObject *self, PyObject * * ******************************************************************************/ -static PyObject *py_binary_format_find_symbol_at(PyObject *self, PyObject *args) +static PyObject *py_program_format_find_symbol_at(PyObject *self, PyObject *args) { PyObject *result; /* Valeur à retourner */ - GBinFormat *format; /* Format de binaire manipulé */ + GProgramFormat *format; /* Format de binaire manipulé */ exe_cv_info_t conv; /* Informations de conversion */ int ret; /* Bilan de lecture des args. */ GBinSymbol *symbol; /* Enventuel symbole trouvé */ bool found; /* Bilan de la recherche */ -#define BINARY_FORMAT_FIND_SYMBOL_AT_METHOD PYTHON_METHOD_DEF \ +#define PROGRAM_FORMAT_FIND_SYMBOL_AT_METHOD PYTHON_METHOD_DEF \ ( \ find_symbol_at, "$self, addr, /", \ - METH_VARARGS, py_binary_format, \ + METH_VARARGS, py_program_format, \ "Find the symbol located at a given address, provided as a" \ " pychrysalide.arch.vmpa instance.\n" \ "\n" \ @@ -671,14 +625,14 @@ static PyObject *py_binary_format_find_symbol_at(PyObject *self, PyObject *args) " None if no symbol was found." \ ) - format = G_BIN_FORMAT(pygobject_get(self)); + format = G_PROGRAM_FORMAT(pygobject_get(self)); conv.format = G_IS_EXE_FORMAT(format) ? G_EXE_FORMAT(format) : NULL; ret = PyArg_ParseTuple(args, "O&", convert_to_vmpa_using_executable, &conv); if (!ret) return NULL; - found = g_binary_format_find_symbol_at(format, conv.vmpa, &symbol); + found = g_program_format_find_symbol_at(format, conv.vmpa, &symbol); if (found) { @@ -709,19 +663,19 @@ static PyObject *py_binary_format_find_symbol_at(PyObject *self, PyObject *args) * * ******************************************************************************/ -static PyObject *py_binary_format_find_next_symbol_at(PyObject *self, PyObject *args) +static PyObject *py_program_format_find_next_symbol_at(PyObject *self, PyObject *args) { PyObject *result; /* Valeur à retourner */ - GBinFormat *format; /* Format de binaire manipulé */ + GProgramFormat *format; /* Format de binaire manipulé */ exe_cv_info_t conv; /* Informations de conversion */ int ret; /* Bilan de lecture des args. */ GBinSymbol *symbol; /* Enventuel symbole trouvé */ bool found; /* Bilan de la recherche */ -#define BINARY_FORMAT_FIND_NEXT_SYMBOL_AT_METHOD PYTHON_METHOD_DEF \ +#define PROGRAM_FORMAT_FIND_NEXT_SYMBOL_AT_METHOD PYTHON_METHOD_DEF \ ( \ find_next_symbol_at, "$self, addr, /", \ - METH_VARARGS, py_binary_format, \ + METH_VARARGS, py_program_format, \ "Find the symbol next to the one found at a given address," \ " provided as a pychrysalide.arch.vmpa instance.\n" \ "\n" \ @@ -729,14 +683,14 @@ static PyObject *py_binary_format_find_next_symbol_at(PyObject *self, PyObject * " None if no symbol was found." \ ) - format = G_BIN_FORMAT(pygobject_get(self)); + format = G_PROGRAM_FORMAT(pygobject_get(self)); conv.format = G_IS_EXE_FORMAT(format) ? G_EXE_FORMAT(format) : NULL; ret = PyArg_ParseTuple(args, "O&", convert_to_vmpa_using_executable, &conv); if (!ret) return NULL; - found = g_binary_format_find_next_symbol_at(format, conv.vmpa, &symbol); + found = g_program_format_find_next_symbol_at(format, conv.vmpa, &symbol); if (found) { @@ -767,10 +721,10 @@ static PyObject *py_binary_format_find_next_symbol_at(PyObject *self, PyObject * * * ******************************************************************************/ -static PyObject *py_binary_format_resolve_symbol(PyObject *self, PyObject *args) +static PyObject *py_program_format_resolve_symbol(PyObject *self, PyObject *args) { PyObject *result; /* Valeur à retourner */ - GBinFormat *format; /* Format de binaire manipulé */ + GProgramFormat *format; /* Format de binaire manipulé */ exe_cv_info_t conv; /* Informations de conversion */ int strict; /* Tolérance acceptée */ int ret; /* Bilan de lecture des args. */ @@ -778,10 +732,10 @@ static PyObject *py_binary_format_resolve_symbol(PyObject *self, PyObject *args) phys_t diff; /* Décalage éventuel mesuré */ bool found; /* Bilan de la recherche */ -#define BINARY_FORMAT_RESOLVE_SYMBOL_METHOD PYTHON_METHOD_DEF \ +#define PROGRAM_FORMAT_RESOLVE_SYMBOL_METHOD PYTHON_METHOD_DEF \ ( \ resolve_symbol, "$self, addr, strict, /", \ - METH_VARARGS, py_binary_format, \ + METH_VARARGS, py_program_format, \ "Search for a position inside a symbol by a given address.\n" \ "\n" \ "The result is a couple of (pychrysalide.format.BinSymbol," \ @@ -793,14 +747,14 @@ static PyObject *py_binary_format_resolve_symbol(PyObject *self, PyObject *args) " always 0 upon success." \ ) - format = G_BIN_FORMAT(pygobject_get(self)); + format = G_PROGRAM_FORMAT(pygobject_get(self)); conv.format = G_IS_EXE_FORMAT(format) ? G_EXE_FORMAT(format) : NULL; ret = PyArg_ParseTuple(args, "O&p", convert_to_vmpa_using_executable, &conv, &strict); if (!ret) return NULL; - found = g_binary_format_resolve_symbol(format, conv.vmpa, strict, &symbol, &diff); + found = g_program_format_resolve_symbol(format, conv.vmpa, strict, &symbol, &diff); if (found) { @@ -835,27 +789,28 @@ static PyObject *py_binary_format_resolve_symbol(PyObject *self, PyObject *args) * * ******************************************************************************/ -static PyObject *py_binary_format_get_flags(PyObject *self, void *closure) +static PyObject *py_program_format_get_flags(PyObject *self, void *closure) { PyObject *result; /* Valeur à retourner */ - GBinFormat *format; /* Elément à consulter */ + GProgramFormat *format; /* Elément à consulter */ FormatFlag flags; /* Indications complémentaires */ -#define BINARY_FORMAT_FLAGS_ATTRIB PYTHON_GET_DEF_FULL \ +#define PROGRAM_FORMAT_FLAGS_ATTRIB PYTHON_GET_DEF_FULL \ ( \ - flags, py_binary_format, \ + flags, py_program_format, \ "Provide all the flags set for a format. The return value" \ " is of type pychrysalide.format.BinFormat.FormatFlag." \ ) - format = G_BIN_FORMAT(pygobject_get(self)); - flags = g_binary_format_get_flags(format); + format = G_PROGRAM_FORMAT(pygobject_get(self)); + flags = g_program_format_get_flags(format); - result = cast_with_constants_group_from_type(get_python_binary_format_type(), "FormatFlag", flags); + result = cast_with_constants_group_from_type(get_python_program_format_type(), "FormatFlag", flags); return result; } +#endif /****************************************************************************** @@ -871,29 +826,31 @@ static PyObject *py_binary_format_get_flags(PyObject *self, void *closure) * * ******************************************************************************/ -static PyObject *py_binary_format_get_endianness(PyObject *self, void *closure) +static PyObject *py_program_format_get_endianness(PyObject *self, void *closure) { PyObject *result; /* Valeur à retourner */ - GBinFormat *format; /* Elément à consulter */ + GProgramFormat *format; /* Elément à consulter */ SourceEndian endianness; /* Boutisme du format */ -#define BINARY_FORMAT_ENDIANNESS_ATTRIB PYTHON_GET_DEF_FULL \ +#define PROGRAM_FORMAT_ENDIANNESS_ATTRIB PYTHON_GET_DEF_FULL \ ( \ - endianness, py_binary_format, \ + endianness, py_program_format, \ "Endianness of the format. The return value is of type" \ - " pychrysalide.analysis.BinContent.SourceEndian." \ + " pychrysalide.SourceEndian." \ ) - format = G_BIN_FORMAT(pygobject_get(self)); - endianness = g_binary_format_get_endianness(format); + format = G_PROGRAM_FORMAT(pygobject_get(self)); + endianness = g_program_format_get_endianness(format); - result = cast_with_constants_group_from_type(get_python_binary_content_type(), "SourceEndian", endianness); + result = cast_with_constants_group_from_module("pychrysalide", "SourceEndian", endianness); return result; } +#if 0 + /****************************************************************************** * * * Paramètres : self = classe représentant un format binaire. * @@ -907,15 +864,15 @@ static PyObject *py_binary_format_get_endianness(PyObject *self, void *closure) * * ******************************************************************************/ -static PyObject *py_binary_format_get_symbols(PyObject *self, void *closure) +static PyObject *py_program_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 */ -#define BINARY_FORMAT_SYMBOLS_ATTRIB PYTHON_GET_DEF_FULL \ +#define PROGRAM_FORMAT_SYMBOLS_ATTRIB PYTHON_GET_DEF_FULL \ ( \ - symbols, py_binary_format, \ + symbols, py_program_format, \ "Iterable list of all symbols found in the binary format.\n" \ "\n" \ "The returned iterator is a pychrysalide.format.SymIterator" \ @@ -935,13 +892,15 @@ static PyObject *py_binary_format_get_symbols(PyObject *self, void *closure) } +#endif + /* ---------------------------------------------------------------------------------- */ /* CONSERVATION DES SOUCIS DURANT LE CHARGEMENT */ /* ---------------------------------------------------------------------------------- */ - +#if 0 /****************************************************************************** * * * Paramètres : self = architecture concernée par la procédure. * @@ -955,18 +914,18 @@ static PyObject *py_binary_format_get_symbols(PyObject *self, void *closure) * * ******************************************************************************/ -static PyObject *py_binary_format_add_error(PyObject *self, PyObject *args) +static PyObject *py_program_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é */ + GProgramFormat *format; /* Format binaire manipulé */ -#define BINARY_FORMAT_ADD_ERROR_METHOD PYTHON_METHOD_DEF \ +#define PROGRAM_FORMAT_ADD_ERROR_METHOD PYTHON_METHOD_DEF \ ( \ add_error, "$self, type, addr, desc, /", \ - METH_VARARGS, py_binary_format, \ + METH_VARARGS, py_program_format, \ "Extend the list of detected errors linked to the format.\n" \ "\n" \ "The type of error has to be one of the" \ @@ -976,12 +935,12 @@ static PyObject *py_binary_format_add_error(PyObject *self, PyObject *args) " what has failed." \ ) - ret = PyArg_ParseTuple(args, "O&O&s", convert_to_binary_format_error, &type, convert_any_to_vmpa, &addr, &desc); + ret = PyArg_ParseTuple(args, "O&O&s", convert_to_program_format_error, &type, convert_any_to_vmpa, &addr, &desc); if (!ret) return NULL; - format = G_BIN_FORMAT(pygobject_get(self)); + format = G_PROGRAM_FORMAT(pygobject_get(self)); - g_binary_format_add_error(format, type, addr, desc); + g_program_format_add_error(format, type, addr, desc); clean_vmpa_arg(addr); @@ -1003,10 +962,10 @@ static PyObject *py_binary_format_add_error(PyObject *self, PyObject *args) * * ******************************************************************************/ -static PyObject *py_binary_format_get_errors(PyObject *self, void *closure) +static PyObject *py_program_format_get_errors(PyObject *self, void *closure) { PyObject *result; /* Instance Python à retourner */ - GBinFormat *format; /* Format binaire manipulé */ + GProgramFormat *format; /* Format binaire manipulé */ size_t count; /* Nombre d'éléments à traiter */ size_t i; /* Boucle de parcours */ #ifndef NDEBUG @@ -1018,9 +977,9 @@ static PyObject *py_binary_format_get_errors(PyObject *self, void *closure) PyObject *py_type; /* Version Python du type */ PyObject *error; /* Nouvelle erreur à rajouter */ -#define BINARY_FORMAT_ERRORS_ATTRIB PYTHON_GET_DEF_FULL \ +#define PROGRAM_FORMAT_ERRORS_ATTRIB PYTHON_GET_DEF_FULL \ ( \ - errors, py_binary_format, \ + errors, py_program_format, \ "List of all detected errors which occurred while loading the binary.\n" \ "\n" \ "The result is a tuple of (pychrysalide.format.BinFormat.BinaryFormatError," \ @@ -1028,24 +987,24 @@ static PyObject *py_binary_format_get_errors(PyObject *self, void *closure) " description for each error." \ ) - format = G_BIN_FORMAT(pygobject_get(self)); + format = G_PROGRAM_FORMAT(pygobject_get(self)); - g_binary_format_lock_errors(format); + g_program_format_lock_errors(format); - count = g_binary_format_count_errors(format); + count = g_program_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); + status = g_program_format_get_error(format, i, &type, &addr, &desc); assert(status); #else - g_binary_format_get_error(format, i, &type, &addr, &desc); + g_program_format_get_error(format, i, &type, &addr, &desc); #endif - py_type = cast_with_constants_group_from_type(get_python_binary_format_type(), "BinaryFormatError", type); + py_type = cast_with_constants_group_from_type(get_python_program_format_type(), "BinaryFormatError", type); error = Py_BuildValue("OO&s", py_type, build_from_internal_vmpa, &addr, desc); Py_DECREF(py_type); @@ -1053,11 +1012,12 @@ static PyObject *py_binary_format_get_errors(PyObject *self, void *closure) } - g_binary_format_unlock_errors(format); + g_program_format_unlock_errors(format); return result; } +#endif /****************************************************************************** @@ -1072,51 +1032,54 @@ static PyObject *py_binary_format_get_errors(PyObject *self, void *closure) * * ******************************************************************************/ -PyTypeObject *get_python_binary_format_type(void) +PyTypeObject *get_python_program_format_type(void) { - static PyMethodDef py_bin_format_methods[] = { - BINARY_FORMAT_SET_FLAG_METHOD, - BINARY_FORMAT_UNSET_FLAG_METHOD, - BINARY_FORMAT_HAS_FLAG_METHOD, - BINARY_FORMAT_REGISTER_CODE_POINT_METHOD, - BINARY_FORMAT_ADD_SYMBOL_METHOD, - BINARY_FORMAT_REMOVE_SYMBOL_METHOD, - BINARY_FORMAT_FIND_SYMBOL_BY_LABEL_METHOD, - BINARY_FORMAT_FIND_SYMBOL_AT_METHOD, - BINARY_FORMAT_FIND_NEXT_SYMBOL_AT_METHOD, - BINARY_FORMAT_RESOLVE_SYMBOL_METHOD, - BINARY_FORMAT_ADD_ERROR_METHOD, + static PyMethodDef py_program_format_methods[] = { + PROGRAM_FORMAT_GET_ENDIANNESS_WRAPPER, + /* + PROGRAM_FORMAT_SET_FLAG_METHOD, + PROGRAM_FORMAT_UNSET_FLAG_METHOD, + PROGRAM_FORMAT_HAS_FLAG_METHOD, + PROGRAM_FORMAT_REGISTER_CODE_POINT_METHOD, + PROGRAM_FORMAT_ADD_SYMBOL_METHOD, + PROGRAM_FORMAT_REMOVE_SYMBOL_METHOD, + PROGRAM_FORMAT_FIND_SYMBOL_BY_LABEL_METHOD, + PROGRAM_FORMAT_FIND_SYMBOL_AT_METHOD, + PROGRAM_FORMAT_FIND_NEXT_SYMBOL_AT_METHOD, + PROGRAM_FORMAT_RESOLVE_SYMBOL_METHOD, + PROGRAM_FORMAT_ADD_ERROR_METHOD, + */ { NULL } }; - static PyGetSetDef py_bin_format_getseters[] = { - BINARY_FORMAT_FLAGS_ATTRIB, - BINARY_FORMAT_ENDIANNESS_ATTRIB, - BINARY_FORMAT_SYMBOLS_ATTRIB, - BINARY_FORMAT_ERRORS_ATTRIB, + static PyGetSetDef py_program_format_getseters[] = { + //PROGRAM_FORMAT_FLAGS_ATTRIB, + PROGRAM_FORMAT_ENDIANNESS_ATTRIB, + //PROGRAM_FORMAT_SYMBOLS_ATTRIB, + //PROGRAM_FORMAT_ERRORS_ATTRIB, { NULL } }; - static PyTypeObject py_bin_format_type = { + static PyTypeObject py_program_format_type = { PyVarObject_HEAD_INIT(NULL, 0) - .tp_name = "pychrysalide.format.BinFormat", + .tp_name = "pychrysalide.format.ProgramFormat", .tp_basicsize = sizeof(PyGObject), .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_BASETYPE, - .tp_doc = BINARY_FORMAT_DOC, + .tp_doc = PROGRAM_FORMAT_DOC, - .tp_methods = py_bin_format_methods, - .tp_getset = py_bin_format_getseters, + .tp_methods = py_program_format_methods, + .tp_getset = py_program_format_getseters, - .tp_init = py_binary_format_init, - .tp_new = py_binary_format_new, + .tp_init = py_program_format_init, + .tp_new = py_program_format_new, }; - return &py_bin_format_type; + return &py_program_format_type; } @@ -1133,13 +1096,13 @@ PyTypeObject *get_python_binary_format_type(void) * * ******************************************************************************/ -bool ensure_python_binary_format_is_registered(void) +bool ensure_python_program_format_is_registered(void) { PyTypeObject *type; /* Type Python 'BinFormat' */ PyObject *module; /* Module à recompléter */ PyObject *dict; /* Dictionnaire du module */ - type = get_python_binary_format_type(); + type = get_python_program_format_type(); if (!PyType_HasFeature(type, Py_TPFLAGS_READY)) { @@ -1150,11 +1113,13 @@ bool ensure_python_binary_format_is_registered(void) if (!ensure_python_known_format_is_registered()) return false; - if (!register_class_for_pygobject(dict, G_TYPE_BIN_FORMAT, type)) + if (!register_class_for_pygobject(dict, G_TYPE_PROGRAM_FORMAT, type)) return false; - if (!define_binary_format_constants(type)) + /* + if (!define_program_format_constants(type)) return false; + */ } @@ -1176,11 +1141,11 @@ bool ensure_python_binary_format_is_registered(void) * * ******************************************************************************/ -int convert_to_binary_format(PyObject *arg, void *dst) +int convert_to_program_format(PyObject *arg, void *dst) { int result; /* Bilan à retourner */ - result = PyObject_IsInstance(arg, (PyObject *)get_python_binary_format_type()); + result = PyObject_IsInstance(arg, (PyObject *)get_python_program_format_type()); switch (result) { @@ -1194,7 +1159,7 @@ int convert_to_binary_format(PyObject *arg, void *dst) break; case 1: - *((GBinFormat **)dst) = G_BIN_FORMAT(pygobject_get(arg)); + *((GProgramFormat **)dst) = G_PROGRAM_FORMAT(pygobject_get(arg)); break; default: diff --git a/plugins/pychrysalide/format/program.h b/plugins/pychrysalide/format/program.h index 04ac9e3..647d122 100644 --- a/plugins/pychrysalide/format/program.h +++ b/plugins/pychrysalide/format/program.h @@ -1,8 +1,8 @@ /* Chrysalide - Outil d'analyse de fichiers binaires - * format.h - prototypes pour l'équivalent Python du fichier "format/format.h" + * program.h - prototypes pour l'équivalent Python du fichier "format/program.h" * - * Copyright (C) 2018-2020 Cyrille Bagard + * Copyright (C) 2018-2024 Cyrille Bagard * * This file is part of Chrysalide. * @@ -22,8 +22,8 @@ */ -#ifndef _PLUGINS_PYCHRYSALIDE_FORMAT_FORMAT_H -#define _PLUGINS_PYCHRYSALIDE_FORMAT_FORMAT_H +#ifndef _PLUGINS_PYCHRYSALIDE_FORMAT_PROGRAM_H +#define _PLUGINS_PYCHRYSALIDE_FORMAT_PROGRAM_H #include <Python.h> @@ -31,29 +31,18 @@ -/* ------------------------ 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 ensure_python_binary_symbol_iterator_is_registered(void); - - - /* ---------------------------- FORMAT BINAIRE GENERIQUE ---------------------------- */ /* Fournit un accès à une définition de type à diffuser. */ -PyTypeObject *get_python_binary_format_type(void); +PyTypeObject *get_python_program_format_type(void); -/* Prend en charge l'objet 'pychrysalide.format.BinFormat'. */ -bool ensure_python_binary_format_is_registered(void); +/* Prend en charge l'objet 'pychrysalide.format.ProgramFormat'. */ +bool ensure_python_program_format_is_registered(void); /* Tente de convertir en format de binaire. */ -int convert_to_binary_format(PyObject *, void *); +int convert_to_program_format(PyObject *, void *); -#endif /* _PLUGINS_PYCHRYSALIDE_FORMAT_FORMAT_H */ +#endif /* _PLUGINS_PYCHRYSALIDE_FORMAT_PROGRAM_H */ |