summaryrefslogtreecommitdiff
path: root/src/analysis
diff options
context:
space:
mode:
Diffstat (limited to 'src/analysis')
-rwxr-xr-xsrc/analysis/Makefile.am1
-rw-r--r--src/analysis/routine.c96
-rw-r--r--src/analysis/routine.h10
-rw-r--r--src/analysis/type.c1377
-rw-r--r--src/analysis/type.h312
-rw-r--r--src/analysis/variable.c164
-rw-r--r--src/analysis/variable.h47
7 files changed, 1981 insertions, 26 deletions
diff --git a/src/analysis/Makefile.am b/src/analysis/Makefile.am
index d7f0f0e..3c22aa6 100755
--- a/src/analysis/Makefile.am
+++ b/src/analysis/Makefile.am
@@ -12,6 +12,7 @@ libanalysis_la_SOURCES = \
line_prologue.h line_prologue.c \
roptions.h roptions.c \
routine.h routine.c \
+ type.h type.c \
variable.h variable.c
libanalysis_la_LDFLAGS =
diff --git a/src/analysis/routine.c b/src/analysis/routine.c
index 4bbd712..cfa7cd5 100644
--- a/src/analysis/routine.c
+++ b/src/analysis/routine.c
@@ -43,17 +43,15 @@ struct _GBinRoutine
RoutineType type; /* Type de routine */
- variable *ret_type; /* Type retourné */
+ GOpenidaType *ret_type; /* Type retourné */
char *name; /* Désignation humaine */
+ GOpenidaType *full_name; /* Désignation très complète */
- variable **args_types; /* Types d'arguments */
- size_t old_args_count; /* Nombre d'arguments */
-
- GUnknownVariable **args; /* Arguments de la routines */
+ GBinVariable **args; /* Arguments de la routines */
size_t args_count; /* Nombre d'arguments */
- GUnknownVariable **locals; /* Variables locales du code */
+ GBinVariable **locals; /* Variables locales du code */
size_t locals_count; /* Nombre de variables locales */
};
@@ -356,6 +354,9 @@ void g_binary_routine_set_name(GBinRoutine *routine, char *name)
const char *g_binary_routine_get_name(const GBinRoutine *routine)
{
+ if (routine->name == NULL && routine->full_name != NULL)
+ g_binary_routine_set_name(routine, g_openida_type_to_string(routine->full_name));
+
return routine->name;
}
@@ -364,7 +365,49 @@ const char *g_binary_routine_get_name(const GBinRoutine *routine)
/******************************************************************************
* *
* Paramètres : routine = routine à mettre à jour. *
-* var = variable représentant un type de retour. *
+* type = désignation complète du nom de la routine. *
+* *
+* Description : Définit de façon indirecte le nom humain d'une routine. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_binary_routine_set_name_from_type(GBinRoutine *routine, GOpenidaType *type)
+{
+ if (routine->full_name != NULL)
+ g_object_unref(G_OBJECT(routine->full_name));
+
+ routine->full_name = type;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : routine = routine à consulter. *
+* *
+* Description : Fournit le type construisant le nom humain d'une routine. *
+* *
+* Retour : Eventuel type à l'origine du nom ou NULL. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+const GOpenidaType *g_binary_routine_get_type_from_name(const GBinRoutine *routine)
+{
+ return routine->full_name;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : routine = routine à mettre à jour. *
+* type = indication sur le type de retour. *
* *
* Description : Définit le type de retour d'une routine. *
* *
@@ -374,12 +417,13 @@ const char *g_binary_routine_get_name(const GBinRoutine *routine)
* *
******************************************************************************/
-void g_binary_routine_set_return_type(GBinRoutine *routine, variable *var)
+void g_binary_routine_set_return_type(GBinRoutine *routine, GOpenidaType *type)
{
if (routine->ret_type != NULL)
- delete_var(routine->ret_type);
+ g_object_unref(G_OBJECT(routine->ret_type));
- routine->ret_type = var;
+ routine->ret_type = type;
+ g_object_ref(G_OBJECT(type));
}
@@ -397,14 +441,14 @@ void g_binary_routine_set_return_type(GBinRoutine *routine, variable *var)
* *
******************************************************************************/
-void g_binary_routine_add_arg(GBinRoutine *routine, variable *var)
+void g_binary_routine_add_arg(GBinRoutine *routine, GBinVariable *var)
{
- routine->old_args_count++;
+ routine->args_count++;
- routine->args_types = (variable **)realloc(routine->args_types,
- routine->old_args_count * sizeof(variable *));
+ routine->args = (GBinVariable **)realloc(routine->args,
+ routine->args_count * sizeof(GBinVariable *));
- routine->args_types[routine->old_args_count - 1] = var;
+ routine->args[routine->args_count - 1] = var;
}
@@ -425,6 +469,7 @@ void g_binary_routine_add_arg(GBinRoutine *routine, variable *var)
void g_binary_routine_register_if_needed(GBinRoutine *routine, size_t offset, bool local)
{
+#if 0 /* FIXME */
GUnknownVariable ***list; /* Liste à manipuler */
size_t *count; /* Taille de la liste */
bool found; /* Indication de présence */
@@ -464,7 +509,7 @@ void g_binary_routine_register_if_needed(GBinRoutine *routine, size_t offset, bo
}
-
+#endif
}
@@ -484,6 +529,7 @@ void g_binary_routine_register_if_needed(GBinRoutine *routine, size_t offset, bo
size_t g_binary_routine_get_var_index_from_offset(const GBinRoutine *routine, size_t offset, bool local)
{
+#if 0 /* FIXME */
size_t result; /* Indice à renvoyer */
GUnknownVariable ***list; /* Liste à manipuler */
size_t *count; /* Taille de la liste */
@@ -507,6 +553,9 @@ size_t g_binary_routine_get_var_index_from_offset(const GBinRoutine *routine, si
result = i;
return result;
+#endif
+
+ return SIZE_MAX;
}
@@ -534,12 +583,12 @@ char *g_binary_routine_to_string(const GBinRoutine *routine)
switch (routine->type)
{
case RTT_CONSTRUCTOR:
- result = strdup(routine->name);
+ result = strdup(g_binary_routine_get_name(routine));
result = stradd(result, "::");
break;
case RTT_DESTRUCTOR:
- result = strdup(routine->name);
+ result = strdup(g_binary_routine_get_name(routine));
result = stradd(result, "::~");
break;
@@ -548,8 +597,9 @@ char *g_binary_routine_to_string(const GBinRoutine *routine)
if (routine->ret_type == NULL) result = strdup("??? ");
else
{
- result = var_to_string(routine->ret_type);
- result = stradd(result, " ");
+ result = g_openida_type_to_string(routine->ret_type);
+ if (!g_openida_type_is_pointer(routine->ret_type, true))
+ result = stradd(result, " ");
}
break;
@@ -557,17 +607,17 @@ char *g_binary_routine_to_string(const GBinRoutine *routine)
/* Nom de la routine */
- result = stradd(result, routine->name);
+ result = stradd(result, g_binary_routine_get_name(routine));
/* Liste des arguments */
result = stradd(result, "(");
- for (i = 0; i < routine->old_args_count; i++)
+ for (i = 0; i < routine->args_count; i++)
{
if (i > 0) result = stradd(result, ", ");
- typestr = var_to_string(routine->args_types[i]);
+ typestr = g_binary_variable_to_string(routine->args[i]);
result = stradd(result, typestr);
free(typestr);
diff --git a/src/analysis/routine.h b/src/analysis/routine.h
index 4e47b5e..1a2b493 100644
--- a/src/analysis/routine.h
+++ b/src/analysis/routine.h
@@ -91,11 +91,17 @@ void g_binary_routine_set_name(GBinRoutine *, char *);
/* Désignation humainement lisible ou NULL si non définie. */
const char *g_binary_routine_get_name(const GBinRoutine *);
+/* Définit de façon indirecte le nom humain d'une routine. */
+void g_binary_routine_set_name_from_type(GBinRoutine *, GOpenidaType *);
+
+/* Fournit le type construisant le nom humain d'une routine. */
+const GOpenidaType *g_binary_routine_get_type_from_name(const GBinRoutine *);
+
/* Définit le type de retour d'une routine. */
-void g_binary_routine_set_return_type(GBinRoutine *, variable *);
+void g_binary_routine_set_return_type(GBinRoutine *, GOpenidaType *);
/* Ajoute un argument à une routine. */
-void g_binary_routine_add_arg(GBinRoutine *, variable *);
+void g_binary_routine_add_arg(GBinRoutine *, GBinVariable *);
/* S'assure qu'une variable est bien associée à une routine. */
void g_binary_routine_register_if_needed(GBinRoutine *, size_t, bool);
diff --git a/src/analysis/type.c b/src/analysis/type.c
new file mode 100644
index 0000000..c113499
--- /dev/null
+++ b/src/analysis/type.c
@@ -0,0 +1,1377 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * variable.h - prototypes pour la manipulation des variables en tout genre
+ *
+ * Copyright (C) 2009 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 "type.h"
+
+
+#include <malloc.h>
+#include <stdarg.h>
+#include <string.h>
+
+
+#include "routine.h"
+#include "../common/extstr.h"
+
+
+
+/* ------------------------ REPRESENTATION INTERNE DES TYPES ------------------------ */
+
+
+/* Décrit le type fourni sous forme de caractères. */
+typedef GOpenidaType * (* type_dup_fc) (const GOpenidaType *);
+
+/* Décrit le type fourni sous forme de caractères. */
+typedef char * (* type_to_string_fc) (const GOpenidaType *);
+
+
+/* Description de type quelconque (instance) */
+struct _GOpenidaType
+{
+ GObject parent; /* A laisser en premier */
+
+ type_dup_fc dup; /* Copie d'instance existante */
+ type_to_string_fc to_string; /* Conversion au format texte */
+
+ TypeQualifier qualifiers; /* Eventuels qualificatifs */
+
+ GTypesManager *manager; /* Gestionnaire global */
+
+};
+
+/* Description de type quelconque (classe) */
+struct _GOpenidaTypeClass
+{
+ GObjectClass parent; /* A laisser en premier */
+
+};
+
+
+/* Initialise la classe des types quelconques. */
+static void g_openida_type_class_init(GOpenidaTypeClass *);
+
+/* Initialise l'instance d'un type quelconque. */
+static void g_openida_type_init(GOpenidaType *);
+
+
+
+/* ---------------------------- TYPES DE DONNEES SIMPLES ---------------------------- */
+
+
+/* Description de type basique (instance) */
+struct _GBasicType
+{
+ GOpenidaType parent; /* A laisser en premier */
+
+ BaseType type; /* Type représenté si connu */
+
+};
+
+/* Description de type basique (classe) */
+struct _GBasicTypeClass
+{
+ GOpenidaTypeClass parent; /* A laisser en premier */
+
+};
+
+
+/* Initialise la classe des types basiques. */
+static void g_basic_type_class_init(GBasicTypeClass *);
+
+/* Initialise l'instance d'un type basique. */
+static void g_basic_type_init(GBasicType *);
+
+/* Crée un copie d'un type existant. */
+static GOpenidaType *g_basic_type_dup(const GBasicType *);
+
+/* Décrit le type fourni sous forme de caractères. */
+static char *g_basic_type_to_string(const GBasicType *);
+
+
+
+/* -------------------------- VARIABLES DEPENDANT D'AUTRES -------------------------- */
+
+
+/* Description de type encapsulé (instance) */
+struct _GEncapsulatedType
+{
+ GOpenidaType parent; /* A laisser en premier */
+
+ EncapsulationType type; /* Encapsulation utilisée */
+ GOpenidaType *child; /* Sous-type encadré */
+ GBinRoutine *routine; /* Routine pointée */
+
+};
+
+/* Description de type encapsulé (classe) */
+struct _GEncapsulatedTypeClass
+{
+ GOpenidaTypeClass parent; /* A laisser en premier */
+
+};
+
+
+/* Initialise la classe des types encapsulés. */
+static void g_encapsulated_type_class_init(GEncapsulatedTypeClass *);
+
+/* Initialise l'instance d'un type encapsulé. */
+static void g_encapsulated_type_init(GEncapsulatedType *);
+
+/* Crée un copie d'un type existant. */
+static GOpenidaType *g_encapsulated_type_dup(const GEncapsulatedType *);
+
+/* Décrit le type fourni sous forme de caractères. */
+static char *g_encapsulated_type_to_string(const GEncapsulatedType *);
+
+
+
+/* ---------------------- CLASSES / STRUCTURES ET ENUMERATIONS ---------------------- */
+
+
+/* Description de type classe/structure et enumeration (instance) */
+struct _GClassEnumType
+{
+ GOpenidaType parent; /* A laisser en premier */
+
+ ClassEnumType type; /* Type représenté si connu */
+ char *name; /* Description humaine */
+
+};
+
+/* Description de type classe/structure et enumeration (classe) */
+struct _GClassEnumTypeClass
+{
+ GOpenidaTypeClass parent; /* A laisser en premier */
+
+};
+
+
+/* Initialise la classe des types classe ou assimilés. */
+static void g_class_enum_type_class_init(GClassEnumTypeClass *);
+
+/* Initialise l'instance d'un type classe ou assimilé. */
+static void g_class_enum_type_init(GClassEnumType *);
+
+/* Crée un copie d'un type existant. */
+static GOpenidaType *g_class_enum_type_dup(const GClassEnumType *);
+
+/* Décrit le type fourni sous forme de caractères. */
+static char *g_class_enum_type_to_string(const GClassEnumType *);
+
+
+
+/* ----------------------- ELEMENTS REPOSANT SUR DES GABARITS ----------------------- */
+
+
+/* Description de type reposant sur des gabarits (instance) */
+struct _GTemplateType
+{
+ GClassEnumType parent; /* A laisser en premier */
+
+ GOpenidaType **models; /* Sous-types associés */
+ size_t models_count; /* Quantité de ces modèles */
+
+};
+
+/* Description de type reposant sur des gabarits (classe) */
+struct _GTemplateTypeClass
+{
+ GClassEnumTypeClass parent; /* A laisser en premier */
+
+};
+
+
+/* Initialise la classe des types reposant sur des gabarits. */
+static void g_template_type_class_init(GTemplateTypeClass *);
+
+/* Initialise l'instance d'un type reposant sur des gabarits. */
+static void g_template_type_init(GTemplateType *);
+
+/* Crée un copie d'un type existant. */
+static GOpenidaType *g_template_type_dup(const GTemplateType *);
+
+/* Décrit le type fourni sous forme de caractères. */
+static char *g_template_type_to_string(const GTemplateType *);
+
+
+
+/* ---------------------- VALEUR LITERALE DES TYPES INSTANCIES ---------------------- */
+
+
+/* Description de type instancié avec une valeur litérale (instance) */
+struct _GLiteralType
+{
+ GOpenidaType parent; /* A laisser en premier */
+
+ GOpenidaType *orig; /* Type instancié */
+ literal_value value; /* Valeur d'instance */
+
+};
+
+/* Description de type instancié avec une valeur litérale (classe) */
+struct _GLiteralTypeClass
+{
+ GOpenidaTypeClass parent; /* A laisser en premier */
+
+};
+
+
+/* Initialise la classe des types instanciés avec des valeurs. */
+static void g_literal_type_class_init(GLiteralTypeClass *);
+
+/* Initialise l'instance d'un type instancié avec une valeur. */
+static void g_literal_type_init(GLiteralType *);
+
+/* Crée un copie d'un type existant. */
+static GOpenidaType *g_literal_type_dup(const GLiteralType *);
+
+/* Décrit le type fourni sous forme de caractères. */
+static char *g_literal_type_to_string(const GLiteralType *);
+
+
+
+/* -------------------------- COLLECTE ET GESTION DE TYPES -------------------------- */
+
+
+/* Description de type quelconque (instance) */
+struct _GTypesManager
+{
+ GObject parent; /* A laisser en premier */
+
+ MemoryDataSize wdsize; /* Taille d'un mot en octet */
+
+};
+
+/* Description de type quelconque (classe) */
+struct _GTypesManagerClass
+{
+ GObjectClass parent; /* A laisser en premier */
+
+};
+
+
+/* Initialise la classe des gestionnaires de types. */
+static void g_types_manager_class_init(GTypesManagerClass *);
+
+/* Initialise l'instance d'un gestionnaire de types. */
+static void g_types_manager_init(GTypesManager *manager);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* REPRESENTATION INTERNE DES TYPES */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour un type quelconque. */
+G_DEFINE_TYPE(GOpenidaType, g_openida_type, G_TYPE_OBJECT);
+
+
+/******************************************************************************
+* *
+* Paramètres : klass = classe à initialiser. *
+* *
+* Description : Initialise la classe des types quelconques. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_openida_type_class_init(GOpenidaTypeClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : type = instance à initialiser. *
+* *
+* Description : Initialise l'instance d'un type quelconque. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_openida_type_init(GOpenidaType *type)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : type = type à dupliquer. *
+* *
+* Description : Crée un copie d'un type existant. *
+* *
+* Retour : Nouvelle instance de type identique à celle fournie. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GOpenidaType *g_openida_type_dup(const GOpenidaType *type)
+{
+ return type->dup(type);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : type = type à convertir. *
+* *
+* Description : Décrit le type fourni sous forme de caractères. *
+* *
+* Retour : Chaîne à libérer de la mémoire après usage. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+char *g_openida_type_to_string(const GOpenidaType *type)
+{
+ char *result; /* Chaîne à retourner */
+
+ result = type->to_string(type);
+
+ if (type->qualifiers & TQF_RESTRICT)
+ strprep(result, "restrict ");
+
+ if (type->qualifiers & TQF_VOLATILE)
+ strprep(result, "volatile ");
+
+ if (type->qualifiers & TQF_CONST)
+ strprep(result, "const ");
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : type = instance à mettre à jour. *
+* qualifier = nouveau qualificatif pour la variable. *
+* *
+* Description : Ajoute un qualificatif à une instance de type. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_openida_type_add_qualifier(GOpenidaType *type, TypeQualifier qualifier)
+{
+ type->qualifiers |= qualifier;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : type = type à analyser. *
+* large = doit-on aussi inclure les types 'référence' ? *
+* *
+* Description : Indique la terminaison de la représentation du type. *
+* *
+* Retour : true ou false, selon le type fourni. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool g_openida_type_is_pointer(const GOpenidaType *type, bool large)
+{
+ bool result; /* Bilan à retourner */
+
+ result = G_IS_ENCAPSULATED_TYPE(type);
+
+ if (result)
+ switch (G_ENCAPSULATED_TYPE(type)->type)
+ {
+ case ECT_POINTER:
+ result = true;
+ break;
+ case ECT_REFERENCE:
+ case ECT_RVALUE_REF:
+ result = large;
+ break;
+ default:
+ result = false;
+ break;
+ }
+
+ return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* TYPES DE DONNEES SIMPLES */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour un type basique. */
+G_DEFINE_TYPE(GBasicType, g_basic_type, G_TYPE_OPENIDA_TYPE);
+
+
+/******************************************************************************
+* *
+* Paramètres : klass = classe à initialiser. *
+* *
+* Description : Initialise la classe des types basiques. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_basic_type_class_init(GBasicTypeClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : type = instance à initialiser. *
+* *
+* Description : Initialise l'instance d'un type basique. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_basic_type_init(GBasicType *type)
+{
+ GOpenidaType *oida_type; /* Version basique */
+
+ oida_type = G_OPENIDA_TYPE(type);
+
+ oida_type->dup = (type_dup_fc)g_basic_type_dup;
+ oida_type->to_string = (type_to_string_fc)g_basic_type_to_string;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : type = type simple à représenter. *
+* *
+* Description : Crée une représentation de type basique. *
+* *
+* Retour : Adresse de la structure mise en place. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GOpenidaType *g_basic_type_new(BaseType type)
+{
+ GBasicType *result; /* Structure à retourner */
+
+ result = g_object_new(G_TYPE_BASIC_TYPE, NULL);
+
+ result->type = type;
+
+ return G_OPENIDA_TYPE(result);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : type = type à dupliquer. *
+* *
+* Description : Crée un copie d'un type existant. *
+* *
+* Retour : Nouvelle instance de type identique à celle fournie. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static GOpenidaType *g_basic_type_dup(const GBasicType *type)
+{
+ return g_basic_type_new(type->type);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : type = type à convertir. *
+* *
+* Description : Décrit le type fourni sous forme de caractères. *
+* *
+* Retour : Chaîne à libérer de la mémoire après usage. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static char *g_basic_type_to_string(const GBasicType *type)
+{
+ const char *desc; /* Représentation à copier */
+
+ switch (type->type)
+ {
+ case BTP_VOID:
+ desc = "void";
+ break;
+
+ case BTP_WCHAR_T:
+ desc = "wchar_t";
+ break;
+
+ case BTP_BOOL:
+ desc = "bool";
+ break;
+
+ case BTP_CHAR:
+ desc = "char";
+ break;
+
+ case BTP_SCHAR:
+ desc = "signed char";
+ break;
+
+ case BTP_UCHAR:
+ desc = "unsigned char";
+ break;
+
+ case BTP_SHORT:
+ desc = "short";
+ break;
+
+ case BTP_USHORT:
+ desc = "unsigned short";
+ break;
+
+ case BTP_INT:
+ desc = "int";
+ break;
+
+ case BTP_UINT:
+ desc = "unsigned int";
+ break;
+
+ case BTP_LONG:
+ desc = "long";
+ break;
+
+ case BTP_ULONG:
+ desc = "unsigned long";
+ break;
+
+ case BTP_LONG_LONG:
+ desc = "long long";
+ break;
+
+ case BTP_ULONG_LONG:
+ desc = "unsigned long long";
+ break;
+
+ case BTP_INT128:
+ desc = "__int128";
+ break;
+
+ case BTP_UINT128:
+ desc = "unsigned __int128";
+ break;
+
+ case BTP_FLOAT:
+ desc = "float";
+ break;
+
+ case BTP_DOUBLE:
+ desc = "double";
+ break;
+
+ case BTP_LONG_DOUBLE:
+ desc = "long double";
+ break;
+
+ case BTP_FLOAT128:
+ desc = "__float128";
+ break;
+
+ case BTP_ELLIPSIS:
+ desc = "...";
+ break;
+
+ case BTP_754R_64:
+ desc = "__float754r_64";
+ break;
+
+ case BTP_754R_128:
+ desc = "__float754r_128";
+ break;
+
+ case BTP_754R_32:
+ desc = "__float754r_32";
+ break;
+
+ case BTP_754R_16:
+ desc = "__float754r_16";
+ break;
+
+ case BTP_CHAR32_T:
+ desc = "char32_t";
+ break;
+
+ case BTP_CHAR16_T:
+ desc = "char16_t";
+ break;
+
+ default:
+ case BTP_OTHER:
+ desc = "user";
+ break;
+
+ }
+
+ return strdup(desc);
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* VARIABLES DEPENDANT D'AUTRES */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour un type encapsulé. */
+G_DEFINE_TYPE(GEncapsulatedType, g_encapsulated_type, G_TYPE_OPENIDA_TYPE);
+
+
+/******************************************************************************
+* *
+* Paramètres : klass = classe à initialiser. *
+* *
+* Description : Initialise la classe des types encapsulés. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_encapsulated_type_class_init(GEncapsulatedTypeClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : type = instance à initialiser. *
+* *
+* Description : Initialise l'instance d'un type encapsulé. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_encapsulated_type_init(GEncapsulatedType *type)
+{
+ GOpenidaType *oida_type; /* Version basique */
+
+ oida_type = G_OPENIDA_TYPE(type);
+
+ oida_type->dup = (type_dup_fc)g_encapsulated_type_dup;
+ oida_type->to_string = (type_to_string_fc)g_encapsulated_type_to_string;
+
+}
+
+
+/******************************************************************************
+* *
+* 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 : - *
+* *
+******************************************************************************/
+
+GOpenidaType *g_encapsulated_type_new(EncapsulationType type, ...)
+{
+ GEncapsulatedType *result; /* Structure à retourner */
+ va_list ap; /* Liste variable d'arguments */
+
+ result = g_object_new(G_TYPE_ENCAPSULATED_TYPE, NULL);
+
+ result->type = type;
+
+ va_start(ap, type);
+
+ switch (type)
+ {
+ case ECT_ROUTINE:
+ result->routine = va_arg(ap, GBinRoutine *);
+ g_binary_routine_set_name(result->routine, "(*)");
+ break;
+
+ default:
+ result->child = va_arg(ap, GOpenidaType *);
+ break;
+
+ }
+
+ va_end(ap);
+
+ return G_OPENIDA_TYPE(result);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : type = type à dupliquer. *
+* *
+* Description : Crée un copie d'un type existant. *
+* *
+* Retour : Nouvelle instance de type identique à celle fournie. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static GOpenidaType *g_encapsulated_type_dup(const GEncapsulatedType *type)
+{
+ GOpenidaType *result; /* Nouvelle instance à renvoyer*/
+ GOpenidaType *child; /* Copie du type interne */
+
+ switch (type->type)
+ {
+ case ECT_ROUTINE:
+ g_object_ref(G_OBJECT(type->routine));
+ result = g_encapsulated_type_new(type->type, type->routine);
+ break;
+
+ default:
+ child = g_openida_type_dup(type->child);
+ result = g_encapsulated_type_new(type->type, child);
+ break;
+
+ }
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : type = type à convertir. *
+* *
+* Description : Décrit le type fourni sous forme de caractères. *
+* *
+* Retour : Chaîne à libérer de la mémoire après usage. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static char *g_encapsulated_type_to_string(const GEncapsulatedType *type)
+{
+ char *result; /* Chaîne finale à renvoyer */
+
+ switch (type->type)
+ {
+ case ECT_ROUTINE:
+ result = g_binary_routine_to_string(type->routine);
+ break;
+
+ default:
+ result = g_openida_type_to_string(type->child);
+ break;
+
+ }
+
+ switch (type->type)
+ {
+ case ECT_POINTER:
+
+ if (G_IS_ENCAPSULATED_TYPE(type->child)
+ && G_ENCAPSULATED_TYPE(type->child)->type == ECT_ROUTINE) break;
+
+ if (!g_openida_type_is_pointer(type->child, false))
+ result = stradd(result, " ");
+ result = stradd(result, "*");
+
+ break;
+
+ case ECT_REFERENCE:
+ result = stradd(result, " &");
+ break;
+ case ECT_RVALUE_REF:
+ result = stradd(result, " &&");
+ break;
+ case ECT_COMPLEX:
+ result = stradd(result, " complex");
+ break;
+ case ECT_IMAGINARY:
+ result = stradd(result, " imaginary");
+ break;
+
+ default:
+ break;
+
+ }
+
+ return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* CLASSES / STRUCTURES ET ENUMERATIONS */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour un type classe ou assimilé. */
+G_DEFINE_TYPE(GClassEnumType, g_class_enum_type, G_TYPE_OPENIDA_TYPE);
+
+
+/******************************************************************************
+* *
+* Paramètres : klass = classe à initialiser. *
+* *
+* Description : Initialise la classe des types classe ou assimilés. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_class_enum_type_class_init(GClassEnumTypeClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : type = instance à initialiser. *
+* *
+* Description : Initialise l'instance d'un type classe ou assimilé. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_class_enum_type_init(GClassEnumType *type)
+{
+ GOpenidaType *oida_type; /* Version basique */
+
+ oida_type = G_OPENIDA_TYPE(type);
+
+ oida_type->dup = (type_dup_fc)g_class_enum_type_dup;
+ oida_type->to_string = (type_to_string_fc)g_class_enum_type_to_string;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : type = type de structure à représenter. *
+* name = désignation humaine du type. *
+* *
+* Description : Crée une représentation de classe, structure ou énumération. *
+* *
+* Retour : Adresse de la structure mise en place. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GOpenidaType *g_class_enum_type_new(ClassEnumType type, const char *name)
+{
+ GClassEnumType *result; /* Structure à retourner */
+
+ result = g_object_new(G_TYPE_CLASS_ENUM_TYPE, NULL);
+
+ result->type = type;
+ result->name = strdup(name);
+
+ return G_OPENIDA_TYPE(result);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : type = type à dupliquer. *
+* *
+* Description : Crée un copie d'un type existant. *
+* *
+* Retour : Nouvelle instance de type identique à celle fournie. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static GOpenidaType *g_class_enum_type_dup(const GClassEnumType *type)
+{
+ return g_class_enum_type_new(type->type, type->name);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : type = type à convertir. *
+* *
+* Description : Décrit le type fourni sous forme de caractères. *
+* *
+* Retour : Chaîne à libérer de la mémoire après usage. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static char *g_class_enum_type_to_string(const GClassEnumType *type)
+{
+ return strdup(type->name);
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* ELEMENTS REPOSANT SUR DES GABARITS */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour un type reposant sur des gabarits. */
+G_DEFINE_TYPE(GTemplateType, g_template_type, G_TYPE_CLASS_ENUM_TYPE);
+
+
+/******************************************************************************
+* *
+* Paramètres : klass = classe à initialiser. *
+* *
+* Description : Initialise la classe des types reposant sur des gabarits. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_template_type_class_init(GTemplateTypeClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : type = instance à initialiser. *
+* *
+* Description : Initialise l'instance d'un type reposant sur des gabarits. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_template_type_init(GTemplateType *type)
+{
+ GOpenidaType *oida_type; /* Version basique */
+ GClassEnumType *ce_type; /* Version basique #2 */
+
+ oida_type = G_OPENIDA_TYPE(type);
+
+ oida_type->dup = (type_dup_fc)g_template_type_dup;
+ oida_type->to_string = (type_to_string_fc)g_template_type_to_string;
+
+ ce_type = G_CLASS_ENUM_TYPE(type);
+
+ ce_type->type = CET_CLASS;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : name = désignation humaine du type. *
+* list = élements du modèle sur lequel doit reposer le type. *
+* *
+* Description : Crée une représentation de type reposant sur des gabarits. *
+* *
+* Retour : Adresse de la structure mise en place. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GOpenidaType *g_template_type_new(const char *name, GSList *list)
+{
+ GTemplateType *result; /* Structure à retourner */
+
+ result = g_object_new(G_TYPE_TEMPLATE_TYPE, NULL);
+
+ G_CLASS_ENUM_TYPE(result)->name = strdup(name);
+
+ g_template_type_add_params(result, list);
+
+ return G_OPENIDA_TYPE(result);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : type = type à dupliquer. *
+* *
+* Description : Crée un copie d'un type existant. *
+* *
+* Retour : Nouvelle instance de type identique à celle fournie. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static GOpenidaType *g_template_type_dup(const GTemplateType *type)
+{
+ GOpenidaType *result; /* Copie à retourner */
+ GSList *list; /* Format de liste à fournir */
+ size_t i; /* Boucle de parcours */
+
+ list = NULL;
+
+ for (i = 0; i < type->models_count; i++)
+ list = g_slist_prepend(list, type->models[i]);
+
+ result = g_template_type_new(G_CLASS_ENUM_TYPE(type)->name, list);
+
+ g_slist_free(list);
+
+ return G_OPENIDA_TYPE(result);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : type = type à convertir. *
+* *
+* Description : Décrit le type fourni sous forme de caractères. *
+* *
+* Retour : Chaîne à libérer de la mémoire après usage. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static char *g_template_type_to_string(const GTemplateType *type)
+{
+ char *result; /* Valeur à renvoyer */
+ size_t i; /* Boucle de parcours */
+ char *sub; /* Sous-type à décrire */
+
+ result = g_class_enum_type_to_string(G_CLASS_ENUM_TYPE(type));
+
+ result = stradd(result, "<");
+
+ for (i = 0; i < type->models_count; i++)
+ {
+ if (i > 0) result = stradd(result, ", ");
+
+ sub = g_openida_type_to_string(type->models[i]);
+ result = stradd(result, sub);
+ free(sub);
+
+ }
+
+ result = stradd(result, ">");
+
+ return result;
+
+}
+
+
+
+/******************************************************************************
+* *
+* Paramètres : type = type à mettre à jour. *
+* list = élements du modèle sur lequel doit reposer le type. *
+* *
+* Description : Ajoute une série de paramètres à un gabarit. *
+* *
+* Retour : - *
+* *
+* Remarques : La liste doit contenir des éléments dans l'ordre inverse *
+* d'apparition. De plus, elle est libérée dans cette fonction. *
+* *
+******************************************************************************/
+
+void g_template_type_add_params(GTemplateType *type, GSList *list)
+{
+ GSList *iter; /* Boucle de parcours */
+
+ list = g_slist_reverse(list);
+ for (iter = list; iter != NULL; iter = g_slist_next(iter))
+ {
+ type->models = (GOpenidaType **)realloc(type->models,
+ ++type->models_count * sizeof(GOpenidaType *));
+ type->models[type->models_count - 1] = G_OPENIDA_TYPE(iter->data);
+ }
+ g_slist_free(list);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : type = type à consulter. *
+* index = indice du paramètre à retourner. *
+* *
+* Description : Fournit un paramètre donné du gabarit. *
+* *
+* Retour : Type inclus dans le modèle ou NULL si mauvais indice. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GOpenidaType *g_template_type_get_param(const GTemplateType *type, size_t index)
+{
+ return (index < type->models_count ? type->models[index] : NULL);
+
+}
+
+
+/* ---------------------------------------------------------------------------------- */
+/* VALEUR LITERALE DES TYPES INSTANCIES */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour un type reposant sur des gabarits. */
+G_DEFINE_TYPE(GLiteralType, g_literal_type, G_TYPE_OPENIDA_TYPE);
+
+
+/******************************************************************************
+* *
+* Paramètres : klass = classe à initialiser. *
+* *
+* Description : Initialise la classe des types instanciés avec des valeurs. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_literal_type_class_init(GLiteralTypeClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : type = instance à initialiser. *
+* *
+* Description : Initialise l'instance d'un type instancié avec une valeur. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_literal_type_init(GLiteralType *type)
+{
+ GOpenidaType *oida_type; /* Version basique */
+
+ oida_type = G_OPENIDA_TYPE(type);
+
+ oida_type->dup = (type_dup_fc)g_literal_type_dup;
+ oida_type->to_string = (type_to_string_fc)g_literal_type_to_string;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : orig = type d'origine instancié. *
+* value = valeur de l'instanciation. *
+* *
+* Description : Crée une représentation de type instancié avec une valeur. *
+* *
+* Retour : Adresse de la structure mise en place. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GOpenidaType *g_literal_type_new(GOpenidaType *orig, literal_value value)
+{
+ GLiteralType *result; /* Structure à retourner */
+
+ result = g_object_new(G_TYPE_LITERAL_TYPE, NULL);
+
+ result->orig = orig;
+ result->value = value;
+
+ g_object_ref(orig);
+
+ return G_OPENIDA_TYPE(result);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : type = type à dupliquer. *
+* *
+* Description : Crée un copie d'un type existant. *
+* *
+* Retour : Nouvelle instance de type identique à celle fournie. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static GOpenidaType *g_literal_type_dup(const GLiteralType *type)
+{
+ GOpenidaType *orig; /* Copie du type interne */
+
+ orig = g_openida_type_dup(type->orig);
+
+ return g_literal_type_new(orig, type->value);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : type = type à convertir. *
+* *
+* Description : Décrit le type fourni sous forme de caractères. *
+* *
+* Retour : Chaîne à libérer de la mémoire après usage. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static char *g_literal_type_to_string(const GLiteralType *type)
+{
+ char *result; /* Valeur à renvoyer */
+ size_t max; /* Longueur totale du texte */
+
+ if (G_IS_BASIC_TYPE(type->orig))
+ switch (G_BASIC_TYPE(type->orig)->type)
+ {
+ case BTP_BOOL:
+ result = strdup(type->value.int_val ? "true" : "false");
+ break;
+
+ case BTP_INT:
+ max = strlen("2147483647" /* INT_MAX */) + 1;
+ result = (char *)calloc(max, sizeof(char));
+ snprintf(result, max, "%d", type->value.int_val);
+ break;
+
+ default:
+ result = strdup("TODO");
+ break;
+
+ }
+ else result = strdup("???");
+
+ return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* COLLECTE ET GESTION DE TYPES */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour un gestionnaire de types. */
+G_DEFINE_TYPE(GTypesManager, g_types_manager, G_TYPE_OBJECT);
+
+
+/******************************************************************************
+* *
+* Paramètres : klass = classe à initialiser. *
+* *
+* Description : Initialise la classe des gestionnaires de types. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_types_manager_class_init(GTypesManagerClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : manager = instance à initialiser. *
+* *
+* Description : Initialise l'instance d'un gestionnaire de types. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_types_manager_init(GTypesManager *manager)
+{
+
+}
diff --git a/src/analysis/type.h b/src/analysis/type.h
new file mode 100644
index 0000000..b127eb3
--- /dev/null
+++ b/src/analysis/type.h
@@ -0,0 +1,312 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * variable.h - prototypes pour la manipulation des variables en tout genre
+ *
+ * Copyright (C) 2009 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_TYPE_H
+#define _ANALYSIS_TYPE_H
+
+
+#include <glib.h>
+#include <glib-object.h>
+
+
+#include "../arch/archbase.h"
+#include "../arch/processor.h"
+
+
+
+/* ------------------------ REPRESENTATION INTERNE DES TYPES ------------------------ */
+
+
+#define G_TYPE_OPENIDA_TYPE g_openida_type_get_type()
+#define G_OPENIDA_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_openida_type_get_type(), GOpenidaType))
+#define G_IS_OPENIDA_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_openida_type_get_type()))
+#define G_OPENIDA_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_OPENIDA_TYPE, GOpenidaTypeClass))
+#define G_IS_OPENIDA_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_OPENIDA_TYPE))
+#define G_OPENIDA_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_OPENIDA_TYPE, GOpenidaTypeClass))
+
+
+/* Description de type quelconque (instance) */
+typedef struct _GOpenidaType GOpenidaType;
+
+/* Description de type quelconque (classe) */
+typedef struct _GOpenidaTypeClass GOpenidaTypeClass;
+
+
+/* Qualificatifs de variables */
+typedef enum _TypeQualifier
+{
+ TQF_RESTRICT = (1 << 0), /* restrict (C99) */
+ TQF_VOLATILE = (1 << 1), /* volatile */
+ TQF_CONST = (1 << 2) /* const */
+
+} TypeQualifier;
+
+
+/* Indique le type défini pour un type quelconque. */
+GType g_openida_type_get_type(void);
+
+/* Crée un copie d'un type existant. */
+GOpenidaType *g_openida_type_dup(const GOpenidaType *);
+
+/* Décrit le type fourni sous forme de caractères. */
+char *g_openida_type_to_string(const GOpenidaType *);
+
+/* Ajoute un qualificatif à une instance de type. */
+void g_openida_type_add_qualifier(GOpenidaType *, TypeQualifier);
+
+/* Indique la terminaison de la représentation du type. */
+bool g_openida_type_is_pointer(const GOpenidaType *, bool);
+
+
+
+/* ---------------------------- 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;
+
+
+#define G_TYPE_BASIC_TYPE g_basic_type_get_type()
+#define G_BASIC_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_basic_type_get_type(), GBasicType))
+#define G_IS_BASIC_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_basic_type_get_type()))
+#define G_BASIC_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_BASIC_TYPE, GBasicTypeClass))
+#define G_IS_BASIC_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_BASIC_TYPE))
+#define G_BASIC_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_BASIC_TYPE, GBasicTypeClass))
+
+
+/* Description de type basique (instance) */
+typedef struct _GBasicType GBasicType;
+
+/* Description de type basique (classe) */
+typedef struct _GBasicTypeClass GBasicTypeClass;
+
+
+/* Indique le type défini pour un type basique. */
+GType g_basic_type_get_type(void);
+
+/* Crée une représentation de type basique. */
+GOpenidaType *g_basic_type_new(BaseType);
+
+
+
+/* -------------------------- VARIABLES DEPENDANT D'AUTRES -------------------------- */
+
+
+#define G_TYPE_ENCAPSULATED_TYPE g_encapsulated_type_get_type()
+#define G_ENCAPSULATED_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_encapsulated_type_get_type(), GEncapsulatedType))
+#define G_IS_ENCAPSULATED_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_encapsulated_type_get_type()))
+#define G_ENCAPSULATED_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_ENCAPSULATED_TYPE, GEncapsulatedTypeClass))
+#define G_IS_ENCAPSULATED_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_ENCAPSULATED_TYPE))
+#define G_ENCAPSULATED_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_ENCAPSULATED_TYPE, GEncapsulatedTypeClass))
+
+
+/* Description de type encapsulé (instance) */
+typedef struct _GEncapsulatedType GEncapsulatedType;
+
+/* Description de type encapsulé (classe) */
+typedef struct _GEncapsulatedTypeClass GEncapsulatedTypeClass;
+
+
+/* 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) */
+
+ ECT_ROUTINE /* Pointeur vers une routine */
+
+} EncapsulationType;
+
+
+/* Indique le type défini pour un type encapsulé. */
+GType g_encapsulated_type_get_type(void);
+
+/* Crée une représentation de variable dérivée. */
+GOpenidaType *g_encapsulated_type_new(EncapsulationType, ...);
+
+
+
+/* ---------------------- CLASSES / STRUCTURES ET ENUMERATIONS ---------------------- */
+
+
+#define G_TYPE_CLASS_ENUM_TYPE g_class_enum_type_get_type()
+#define G_CLASS_ENUM_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_class_enum_type_get_type(), GClassEnumType))
+#define G_IS_CLASS_ENUM_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_class_enum_type_get_type()))
+#define G_CLASS_ENUM_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_CLASS_ENUM_TYPE, GClassEnumTypeClass))
+#define G_IS_CLASS_ENUM_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_CLASS_ENUM_TYPE))
+#define G_CLASS_ENUM_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_CLASS_ENUM_TYPE, GClassEnumTypeClass))
+
+
+/* Description de type classe/structure et enumeration (instance) */
+typedef struct _GClassEnumType GClassEnumType;
+
+/* Description de type classe/structure et enumeration (classe) */
+typedef struct _GClassEnumTypeClass GClassEnumTypeClass;
+
+
+/* Type pris en compte */
+typedef enum _ClassEnumType
+{
+ CET_UNKNOWN, /* Statut inconnu */
+ CET_STRUCT, /* Structure */
+ CET_ENUM, /* Enumération */
+ CET_CLASS /* Classe */
+
+} ClassEnumType;
+
+
+/* Indique le type défini pour un type classe ou assimilé. */
+GType g_class_enum_type_get_type(void);
+
+/* Crée une représentation de classe, structure ou énumération. */
+GOpenidaType *g_class_enum_type_new(ClassEnumType, const char *);
+
+
+
+/* ----------------------- ELEMENTS REPOSANT SUR DES GABARITS ----------------------- */
+
+
+#define G_TYPE_TEMPLATE_TYPE g_template_type_get_type()
+#define G_TEMPLATE_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_template_type_get_type(), GTemplateType))
+#define G_IS_TEMPLATE_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_template_type_get_type()))
+#define G_TEMPLATE_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_TEMPLATE_TYPE, GTemplateTypeClass))
+#define G_IS_TEMPLATE_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_TEMPLATE_TYPE))
+#define G_TEMPLATE_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_TEMPLATE_TYPE, GTemplateTypeClass))
+
+
+/* Description de type reposant sur des gabarits (instance) */
+typedef struct _GTemplateType GTemplateType;
+
+/* Description de type reposant sur des gabarits (classe) */
+typedef struct _GTemplateTypeClass GTemplateTypeClass;
+
+
+/* Indique le type défini pour un type reposant sur des gabarits. */
+GType g_template_type_get_type(void);
+
+/* Crée une représentation de type reposant sur des gabarits. */
+GOpenidaType *g_template_type_new(const char *, GSList *);
+
+/* Ajoute une série de paramètres à un gabarit. */
+void g_template_type_add_params(GTemplateType *, GSList *);
+
+/* Fournit un paramètre donné du gabarit. */
+GOpenidaType *g_template_type_get_param(const GTemplateType *, size_t);
+
+
+
+/* ---------------------- VALEUR LITERALE DES TYPES INSTANCIES ---------------------- */
+
+
+#define G_TYPE_LITERAL_TYPE g_literal_type_get_type()
+#define G_LITERAL_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_literal_type_get_type(), GLiteralType))
+#define G_IS_LITERAL_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_literal_type_get_type()))
+#define G_LITERAL_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_LITERAL_TYPE, GLiteralTypeClass))
+#define G_IS_LITERAL_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_LITERAL_TYPE))
+#define G_LITERAL_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_LITERAL_TYPE, GLiteralTypeClass))
+
+
+/* Description de type instancié avec une valeur litérale (instance) */
+typedef struct _GLiteralType GLiteralType;
+
+/* Description de type instancié avec une valeur litérale (classe) */
+typedef struct _GLiteralTypeClass GLiteralTypeClass;
+
+
+/* Valeurs instanciées supportées */
+typedef union _literal_value
+{
+ int int_val; /* Valeur entière */
+ float float_val; /* Valeur flottante */
+
+} literal_value;
+
+
+/* Indique le type défini pour un type instancié avec une valeur litérale. */
+GType g_literal_type_get_type(void);
+
+/* Crée une représentation de type instancié avec une valeur. */
+GOpenidaType *g_literal_type_new(GOpenidaType *, literal_value);
+
+
+
+/* -------------------------- COLLECTE ET GESTION DE TYPES -------------------------- */
+
+
+#define G_TYPE_TYPES_MANAGER g_types_manager_get_type()
+#define G_TYPES_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_types_manager_get_type(), GTypesManager))
+#define G_IS_TYPES_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_types_manager_get_type()))
+#define G_TYPES_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_TYPES_MANAGER, GTypesManagerClass))
+#define G_IS_TYPES_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_TYPES_MANAGER))
+#define G_TYPES_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_TYPES_MANAGER, GTypesManagerClass))
+
+
+/* Description d'un gestionnaire de types (instance) */
+typedef struct _GTypesManager GTypesManager;
+
+/* Description d'un gestionnaire de types (classe) */
+typedef struct _GTypesManagerClass GTypesManagerClass;
+
+
+/* Indique le type défini pour un gestionnaire de types. */
+GType g_types_manager_get_type(void);
+
+
+
+
+
+#endif /* _ANALYSIS_TYPE_H */
diff --git a/src/analysis/variable.c b/src/analysis/variable.c
index 01c780e..e24f7e1 100644
--- a/src/analysis/variable.c
+++ b/src/analysis/variable.c
@@ -24,6 +24,162 @@
#include "variable.h"
+#include "../common/extstr.h"
+
+
+
+/* ------------------- ASSOCIATION D'UN TYPE ET D'UNE DESIGNATION ------------------- */
+
+
+/* Variable typée (instance) */
+struct _GBinVariable
+{
+ GObject parent; /* A laisser en premier */
+
+ GOpenidaType *type; /* Type de la variable */
+ char *name; /* Désignation humaine */
+
+};
+
+/* Variable typée (classe) */
+struct _GBinVariableClass
+{
+ GObjectClass parent; /* A laisser en premier */
+
+};
+
+
+/* Initialise la classe des variables. */
+static void g_binary_variable_class_init(GBinVariableClass *);
+
+/* Initialise l'instande d'une variable. */
+static void g_binary_variable_init(GBinVariable *);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* ASSOCIATION D'UN TYPE ET D'UNE DESIGNATION */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour une base de variable. */
+G_DEFINE_TYPE(GBinVariable, g_binary_variable, G_TYPE_OBJECT);
+
+
+/******************************************************************************
+* *
+* Paramètres : klass = classe à initialiser. *
+* *
+* Description : Initialise la classe des variables. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_binary_variable_class_init(GBinVariableClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : var = instance à initialiser. *
+* *
+* Description : Initialise l'instande d'une variable. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_binary_variable_init(GBinVariable *var)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : type = type de la variable à mettre en place. *
+* *
+* Description : Crée une représentation de variable de type donné. *
+* *
+* Retour : Variable mise en place. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GBinVariable *g_binary_variable_new(GOpenidaType *type)
+{
+ GBinVariable *result; /* Variable à retourner */
+
+ result = g_object_new(G_TYPE_BIN_VARIABLE, NULL);
+
+ result->type = type;
+ g_object_ref(G_OBJECT(type));
+
+ return result;
+
+}
+
+
+
+
+
+
+
+
+/******************************************************************************
+* *
+* Paramètres : var = variable à convertir. *
+* *
+* Description : Décrit la variable donnée sous forme de caractères. *
+* *
+* Retour : Chaîne à libérer de la mémoire après usage. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+char *g_binary_variable_to_string(const GBinVariable *var)
+{
+ char *result; /* Valeur à retourner */
+
+ result = g_openida_type_to_string(var->type);
+
+ if (var->name != NULL)
+ {
+ if (!g_openida_type_is_pointer(var->type, true))
+ result = stradd(result, " ");
+
+ result = stradd(result, var->name);
+
+ }
+
+ return result;
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
#include <malloc.h>
#include <stdint.h>
#include <string.h>
@@ -34,6 +190,14 @@
+
+
+
+
+
+
+
+
/* -------------------- BASE DE VARIABLES OU VARIABLES INCONNUES -------------------- */
diff --git a/src/analysis/variable.h b/src/analysis/variable.h
index f2bbb87..ab5a037 100644
--- a/src/analysis/variable.h
+++ b/src/analysis/variable.h
@@ -29,6 +29,46 @@
#include <glib-object.h>
+#include "type.h"
+
+
+
+/* ------------------- ASSOCIATION D'UN TYPE ET D'UNE DESIGNATION ------------------- */
+
+
+#define G_TYPE_BIN_VARIABLE g_binary_variable_get_type()
+#define G_BINARY_VARIABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_binary_variable_get_type(), GBinVariable))
+#define G_IS_BIN_VARIABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_binary_variable_get_type()))
+#define G_BINARY_VARIABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_BIN_VARIABLE, GBinVariableClass))
+#define G_IS_BIN_VARIABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_BIN_VARIABLE))
+#define G_BINARY_VARIABLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_BIN_VARIABLE, GBinVariableClass))
+
+
+/* Base de variable (instance) */
+typedef struct _GBinVariable GBinVariable;
+
+/* Base de variable (classe) */
+typedef struct _GBinVariableClass GBinVariableClass;
+
+
+/* Indique le type défini pour une base de variable. */
+GType g_binary_variable_get_type(void);
+
+/* Crée une représentation de variable de type donné. */
+GBinVariable *g_binary_variable_new(GOpenidaType *);
+
+
+
+
+/* Décrit la variable donnée sous forme de caractères. */
+char *g_binary_variable_to_string(const GBinVariable *);
+
+
+
+
+
+
+
/* -------------------- BASE DE VARIABLES OU VARIABLES INCONNUES -------------------- */
@@ -79,6 +119,7 @@ typedef struct _variable variable;
/* Liste des types de base existants */
+#if 0
typedef enum _BaseType
{
BTP_VOID, /* void */
@@ -111,7 +152,7 @@ typedef enum _BaseType
BTP_OTHER /* Extension utilisateur */
} BaseType;
-
+#endif
/* Variable repésentant un argument ou un type de retour */
@@ -144,6 +185,7 @@ typedef struct _complex_variable complex_variable;
/* Type de ces variables */
+#if 0
typedef enum _ClassEnumType
{
CET_UNKNOWN, /* Statut inconnu */
@@ -152,6 +194,7 @@ typedef enum _ClassEnumType
CET_CLASS /* Classe */
} ClassEnumType;
+#endif
/* Représentation des classes et des énumérations */
@@ -167,6 +210,7 @@ complex_variable *create_class_enum_var(char *);
/* Cas d'encapsulation possibles */
+#if 0
typedef enum _EncapsulationType
{
ECT_POINTER, /* Pointeur */
@@ -176,6 +220,7 @@ typedef enum _EncapsulationType
ECT_IMAGINARY /* Imaginaire (C 2000) */
} EncapsulationType;
+#endif
/* Représentation des variables dérivées */