diff options
Diffstat (limited to 'src/analysis')
| -rwxr-xr-x | src/analysis/Makefile.am | 4 | ||||
| -rw-r--r-- | src/analysis/prototype.c | 260 | ||||
| -rw-r--r-- | src/analysis/prototype.h | 69 | ||||
| -rw-r--r-- | src/analysis/variable.c | 728 | ||||
| -rw-r--r-- | src/analysis/variable.h | 176 |
5 files changed, 1236 insertions, 1 deletions
diff --git a/src/analysis/Makefile.am b/src/analysis/Makefile.am index c3b2e64..e652f5d 100755 --- a/src/analysis/Makefile.am +++ b/src/analysis/Makefile.am @@ -2,7 +2,9 @@ lib_LIBRARIES = libanalysis.a libanalysis_a_SOURCES = \ - line.h line.c + line.h line.c \ + prototype.h prototype.c \ + variable.h variable.c libanalysis_a_CFLAGS = $(AM_CFLAGS) diff --git a/src/analysis/prototype.c b/src/analysis/prototype.c new file mode 100644 index 0000000..aa3ca2f --- /dev/null +++ b/src/analysis/prototype.c @@ -0,0 +1,260 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * prototype.c - manipulation des prototypes de fonctions et de variables + * + * Copyright (C) 2008 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 Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#include "prototype.h" + + +#include <malloc.h> + + +#include "../common/extstr.h" + + + +/* Variable représentant un prototype de routine */ +struct _bin_routine +{ + RoutineType type; /* Type de routine */ + + variable *ret_type; /* Type retourné */ + + char *name; /* Désignation humaine */ + + variable **args_types; /* Types d'arguments */ + size_t args_count; /* Nombre d'arguments */ + +}; + + + +/****************************************************************************** +* * +* Paramètres : - * +* * +* Description : Crée une représentation de routine. * +* * +* Retour : Adresse de la structure mise en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bin_routine *create_binary_routine(void) +{ + bin_routine *result; /* Structure à retourner */ + + result = (bin_routine *)calloc(1, sizeof(bin_routine)); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : routine = routine à effacer. * +* * +* Description : Supprime une représentation de routine de la mémoire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void delete_binary_routine(bin_routine *routine) +{ + size_t i; /* Boucle de parcours */ + + if (routine->ret_type) + delete_var(routine->ret_type); + + if (routine->name != NULL) + free(routine->name); + + for (i = 0; i < routine->args_count; i++) + delete_var(routine->args_types[i]); + + free(routine); + +} + + +/****************************************************************************** +* * +* Paramètres : routine = routine à mettre à jour. * +* type = type de routine spécifié. * +* * +* Description : Définit le type d'une routine. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void set_binary_routine_type(bin_routine *routine, RoutineType type) +{ + routine->type = type; + +} + + +/****************************************************************************** +* * +* Paramètres : routine = routine à mettre à jour. * +* name = désignation humainement lisible. * +* * +* Description : Définit le nom humain d'une routine. * +* * +* Retour : - * +* * +* Remarques : Le nom ne doit pas ensuite être libéré par l'appelant ! * +* * +******************************************************************************/ + +void set_binary_routine_name(bin_routine *routine, char *name) +{ + if (routine->name != NULL) + free(routine->name); + + routine->name = name; + +} + + +/****************************************************************************** +* * +* Paramètres : routine = routine à mettre à jour. * +* var = variable représentant un type de retour. * +* * +* Description : Définit le type de retour d'une routine. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void set_binary_routine_return_type(bin_routine *routine, variable *var) +{ + if (routine->ret_type != NULL) + delete_var(routine->ret_type); + + routine->ret_type = var; + +} + + +/****************************************************************************** +* * +* Paramètres : routine = routine à mettre à jour. * +* var = variable représentant un argument supplémentaire. * +* * +* Description : Ajoute un argument à une routine. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void add_arg_to_binary_routine(bin_routine *routine, variable *var) +{ + routine->args_count++; + + routine->args_types = (variable **)realloc(routine->args_types, + routine->args_count * sizeof(variable *)); + + routine->args_types[routine->args_count - 1] = var; + +} + + +/****************************************************************************** +* * +* Paramètres : routine = routine à consulter. * +* * +* Description : Décrit le prototype de la routine sous forme de caractères. * +* * +* Retour : Chaîne de caractères à libérer de la mémoire. * +* * +* Remarques : - * +* * +******************************************************************************/ + +char *routine_to_string(const bin_routine *routine) +{ + char *result; /* Chaîne à renvoyer */ + size_t i; /* Boucle de parcours */ + char *typestr; /* Stockage de nom temporaire */ + + /* Retour de la fonction */ + + switch (routine->type) + { + case RTT_CONSTRUCTOR: + result = strdup(routine->name); + result = stradd(result, "::"); + break; + + case RTT_DESTRUCTOR: + result = strdup(routine->name); + result = stradd(result, "::~"); + break; + + default: /* Pour gcc */ + case RTT_CLASSIC: + if (routine->ret_type == NULL) result = strdup("??? "); + else + { + result = var_to_string(routine->ret_type); + result = stradd(result, " "); + } + break; + + } + + /* Nom de la routine */ + + result = stradd(result, routine->name); + + /* Liste des arguments */ + + result = stradd(result, "("); + + for (i = 0; i < routine->args_count; i++) + { + if (i > 0) result = stradd(result, ", "); + + typestr = var_to_string(routine->args_types[i]); + result = stradd(result, typestr); + free(typestr); + + } + + result = stradd(result, ")"); + + return result; + +} diff --git a/src/analysis/prototype.h b/src/analysis/prototype.h new file mode 100644 index 0000000..f86d541 --- /dev/null +++ b/src/analysis/prototype.h @@ -0,0 +1,69 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * prototype.h - prototypes pour la manipulation des prototypes de fonctions et de variables + * + * Copyright (C) 2008 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 Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _ANALYSIS_PROTOTYPE_H +#define _ANALYSIS_PROTOTYPE_H + + +#include "variable.h" + + + +/* Type de routine traitée */ +typedef enum _RoutineType +{ + RTT_CLASSIC, /* Fonction ou méthode */ + RTT_CONSTRUCTOR, /* Constructeur */ + RTT_DESTRUCTOR /* Destructeur */ + +} RoutineType; + + +/* Variable représentant un prototype de routine */ +typedef struct _bin_routine bin_routine; + + +/* Crée une représentation de routine. */ +bin_routine *create_binary_routine(void); + +/* Supprime une représentation de routine de la mémoire. */ +void delete_binary_routine(bin_routine *); + +/* Définit le type d'une routine. */ +void set_binary_routine_type(bin_routine *, RoutineType); + +/* Définit le nom humain d'une routine. */ +void set_binary_routine_name(bin_routine *, char *); + +/* Définit le type de retour d'une routine. */ +void set_binary_routine_return_type(bin_routine *, variable *); + +/* Ajoute un argument à une routine. */ +void add_arg_to_binary_routine(bin_routine *, variable *); + +/* Décrit le prototype de la routine sous forme de caractères. */ +char *routine_to_string(const bin_routine *); + + + +#endif /* _ANALYSIS_PROTOTYPE_H */ diff --git a/src/analysis/variable.c b/src/analysis/variable.c new file mode 100644 index 0000000..058c152 --- /dev/null +++ b/src/analysis/variable.c @@ -0,0 +1,728 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * variable.c - manipulation des variables en tout genre + * + * Copyright (C) 2008 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 Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#include "variable.h" + + +#include <malloc.h> +#include <stdbool.h> +#include <string.h> + + +#include "../common/extstr.h" + + + +/* ---------------------------- TYPES DE DONNEES SIMPLES ---------------------------- */ + + +/* Variable représentant un argument ou un type de retour */ +struct _simple_variable +{ + BaseType type; /* Type représenté */ + +}; + + +/* Décrit la variable simple sous forme de caractères. */ +char *simple_var_to_string(const simple_variable *); + +/* Supprime de la mémoire une variable de type simple. */ +void delete_simple_var(simple_variable *); + + + +/* --------------------- ENCAPSULATIONS DES VARIABLES COMPLEXES --------------------- */ + + +/* Supprime de la mémoire une variable de type complexe. */ +typedef void (* delete_complex_fc) (complex_variable *); + +/* Décrit la variable complexe sous forme de caractères. */ +typedef char * (* complex_to_string_fc) (const complex_variable *); + + +/* Représentation d'une variable complexe */ +struct _complex_variable +{ + delete_complex_fc delete; /* Procédure de suppression */ + complex_to_string_fc to_string; /* Conversion en chaîne */ + +}; + + +/* Initialise une représentation de variable complexe. */ +void init_complex_var(complex_variable *); + +/* Supprime de la mémoire une variable de type complexe. */ +void delete_complex_var(complex_variable *); + +/* Décrit la variable simple sous forme de caractères. */ +char *complex_var_to_string(const complex_variable *); + + + +/* ---------------------- VARIABLES DE CLASSES ET ENUMERATIONS ---------------------- */ + + +/* Représentation des classes et des énumérations */ +struct _class_enum_variable +{ + complex_variable complex; /* A laisser en premier */ + + ClassEnumType type; /* Type représenté si connu */ + + char *desc; /* Description humaine */ + +}; + + +/* Supprime de la mémoire une variable de classe/enumération. */ +void delete_class_enum_var(class_enum_variable *); + +/* Décrit la variable complexe sous forme de caractères. */ +char *class_enum_var_to_string(const class_enum_variable *); + + + +/* -------------------------- VARIABLES DEPENDANT D'AUTRES -------------------------- */ + + +/* Représentation des variables dérivées */ +struct _encapsulated_variable +{ + complex_variable complex; /* A laisser en premier */ + + EncapsulationType type; /* Encapsulation utilisée */ + variable *child; /* Sous-type encadré */ + +}; + + +/* Supprime de la mémoire une variable dérivée. */ +void delete_encapsulated_var(encapsulated_variable *); + +/* Décrit la variable dérivée sous forme de caractères. */ +char *encapsulated_var_to_string(const encapsulated_variable *); + + + +/* ---------------------- MANIPULATION GENERIQUE DES VARIABLES ---------------------- */ + + +/* Variable représentant un argument ou un type de retour */ +struct _variable +{ + union + { + simple_variable *simple; /* Variable simple */ + complex_variable *complex; /* Variable plus compliquée */ + + } value; + + bool is_simple; /* Choix du champ valide */ + + VariableQualifier qualifiers; /* Eventuels qualificatifs */ + +}; + + + +/* ---------------------------------------------------------------------------------- */ +/* TYPES DE DONNEES SIMPLES */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : - * +* * +* Description : Crée une représentation de variable. * +* * +* Retour : Adresse de la structure mise en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +simple_variable *create_simple_var(void) +{ + simple_variable *result; /* Structure à retourner */ + + result = (simple_variable *)calloc(1, sizeof(simple_variable)); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : type = type de base à représenter. * +* * +* Description : Crée une représentation de variable à type connu. * +* * +* Retour : Adresse de la structure mise en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +simple_variable *create_typed_simple_var(BaseType type) +{ + simple_variable *result; /* Structure à retourner */ + + result = create_simple_var(); + + set_simple_var_type(result, type); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : var = variable à effacer. * +* * +* Description : Supprime de la mémoire une variable de type simple. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void delete_simple_var(simple_variable *var) +{ + free(var); + +} + + +/****************************************************************************** +* * +* Paramètres : var = variable à mettre à jour. * +* type = type de base à représenter. * +* * +* Description : Définit le type d'une variable simple. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void set_simple_var_type(simple_variable *var, BaseType type) +{ + var->type = type; + +} + + +/****************************************************************************** +* * +* Paramètres : var = variable à consulter. * +* * +* Description : Décrit la variable simple sous forme de caractères. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +char *simple_var_to_string(const simple_variable *var) +{ + char *result; /* Chaîne à renvoyer */ + + switch (var->type) + { + case BTP_VOID: + result = "void"; + break; + case BTP_WCHAR_T: + result = "wchar_t"; + break; + case BTP_BOOL: + result = "bool"; + break; + case BTP_CHAR: + result = "char"; + break; + case BTP_SCHAR: + result = "signed char"; + break; + case BTP_UCHAR: + result = "unsigned char"; + break; + case BTP_SHORT: + result = "short"; + break; + case BTP_USHORT: + result = "unsigned short"; + break; + case BTP_INT: + result = "int"; + break; + case BTP_UINT: + result = "unsigned int"; + break; + case BTP_LONG: + result = "long"; + break; + case BTP_ULONG: + result = "unsigned long"; + break; + case BTP_LONG_LONG: + result = "long long"; + break; + case BTP_ULONG_LONG: + result = "unsigned long long"; + break; + case BTP_INT128: + result = "__int128"; + break; + case BTP_UINT128: + result = "__uint128"; + break; + case BTP_FLOAT: + result = "float"; + break; + case BTP_DOUBLE: + result = "double"; + break; + case BTP_LONG_DOUBLE: + result = "__float80"; + break; + case BTP_FLOAT128: + result = "__float128"; + break; + case BTP_ELLIPSIS: + result = "..."; + break; + case BTP_754R_64: + result = "754r_float64"; + break; + case BTP_754R_128: + result = "754r_float128"; + break; + case BTP_754R_32: + result = "754r_float32"; + break; + case BTP_754R_16: + result = "754r_float16"; + break; + case BTP_CHAR32_T: + result = "char32_t"; + break; + case BTP_CHAR16_T: + result = "char16_t"; + break; + case BTP_OTHER: + result = "[toto]"; /* FIXME */ + break; + default: + result = "/* pour gcc */"; + break; + } + + result = strdup(result); + + return result; + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* ENCAPSULATIONS DES VARIABLES COMPLEXES */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : var = structure vierge à préparer. * +* * +* Description : Initialise une représentation de variable complexe. * +* * +* Retour : Adresse de la structure mise en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +void init_complex_var(complex_variable *var) +{ + +} + + +/****************************************************************************** +* * +* Paramètres : var = variable à effacer. * +* * +* Description : Supprime de la mémoire une variable de type complexe. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void delete_complex_var(complex_variable *var) +{ + var->delete(var); + +} + + +/****************************************************************************** +* * +* Paramètres : var = variable à consulter. * +* * +* Description : Décrit la variable complexe sous forme de caractères. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +char *complex_var_to_string(const complex_variable *var) +{ + return var->to_string(var); + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* VARIABLES DE CLASSES ET ENUMERATIONS */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : type = type de base à représenter. * +* desc = description humaine de la variable. * +* * +* Description : Crée une représentation de variable de classe/enumération. * +* * +* Retour : Adresse de la structure mise en place. * +* * +* Remarques : La description ne doit pas être libérée par l'appelant ! * +* * +******************************************************************************/ + +complex_variable *create_class_enum_var(char *desc) +{ + class_enum_variable *result; /* Structure à retourner */ + + result = (class_enum_variable *)calloc(1, sizeof(class_enum_variable)); + + init_complex_var(COMPLEX_VAR(result)); + + COMPLEX_VAR(result)->delete = (delete_complex_fc)delete_class_enum_var; + COMPLEX_VAR(result)->to_string = (complex_to_string_fc)class_enum_var_to_string; + + result->desc = desc; + + return COMPLEX_VAR(result); + +} + + +/****************************************************************************** +* * +* Paramètres : var = variable à effacer. * +* * +* Description : Supprime de la mémoire une variable de classe/enumération. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void delete_class_enum_var(class_enum_variable *var) +{ + free(var->desc); + + free(var); + +} + + +/****************************************************************************** +* * +* Paramètres : var = variable à consulter. * +* * +* Description : Décrit la variable complexe sous forme de caractères. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +char *class_enum_var_to_string(const class_enum_variable *var) +{ + return strdup(var->desc); + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* VARIABLES DEPENDANT D'AUTRES */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : type = type d'extension à représenter. * +* child = variable dont on doit dériver. * +* * +* Description : Crée une représentation de variable dérivée. * +* * +* Retour : Adresse de la structure mise en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +complex_variable *create_encapsulated_var(EncapsulationType type, variable *child) +{ + encapsulated_variable *result; /* Structure à retourner */ + + result = (encapsulated_variable *)calloc(1, sizeof(encapsulated_variable)); + + init_complex_var(COMPLEX_VAR(result)); + + COMPLEX_VAR(result)->delete = (delete_complex_fc)delete_encapsulated_var; + COMPLEX_VAR(result)->to_string = (complex_to_string_fc)encapsulated_var_to_string; + + result->type = type; + result->child = child; + + return COMPLEX_VAR(result); + +} + + +/****************************************************************************** +* * +* Paramètres : var = variable à effacer. * +* * +* Description : Supprime de la mémoire une variable dérivée. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void delete_encapsulated_var(encapsulated_variable *var) +{ + delete_var(var->child); + + free(var); + +} + + +/****************************************************************************** +* * +* Paramètres : var = variable à consulter. * +* * +* Description : Décrit la variable dérivée sous forme de caractères. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +char *encapsulated_var_to_string(const encapsulated_variable *var) +{ + char *result; /* Chaîne finale à renvoyer */ + + result = var_to_string(var->child); + + switch (var->type) + { + case ECT_POINTER: + if (result[strlen(result) - 1] == '*') result = stradd(result, "*"); + else result = stradd(result, " *"); + break; + case ECT_REFERENCE: + result = stradd(result, " &"); + break; + case ECT_RVALUE_REF: + result = stradd(result, " [[rval ???]]") /* FIXME */; + break; + case ECT_COMPLEX: + result = stradd(result, " complex"); + break; + case ECT_IMAGINARY: + result = stradd(result, " imaginary"); + break; + } + + return result; + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* MANIPULATION GENERIQUE DES VARIABLES */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : var = variable à emballer. * +* * +* Description : Crée une représentation de variable (simple). * +* * +* Retour : Adresse de la structure mise en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +variable *create_var_from_simple_one(simple_variable *var) +{ + variable *result; /* Structure à retourner */ + + result = (variable *)calloc(1, sizeof(variable)); + + result->value.simple = var; + result->is_simple = true; + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : var = variable à emballer. * +* * +* Description : Crée une représentation de variable (complexe). * +* * +* Retour : Adresse de la structure mise en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +variable *create_var_from_complex_one(complex_variable *var) +{ + variable *result; /* Structure à retourner */ + + result = (variable *)calloc(1, sizeof(variable)); + + result->value.complex = var; + result->is_simple = false; + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : var = variable à effecer. * +* * +* Description : Supprime la représentation de variable de la mémoire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void delete_var(variable *var) +{ + if (var->is_simple) delete_simple_var(var->value.simple); + else delete_complex_var(var->value.complex); + + free(var); + +} + + +/****************************************************************************** +* * +* Paramètres : var = variable à mettre à jour. * +* qualifier = nouveau qualificatif pour la variable. * +* * +* Description : Ajoute un qualificatif à la variable. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void add_qualifier_to_var(variable *var, VariableQualifier qualifier) +{ + var->qualifiers |= qualifier; + +} + + +/****************************************************************************** +* * +* Paramètres : var = variable à consulter. * +* * +* Description : Décrit la variable sous forme de caractères. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +char *var_to_string(const variable *var) +{ + char *result; /* Chaîne à renvoyer */ + + if (var->is_simple) result = simple_var_to_string(var->value.simple); + else result = complex_var_to_string(var->value.complex); + + if (var->qualifiers & VQF_RESTRICT) + strprep(result, "restrict "); + + if (var->qualifiers & VQF_VOLATILE) + strprep(result, "volatile "); + + if (var->qualifiers & VQF_CONST) + strprep(result, "const "); + + return result; + +} diff --git a/src/analysis/variable.h b/src/analysis/variable.h new file mode 100644 index 0000000..8b50cf4 --- /dev/null +++ b/src/analysis/variable.h @@ -0,0 +1,176 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * variable.h - prototypes pour la manipulation des variables en tout genre + * + * Copyright (C) 2008 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 Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _ANALYSIS_VARIABLE_H +#define _ANALYSIS_VARIABLE_H + + + +/* Variable repésentant un argument ou un type de retour */ +typedef struct _variable variable; + + + +/* ---------------------------- TYPES DE DONNEES SIMPLES ---------------------------- */ + + +/* Liste des types de base existants */ +typedef enum _BaseType +{ + BTP_VOID, /* void */ + BTP_WCHAR_T, /* wchar_t */ + BTP_BOOL, /* bool */ + BTP_CHAR, /* char */ + BTP_SCHAR, /* signed char */ + BTP_UCHAR, /* unsigned char */ + BTP_SHORT, /* short */ + BTP_USHORT, /* unsigned short */ + BTP_INT, /* int */ + BTP_UINT, /* unsigned int */ + BTP_LONG, /* long */ + BTP_ULONG, /* unsigned long */ + BTP_LONG_LONG, /* long long, __int64 */ + BTP_ULONG_LONG, /* unsigned long long, __int64 */ + BTP_INT128, /* __int128 */ + BTP_UINT128, /* unsigned __int128 */ + BTP_FLOAT, /* float */ + BTP_DOUBLE, /* double */ + BTP_LONG_DOUBLE, /* long double, __float80 */ + BTP_FLOAT128, /* __float128 */ + BTP_ELLIPSIS, /* ... */ + BTP_754R_64, /* IEEE 754r float (64 bits) */ + BTP_754R_128, /* IEEE 754r float (128 bits) */ + BTP_754R_32, /* IEEE 754r float (32 bits) */ + BTP_754R_16, /* IEEE 754r float (16 bits) */ + BTP_CHAR32_T, /* char32_t */ + BTP_CHAR16_T, /* char16_t */ + BTP_OTHER /* Extension utilisateur */ + +} BaseType; + + + +/* Variable repésentant un argument ou un type de retour */ +typedef struct _simple_variable simple_variable; + + +/* Crée une représentation de variable. */ +simple_variable *create_simple_var(void); + +/* Crée une représentation de variable à type connu. */ +simple_variable *create_typed_simple_var(BaseType); + +/* Définit le type d'une variable simple. */ +void set_simple_var_type(simple_variable *, BaseType); + + + +/* --------------------- ENCAPSULATIONS DES VARIABLES COMPLEXES --------------------- */ + + +/* Représentation d'une variable complexe */ +typedef struct _complex_variable complex_variable; + + +#define COMPLEX_VAR(v) ((complex_variable *)v) + + + +/* ---------------------- VARIABLES DE CLASSES ET ENUMERATIONS ---------------------- */ + + +/* Type de ces variables */ +typedef enum _ClassEnumType +{ + CET_UNKNOWN, /* Statut inconnu */ + CET_STRUCT, /* Structure */ + CET_ENUM, /* Enumération */ + CET_CLASS /* Classe */ + +} ClassEnumType; + + +/* Représentation des classes et des énumérations */ +typedef struct _class_enum_variable class_enum_variable; + + +/* Crée une représentation de variable de classe/enumération. */ +complex_variable *create_class_enum_var(char *); + + + +/* -------------------------- VARIABLES DEPENDANT D'AUTRES -------------------------- */ + + +/* Cas d'encapsulation possibles */ +typedef enum _EncapsulationType +{ + ECT_POINTER, /* Pointeur */ + ECT_REFERENCE, /* Référence */ + ECT_RVALUE_REF, /* Référence ?? (C++0x) */ + ECT_COMPLEX, /* Complexe (C 2000) */ + ECT_IMAGINARY /* Imaginaire (C 2000) */ + +} EncapsulationType; + + +/* Représentation des variables dérivées */ +typedef struct _encapsulated_variable encapsulated_variable; + + +/* Crée une représentation de variable dérivée. */ +complex_variable *create_encapsulated_var(EncapsulationType, variable *); + + + +/* ---------------------- MANIPULATION GENERIQUE DES VARIABLES ---------------------- */ + + +/* Qualificatifs de variables */ +typedef enum _VariableQualifier +{ + VQF_RESTRICT = (1 << 0), /* restrict (C99) */ + VQF_VOLATILE = (1 << 1), /* volatile */ + VQF_CONST = (1 << 2) /* const */ + +} VariableQualifier; + + +/* Crée une représentation de variable (simple). */ +variable *create_var_from_simple_one(simple_variable *); + +/* Crée une représentation de variable (complexe). */ +variable *create_var_from_complex_one(complex_variable *); + +/* Supprime la représentation de variable de la mémoire. */ +void delete_var(variable *); + +/* Ajoute un qualificatif à la variable. */ +void add_qualifier_to_var(variable *, VariableQualifier); + +/* Décrit la variable sous forme de caractères. */ +char *var_to_string(const variable *); + + + +#endif /* _ANALYSIS_VARIABLE_H */ |