/* OpenIDA - Outil d'analyse de fichiers binaires
 * executable.c - équivalent Python du fichier "format/executable.h"
 *
 * Copyright (C) 2010 Cyrille Bagard
 *
 *  This file is part of OpenIDA.
 *
 *  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 "executable.h"


#include "format.h"








/******************************************************************************
*                                                                             *
*  Paramètres  : format = instance existante GLib.                            *
*                                                                             *
*  Description : Crée un nouvel objet Python de type 'ExeFormat'.             *
*                                                                             *
*  Retour      : Instance Python mise en place.                               *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

PyObject *py_executable_format_from_c(GExeFormat *format)
{
    return NULL;//py_binary_format_from_c(G_BIN_FORMAT(format));

}








/* Classe 'format.executable' pour Python */
typedef struct _py_executable
{
    PyObject_HEAD

    GExeFormat *glib;                       /* Format d'exécutable GLib    */

} py_executable;




/* Crée un nouvel objet Python de type 'py_executable'. */
static PyObject *py_executable_new(PyTypeObject *, PyObject *, PyObject *);





/* Fournit le type d'objet 'format.executable' pour Python. */
static PyTypeObject *get_format_executable_type(void);




/******************************************************************************
*                                                                             *
*  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 'py_executable'.         *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static PyObject *py_executable_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
    py_executable *result;                  /* Instance à retourner        */

    result = (py_executable *)type->tp_alloc(type, 0);

    return (PyObject *)result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : executable = objet GLib existant à transposer.               *
*                                                                             *
*  Description : Convertit une instance GLib en objet Python 'py_executable'. *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

PyObject *py_executable_convert(GExeFormat *executable)
{
    py_executable *result;                  /* Instance à retourner        */
    PyTypeObject *type;                     /* Type Python à instancier    */

    result = (py_executable *)g_object_get_data(G_OBJECT(executable), "python_object");

    if (result == NULL)
    {
        type = get_format_executable_type();

        result = (py_executable *)type->tp_alloc(type, 0);

        result->glib = executable;
        g_object_ref(executable);

        g_object_set_data(G_OBJECT(executable), "python_object", result);

    }
    else Py_INCREF((PyObject *)result);

    return (PyObject *)result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : executable = instance Python dont la référence est à donner. *
*                                                                             *
*  Description : Fournit l'instance GLib d'une instance Python.               *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GExeFormat *py_executable_get_glib_instance(PyObject *executable)
{
    return ((py_executable *)executable)->glib;

}










/******************************************************************************
*                                                                             *
*  Paramètres  : -                                                            *
*                                                                             *
*  Description : Fournit le type d'objet 'format.executable' pour Python.     *
*                                                                             *
*  Retour      : Adresse du type vivant à manipuler.                          *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static PyTypeObject *get_format_executable_type(void)
{
    static PyTypeObject *result = NULL;     /* Type pour objet à retourner */

    static PyMethodDef py_executable_methods[] = {
        { NULL }
    };

    static PyGetSetDef py_executable_getset[] = {
        { NULL }
    };

    static PyTypeObject py_executable_type = {

        PyObject_HEAD_INIT(NULL)

        .tp_name        = "pyoida.format.Executable",
        .tp_basicsize   = sizeof(py_executable),

        .tp_flags       = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,

        .tp_doc         = "PyOIDA loaded executable to analyse",

        .tp_methods     = py_executable_methods,
        .tp_getset      = py_executable_getset,
        .tp_new         = (newfunc)py_executable_new

    };

    if (result == NULL) result = &py_executable_type;

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : module = module dont la définition est à compléter.          *
*                                                                             *
*  Description : Ajoute l'objet 'format.executable' au module Python.         *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool add_format_executable_to_python_module(PyObject *module)
{
    PyTypeObject *py_executable_type;       /* Type défini pour Python     */
    int ret;                                /* Bilan d'un appel            */

    py_executable_type = get_format_executable_type();

    if (PyType_Ready(py_executable_type) < 0)
        return false;

    Py_INCREF(py_executable_type);
    ret = PyModule_AddObject(module, "Executable", (PyObject *)py_executable_type);

    return (ret == 0);

}