Updated the Python bindings.

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

1 files changed, 651 insertions, 9 deletions

diff --git a/plugins/pychrysa/arch/vmpa.c b/plugins/pychrysa/arch/vmpa.c
index 43131b5..350f61b 100644
--- a/plugins/pychrysa/arch/vmpa.c
+++ b/plugins/pychrysa/arch/vmpa.c
@@ -28,11 +28,14 @@
 #include <string.h>
 
 
+#include "../helpers.h"
 
 
 
 
 
+/* ---------------------- DEFINITION D'UNE POSITION EN MEMOIRE ---------------------- */
+
 
 
 typedef struct _py_vmpa_t
@@ -49,7 +52,7 @@ typedef struct _py_vmpa_t
 /* Fournit une représentation d'une variable 'vmpa_t'. */
 static PyObject *py_vmpa_to_str(PyObject *);
 
-/* Effectue une conversion d'un objet Python en type 'vmpa_t'. */
+/* Effectue une comparaison avec un objet Python 'vmpa_t'. */
 static PyObject *py_vmpa_richcompare(PyObject *, PyObject *, int);
 
 /* Fournit une partie du contenu de la position représentée. */
@@ -67,12 +70,74 @@ static bool convert_pyobj_to_vmpa(PyObject *, vmpa2t *);
 /* Effectue une opération de type 'add' avec le type 'vmpa'. */
 static PyObject *py_vmpa_nb_add(PyObject *, PyObject *);
 
+/* Définit les constantes pour les localisations. */
+static bool py_vmpa_define_constants(PyTypeObject *);
+
+
+
+/* ------------------------ DEFINITION D'UNE ZONE EN MEMOIRE ------------------------ */
+
+
+/* Couverture mémoire */
+typedef struct _py_mrange_t
+{
+    PyObject_HEAD                           /* Préambule Python            */
+
+    mrange_t range;                         /* Informations internes       */
+
+} py_mrange_t;
+
+
+/* Fournit une représentation d'une variable 'mrange_t'. */
+static PyObject *py_mrange_to_str(PyObject *);
+
+
+
+/* Effectue une comparaison avec un objet Python 'mrange_t'. */
+static PyObject *py_mrange_richcompare(PyObject *, PyObject *, int);
+
+
+
+/* Indique si une zone en contient une autre ou non. */
+static PyObject *py_mrange_contains(PyObject *, PyObject *);
+
+
+
+
+/* Fournit la position de départ de la zone mémoire représentée. */
+static PyObject *py_mrange_get_addr(PyObject *, void *);
+
+/* Définit la position de départ de la zone mémoire représentée. */
+static int py_mrange_set_addr(PyObject *, PyObject *, void *);
+
+/* Fournit la taille de la zone mémoire représentée. */
+static PyObject *py_mrange_get_length(PyObject *, void *);
+
+/* Définit la taille de la zone mémoire représentée. */
+static int py_mrange_set_length(PyObject *, PyObject *, void *);
+
+/* Calcule la position extérieure finale d'une couverture. */
+static PyObject *py_mrange_get_end_addr(PyObject *, void *);
+
+
+
 
+/* Crée un nouvel objet Python de type 'mrange'. */
+static PyObject *py_mrange_new(PyTypeObject *, PyObject *, PyObject *);
 
 
 
 
 
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                        DEFINITION D'UNE POSITION EN MEMOIRE                        */
+/* ---------------------------------------------------------------------------------- */
+
+
+
+
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : obj = objet Python à traiter.                                *
@@ -119,7 +184,7 @@ static PyObject *py_vmpa_to_str(PyObject *obj)
 *  Paramètres  : obj  = objet Python à tenter de convertir.                   *
 *                addr = structure équivalente pour Chrysalide.                *
 *                                                                             *
-*  Description : Effectue une conversion d'un objet Python en type 'vmpa_t'.  *
+*  Description : Effectue une comparaison avec un objet Python 'vmpa_t'.      *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -184,7 +249,7 @@ static PyObject *py_vmpa_get_value(PyObject *self, void *closure)
 
     key = (char *)closure;
 
