/* Chrysalide - Outil d'analyse de fichiers binaires * instriter.c - équivalent Python du fichier "arch/instriter.c" * * Copyright (C) 2016 Cyrille Bagard * * This file is part of Chrysalide. * * Chrysalide is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 3 of the License, or * (at your option) any later version. * * Chrysalide is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "instriter.h" #include #include #include "processor.h" /* Transcription d'un itérateur en Python */ typedef struct _PyInstrIterator { PyObject_HEAD; /* A laisser en premier */ instr_iter_t *native; /* Version native de l'objet */ } PyInstrIterator; /* Libère de la mémoire un itérateur sur des instructions. */ static void py_instr_iterator_dealloc(PyInstrIterator *); /* Fournit l'instruction qui en suit une autre. */ static PyObject *py_instr_iterator_next(PyInstrIterator *); /* Initialise un nouvel itérateur. */ static int py_instr_iterator_init(PyInstrIterator *, PyObject *, PyObject *); /* Construit un nouvel itérateur. */ static PyObject *py_instr_iterator_new(PyTypeObject *, PyObject *, PyObject *); /****************************************************************************** * * * Paramètres : self = itérateur à supprimer. * * * * Description : Libère de la mémoire un itérateur sur des instructions. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void py_instr_iterator_dealloc(PyInstrIterator *self) { delete_instruction_iterator(self->native); Py_TYPE(self)->tp_free((PyObject *)self); } /****************************************************************************** * * * Paramètres : self = itérateur à manipuler. * * * * Description : Fournit l'instruction qui en suit une autre. * * * * Retour : Instruction suivante trouvée, ou NULL. * * * * Remarques : - * * * ******************************************************************************/ static PyObject *py_instr_iterator_next(PyInstrIterator *self) { PyObject *result; /* Résultat à retourner */ GArchInstruction *next; /* Instruction suivante */ next = get_instruction_iterator_next(self->native); if (next != NULL) { result = pygobject_new(G_OBJECT(next)); g_object_unref(G_OBJECT(next)); } else { PyErr_SetNone(PyExc_StopIteration); result = NULL; } return result; } /****************************************************************************** * * * Paramètres : self = instance d'objet à initialiser. * * args = arguments passés pour l'appel. * * kwds = mots clefs éventuellement fournis en complément. * * * * Description : Initialise un nouvel itérateur. * * * * Retour : Bilan de l'opération. * * * * Remarques : - * * * ******************************************************************************/ static int py_instr_iterator_init(PyInstrIterator *self, PyObject *args, PyObject *kwds) { int result; /* Bilan à retourner */ PyObject *proc_obj; /* Processeur version Python */ unsigned long index; /* Indice de première instruc. */ int ret; /* Bilan de lecture des args. */ GArchProcessor *proc; /* Version native du processeur*/ result = -1; ret = PyArg_ParseTuple(args, "Ok", &proc_obj, &index); if (ret == 0) goto piii_exit; ret = PyObject_IsInstance(proc_obj, (PyObject *)get_python_arch_processor_type()); if (!ret) goto piii_exit; proc = G_ARCH_PROCESSOR(pygobject_get(proc_obj)); self->native = create_instruction_iterator(proc, index); result = 0; piii_exit: return result; } /****************************************************************************** * * * Paramètres : type = type d'objet à mettre en place. * * args = arguments passés pour l'appel. * * kwds = mots clefs éventuellement fournis en complément. * * * * Description : Construit un nouvel itérateur. * * * * Retour : Définition d'objet pour Python. * * * * Remarques : - * * * ******************************************************************************/ static PyObject *py_instr_iterator_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { PyInstrIterator *result; /* Nouvelle instance à renvoyer*/ int ret; /* Bilan de l'initialisation */ result = (PyInstrIterator *)type->tp_alloc(type, 0); if (result != NULL) { ret = py_instr_iterator_init(result, args, kwds); if (ret != 0) { Py_DECREF(result); result = NULL; } } return (PyObject *)result; } /****************************************************************************** * * * Paramètres : - * * * * Description : Fournit un accès à une définition de type à diffuser. * * * * Retour : Définition d'objet pour Python. * * * * Remarques : - * * * ******************************************************************************/ PyTypeObject *get_python_instr_iterator_type(void) { static PyTypeObject py_instr_iterator_type = { PyVarObject_HEAD_INIT(NULL, 0) .tp_name = "pychrysalide.arch.InstrIterator", .tp_basicsize = sizeof(PyInstrIterator), .tp_dealloc = (destructor)py_instr_iterator_dealloc, .tp_flags = Py_TPFLAGS_DEFAULT, .tp_doc = "Iterator for Chrysalide instructions loaded in a given processor.", .tp_iter = PyObject_SelfIter, .tp_iternext = (iternextfunc)py_instr_iterator_next, .tp_init = (initproc)py_instr_iterator_init, .tp_new = py_instr_iterator_new, }; return &py_instr_iterator_type; } /****************************************************************************** * * * Paramètres : module = module dont la définition est à compléter. * * * * Description : Prend en charge l'objet 'pychrysalide.arch.InstrIterator'. * * * * Retour : Bilan de l'opération. * * * * Remarques : - * * * ******************************************************************************/ bool register_python_instr_iterator(PyObject *module) { PyTypeObject *py_instr_iterator_type; /* Type Python 'BinContent' */ int ret; /* Bilan d'un appel */ py_instr_iterator_type = get_python_instr_iterator_type(); if (PyType_Ready(py_instr_iterator_type) < 0) return false; Py_INCREF(py_instr_iterator_type); ret = PyModule_AddObject(module, "InstrIterator", (PyObject *)py_instr_iterator_type); return (ret == 0); }