Updated the Python bindings.

git-svn-id: svn://svn.gna.org/svn/chrysalide/trunk@552 abbe820e-26c8-41b2-8c08-b7b2b41f8b0a

9 files changed, 669 insertions, 101 deletions

diff --git a/plugins/pychrysa/glibext/Makefile.am b/plugins/pychrysa/glibext/Makefile.am
index 8383434..0a61da2 100644
--- a/plugins/pychrysa/glibext/Makefile.am
+++ b/plugins/pychrysa/glibext/Makefile.am
@@ -1,12 +1,10 @@
 
 noinst_LTLIBRARIES = libpychrysaglibext.la
 
-# libpychrysaglibext_la_SOURCES =			\
-# 	bufferline.h bufferline.c			\
-# 	codebuffer.h codebuffer.c			\
-# 	module.h module.c
-
 libpychrysaglibext_la_SOURCES =			\
+	bincontent.h bincontent.c			\
+	bufferline.h bufferline.c			\
+	codebuffer.h codebuffer.c			\
 	configuration.h configuration.c		\
 	module.h module.c
 
diff --git a/plugins/pychrysa/glibext/bincontent.c b/plugins/pychrysa/glibext/bincontent.c
new file mode 100644
index 0000000..5c9856e
--- /dev/null
+++ b/plugins/pychrysa/glibext/bincontent.c
@@ -0,0 +1,267 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * bincontent.c - prototypes pour l'équivalent Python du fichier "glibext/gbincontent.c"
+ *
+ * Copyright (C) 2015 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  OpenIDA 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.
+ *
+ *  OpenIDA 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 "bincontent.h"
+
+
+#include <pygobject.h>
+
+
+#include <glibext/gbincontent.h>
+
+
+#include "../arch/vmpa.h"
+
+
+/* Crée un nouvel objet Python de type 'BinContent'. */
+static PyObject *py_binary_content_new(PyTypeObject *, PyObject *, PyObject *);
+
+/* Fournit une empreinte unique (SHA256) pour les données. */
+static PyObject *py_binary_content_get_checksum(PyObject *, PyObject *);
+
+/* Lit un nombre non signé sur un octet. */
+static PyObject *py_binary_content_read_u8(PyObject *, PyObject *);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  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 'BinContent'.            *
+*                                                                             *
+*  Retour      : Instance Python mise en place.                               *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PyObject *py_binary_content_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    PyObject *result;                       /* Instance à retourner        */
+    const char *filename;                   /* Nom du fichier à charger    */
+    int ret;                                /* Bilan de lecture des args.  */
+    GBinContent *content;                   /* Version GLib du contenu     */
+
+    ret = PyArg_ParseTuple(args, "s", &filename);
+    if (!ret) Py_RETURN_NONE;
+
+    content = g_binary_content_new_from_file(filename);
+
+    result = pygobject_new(G_OBJECT(content));
+    g_object_unref(content);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : self = contenu binaire à manipuler.                          *
+*                args = non utilisé ici.                                      *
+*                                                                             *
+*  Description : Fournit une empreinte unique (SHA256) pour les données.      *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PyObject *py_binary_content_get_checksum(PyObject *self, PyObject *args)
+{
+    PyObject *result;                       /* Instance à retourner        */
+    GBinContent *content;                   /* Version GLib du format      */
+    const gchar *checksum;                  /* Empreinte fournie           */
+
+    content = G_BIN_CONTENT(pygobject_get(self));
+
+    checksum = g_binary_content_get_cheksum(content);
+
+    result = PyUnicode_FromString(checksum);
+    Py_INCREF(result);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : self = contenu binaire à manipuler.                          *
+*                args = non utilisé ici.                                      *
+*                                                                             *
+*  Description : Lit un nombre non signé sur un octet.                        *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PyObject *py_binary_content_read_u8(PyObject *self, PyObject *args)
+{
+    PyObject *result;                       /* Instance à retourner        */
+    GBinContent *content;                   /* Version GLib du format      */
+    int ret;                                /* Bilan de lecture des args.  */
+    PyObject *addr_obj;                     /* Objet pour une position     */
+    vmpa2t *addr;                           /* Position interne associée   */
+    uint8_t val;                            /* Valeur lue à faire suivre   */
+    bool status;                            /* Bilan de l'opération        */
+
+    content = G_BIN_CONTENT(pygobject_get(self));
+
+    printf("Passage\n");
+
+    ret = PyArg_ParseTuple(args, "O", &addr_obj);
+
+    printf("ret == %d\n", ret);
+
+    if (!ret) return NULL;
+
+    addr = get_internal_vmpa(addr_obj);
+    if (addr == NULL) /* ... */;
+
+    status = g_binary_content_read_u8(content, addr, /*SourceEndian endian*/0, &val);
+    if (!status) return NULL;
+
+    printf("val :: 0x%02hhx\n", val);
+
+    result = PyBytes_FromStringAndSize((char *)&val, 1);;
+    //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_binary_content_type(void)
+{
+    static PyMethodDef py_binary_content_methods[] = {
+        { "get_cheksum", py_binary_content_get_checksum,
+          METH_NOARGS,
+          "Compute a SHA256 hash as chechsum of handled data."
+        },
+        { "read_u8", py_binary_content_read_u8,
+          METH_VARARGS,
+          "read_u8($self, addr, /)\n--\n\nRead an unsigned byte from a given position."
+        },
+        { NULL }
+    };
+
+    static PyGetSetDef py_binary_content_getseters[] = {
+        { NULL }
+    };
+
+    static PyTypeObject py_binary_content_type = {
+
+        PyVarObject_HEAD_INIT(NULL, 0)
+
+        .tp_name        = "pychrysalide.glibext.BinContent",
+        .tp_basicsize   = sizeof(PyGObject),
+
+        .tp_flags       = Py_TPFLAGS_DEFAULT,
+
+        .tp_doc         = "PyChrysalide binary content",
+
+        .tp_methods     = py_binary_content_methods,
+        .tp_getset      = py_binary_content_getseters,
+        .tp_new         = (newfunc)py_binary_content_new
+
+    };
+
+    return &py_binary_content_type;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : module = module dont la définition est à compléter.          *
+*                                                                             *
+*  Description : Prend en charge l'objet 'pychrysalide.glibext.BinContent'.   *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool register_python_binary_content(PyObject *module)
+{
+    PyTypeObject *py_binary_content_type;   /* Type Python 'BinContent'    */
+    int ret;                                /* Bilan d'un appel            */
+    PyObject *dict;                         /* Dictionnaire du module      */
+
+    py_binary_content_type = get_python_binary_content_type();
+
+    py_binary_content_type->tp_base = &PyGObject_Type;
+    py_binary_content_type->tp_basicsize = py_binary_content_type->tp_base->tp_basicsize;
+
+    if (PyType_Ready(py_binary_content_type) != 0)
+        return false;
+
+    Py_INCREF(py_binary_content_type);
+    ret = PyModule_AddObject(module, "BinContent", (PyObject *)py_binary_content_type);
+    if (ret != 0) return false;
+
+    dict = PyModule_GetDict(module);
+    pygobject_register_class(dict, "BinContent", G_TYPE_BIN_CONTENT, py_binary_content_type,
+                             Py_BuildValue("(O)", py_binary_content_type->tp_base));
+
+    return true;
+
+}
diff --git a/plugins/pychrysa/glibext/bincontent.h b/plugins/pychrysa/glibext/bincontent.h
new file mode 100644
index 0000000..b6ae9a5
--- /dev/null
+++ b/plugins/pychrysa/glibext/bincontent.h
@@ -0,0 +1,42 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * bincontent.h - prototypes pour l'équivalent Python du fichier "glibext/gbincontent.h"
+ *
+ * Copyright (C) 2015 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  OpenIDA 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.
+ *
+ *  OpenIDA 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_PYCHRYSA_GLIBEXT_BINCONTENT_H
+#define _PLUGINS_PYCHRYSA_GLIBEXT_BINCONTENT_H
+
+
+#include <Python.h>
+#include <stdbool.h>
+
+
+
+/* Fournit un accès à une définition de type à diffuser. */
+PyTypeObject *get_python_binary_content_type(void);
+
+/* Prend en charge l'objet 'pychrysalide.glibext.BinContent'. */
+bool register_python_binary_content(PyObject *);
+
+
+
+#endif  /* _PLUGINS_PYCHRYSA_GLIBEXT_BINCONTENT_H */
diff --git a/plugins/pychrysa/glibext/bufferline.c b/plugins/pychrysa/glibext/bufferline.c
index d5b8b13..ce85cfb 100644
--- a/plugins/pychrysa/glibext/bufferline.c
+++ b/plugins/pychrysa/glibext/bufferline.c
@@ -29,16 +29,35 @@
 #include <pygobject.h>
 
 
+#include <i18n.h>
+
+
 #include <glibext/gbufferline.h>
 
 
-#include "../quirks.h"
+#include "../helpers.h"
+#include "../arch/vmpa.h"
 
 
 
 /* Reconstruit et fournit le texte présent sur une ligne tampon. */
 static PyObject *py_buffer_line_get_text(PyObject *, PyObject *);
 
+/* Ajoute une propriété particulière à une ligne donnée. */
+static PyObject *py_buffer_line_add_flag(PyObject *, PyObject *);
+
+/* Retire une propriété particulière à une ligne donnée. */
+static PyObject *py_buffer_line_remove_flag(PyObject *, PyObject *);
+
+/* Fournit l'emplacement où se situe un symbole. */
+static PyObject *py_buffer_line_get_range(PyObject *, void *);
+
+/* Renseigne sur les propriétés particulières liées à une ligne. */
+static PyObject *py_buffer_line_get_flags(PyObject *, void *);
+
+/* Définit les constantes pour les lignes de tampon. */
+static bool py_buffer_line_define_constants(PyTypeObject *);
+
 
 
 /******************************************************************************
@@ -57,13 +76,26 @@ static PyObject *py_buffer_line_get_text(PyObject *, PyObject *);
 static PyObject *py_buffer_line_get_text(PyObject *self, PyObject *args)
 {
     PyObject *result;                       /* Trouvailles à retourner     */
+    BufferLineColumn first;                 /* Première colonne à parcourir*/
+    BufferLineColumn end;                   /* Dernière colonne à parcourir*/
+    int markup;                             /* Besoin de décorations ?     */
+    int ret;                                /* Bilan de lecture des args.  */
     GBufferLine *line;                      /* Version native              */
     char *text;                             /* Texte reconstruit à libérer */
 
+    ret = PyArg_ParseTuple(args, "IIp", &first, &end, &markup);
+    if (!ret) return NULL;
+
+    if (first >= BLC_COUNT || end >= BLC_COUNT)
+    {
+        PyErr_SetString(PyExc_ValueError, _("Invalid range in arguments"));
+        return NULL;
+    }
+
     line = G_BUFFER_LINE(pygobject_get(self));
-    text = "";//g_buffer_line_get_text(line);
+    text = g_buffer_line_get_text(line, first, end, markup);
 
-    result = PyString_FromString(text);
+    result = PyUnicode_FromString(text);
 
     free(text);
 
@@ -74,60 +106,278 @@ static PyObject *py_buffer_line_get_text(PyObject *self, PyObject *args)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : module = module dont la définition est à compléter.          *
+*  Paramètres  : self = classe représentant une ligne de tampon.              *
+*                args = arguments fournis à l'appel.                          *
 *                                                                             *
-*  Description : Prend en charge l'objet 'pychrysalide.glibext.BufferLine'.   *
+*  Description : Ajoute une propriété particulière à une ligne donnée.        *
 *                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-bool register_python_buffer_line(PyObject *module)
+static PyObject *py_buffer_line_add_flag(PyObject *self, PyObject *args)
 {
-    PyObject *pygobj_mod;                   /* Module Python-GObject       */
-    int ret;                                /* Bilan d'un appel            */
+    BufferLineFlags flag;                   /* Drapeau à considérer        */
+    int ret;                                /* Bilan de lecture des args.  */
+    GBufferLine *line;                      /* Version native              */
+
+    ret = PyArg_ParseTuple(args, "I", &flag);
+    if (!ret) return NULL;
+
+    if ((flag & ~BLF_ALL) != 0)
+    {
+        PyErr_SetString(PyExc_ValueError, _("Invalid flag"));
+        return NULL;
+    }
+
+    line = G_BUFFER_LINE(pygobject_get(self));
+    g_buffer_line_add_flag(line, flag);
+
+    Py_RETURN_NONE;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : self = classe représentant une ligne de tampon.              *
+*                args = arguments fournis à l'appel.                          *
+*                                                                             *
+*  Description : Retire une propriété particulière à une ligne donnée.        *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PyObject *py_buffer_line_remove_flag(PyObject *self, PyObject *args)
+{
+    BufferLineFlags flag;                   /* Drapeau à considérer        */
+    int ret;                                /* Bilan de lecture des args.  */
+    GBufferLine *line;                      /* Version native              */
+
+    ret = PyArg_ParseTuple(args, "I", &flag);
+    if (!ret) return NULL;
+
+    if ((flag & ~BLF_ALL) != 0)
+    {
+        PyErr_SetString(PyExc_ValueError, _("Invalid flag"));
+        return NULL;
+    }
+
+    line = G_BUFFER_LINE(pygobject_get(self));
+    g_buffer_line_remove_flag(line, flag);
+
+    Py_RETURN_NONE;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : self    = objet Python concerné par l'appel.                 *
+*                closure = non utilisé ici.                                   *
+*                                                                             *
+*  Description : Indique la zone mémoire où se situe la ligne.                *
+*                                                                             *
+*  Retour      : Emplacement mémoire virtuel ou physique.                     *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PyObject *py_buffer_line_get_range(PyObject *self, void *closure)
+{
+    PyObject *result;                       /* Valeur à retourner          */
+    GBufferLine *line;                      /* Elément à consulter         */
+    const mrange_t *range;                  /* Couverture courante         */
+
+    line = G_BUFFER_LINE(pygobject_get(self));
+    range = g_buffer_line_get_range(line);
+
+    result = build_from_internal_mrange(range);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : self    = objet Python concerné par l'appel.                 *
+*                closure = non utilisé ici.                                   *
+*                                                                             *
+*  Description : Renseigne sur les propriétés particulières liées à une ligne.*
+*                                                                             *
+*  Retour      : Propriétés intégrées.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PyObject *py_buffer_line_get_flags(PyObject *self, void *closure)
+{
+    PyObject *result;                       /* Valeur à retourner          */
+    GBufferLine *line;                      /* Elément à consulter         */
+    BufferLineFlags flags;                  /* Drapeaux à exporter         */
+
+    line = G_BUFFER_LINE(pygobject_get(self));
+    flags = g_buffer_line_get_flags(line);
+
+    result = PyLong_FromLong(flags);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : obj_type = type dont le dictionnaire est à compléter.        *
+*                                                                             *
+*  Description : Définit les constantes pour les lignes de tampon.            *
+*                                                                             *
+*  Retour      : true en cas de succès de l'opération, false sinon.           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool py_buffer_line_define_constants(PyTypeObject *obj_type)
+{
+    bool result;                            /* Bilan à retourner           */
+
+    result = true;
+
+    result &= PyDict_AddIntMacro(obj_type, BLC_PHYSICAL);
+    result &= PyDict_AddIntMacro(obj_type, BLC_VIRTUAL);
+    result &= PyDict_AddIntMacro(obj_type, BLC_BINARY);
+    result &= PyDict_AddIntMacro(obj_type, BLC_ASSEMBLY_HEAD);
+    result &= PyDict_AddIntMacro(obj_type, BLC_ASSEMBLY);
+    result &= PyDict_AddIntMacro(obj_type, BLC_COMMENTS);
+    result &= PyDict_AddIntMacro(obj_type, BLC_COUNT);
+    result &= PyDict_AddIntMacro(obj_type, BLC_LAST_USED);
+    result &= PyDict_AddIntMacro(obj_type, BLC_INVALID);
+    result &= PyDict_AddIntMacro(obj_type, BLC_MAIN);
+    result &= PyDict_AddIntMacro(obj_type, BLC_FIRST);
+    result &= PyDict_AddIntMacro(obj_type, BLC_DISPLAY);
+
+    result &= PyDict_AddIntMacro(obj_type, BLF_NONE);
+    result &= PyDict_AddIntMacro(obj_type, BLF_HAS_CODE);
+    result &= PyDict_AddIntMacro(obj_type, BLF_ENTRYPOINT);
+    result &= PyDict_AddIntMacro(obj_type, BLF_BOOKMARK);
+
+    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_buffer_line_type(void)
+{
     static PyMethodDef py_buffer_line_methods[] = {
         {
-            "get_text", (PyCFunction)py_buffer_line_get_text,
-            METH_NOARGS,
-            "Rebuild and provide the text of a buffer line."
+            "get_text", py_buffer_line_get_text,
+            METH_VARARGS,
+            "get_text($self, first_col, last_col, markup, /)\n--\n\nProvide the text of a buffer line."
+        },
+        {
+            "add_flag", py_buffer_line_add_flag,
+            METH_VARARGS,
+            "add_flag($self, flag, /)\n--\n\nAdd a flag to the buffer line."
+        },
+        {
+            "remove_flag", py_buffer_line_remove_flag,
+            METH_VARARGS,
+            "remove_flag($self, flag, /)\n--\n\nRemove a flag from the buffer line."
+        },
+        { NULL }
+    };
+
+    static PyGetSetDef py_buffer_line_getseters[] = {
+        {
+            "range", py_buffer_line_get_range, NULL,
+            "Range covered by the line.", NULL
+        },
+        {
+            "flags", py_buffer_line_get_flags, NULL,
+            "Current flags of the buffer line.", NULL
         },
         { NULL }
     };
 
     static PyTypeObject py_buffer_line_type = {
 
-        PyObject_HEAD_INIT(NULL)
+        PyVarObject_HEAD_INIT(NULL, 0)
 
         .tp_name        = "pychrysalide.glibext.BufferLine",
         .tp_basicsize   = sizeof(PyGObject),
 
-        .tp_flags       = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+        .tp_flags       = Py_TPFLAGS_DEFAULT,
 
         .tp_doc         = "PyChrysalide buffer line",
 
-        .tp_methods     = py_buffer_line_methods
+        .tp_methods     = py_buffer_line_methods,
+        .tp_getset      = py_buffer_line_getseters,
 
     };
 
-    pygobj_mod = PyImport_ImportModule("gobject");
-    if (pygobj_mod == NULL) return false;
+    return &py_buffer_line_type;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : module = module dont la définition est à compléter.          *
+*                                                                             *
+*  Description : Prend en charge l'objet 'pychrysalide.glibext.BufferLine'.   *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
 
-    py_buffer_line_type.tp_base = (PyTypeObject *)PyObject_GetAttrString(pygobj_mod, "GObject");
-    Py_DECREF(pygobj_mod);
+bool register_python_buffer_line(PyObject *module)
+{
+    PyTypeObject *py_buffer_line_type;      /* Type Python 'BufferLine'    */
+    int ret;                                /* Bilan d'un appel            */
+    PyObject *dict;                         /* Dictionnaire du module      */
+
+    py_buffer_line_type = get_python_buffer_line_type();
+
+    py_buffer_line_type->tp_base = &PyGObject_Type;
+    py_buffer_line_type->tp_basicsize = py_buffer_line_type->tp_base->tp_basicsize;
+
+    if (PyType_Ready(py_buffer_line_type) != 0)
+        return false;
 
-    if (PyType_Ready(&py_buffer_line_type) < 0)
+    if (!py_buffer_line_define_constants(py_buffer_line_type))
         return false;
 
-    Py_INCREF(&py_buffer_line_type);
-    ret = PyModule_AddObject(module, "BufferLine", (PyObject *)&py_buffer_line_type);
+    Py_INCREF(py_buffer_line_type);
+    ret = PyModule_AddObject(module, "BufferLine", (PyObject *)py_buffer_line_type);
+    if (ret != 0) return false;
 
-    pygobject_register_class(module, "GBufferLine", G_TYPE_BUFFER_LINE, &py_buffer_line_type,
-                             Py_BuildValue("(O)", py_buffer_line_type.tp_base));
+    dict = PyModule_GetDict(module);
+    pygobject_register_class(dict, "BufferLine", G_TYPE_BUFFER_LINE, py_buffer_line_type,
+                             Py_BuildValue("(O)", py_buffer_line_type->tp_base));
 
-    return (ret == 0);
+    return true;
 
 }
diff --git a/plugins/pychrysa/glibext/bufferline.h b/plugins/pychrysa/glibext/bufferline.h
index 282a61a..e02b05f 100644
--- a/plugins/pychrysa/glibext/bufferline.h
+++ b/plugins/pychrysa/glibext/bufferline.h
@@ -31,6 +31,9 @@
 
 
 
+/* Fournit un accès à une définition de type à diffuser. */
+PyTypeObject *get_python_buffer_line_type(void);
+
 /* Prend en charge l'objet 'pychrysalide.glibext.BufferLine'. */
 bool register_python_buffer_line(PyObject *);
 
diff --git a/plugins/pychrysa/glibext/codebuffer.c b/plugins/pychrysa/glibext/codebuffer.c
index 6368ee7..9d9bc96 100644
--- a/plugins/pychrysa/glibext/codebuffer.c
+++ b/plugins/pychrysa/glibext/codebuffer.c
@@ -31,7 +31,7 @@
 #include <glibext/gcodebuffer.h>
 
 
-#include "../quirks.h"
+#include "../arch/vmpa.h"
 
 
 
@@ -56,15 +56,22 @@ static PyObject *py_code_buffer_find_line_by_addr(PyObject *, PyObject *);
 static PyObject *py_code_buffer_find_line_by_addr(PyObject *self, PyObject *args)
 {
     PyObject *result;                       /* Trouvailles à retourner     */
-    GCodeBuffer *buffer;                    /* Version native              */
-    vmpa_t addr;                            /* Adresse visée par l'opérat° */
+    PyObject *py_vmpa;                      /* Localisation version Python */
     int ret;                                /* Bilan de lecture des args.  */
+    vmpa2t *addr;                           /* Adresse visée par l'opérat° */
+    GCodeBuffer *buffer;                    /* Version native              */
     GBufferLine *line;                      /* Ligne trouvée               */
 
-    buffer = G_CODE_BUFFER(pygobject_get(self));
+    ret = PyArg_ParseTuple(args, "O", &py_vmpa);
+    if (!ret) return NULL;
 
-    ret = PyArg_ParseTuple(args, "K", &addr);
-    if (!ret) Py_RETURN_NONE;
+    ret = PyObject_IsInstance(py_vmpa, (PyObject *)get_python_vmpa_type());
+    if (!ret) return NULL;
+
+    addr = get_internal_vmpa(py_vmpa);
+    if (addr == NULL) return NULL;
+
+    buffer = G_CODE_BUFFER(pygobject_get(self));
 
     line = g_code_buffer_find_line_by_addr(buffer, addr, 0, NULL);
     if (line == NULL) Py_RETURN_NONE;
@@ -78,60 +85,86 @@ static PyObject *py_code_buffer_find_line_by_addr(PyObject *self, PyObject *args
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : module = module dont la définition est à compléter.          *
+*  Paramètres  : -                                                            *
 *                                                                             *
-*  Description : Prend en charge l'objet 'pychrysalide.glibext.Codebuffer'.   *
+*  Description : Fournit un accès à une définition de type à diffuser.        *
 *                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
+*  Retour      : Définition d'objet pour Python.                              *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-bool register_python_code_buffer(PyObject *module)
+PyTypeObject *get_python_code_buffer_type(void)
 {
-    PyObject *pygobj_mod;                   /* Module Python-GObject       */
-    int ret;                                /* Bilan d'un appel            */
-
     static PyMethodDef py_code_buffer_methods[] = {
         {
             "find_line_by_addr", (PyCFunction)py_code_buffer_find_line_by_addr,
             METH_VARARGS,
-            "Find a buffer line with a given address."
+            "find_line_by_addr($self, addr, /)\n--\n\nFind a buffer line with a given address."
         },
         { NULL }
     };
 
+    static PyGetSetDef py_code_buffer_getseters[] = {
+        { NULL }
+    };
+
     static PyTypeObject py_code_buffer_type = {
 
-        PyObject_HEAD_INIT(NULL)
+        PyVarObject_HEAD_INIT(NULL, 0)
 
         .tp_name        = "pychrysalide.glibext.CodeBuffer",
         .tp_basicsize   = sizeof(PyGObject),
 
-        .tp_flags       = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+        .tp_flags       = Py_TPFLAGS_DEFAULT,
 
         .tp_doc         = "PyChrysalide code buffer",
 
-        .tp_methods     = py_code_buffer_methods
+        .tp_methods     = py_code_buffer_methods,
+        .tp_getset      = py_code_buffer_getseters,
 
     };
 
-    pygobj_mod = PyImport_ImportModule("gobject");
-    if (pygobj_mod == NULL) return false;
+    return &py_code_buffer_type;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : module = module dont la définition est à compléter.          *
+*                                                                             *
+*  Description : Prend en charge l'objet 'pychrysalide.glibext.CodeBuffer'.   *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool register_python_code_buffer(PyObject *module)
+{
+    PyTypeObject *py_code_buffer_type;      /* Type Python 'CodeBuffer'    */
+    int ret;                                /* Bilan d'un appel            */
+    PyObject *dict;                         /* Dictionnaire du module      */
+
+    py_code_buffer_type = get_python_code_buffer_type();
 
-    py_code_buffer_type.tp_base = (PyTypeObject *)PyObject_GetAttrString(pygobj_mod, "GObject");
-    Py_DECREF(pygobj_mod);
+    py_code_buffer_type->tp_base = &PyGObject_Type;
+    py_code_buffer_type->tp_basicsize = py_code_buffer_type->tp_base->tp_basicsize;
 
-    if (PyType_Ready(&py_code_buffer_type) < 0)
+    if (PyType_Ready(py_code_buffer_type) != 0)
         return false;
 
-    Py_INCREF(&py_code_buffer_type);
-    ret = PyModule_AddObject(module, "CodeBuffer", (PyObject *)&py_code_buffer_type);
+    Py_INCREF(py_code_buffer_type);
+    ret = PyModule_AddObject(module, "CodeBuffer", (PyObject *)py_code_buffer_type);
+    if (ret != 0) return false;
 
-    pygobject_register_class(module, "GCodeBuffer", G_TYPE_CODE_BUFFER, &py_code_buffer_type,
-                             Py_BuildValue("(O)", py_code_buffer_type.tp_base));
+    dict = PyModule_GetDict(module);
+    pygobject_register_class(dict, "CodeBuffer", G_TYPE_CODE_BUFFER, py_code_buffer_type,
+                             Py_BuildValue("(O)", py_code_buffer_type->tp_base));
 
-    return (ret == 0);
+    return true;
 
 }
diff --git a/plugins/pychrysa/glibext/codebuffer.h b/plugins/pychrysa/glibext/codebuffer.h
index e921e36..83ec508 100644
--- a/plugins/pychrysa/glibext/codebuffer.h
+++ b/plugins/pychrysa/glibext/codebuffer.h
@@ -31,6 +31,9 @@
 
 
 
+/* Fournit un accès à une définition de type à diffuser. */
+PyTypeObject *get_python_code_buffer_type(void);
+
 /* Prend en charge l'objet 'pychrysalide.glibext.CodeBuffer'. */
 bool register_python_code_buffer(PyObject *);
 
diff --git a/plugins/pychrysa/glibext/configuration.c b/plugins/pychrysa/glibext/configuration.c
index 9820af3..fd35b19 100644
--- a/plugins/pychrysa/glibext/configuration.c
+++ b/plugins/pychrysa/glibext/configuration.c
@@ -67,15 +67,10 @@ static bool py_config_param_define_constants(PyObject *);
 /* ----------------------------- PARCOURS DE PARAMETRES ----------------------------- */
 
 
-
+/* Parcours des éléments de configuration */
 typedef struct _pyConfigParamIterator
 {
-
-  PyObject_HEAD
-  long int m;
-  long int i;
-
-
+    PyObject_HEAD                           /* A laisser en premier        */
 
     GGenConfig *config;                     /* Configuration à parcourir   */
     GList *params;                          /* Liste de paramètres         */
@@ -85,15 +80,10 @@ typedef struct _pyConfigParamIterator
 } pyConfigParamIterator;
 
 
-
-
 /* Prend acte d'un compteur de référence à 0. */
 static void py_config_param_iterator_dealloc(PyObject *);
 
 /* Fournit un itérateur pour paramètres de configuration. */
-static PyObject *py_config_param_iterator_iter(PyObject *);
-
-/* Fournit un itérateur pour paramètres de configuration. */
 static PyObject *py_config_param_iterator_next(PyObject *);
 
 /* Initialise un objet Python de type 'ConfigParamIterator'. */
@@ -646,28 +636,7 @@ static void py_config_param_iterator_dealloc(PyObject *self)
     g_generic_config_runlock(iterator->config);
     g_object_unref(G_OBJECT(iterator->config));
 
-    Py_TYPE(self)->tp_free((PyObject*)self);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : self = itérateur à manipuler.                                *
-*                                                                             *
-*  Description : Fournit un itérateur pour paramètres de configuration.       *
-*                                                                             *
-*  Retour      : Instance Python prête à emploi.                              *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static PyObject *py_config_param_iterator_iter(PyObject *self)
-{
-    Py_INCREF(self);
-
-    return self;
+    Py_TYPE(self)->tp_free((PyObject *)self);
 
 }
 
@@ -700,7 +669,7 @@ static PyObject *py_config_param_iterator_next(PyObject *self)
     if (item != NULL)
     {
         result = pygobject_new(G_OBJECT(item->data));
-        Py_XINCREF(result);
+        Py_INCREF(result);
     }
     else
     {
@@ -782,7 +751,7 @@ PyTypeObject *get_python_config_param_iterator_type(void)
 
         .tp_doc         = "Iterator for configuration parameters",
 
-        .tp_iter        = py_config_param_iterator_iter,
+        .tp_iter        = PyObject_SelfIter,
         .tp_iternext    = py_config_param_iterator_next,
 
         .tp_init        = py_config_param_iterator_init,
@@ -816,7 +785,6 @@ bool register_python_config_param_iterator(PyObject *module)
     py_config_param_iterator_type = get_python_config_param_iterator_type();
 
     py_config_param_iterator_type->tp_base = &PyBaseObject_Type;
-    py_config_param_iterator_type->tp_basicsize = py_config_param_iterator_type->tp_base->tp_basicsize;
 
     if (PyType_Ready(py_config_param_iterator_type) != 0)
         return false;
@@ -1063,7 +1031,7 @@ static PyObject *py_generic_config_list_params(PyObject *self, PyObject *args)
     PyObject *args_list;                    /* Arguments de mise en place  */
 
     iterator_type = get_python_config_param_iterator_type();
-    
+
     Py_INCREF(self);
 
     args_list = Py_BuildValue("(O)", self);
diff --git a/plugins/pychrysa/glibext/module.c b/plugins/pychrysa/glibext/module.c
index 9f3d3a8..0cb96a7 100644
--- a/plugins/pychrysa/glibext/module.c
+++ b/plugins/pychrysa/glibext/module.c
@@ -25,6 +25,12 @@
 #include "module.h"
 
 
+#include <assert.h>
+
+
+#include "bincontent.h"
+#include "bufferline.h"
+#include "codebuffer.h"
 #include "configuration.h"
 
 
@@ -75,18 +81,16 @@ bool add_glibext_module_to_python_module(PyObject *super)
 
     result = true;
 
+    result &= register_python_binary_content(module);
+    result &= register_python_buffer_line(module);
+    result &= register_python_code_buffer(module);
     result &= register_python_config_param(module);
     result &= register_python_config_param_iterator(module);
     result &= register_python_generic_config(module);
 
  agmtpm_exit:
 
-    if (!result)
-    {
-        printf("something went wrong in %s...\n", __FUNCTION__);
-        /* ... */
-
-    }
+    assert(result);
 
     return result;