-    if (strcmp(key, "phy") == 0)
+    if (strcmp(key, "phys") == 0)
     {
         if (get_phy_addr(&vmpa->addr) == VMPA_NO_PHYSICAL)
         {
@@ -236,7 +301,7 @@ static int py_vmpa_set_value(PyObject *self, PyObject *value, void *closure)
 
     key = (char *)closure;
 
-    if (strcmp(key, "phy") == 0)
+    if (strcmp(key, "phys") == 0)
     {
         if (value == Py_None)
             init_vmpa(&vmpa->addr, VMPA_NO_PHYSICAL, get_virt_addr(&vmpa->addr));
@@ -296,7 +361,7 @@ static int py_vmpa_set_value(PyObject *self, PyObject *value, void *closure)
 
 static PyObject *py_vmpa_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 {
-    py_vmpa_t *result;                       /* Instance à retourner        */
+    py_vmpa_t *result;                      /* Instance à retourner        */
     unsigned long long phy;                 /* Position physique           */
     unsigned long long virt;                /* Adresse en mémoire virtuelle*/
     int ret;                                /* Bilan de lecture des args.  */
@@ -442,6 +507,32 @@ void change_editor_items_current_view_content(void/*GtkViewPanel*/ *view)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : obj_type = type dont le dictionnaire est à compléter.        *
+*                                                                             *
+*  Description : Définit les constantes pour les localisations.               *
+*                                                                             *
+*  Retour      : true en cas de succès de l'opération, false sinon.           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool py_vmpa_define_constants(PyTypeObject *obj_type)
+{
+    bool result;                            /* Bilan à retourner           */
+
+    result = true;
+
+    result &= PyDict_AddIntMacro(obj_type, VMPA_NO_PHYSICAL);
+    result &= PyDict_AddIntMacro(obj_type, VMPA_NO_VIRTUAL);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : -                                                            *
 *                                                                             *
 *  Description : Fournit un accès à une définition de type à diffuser.        *
@@ -504,13 +595,13 @@ PyTypeObject *get_python_vmpa_type(void)
     static PyGetSetDef py_vmpa_getseters[] = {
 
         {
-            "phy", py_vmpa_get_value, py_vmpa_set_value,
-            "Give access to the physical offset of the location", "phy"
+            "phys", py_vmpa_get_value, py_vmpa_set_value,
+            "Give access to the physical offset of the location.", "phys"
         },
 
         {
             "virt", py_vmpa_get_value, py_vmpa_set_value,
-            "Give access to the virtual address of the location", "virt"
+            "Give access to the virtual address of the location.", "virt"
         },
         { NULL }
 
@@ -529,7 +620,7 @@ PyTypeObject *get_python_vmpa_type(void)
 
         .tp_flags       = Py_TPFLAGS_DEFAULT,
 
-        .tp_doc         = "Python object for vmpa_t",
+        .tp_doc         = "Python object for vmpa_t.",
 
         .tp_richcompare = py_vmpa_richcompare,
 
@@ -565,6 +656,9 @@ bool register_python_vmpa(PyObject *module)
     if (PyType_Ready(py_vmpa_type) != 0)
         return false;
 
+    if (!py_vmpa_define_constants(py_vmpa_type))
+        return false;
+
     Py_INCREF(py_vmpa_type);
     ret = PyModule_AddObject(module, "vmpa", (PyObject *)py_vmpa_type);
 
@@ -595,3 +689,551 @@ vmpa2t *get_internal_vmpa(PyObject *obj)
     return &((py_vmpa_t *)obj)->addr;
 
 }
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : addr = structure interne à copier en objet Python.           *
+*                                                                             *
+*  Description : Convertit une structure de type 'vmpa2t' en objet Python.    *
+*                                                                             *
+*  Retour      : Object Python résultant de la conversion opérée.             *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+PyObject *build_from_internal_vmpa(const vmpa2t *addr)
+{
+    py_vmpa_t *result;                      /* Instance à retourner        */
+    PyTypeObject *type;                     /* Type à instancier           */
+
+    type = get_python_vmpa_type();
+
+    result = (py_vmpa_t *)type->tp_alloc(type, 0);
+
+    copy_vmpa(&result->addr, addr);
+
+    return (PyObject *)result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                          DEFINITION D'UNE ZONE EN MEMOIRE                          */
+/* ---------------------------------------------------------------------------------- */
+
+
+
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : obj = objet Python à traiter.                                *
+*                                                                             *
+*  Description : Fournit une représentation d'une variable 'mrange_t'.        *
+*                                                                             *
+*  Retour      : Chaîne de caractère pour Python.                             *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PyObject *py_mrange_to_str(PyObject *obj)
+{
+    PyObject *result;                       /* Chaîne à retourner          */
+
+    result = PyUnicode_FromFormat("<TODO!>");
+
+    return result;
+
+}
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : obj  = objet Python à tenter de convertir.                   *
+*                addr = structure équivalente pour Chrysalide.                *
+*                                                                             *
+*  Description : Effectue une comparaison avec un objet Python 'mrange_t'.    *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PyObject *py_mrange_richcompare(PyObject *a, PyObject *b, int op)
+{
+    PyObject *result;                       /* Chaîne à retourner          */
+    mrange_t *range_a;                      /* Premier espace à traiter    */
+    mrange_t *range_b;                      /* Second espace à traiter     */
+    int status;                             /* Résultat d'une comparaison  */
+
+    range_a = get_internal_mrange(a);
+
+    range_b = get_internal_mrange(b);
+    if (range_b == NULL) return NULL;
+
+    status = cmp_mrange(range_a, range_b);
+
+    switch (op)
+    {
+        case Py_LT:
+            result = status < 0 ? Py_True : Py_False;
+            break;
+
+        case Py_LE:
+            result = status <= 0 ? Py_True : Py_False;
+            break;
+
+        case Py_EQ:
+            result = status == 0 ? Py_True : Py_False;
+            break;
+
+        case Py_NE:
+            result = status != 0 ? Py_True : Py_False;
+            break;
+
+        case Py_GT:
+            result = status > 0 ? Py_True : Py_False;
+            break;
+
+        case Py_GE:
+            result = status >= 0 ? Py_True : Py_False;
+            break;
+
+        default:
+            result = Py_NotImplemented;
+            break;
+
+    }
+
+    Py_INCREF(result);
+
+    return result;
+
+}
+
+
+
+
+
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : self = contenu binaire à manipuler.                          *
+*                args = non utilisé ici.                                      *
+*                                                                             *
+*  Description : Indique si une zone en contient une autre ou non.            *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PyObject *py_mrange_contains(PyObject *self, PyObject *args)
+{
+    PyObject *result;                       /* Bilan à faire remonter      */
+    int ret;                                /* Bilan de lecture des args.  */
+    PyObject *range_obj;                    /* Objet pour un intervale     */
+    mrange_t *range;                        /* Région mémoire de contenance*/
+    mrange_t *sub;                          /* Région mémoire contenue ?   */
+
+    ret = PyArg_ParseTuple(args, "O", &range_obj);
+    if (!ret) return NULL;
+
+    ret = PyObject_IsInstance(range_obj, (PyObject *)get_python_mrange_type());
+    if (!ret) return NULL;
+
+    range = get_internal_mrange(self);
+    sub = get_internal_mrange(range_obj);
+
+    result = (mrange_contains_mrange(range, sub) ? Py_True : Py_False);
+
+    Py_INCREF(result);
+
+    return result;
+
+}
+
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : self    = définition de l'espace visé par la procédure.      *
+*                closure = élément non utilisé ici.                           *
+*                                                                             *
+*  Description : Fournit la position de départ de la zone mémoire représentée.*
+*                                                                             *
+*  Retour      : Nouvelle objet mis en place.                                 *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PyObject *py_mrange_get_addr(PyObject *self, void *closure)
+{
+    PyObject *result;                       /* Valeur à retourner          */
+    mrange_t *range;                        /* Espace mémoire à manipuler  */
+
+    range = get_internal_mrange(self);
+
+    result = build_from_internal_vmpa(get_mrange_addr(range));
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : self    = définition de l'espace visé par la procédure.      *
+*                value   = valeur fournie à intégrer ou prendre en compte.    *
+*                closure = élément non utilisé ici.                           *
+*                                                                             *
+*  Description : Définit la position de départ de la zone mémoire représentée.*
+*                                                                             *
+*  Retour      : Bilan de l'opération pour Python.                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static int py_mrange_set_addr(PyObject *self, PyObject *value, void *closure)
+{
+    int result;                             /* Bilan à faire remonter      */
+    vmpa2t *addr;                           /* Localisation version C      */
+    mrange_t *range;                        /* Espace mémoire à manipuler  */
+
+    result = 0;
+
+    addr = get_internal_vmpa(value);
+    if (addr == NULL) return -1;
+
+    range = get_internal_mrange(self);
+
+    init_mrange(range, addr, get_mrange_length(range));
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : self    = définition de l'espace visé par la procédure.      *
+*                closure = élément non utilisé ici.                           *
+*                                                                             *
+*  Description : Fournit la taille de la zone mémoire représentée.            *
+*                                                                             *
+*  Retour      : Nouvelle objet mis en place.                                 *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PyObject *py_mrange_get_length(PyObject *self, void *closure)
+{
+    PyObject *result;                       /* Valeur à retourner          */
+    mrange_t *range;                        /* Espace mémoire à manipuler  */
+
+    range = get_internal_mrange(self);
+
+    result = Py_BuildValue("K", get_mrange_length(range));
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : self    = définition de l'espace visé par la procédure.      *
+*                value   = valeur fournie à intégrer ou prendre en compte.    *
+*                closure = élément non utilisé ici.                           *
+*                                                                             *
+*  Description : Définit la taille de la zone mémoire représentée.            *
+*                                                                             *
+*  Retour      : Bilan de l'opération pour Python.                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static int py_mrange_set_length(PyObject *self, PyObject *value, void *closure)
+{
+    int result;                             /* Bilan à faire remonter      */
+    mrange_t *range;                        /* Espace mémoire à manipuler  */
+    PY_LONG_LONG val;                       /* Valeur traduite génériquemt */
+    int overflow;                           /* Détection d'une grosse val. */
+    vmpa2t tmp;                             /* Copie pour recopie          */
+
+    result = 0;
+
+    range = get_internal_mrange(self);
+
+    val = PyLong_AsLongLongAndOverflow(value, &overflow);
+
+    if (val == -1 && (overflow == 1 || PyErr_Occurred()))
+    {
+        result = -1;
+        PyErr_Clear();
+    }
+    else
+    {
+        copy_vmpa(&tmp, get_mrange_addr(range));
+        init_mrange(range, &tmp, val);
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : self    = définition de l'espace visé par la procédure.      *
+*                closure = élément non utilisé ici.                           *
+*                                                                             *
+*  Description : Calcule la position extérieure finale d'une couverture.      *
+*                                                                             *
+*  Retour      : Nouvelle objet mis en place.                                 *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PyObject *py_mrange_get_end_addr(PyObject *self, void *closure)
+{
+    PyObject *result;                       /* Valeur à retourner          */
+    mrange_t *range;                        /* Espace mémoire à manipuler  */
+    vmpa2t end;                             /* Adresse à reproduire        */
+
+    range = get_internal_mrange(self);
+    compute_mrange_end_addr(range, &end);
+
+    result = build_from_internal_vmpa(&end);
+
+    return result;
+
+}
+
+
+
+
+
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type de l'objet à instancier.                         *
+*                args = arguments fournis à l'appel.                          *
+*                kwds = arguments de type key=val fournis.                    *
+*                                                                             *
+*  Description : Crée un nouvel objet Python de type 'mrange'.                *
+*                                                                             *
+*  Retour      : Instance Python mise en place.                               *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PyObject *py_mrange_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    py_mrange_t *result;                    /* Instance à retourner        */
+    PyObject *py_vmpa;                      /* Localisation version Python */
+    unsigned long long length;              /* Taille physique             */
+    int ret;                                /* Bilan de lecture des args.  */
+    vmpa2t *addr;                           /* Localisation version C      */
+
+    ret = PyArg_ParseTuple(args, "OK", &py_vmpa, &length);
+    if (!ret) return NULL;
+
+    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;
+
+    result = (py_mrange_t *)type->tp_alloc(type, 0);
+
+    init_mrange(&result->range, addr, length);
+
+    return (PyObject *)result;
+
+}
+
+
+
+
+
+
+
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Fournit un accès à une définition de type à diffuser.        *
+*                                                                             *
+*  Retour      : Définition d'objet pour Python.                              *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+PyTypeObject *get_python_mrange_type(void)
+{
+    static PyMethodDef py_mrange_methods[] = {
+        { "contains", py_mrange_contains,
+          METH_VARARGS,
+          "contains($self, other, /)\n--\nTell if the current range contains another given range or address."
+        },
+#if 0
+        { "read_u8", py_arch_instruction_read_u8,
+          METH_VARARGS,
+          "read_u8($self, addr, /)\n--\n\nRead an unsigned byte from a given position."
+        },
+#endif
+        { NULL }
+    };
+
+    static PyGetSetDef py_mrange_getseters[] = {
+        {
+            "addr", py_mrange_get_addr, py_mrange_set_addr,
+            "Give access to the start location of the memory range.", NULL
+        },
+        {
+            "length", py_mrange_get_length, py_mrange_set_length,
+            "Give access to the length of the memory range.", NULL
+        },
+        {
+            "end", py_mrange_get_end_addr, NULL,
+            "Provide the final external point of the memory range.", NULL
+        },
+        { NULL }
+    };
+
+    static PyTypeObject py_mrange_type = {
+
+        PyVarObject_HEAD_INIT(NULL, 0)
+
+        .tp_name        = "pychrysalide.arch.mrange",
+        .tp_basicsize   = sizeof(py_mrange_t),
+
+        .tp_str         = py_mrange_to_str,
+
+        .tp_flags       = Py_TPFLAGS_DEFAULT,
+
+        .tp_doc         = "Python object for mrange_t.",
+
+        .tp_richcompare = py_mrange_richcompare,
+
+        .tp_methods     = py_mrange_methods,
+        .tp_getset      = py_mrange_getseters,
+        .tp_new         = (newfunc)py_mrange_new
+
+    };
+
+    return &py_mrange_type;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : module = module dont la définition est à compléter.          *
+*                                                                             *
+*  Description : Prend en charge l'objet 'pychrysalide.arch.mrange'.          *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool register_python_mrange(PyObject *module)
+{
+    PyTypeObject *py_mrange_type;           /* Type Python pour 'mrange'   */
+    int ret;                                /* Bilan d'un appel            */
+
+    py_mrange_type = get_python_mrange_type();
+
+    if (PyType_Ready(py_mrange_type) != 0)
+        return false;
+
+    Py_INCREF(py_mrange_type);
+    ret = PyModule_AddObject(module, "mrange", (PyObject *)py_mrange_type);
+
+    return (ret == 0);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : obj = objet Python à traiter.                                *
+*                                                                             *
+*  Description : Donne accès au coeur d'un objet 'pychrysalide.arch.mrange'.  *
+*                                                                             *
+*  Retour      : Localistion réelle ou NULL en cas de mauvaise conversion.    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+mrange_t *get_internal_mrange(PyObject *obj)
+{
+    int ret;                                /* Bilan d'analyse             */
+
+    ret = PyObject_IsInstance(obj, (PyObject *)get_python_mrange_type());
+    if (!ret) return NULL;
+
+    return &((py_mrange_t *)obj)->range;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : range = structure interne à copier en objet Python.          *
+*                                                                             *
+*  Description : Convertit une structure de type 'mrange_t' en objet Python.  *
+*                                                                             *
+*  Retour      : Object Python résultant de la conversion opérée.             *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+PyObject *build_from_internal_mrange(const mrange_t *range)
+{
+    py_mrange_t *result;                    /* Instance à retourner        */
+    PyTypeObject *type;                     /* Type à instancier           */
+
+    type = get_python_mrange_type();
+
+    result = (py_mrange_t *)type->tp_alloc(type, 0);
+
+    copy_mrange(&result->range, range);
+
+    return (PyObject *)result;
+
+}