summaryrefslogtreecommitdiff
path: root/src/analysis
diff options
context:
space:
mode:
Diffstat (limited to 'src/analysis')
-rwxr-xr-xsrc/analysis/Makefile.am6
-rw-r--r--src/analysis/routine.c30
-rw-r--r--src/analysis/routine.h14
-rw-r--r--src/analysis/type.c1211
-rw-r--r--src/analysis/type.h246
-rwxr-xr-xsrc/analysis/types/Makefile.am23
-rw-r--r--src/analysis/types/basic.c309
-rw-r--r--src/analysis/types/basic.h96
-rw-r--r--src/analysis/types/cse-int.h56
-rw-r--r--src/analysis/types/cse.c153
-rw-r--r--src/analysis/types/cse.h69
-rw-r--r--src/analysis/types/encaps.c313
-rw-r--r--src/analysis/types/encaps.h78
-rw-r--r--src/analysis/types/literal.c205
-rw-r--r--src/analysis/types/literal.h67
-rw-r--r--src/analysis/types/template.c283
-rw-r--r--src/analysis/types/template.h67
-rw-r--r--src/analysis/variable.c21
-rw-r--r--src/analysis/variable.h11
19 files changed, 1796 insertions, 1462 deletions
diff --git a/src/analysis/Makefile.am b/src/analysis/Makefile.am
index b5b345f..1c3950f 100755
--- a/src/analysis/Makefile.am
+++ b/src/analysis/Makefile.am
@@ -12,13 +12,15 @@ libanalysis_la_SOURCES = \
line_prologue.h line_prologue.c \
roptions.h roptions.c \
routine.h routine.c \
+ type-int.h \
type.h type.c \
variable.h variable.c
libanalysis_la_LIBADD = \
binaries/libanalysisbinaries.la \
decomp/libanalysisdecomp.la \
- disass/libanalysisdisass.la
+ disass/libanalysisdisass.la \
+ types/libanalysistypes.la
libanalysis_la_LDFLAGS =
@@ -29,4 +31,4 @@ AM_CPPFLAGS =
AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS)
-SUBDIRS = binaries decomp disass
+SUBDIRS = binaries decomp disass types
diff --git a/src/analysis/routine.c b/src/analysis/routine.c
index 7151fdc..c26886f 100644
--- a/src/analysis/routine.c
+++ b/src/analysis/routine.c
@@ -43,11 +43,11 @@ struct _GBinRoutine
RoutineType type; /* Type de routine */
- GOpenidaType *ret_type; /* Type retourné */
+ GDataType *ret_type; /* Type retourné */
- GOpenidaType *namespace; /* Espace de noms / classe */
+ GDataType *namespace; /* Espace de noms / classe */
char *name; /* Désignation humaine */
- GOpenidaType *full_name; /* Désignation très complète */
+ GDataType *full_name; /* Désignation très complète */
GBinVariable **args; /* Arguments de la routines */
size_t args_count; /* Nombre d'arguments */
@@ -153,13 +153,13 @@ GBinRoutine *g_binary_routine_new(void)
* *
******************************************************************************/
-GBinRoutine *g_binary_routine_new_constructor(GOpenidaType *type)
+GBinRoutine *g_binary_routine_new_constructor(GDataType *type)
{
GBinRoutine *result; /* Structure à retourner */
result = g_object_new(G_TYPE_BIN_ROUTINE, NULL);
- g_binary_routine_set_name(result, _g_openida_type_to_string(type, true));
+ g_binary_routine_set_name(result, _g_data_type_to_string(type, true));
return result;
@@ -360,7 +360,7 @@ void g_binary_routine_set_type(GBinRoutine *routine, RoutineType type)
* *
******************************************************************************/
-void g_binary_routine_set_namespace(GBinRoutine *routine, GOpenidaType *namespace)
+void g_binary_routine_set_namespace(GBinRoutine *routine, GDataType *namespace)
{
routine->namespace = namespace;
@@ -379,7 +379,7 @@ void g_binary_routine_set_namespace(GBinRoutine *routine, GOpenidaType *namespac
* *
******************************************************************************/
-GOpenidaType *g_binary_routine_get_namespace(const GBinRoutine *routine)
+GDataType *g_binary_routine_get_namespace(const GBinRoutine *routine)
{
return routine->namespace;
@@ -424,7 +424,7 @@ 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));
+ g_binary_routine_set_name(routine, g_data_type_to_string(routine->full_name));
return routine->name;
@@ -444,7 +444,7 @@ const char *g_binary_routine_get_name(const GBinRoutine *routine)
* *
******************************************************************************/
-void g_binary_routine_set_name_from_type(GBinRoutine *routine, GOpenidaType *type)
+void g_binary_routine_set_name_from_type(GBinRoutine *routine, GDataType *type)
{
if (routine->full_name != NULL)
g_object_unref(G_OBJECT(routine->full_name));
@@ -466,7 +466,7 @@ void g_binary_routine_set_name_from_type(GBinRoutine *routine, GOpenidaType *typ
* *
******************************************************************************/
-GOpenidaType *g_binary_routine_get_type_from_name(const GBinRoutine *routine)
+GDataType *g_binary_routine_get_type_from_name(const GBinRoutine *routine)
{
return routine->full_name;
@@ -486,7 +486,7 @@ GOpenidaType *g_binary_routine_get_type_from_name(const GBinRoutine *routine)
* *
******************************************************************************/
-void g_binary_routine_set_return_type(GBinRoutine *routine, GOpenidaType *type)
+void g_binary_routine_set_return_type(GBinRoutine *routine, GDataType *type)
{
if (routine->ret_type != NULL)
g_object_unref(G_OBJECT(routine->ret_type));
@@ -511,7 +511,7 @@ void g_binary_routine_set_return_type(GBinRoutine *routine, GOpenidaType *type)
* *
******************************************************************************/
-GOpenidaType *g_binary_routine_get_return_type(const GBinRoutine *routine)
+GDataType *g_binary_routine_get_return_type(const GBinRoutine *routine)
{
return routine->ret_type;
@@ -757,8 +757,8 @@ char *_g_binary_routine_to_string(const GBinRoutine *routine, Routine2StringOpti
if (routine->ret_type == NULL) result = strdup("??? ");
else
{
- result = _g_openida_type_to_string(routine->ret_type, !(options & RSO_LONG_TYPE));
- if (!g_openida_type_is_pointer(routine->ret_type, true))
+ result = _g_data_type_to_string(routine->ret_type, !(options & RSO_LONG_TYPE));
+ if (!g_data_type_is_pointer(routine->ret_type, true))
result = stradd(result, " ");
}
break;
@@ -769,7 +769,7 @@ char *_g_binary_routine_to_string(const GBinRoutine *routine, Routine2StringOpti
if (options & RSO_NAMESPACE && routine->namespace != NULL)
{
- namespace = g_openida_type_to_string(routine->namespace);
+ namespace = g_data_type_to_string(routine->namespace);
result = stradd(result, namespace);
result = stradd(result, "." /* FIXME */);
diff --git a/src/analysis/routine.h b/src/analysis/routine.h
index 8a5085b..3622630 100644
--- a/src/analysis/routine.h
+++ b/src/analysis/routine.h
@@ -77,7 +77,7 @@ GType g_bin_routine_get_type(void);
GBinRoutine *g_binary_routine_new(void);
/* Crée une représentation de routine construisant une instance. */
-GBinRoutine *g_binary_routine_new_constructor(GOpenidaType *);
+GBinRoutine *g_binary_routine_new_constructor(GDataType *);
/* Etablit la comparaison ascendante entre deux routines. */
int g_binary_routine_compare(const GBinRoutine **, const GBinRoutine **);
@@ -101,10 +101,10 @@ off_t g_binary_routine_get_size(const GBinRoutine *);
void g_binary_routine_set_type(GBinRoutine *, RoutineType);
/* Définit le groupe d'appartenance d'une routine donnée. */
-void g_binary_routine_set_namespace(GBinRoutine *, GOpenidaType *);
+void g_binary_routine_set_namespace(GBinRoutine *, GDataType *);
/* Fournit le groupe d'appartenance d'une routine donnée. */
-GOpenidaType *g_binary_routine_get_namespace(const GBinRoutine *);
+GDataType *g_binary_routine_get_namespace(const GBinRoutine *);
/* Définit le nom humain d'une routine. */
void g_binary_routine_set_name(GBinRoutine *, char *);
@@ -113,16 +113,16 @@ void g_binary_routine_set_name(GBinRoutine *, char *);
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 *);
+void g_binary_routine_set_name_from_type(GBinRoutine *, GDataType *);
/* Fournit le type construisant le nom humain d'une routine. */
-GOpenidaType *g_binary_routine_get_type_from_name(const GBinRoutine *);
+GDataType *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 *, GOpenidaType *);
+void g_binary_routine_set_return_type(GBinRoutine *, GDataType *);
/* Fournit le type de retour d'une routine. */
-GOpenidaType *g_binary_routine_get_return_type(const GBinRoutine *);
+GDataType *g_binary_routine_get_return_type(const GBinRoutine *);
/* Ajoute un argument à une routine. */
void g_binary_routine_add_arg(GBinRoutine *, GBinVariable *);
diff --git a/src/analysis/type.c b/src/analysis/type.c
index d04e7ce..ef75080 100644
--- a/src/analysis/type.c
+++ b/src/analysis/type.c
@@ -1,8 +1,8 @@
/* OpenIDA - Outil d'analyse de fichiers binaires
- * variable.h - prototypes pour la manipulation des variables en tout genre
+ * type.h - prototypes pour la manipulation des types en tout genre
*
- * Copyright (C) 2010 Cyrille Bagard
+ * Copyright (C) 2010-2012 Cyrille Bagard
*
* This file is part of OpenIDA.
*
@@ -24,12 +24,11 @@
#include "type.h"
-#include <malloc.h>
#include <stdarg.h>
-#include <string.h>
#include "routine.h"
+#include "type-int.h"
#include "../common/extstr.h"
@@ -37,216 +36,11 @@
/* ------------------------ 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 */
-
- GOpenidaType *namespace; /* Espace de noms / classe */
- 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 *);
+static void g_data_type_class_init(GDataTypeClass *);
/* 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 *);
+static void g_data_type_init(GDataType *);
@@ -284,7 +78,7 @@ static void g_types_manager_init(GTypesManager *manager);
/* Indique le type défini pour un type quelconque. */
-G_DEFINE_TYPE(GOpenidaType, g_openida_type, G_TYPE_OBJECT);
+G_DEFINE_TYPE(GDataType, g_data_type, G_TYPE_OBJECT);
/******************************************************************************
@@ -299,7 +93,7 @@ G_DEFINE_TYPE(GOpenidaType, g_openida_type, G_TYPE_OBJECT);
* *
******************************************************************************/
-static void g_openida_type_class_init(GOpenidaTypeClass *klass)
+static void g_data_type_class_init(GDataTypeClass *klass)
{
}
@@ -317,7 +111,7 @@ static void g_openida_type_class_init(GOpenidaTypeClass *klass)
* *
******************************************************************************/
-static void g_openida_type_init(GOpenidaType *type)
+static void g_data_type_init(GDataType *type)
{
}
@@ -335,7 +129,7 @@ static void g_openida_type_init(GOpenidaType *type)
* *
******************************************************************************/
-GOpenidaType *g_openida_type_dup(const GOpenidaType *type)
+GDataType *g_data_type_dup(const GDataType *type)
{
return type->dup(type);
@@ -355,7 +149,7 @@ GOpenidaType *g_openida_type_dup(const GOpenidaType *type)
* *
******************************************************************************/
-void g_openida_type_set_namespace(GOpenidaType *type, GOpenidaType *namespace)
+void g_data_type_set_namespace(GDataType *type, GDataType *namespace)
{
g_object_ref(G_OBJECT(namespace));
@@ -377,7 +171,7 @@ void g_openida_type_set_namespace(GOpenidaType *type, GOpenidaType *namespace)
* *
******************************************************************************/
-char *_g_openida_type_to_string(const GOpenidaType *type, bool simple)
+char *_g_data_type_to_string(const GDataType *type, bool simple)
{
char *result; /* Chaîne à retourner */
char *namespace; /* Groupe d'appartenance */
@@ -386,7 +180,7 @@ char *_g_openida_type_to_string(const GOpenidaType *type, bool simple)
if (!simple && type->namespace != NULL)
{
- namespace = g_openida_type_to_string(type->namespace);
+ namespace = g_data_type_to_string(type->namespace);
result = strprep(result, "." /* FIXME */);
result = strprep(result, namespace);
@@ -422,7 +216,7 @@ char *_g_openida_type_to_string(const GOpenidaType *type, bool simple)
* *
******************************************************************************/
-void g_openida_type_add_qualifier(GOpenidaType *type, TypeQualifier qualifier)
+void g_data_type_add_qualifier(GDataType *type, TypeQualifier qualifier)
{
type->qualifiers |= qualifier;
@@ -442,14 +236,14 @@ void g_openida_type_add_qualifier(GOpenidaType *type, TypeQualifier qualifier)
* *
******************************************************************************/
-bool g_openida_type_is_pointer(const GOpenidaType *type, bool large)
+bool g_data_type_is_pointer(const GDataType *type, bool large)
{
bool result; /* Bilan à retourner */
result = G_IS_ENCAPSULATED_TYPE(type);
if (result)
- switch (G_ENCAPSULATED_TYPE(type)->type)
+ switch (g_encapsulated_type_get_etype(G_ENCAPSULATED_TYPE(type)))
{
case ECT_POINTER:
result = true;
@@ -470,981 +264,6 @@ bool g_openida_type_is_pointer(const GOpenidaType *type, bool large)
/* ---------------------------------------------------------------------------------- */
-/* 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;
-
- case ECT_ROUTINE: /* Pour GCC */
- default:
- break;
-
- }
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : type = type à consulter. *
-* *
-* Description : Fournit le type d'encapsulation gérée par le type. *
-* *
-* Retour : Type d'encapsulation gérée. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-EncapsulationType g_encapsulated_type_get_etype(const GEncapsulatedType *type)
-{
- return type->type;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : type = type à consulter. *
-* ... = sous-type ou routine encapsulée dans le type. [OUT] *
-* *
-* Description : Fournit la routine encapsulée dans le type. *
-* *
-* Retour : - *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-void g_encapsulated_type_get_item(const GEncapsulatedType *type, ...)
-{
- va_list ap; /* Liste variable d'arguments */
- GOpenidaType **child; /* Adresse pour sous-type */
- GBinRoutine **routine; /* Adresse pour routine */
-
- va_start(ap, type);
-
- switch (type->type)
- {
- case ECT_ROUTINE:
- routine = va_arg(ap, GBinRoutine **);
- *routine = type->routine;
- break;
-
- default:
- child = va_arg(ap, GOpenidaType **);
- *child = type->child;
- break;
-
- }
-
- va_end(ap);
-
-}
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/* 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);
-
- 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. *
-* *
-* Description : Indique le nombre de paramètres associés du gabarit. *
-* *
-* Retour : Nombre de paramètres inclus dans le gabarit. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-size_t g_template_type_count_param(const GTemplateType *type)
-{
- return type->models_count;
-
-}
-
-
-/******************************************************************************
-* *
-* 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 */
/* ---------------------------------------------------------------------------------- */
diff --git a/src/analysis/type.h b/src/analysis/type.h
index 72b64d1..dde256e 100644
--- a/src/analysis/type.h
+++ b/src/analysis/type.h
@@ -1,8 +1,8 @@
/* OpenIDA - Outil d'analyse de fichiers binaires
- * variable.h - prototypes pour la manipulation des variables en tout genre
+ * type.h - prototypes pour la manipulation des types en tout genre
*
- * Copyright (C) 2010 Cyrille Bagard
+ * Copyright (C) 2010-2012 Cyrille Bagard
*
* This file is part of OpenIDA.
*
@@ -37,19 +37,19 @@
/* ------------------------ 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))
+#define G_TYPE_DATA_TYPE g_data_type_get_type()
+#define G_DATA_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_data_type_get_type(), GDataType))
+#define G_IS_DATA_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_data_type_get_type()))
+#define G_DATA_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_DATA_TYPE, GDataTypeClass))
+#define G_IS_DATA_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_DATA_TYPE))
+#define G_DATA_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DATA_TYPE, GDataTypeClass))
/* Description de type quelconque (instance) */
-typedef struct _GOpenidaType GOpenidaType;
+typedef struct _GDataType GDataType;
/* Description de type quelconque (classe) */
-typedef struct _GOpenidaTypeClass GOpenidaTypeClass;
+typedef struct _GDataTypeClass GDataTypeClass;
/* Qualificatifs de variables */
@@ -63,239 +63,27 @@ typedef enum _TypeQualifier
/* Indique le type défini pour un type quelconque. */
-GType g_openida_type_get_type(void);
+GType g_data_type_get_type(void);
/* Crée un copie d'un type existant. */
-GOpenidaType *g_openida_type_dup(const GOpenidaType *);
+GDataType *g_data_type_dup(const GDataType *);
/* Définit le groupe d'appartenance d'un type donné. */
-void g_openida_type_set_namespace(GOpenidaType *, GOpenidaType *);
+void g_data_type_set_namespace(GDataType *, GDataType *);
/* Décrit le type fourni sous forme de caractères. */
-char *_g_openida_type_to_string(const GOpenidaType *, bool);
+char *_g_data_type_to_string(const GDataType *, bool);
-#define g_openida_type_to_string(t) _g_openida_type_to_string((t), false)
+#define g_data_type_to_string(t) _g_data_type_to_string((t), false)
/* Ajoute un qualificatif à une instance de type. */
-void g_openida_type_add_qualifier(GOpenidaType *, TypeQualifier);
+void g_data_type_add_qualifier(GDataType *, TypeQualifier);
/* Indique la terminaison de la représentation du type. */
-bool g_openida_type_is_pointer(const GOpenidaType *, bool);
+bool g_data_type_is_pointer(const GDataType *, 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, ...);
-
-/* Fournit le type d'encapsulation gérée par le type. */
-EncapsulationType g_encapsulated_type_get_etype(const GEncapsulatedType *);
-
-/* Fournit la routine encapsulée dans le type. */
-void g_encapsulated_type_get_item(const GEncapsulatedType *, ...);
-
-
-
-/* ---------------------- 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 *);
-
-/* Indique le nombre de paramètres associés du gabarit. */
-size_t g_template_type_count_param(const GTemplateType *);
-
-/* 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 -------------------------- */
diff --git a/src/analysis/types/Makefile.am b/src/analysis/types/Makefile.am
new file mode 100755
index 0000000..25a8a38
--- /dev/null
+++ b/src/analysis/types/Makefile.am
@@ -0,0 +1,23 @@
+
+noinst_LTLIBRARIES = libanalysistypes.la
+
+libanalysistypes_la_SOURCES = \
+ basic.h basic.c \
+ cse-int.h \
+ cse.h cse.c \
+ encaps.h encaps.c \
+ literal.h literal.c \
+ template.h template.c
+
+libanalysistypes_la_LIBADD =
+
+libanalysistypes_la_LDFLAGS =
+
+
+INCLUDES = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS)
+
+AM_CPPFLAGS =
+
+AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS)
+
+SUBDIRS =
diff --git a/src/analysis/types/basic.c b/src/analysis/types/basic.c
new file mode 100644
index 0000000..436b04e
--- /dev/null
+++ b/src/analysis/types/basic.c
@@ -0,0 +1,309 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * basic.c - manipulation des types de données de base
+ *
+ * Copyright (C) 2012 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 "basic.h"
+
+
+#include <string.h>
+
+
+#include "../type-int.h"
+
+
+
+/* Description de type basique (instance) */
+struct _GBasicType
+{
+ GDataType parent; /* A laisser en premier */
+
+ BaseType type; /* Type représenté si connu */
+
+};
+
+/* Description de type basique (classe) */
+struct _GBasicTypeClass
+{
+ GDataTypeClass 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 GDataType *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 *);
+
+
+
+/* Indique le type défini pour un type basique. */
+G_DEFINE_TYPE(GBasicType, g_basic_type, G_TYPE_DATA_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)
+{
+ GDataType *data_type; /* Version basique */
+
+ data_type = G_DATA_TYPE(type);
+
+ data_type->dup = (type_dup_fc)g_basic_type_dup;
+ data_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 : - *
+* *
+******************************************************************************/
+
+GDataType *g_basic_type_new(BaseType type)
+{
+ GBasicType *result; /* Structure à retourner */
+
+ result = g_object_new(G_TYPE_BASIC_TYPE, NULL);
+
+ result->type = type;
+
+ return G_DATA_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 GDataType *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);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : type = type à consulter. *
+* *
+* Description : Fournit le type de base géré par le type. *
+* *
+* Retour : Type basique. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+BaseType g_basic_type_get_btype(const GBasicType *type)
+{
+ return type->type;
+
+}
diff --git a/src/analysis/types/basic.h b/src/analysis/types/basic.h
new file mode 100644
index 0000000..b58e242
--- /dev/null
+++ b/src/analysis/types/basic.h
@@ -0,0 +1,96 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * basic.h - prototypes pour la manipulation des types de données de base
+ *
+ * Copyright (C) 2012 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_TYPES_BASIC_H
+#define _ANALYSIS_TYPES_BASIC_H
+
+
+#include <glib-object.h>
+
+
+#include "../type.h"
+
+
+
+/* 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. */
+GDataType *g_basic_type_new(BaseType);
+
+/* Fournit le type de base géré par le type. */
+BaseType g_basic_type_get_btype(const GBasicType *);
+
+
+
+#endif /* _ANALYSIS_TYPES_BASIC_H */
diff --git a/src/analysis/types/cse-int.h b/src/analysis/types/cse-int.h
new file mode 100644
index 0000000..2599329
--- /dev/null
+++ b/src/analysis/types/cse-int.h
@@ -0,0 +1,56 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * cse-int.h - prototypes pour la définition interne des types classes / structures / énumérations
+ *
+ * Copyright (C) 2012 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_TYPES_CSE_INT_H
+#define _ANALYSIS_TYPES_CSE_INT_H
+
+
+#include "cse.h"
+#include "../type-int.h"
+
+
+
+/* Description de type classe/structure et enumeration (instance) */
+struct _GClassEnumType
+{
+ GDataType 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
+{
+ GDataTypeClass parent; /* A laisser en premier */
+
+};
+
+
+/* Décrit le type fourni sous forme de caractères. */
+char *g_class_enum_type_to_string(const GClassEnumType *);
+
+
+
+#endif /* _ANALYSIS_TYPES_CSE_INT_H */
diff --git a/src/analysis/types/cse.c b/src/analysis/types/cse.c
new file mode 100644
index 0000000..40d726e
--- /dev/null
+++ b/src/analysis/types/cse.c
@@ -0,0 +1,153 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * cse.c - manipulation des types classes / structures / énumérations
+ *
+ * Copyright (C) 2012 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 "cse.h"
+
+
+#include <string.h>
+
+
+#include "cse-int.h"
+
+
+
+/* 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 GDataType *g_class_enum_type_dup(const GClassEnumType *);
+
+
+
+/* Indique le type défini pour un type classe ou assimilé. */
+G_DEFINE_TYPE(GClassEnumType, g_class_enum_type, G_TYPE_DATA_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)
+{
+ GDataType *data_type; /* Version basique */
+
+ data_type = G_DATA_TYPE(type);
+
+ data_type->dup = (type_dup_fc)g_class_enum_type_dup;
+ data_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 : - *
+* *
+******************************************************************************/
+
+GDataType *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_DATA_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 GDataType *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 : - *
+* *
+******************************************************************************/
+
+char *g_class_enum_type_to_string(const GClassEnumType *type)
+{
+ return strdup(type->name);
+
+}
diff --git a/src/analysis/types/cse.h b/src/analysis/types/cse.h
new file mode 100644
index 0000000..b7dc669
--- /dev/null
+++ b/src/analysis/types/cse.h
@@ -0,0 +1,69 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * cse.h - prototypes pour la manipulation des types classes / structures / énumérations
+ *
+ * Copyright (C) 2012 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_TYPES_CSE_H
+#define _ANALYSIS_TYPES_CSE_H
+
+
+#include <glib-object.h>
+
+
+#include "../type.h"
+
+
+
+#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. */
+GDataType *g_class_enum_type_new(ClassEnumType, const char *);
+
+
+
+#endif /* _ANALYSIS_TYPES_CSE_H */
diff --git a/src/analysis/types/encaps.c b/src/analysis/types/encaps.c
new file mode 100644
index 0000000..492fd46
--- /dev/null
+++ b/src/analysis/types/encaps.c
@@ -0,0 +1,313 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * encaps.c - manipulation des types de données encapsulés
+ *
+ * Copyright (C) 2012 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 "encaps.h"
+
+
+#include "../routine.h"
+#include "../type-int.h"
+#include "../../common/extstr.h"
+
+
+
+/* Description de type encapsulé (instance) */
+struct _GEncapsulatedType
+{
+ GDataType parent; /* A laisser en premier */
+
+ EncapsulationType type; /* Encapsulation utilisée */
+ GDataType *child; /* Sous-type encadré */
+ GBinRoutine *routine; /* Routine pointée */
+
+};
+
+/* Description de type encapsulé (classe) */
+struct _GEncapsulatedTypeClass
+{
+ GDataTypeClass 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 GDataType *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 *);
+
+
+
+/* Indique le type défini pour un type encapsulé. */
+G_DEFINE_TYPE(GEncapsulatedType, g_encapsulated_type, G_TYPE_DATA_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)
+{
+ GDataType *data_type; /* Version basique */
+
+ data_type = G_DATA_TYPE(type);
+
+ data_type->dup = (type_dup_fc)g_encapsulated_type_dup;
+ data_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 : - *
+* *
+******************************************************************************/
+
+GDataType *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, GDataType *);
+ break;
+
+ }
+
+ va_end(ap);
+
+ return G_DATA_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 GDataType *g_encapsulated_type_dup(const GEncapsulatedType *type)
+{
+ GDataType *result; /* Nouvelle instance à renvoyer*/
+ GDataType *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_data_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_data_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_data_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;
+
+ case ECT_ROUTINE: /* Pour GCC */
+ default:
+ break;
+
+ }
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : type = type à consulter. *
+* *
+* Description : Fournit le type d'encapsulation gérée par le type. *
+* *
+* Retour : Type d'encapsulation gérée. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+EncapsulationType g_encapsulated_type_get_etype(const GEncapsulatedType *type)
+{
+ return type->type;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : type = type à consulter. *
+* ... = sous-type ou routine encapsulée dans le type. [OUT] *
+* *
+* Description : Fournit la routine encapsulée dans le type. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_encapsulated_type_get_item(const GEncapsulatedType *type, ...)
+{
+ va_list ap; /* Liste variable d'arguments */
+ GDataType **child; /* Adresse pour sous-type */
+ GBinRoutine **routine; /* Adresse pour routine */
+
+ va_start(ap, type);
+
+ switch (type->type)
+ {
+ case ECT_ROUTINE:
+ routine = va_arg(ap, GBinRoutine **);
+ *routine = type->routine;
+ break;
+
+ default:
+ child = va_arg(ap, GDataType **);
+ *child = type->child;
+ break;
+
+ }
+
+ va_end(ap);
+
+}
diff --git a/src/analysis/types/encaps.h b/src/analysis/types/encaps.h
new file mode 100644
index 0000000..c06767e
--- /dev/null
+++ b/src/analysis/types/encaps.h
@@ -0,0 +1,78 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * encaps.h - prototypes pour la manipulation des types de données encapsulés
+ *
+ * Copyright (C) 2012 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_TYPES_ENCAPS_H
+#define _ANALYSIS_TYPES_ENCAPS_H
+
+
+#include <glib-object.h>
+
+
+#include "../type.h"
+
+
+
+#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. */
+GDataType *g_encapsulated_type_new(EncapsulationType, ...);
+
+/* Fournit le type d'encapsulation gérée par le type. */
+EncapsulationType g_encapsulated_type_get_etype(const GEncapsulatedType *);
+
+/* Fournit la routine encapsulée dans le type. */
+void g_encapsulated_type_get_item(const GEncapsulatedType *, ...);
+
+
+
+#endif /* _ANALYSIS_TYPES_ENCAPS_H */
diff --git a/src/analysis/types/literal.c b/src/analysis/types/literal.c
new file mode 100644
index 0000000..92c8254
--- /dev/null
+++ b/src/analysis/types/literal.c
@@ -0,0 +1,205 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * literal.c - manipulation des valeurs littérales de types instanciés
+ *
+ * Copyright (C) 2012 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 "literal.h"
+
+
+#include <stdio.h>
+#include <string.h>
+
+
+#include "basic.h"
+#include "../type-int.h"
+
+
+
+/* Description de type instancié avec une valeur litérale (instance) */
+struct _GLiteralType
+{
+ GDataType parent; /* A laisser en premier */
+
+ GDataType *orig; /* Type instancié */
+ literal_value value; /* Valeur d'instance */
+
+};
+
+/* Description de type instancié avec une valeur litérale (classe) */
+struct _GLiteralTypeClass
+{
+ GDataTypeClass 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 GDataType *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 *);
+
+
+
+/* Indique le type défini pour un type reposant sur des gabarits. */
+G_DEFINE_TYPE(GLiteralType, g_literal_type, G_TYPE_DATA_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)
+{
+ GDataType *data_type; /* Version basique */
+
+ data_type = G_DATA_TYPE(type);
+
+ data_type->dup = (type_dup_fc)g_literal_type_dup;
+ data_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 : - *
+* *
+******************************************************************************/
+
+GDataType *g_literal_type_new(GDataType *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_DATA_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 GDataType *g_literal_type_dup(const GLiteralType *type)
+{
+ GDataType *orig; /* Copie du type interne */
+
+ orig = g_data_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_get_btype(G_BASIC_TYPE(type->orig)))
+ {
+ 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;
+
+}
diff --git a/src/analysis/types/literal.h b/src/analysis/types/literal.h
new file mode 100644
index 0000000..df279cd
--- /dev/null
+++ b/src/analysis/types/literal.h
@@ -0,0 +1,67 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * literal.h - prototypes pour la manipulation des valeurs littérales de types instanciés
+ *
+ * Copyright (C) 2012 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_TYPES_LITERAL_H
+#define _ANALYSIS_TYPES_LITERAL_H
+
+
+#include <glib-object.h>
+
+
+#include "../type.h"
+
+
+
+#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. */
+GDataType *g_literal_type_new(GDataType *, literal_value);
+
+
+
+#endif /* _ANALYSIS_TYPES_LITERAL_H */
diff --git a/src/analysis/types/template.c b/src/analysis/types/template.c
new file mode 100644
index 0000000..29d39bc
--- /dev/null
+++ b/src/analysis/types/template.c
@@ -0,0 +1,283 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * template.c - manipulation des types reposant sur des gabarits
+ *
+ * Copyright (C) 2012 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 "template.h"
+
+
+#include <malloc.h>
+#include <string.h>
+
+
+#include "cse-int.h"
+#include "../type-int.h"
+#include "../../common/extstr.h"
+
+
+
+/* Description de type reposant sur des gabarits (instance) */
+struct _GTemplateType
+{
+ GClassEnumType parent; /* A laisser en premier */
+
+ GDataType **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 GDataType *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 *);
+
+
+
+/* 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)
+{
+ GDataType *data_type; /* Version basique */
+ GClassEnumType *ce_type; /* Version basique #2 */
+
+ data_type = G_DATA_TYPE(type);
+
+ data_type->dup = (type_dup_fc)g_template_type_dup;
+ data_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 : - *
+* *
+******************************************************************************/
+
+GDataType *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_DATA_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 GDataType *g_template_type_dup(const GTemplateType *type)
+{
+ GDataType *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);
+
+ return G_DATA_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_data_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 = (GDataType **)realloc(type->models,
+ ++type->models_count * sizeof(GDataType *));
+ type->models[type->models_count - 1] = G_DATA_TYPE(iter->data);
+ }
+ g_slist_free(list);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : type = type à consulter. *
+* *
+* Description : Indique le nombre de paramètres associés du gabarit. *
+* *
+* Retour : Nombre de paramètres inclus dans le gabarit. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+size_t g_template_type_count_param(const GTemplateType *type)
+{
+ return type->models_count;
+
+}
+
+
+/******************************************************************************
+* *
+* 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 : - *
+* *
+******************************************************************************/
+
+GDataType *g_template_type_get_param(const GTemplateType *type, size_t index)
+{
+ return (index < type->models_count ? type->models[index] : NULL);
+
+}
diff --git a/src/analysis/types/template.h b/src/analysis/types/template.h
new file mode 100644
index 0000000..8c43a03
--- /dev/null
+++ b/src/analysis/types/template.h
@@ -0,0 +1,67 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * template.h - prototypes pour la manipulation des types reposant sur des gabarits
+ *
+ * Copyright (C) 2012 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_TYPES_TEMPLATE_H
+#define _ANALYSIS_TYPES_TEMPLATE_H
+
+
+#include <glib-object.h>
+
+
+#include "../type.h"
+
+
+
+#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. */
+GDataType *g_template_type_new(const char *, GSList *);
+
+/* Ajoute une série de paramètres à un gabarit. */
+void g_template_type_add_params(GTemplateType *, GSList *);
+
+/* Indique le nombre de paramètres associés du gabarit. */
+size_t g_template_type_count_param(const GTemplateType *);
+
+/* Fournit un paramètre donné du gabarit. */
+GDataType *g_template_type_get_param(const GTemplateType *, size_t);
+
+
+
+#endif /* _ANALYSIS_TYPES_TEMPLATE_H */
diff --git a/src/analysis/variable.c b/src/analysis/variable.c
index 2da691d..7ecf793 100644
--- a/src/analysis/variable.c
+++ b/src/analysis/variable.c
@@ -24,9 +24,11 @@
#include "variable.h"
+#include <malloc.h>
#include <string.h>
+#include "types/cse.h"
#include "../common/extstr.h"
@@ -39,10 +41,10 @@ struct _GBinVariable
{
GObject parent; /* A laisser en premier */
- GOpenidaType *type; /* Type de la variable */
+ GDataType *type; /* Type de la variable */
char *name; /* Désignation humaine */
- GOpenidaType *owner; /* Zone d'appartenance */
+ GDataType *owner; /* Zone d'appartenance */
};
@@ -119,7 +121,7 @@ static void g_binary_variable_init(GBinVariable *var)
* *
******************************************************************************/
-GBinVariable *g_binary_variable_new(GOpenidaType *type)
+GBinVariable *g_binary_variable_new(GDataType *type)
{
GBinVariable *result; /* Variable à retourner */
@@ -145,7 +147,7 @@ GBinVariable *g_binary_variable_new(GOpenidaType *type)
* *
******************************************************************************/
-GOpenidaType *g_binary_variable_get_vtype(const GBinVariable *var)
+GDataType *g_binary_variable_get_vtype(const GBinVariable *var)
{
return var->type;
@@ -207,7 +209,7 @@ void g_binary_variable_set_name(GBinVariable *var, const char *name)
* *
******************************************************************************/
-GOpenidaType *g_binary_variable_get_owner(const GBinVariable *var)
+GDataType *g_binary_variable_get_owner(const GBinVariable *var)
{
return var->owner;
@@ -227,7 +229,7 @@ GOpenidaType *g_binary_variable_get_owner(const GBinVariable *var)
* *
******************************************************************************/
-void g_binary_variable_set_owner(GBinVariable *var, GOpenidaType *owner)
+void g_binary_variable_set_owner(GBinVariable *var, GDataType *owner)
{
var->owner = owner;
@@ -251,11 +253,11 @@ char *g_binary_variable_to_string(const GBinVariable *var, bool simple)
{
char *result; /* Valeur à retourner */
- result = strdup(""); /* FIXME : arg _g_openida_type_to_string(var->type, simple);*/
+ result = strdup(""); /* FIXME : arg _g_data_type_to_string(var->type, simple);*/
if (var->name != NULL)
{
- if (!g_openida_type_is_pointer(var->type, true))
+ if (!g_data_type_is_pointer(var->type, true))
/*result = stradd(result, " ")*/;
result = stradd(result, var->name);
@@ -1052,6 +1054,9 @@ char *encapsulated_var_to_string(const encapsulated_variable *var)
case ECT_IMAGINARY:
result = stradd(result, " imaginary");
break;
+ case ECT_ROUTINE:
+ result = stradd(result, "< routine ? TODO ! >");
+ break;
}
return result;
diff --git a/src/analysis/variable.h b/src/analysis/variable.h
index 63e8361..a68eac2 100644
--- a/src/analysis/variable.h
+++ b/src/analysis/variable.h
@@ -29,7 +29,8 @@
#include <glib-object.h>
-#include "type.h"
+#include "types/basic.h"
+#include "types/encaps.h"
@@ -55,10 +56,10 @@ typedef struct _GBinVariableClass GBinVariableClass;
GType g_binary_variable_get_type(void);
/* Crée une représentation de variable de type donné. */
-GBinVariable *g_binary_variable_new(GOpenidaType *);
+GBinVariable *g_binary_variable_new(GDataType *);
/* Fournit le type d'une variable donnée. */
-GOpenidaType *g_binary_variable_get_vtype(const GBinVariable *);
+GDataType *g_binary_variable_get_vtype(const GBinVariable *);
/* Fournit le nom d'une variable donnée. */
const char *g_binary_variable_get_name(const GBinVariable *);
@@ -67,10 +68,10 @@ const char *g_binary_variable_get_name(const GBinVariable *);
void g_binary_variable_set_name(GBinVariable *, const char *);
/* Fournit la zone d'appartenance d'une variable donnée. */
-GOpenidaType *g_binary_variable_get_owner(const GBinVariable *);
+GDataType *g_binary_variable_get_owner(const GBinVariable *);
/* Définit la zone d'appartenance d'une variable donnée. */
-void g_binary_variable_set_owner(GBinVariable *, GOpenidaType *);
+void g_binary_variable_set_owner(GBinVariable *, GDataType *);
/* Décrit la variable donnée sous forme de caractères. */
char *g_binary_variable_to_string(const GBinVariable *, bool);