From c7a14e50bd002e3922969e9bae7816753aefb073 Mon Sep 17 00:00:00 2001 From: Cyrille Bagard Date: Fri, 12 Oct 2012 07:28:19 +0000 Subject: Reorganized types definitions. git-svn-id: svn://svn.gna.org/svn/chrysalide/trunk@267 abbe820e-26c8-41b2-8c08-b7b2b41f8b0a --- ChangeLog | 51 ++ configure.ac | 1 + plugins/dexresolver/operand.c | 4 +- src/analysis/Makefile.am | 6 +- src/analysis/routine.c | 30 +- src/analysis/routine.h | 14 +- src/analysis/type.c | 1211 +----------------------------------- src/analysis/type.h | 246 +------- src/analysis/types/Makefile.am | 23 + src/analysis/types/basic.c | 309 +++++++++ src/analysis/types/basic.h | 96 +++ src/analysis/types/cse-int.h | 56 ++ src/analysis/types/cse.c | 153 +++++ src/analysis/types/cse.h | 69 ++ src/analysis/types/encaps.c | 313 ++++++++++ src/analysis/types/encaps.h | 78 +++ src/analysis/types/literal.c | 205 ++++++ src/analysis/types/literal.h | 67 ++ src/analysis/types/template.c | 283 +++++++++ src/analysis/types/template.h | 67 ++ src/analysis/variable.c | 21 +- src/analysis/variable.h | 11 +- src/arch/dalvik/decomp/new.c | 2 +- src/arch/dalvik/operands/pool.c | 4 +- src/decomp/lang/asm.c | 4 +- src/decomp/lang/java.c | 10 +- src/decomp/output-int.h | 2 +- src/decomp/output.c | 4 +- src/decomp/output.h | 4 +- src/format/dex/class.c | 4 +- src/format/dex/dex.c | 4 +- src/format/dex/pool.c | 14 +- src/format/dex/pool.h | 4 +- src/format/mangling/context-int.h | 2 +- src/format/mangling/context.c | 2 +- src/format/mangling/context.h | 2 +- src/format/mangling/demangler.c | 4 +- src/format/mangling/demangler.h | 2 +- src/format/mangling/itanium_gram.y | 64 +- src/format/mangling/java_gram.y | 7 +- src/gui/panels/symbols.c | 4 +- 41 files changed, 1923 insertions(+), 1534 deletions(-) create mode 100755 src/analysis/types/Makefile.am create mode 100644 src/analysis/types/basic.c create mode 100644 src/analysis/types/basic.h create mode 100644 src/analysis/types/cse-int.h create mode 100644 src/analysis/types/cse.c create mode 100644 src/analysis/types/cse.h create mode 100644 src/analysis/types/encaps.c create mode 100644 src/analysis/types/encaps.h create mode 100644 src/analysis/types/literal.c create mode 100644 src/analysis/types/literal.h create mode 100644 src/analysis/types/template.c create mode 100644 src/analysis/types/template.h diff --git a/ChangeLog b/ChangeLog index e2c92d1..0acfbff 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,54 @@ +12-10-12 Cyrille Bagard + + * configure.ac: + Add the new Makfiles from the src/analysis/types directory to + AC_CONFIG_FILES. + + * plugins/dexresolver/operand.c: + * src/analysis/Makefile.am: + * src/analysis/routine.c: + * src/analysis/routine.h: + * src/analysis/type.c: + * src/analysis/type.h: + Update code. + + * src/analysis/types/basic.c: + * src/analysis/types/basic.h: + * src/analysis/types/cse.c: + * src/analysis/types/cse.h: + * src/analysis/types/cse-int.h: + * src/analysis/types/encaps.c: + * src/analysis/types/encaps.h: + * src/analysis/types/literal.c: + * src/analysis/types/literal.h: + * src/analysis/types/Makefile.am: + * src/analysis/types/template.c: + * src/analysis/types/template.h: + New entries: reorganize types definitions. + + * src/analysis/variable.c: + * src/analysis/variable.h: + * src/arch/dalvik/decomp/new.c: + * src/arch/dalvik/operands/pool.c: + * src/decomp/lang/asm.c: + * src/decomp/lang/java.c: + * src/decomp/output.c: + * src/decomp/output.h: + * src/decomp/output-int.h: + * src/format/dex/class.c: + * src/format/dex/dex.c: + * src/format/dex/pool.c: + * src/format/dex/pool.h: + * src/format/mangling/context.c: + * src/format/mangling/context.h: + * src/format/mangling/context-int.h: + * src/format/mangling/demangler.c: + * src/format/mangling/demangler.h: + * src/format/mangling/itanium_gram.y: + * src/format/mangling/java_gram.y: + * src/gui/panels/symbols.c: + Update code. + 12-10-08 Cyrille Bagard * plugins/python/androperms/android.png: diff --git a/configure.ac b/configure.ac index 23804fb..8cef052 100644 --- a/configure.ac +++ b/configure.ac @@ -255,6 +255,7 @@ AC_CONFIG_FILES([Makefile src/analysis/binaries/Makefile src/analysis/decomp/Makefile src/analysis/disass/Makefile + src/analysis/types/Makefile src/arch/Makefile src/arch/arm/Makefile src/arch/dalvik/Makefile diff --git a/plugins/dexresolver/operand.c b/plugins/dexresolver/operand.c index 17adaf6..7293599 100644 --- a/plugins/dexresolver/operand.c +++ b/plugins/dexresolver/operand.c @@ -205,7 +205,7 @@ static void g_dalvik_hpool_operand_to_buffer(/*const */GDalvikHPoolOperand *oper GContentExporter *exporter; /* Autre vision de l'opérande */ uint32_t index; /* Indice de l'élément visé */ const char *string; /* Chaîne à afficher */ - GOpenidaType *type; /* Type quelconque */ + GDataType *type; /* Type quelconque */ char *tmp; /* Chaîne à afficher & libérer */ exporter = G_CONTENT_EXPORTER(operand); @@ -248,7 +248,7 @@ static void g_dalvik_hpool_operand_to_buffer(/*const */GDalvikHPoolOperand *oper else { type = g_binary_variable_get_vtype(operand->cache.field); - tmp = g_openida_type_to_string(type); + tmp = g_data_type_to_string(type); g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ASSEMBLY, tmp, strlen(tmp), RTT_VAR_NAME); 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 #include -#include #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 . + */ + + +#include "basic.h" + + +#include + + +#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 . + */ + + +#ifndef _ANALYSIS_TYPES_BASIC_H +#define _ANALYSIS_TYPES_BASIC_H + + +#include + + +#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 . + */ + + +#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 . + */ + + +#include "cse.h" + + +#include + + +#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 . + */ + + +#ifndef _ANALYSIS_TYPES_CSE_H +#define _ANALYSIS_TYPES_CSE_H + + +#include + + +#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 . + */ + + +#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 . + */ + + +#ifndef _ANALYSIS_TYPES_ENCAPS_H +#define _ANALYSIS_TYPES_ENCAPS_H + + +#include + + +#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 . + */ + + +#include "literal.h" + + +#include +#include + + +#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 . + */ + + +#ifndef _ANALYSIS_TYPES_LITERAL_H +#define _ANALYSIS_TYPES_LITERAL_H + + +#include + + +#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 . + */ + + +#include "template.h" + + +#include +#include + + +#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 . + */ + + +#ifndef _ANALYSIS_TYPES_TEMPLATE_H +#define _ANALYSIS_TYPES_TEMPLATE_H + + +#include + + +#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 #include +#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 -#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); diff --git a/src/arch/dalvik/decomp/new.c b/src/arch/dalvik/decomp/new.c index 65da469..ff80411 100644 --- a/src/arch/dalvik/decomp/new.c +++ b/src/arch/dalvik/decomp/new.c @@ -49,7 +49,7 @@ GDecInstruction *dalvik_decomp_instr_new_instance(const GArchInstruction *instr, GArchOperand *operand; /* Opérande de l'instruction */ uint32_t index; /* Indice dans la table */ GDexFormat *format; /* Accès aux constantes */ - GOpenidaType *type; /* Type concerné par l'opérat° */ + GDataType *type; /* Type concerné par l'opérat° */ GBinRoutine *constructor; /* Constructeur reconstruit */ GDecInstruction *call; /* Appel au constructeur */ GDecInstruction *dest; /* Registre de destination */ diff --git a/src/arch/dalvik/operands/pool.c b/src/arch/dalvik/operands/pool.c index 7ec370c..803d173 100644 --- a/src/arch/dalvik/operands/pool.c +++ b/src/arch/dalvik/operands/pool.c @@ -180,7 +180,7 @@ GArchOperand *g_dalvik_pool_operand_new(const GDexFormat *format, DalvikPoolType static void g_dalvik_pool_operand_print(const GDalvikPoolOperand *operand, GBufferLine *line, AsmSyntax syntax) { const char *string; /* Chaîne de caractères #1 */ - GOpenidaType *type; /* Type à représenter */ + GDataType *type; /* Type à représenter */ char *tmp; /* Chaîne de caractères #2 */ GBinVariable *field; /* Champ à représenter */ GBinRoutine *routine; /* Routine à représenter */ @@ -203,7 +203,7 @@ static void g_dalvik_pool_operand_print(const GDalvikPoolOperand *operand, GBuff if (type != NULL) { - tmp = g_openida_type_to_string(type); + tmp = g_data_type_to_string(type); g_object_unref(G_OBJECT(type)); } else diff --git a/src/decomp/lang/asm.c b/src/decomp/lang/asm.c index ab71cc0..30c56cc 100644 --- a/src/decomp/lang/asm.c +++ b/src/decomp/lang/asm.c @@ -57,7 +57,7 @@ static GBufferLine *g_asm_output_write_comments(GAsmOutput *, GCodeBuffer *, con static void g_asm_output_write_comp_sign(GAsmOutput *, GBufferLine *, CompSignType); /* Débute la définition d'une routine. */ -static GBufferLine *g_asm_output_start_routine_prototype(GAsmOutput *, GCodeBuffer *, const GOpenidaType *); +static GBufferLine *g_asm_output_start_routine_prototype(GAsmOutput *, GCodeBuffer *, const GDataType *); /* Termine la définition d'une routine. */ static void g_asm_output_end_routine_prototype(GAsmOutput *, GCodeBuffer *, GBufferLine *); @@ -231,7 +231,7 @@ static void g_asm_output_write_comp_sign(GAsmOutput *output, GBufferLine *line, * * ******************************************************************************/ -static GBufferLine *g_asm_output_start_routine_prototype(GAsmOutput *output, GCodeBuffer *buffer, const GOpenidaType *ret) +static GBufferLine *g_asm_output_start_routine_prototype(GAsmOutput *output, GCodeBuffer *buffer, const GDataType *ret) { GBufferLine *result; /* Adresse nouvelle à remonter */ diff --git a/src/decomp/lang/java.c b/src/decomp/lang/java.c index 21da3af..5092f32 100644 --- a/src/decomp/lang/java.c +++ b/src/decomp/lang/java.c @@ -66,13 +66,13 @@ static GBufferLine *g_java_output_write_comments(GJavaOutput *, GCodeBuffer *, c static void g_java_output_write_comp_sign(GJavaOutput *, GBufferLine *, CompSignType); /* Débute la définition d'une classe. */ -static GBufferLine *g_java_output_start_class(GJavaOutput *, GCodeBuffer *, const GOpenidaType *); +static GBufferLine *g_java_output_start_class(GJavaOutput *, GCodeBuffer *, const GDataType *); /* Termine la définition d'une classe. */ static void g_java_output_end_class(GJavaOutput *, GCodeBuffer *); /* Débute la définition d'une routine. */ -static GBufferLine *g_java_output_start_routine_prototype(GJavaOutput *, GCodeBuffer *, const GOpenidaType *); +static GBufferLine *g_java_output_start_routine_prototype(GJavaOutput *, GCodeBuffer *, const GDataType *); /* Termine la définition d'une routine. */ static void g_java_output_end_routine_prototype(GJavaOutput *, GCodeBuffer *, GBufferLine *); @@ -343,7 +343,7 @@ static void g_java_output_write_comp_sign(GJavaOutput *output, GBufferLine *line * * ******************************************************************************/ -static GBufferLine *g_java_output_start_class(GJavaOutput *output, GCodeBuffer *buffer, const GOpenidaType *type) +static GBufferLine *g_java_output_start_class(GJavaOutput *output, GCodeBuffer *buffer, const GDataType *type) { GBufferLine *result; /* Adresse nouvelle à remonter */ char *name; /* Désignation humaine */ @@ -353,7 +353,7 @@ static GBufferLine *g_java_output_start_class(GJavaOutput *output, GCodeBuffer * g_buffer_line_insert_text(result, BLC_ASSEMBLY_HEAD, "class", 5, RTT_KEY_WORD); g_buffer_line_insert_text(result, BLC_ASSEMBLY_HEAD, " ", 1, RTT_RAW); - name = _g_openida_type_to_string(type, true); + name = _g_data_type_to_string(type, true); g_buffer_line_insert_text(result, BLC_ASSEMBLY_HEAD, name, strlen(name), RTT_RAW); free(name); @@ -413,7 +413,7 @@ static void g_java_output_end_class(GJavaOutput *output, GCodeBuffer *buffer) * * ******************************************************************************/ -static GBufferLine *g_java_output_start_routine_prototype(GJavaOutput *output, GCodeBuffer *buffer, const GOpenidaType *ret) +static GBufferLine *g_java_output_start_routine_prototype(GJavaOutput *output, GCodeBuffer *buffer, const GDataType *ret) { GBufferLine *result; /* Adresse nouvelle à remonter */ diff --git a/src/decomp/output-int.h b/src/decomp/output-int.h index 885d9ca..be057af 100644 --- a/src/decomp/output-int.h +++ b/src/decomp/output-int.h @@ -39,7 +39,7 @@ typedef GBufferLine * (* write_comments_fc) (GLangOutput *, GCodeBuffer *, const typedef void (* write_comp_sign_fc) (GLangOutput *, GBufferLine *, CompSignType); /* Xxx. */ -typedef GBufferLine * (* rlgbuftp_fc) (GLangOutput *, GCodeBuffer *, const GOpenidaType *); +typedef GBufferLine * (* rlgbuftp_fc) (GLangOutput *, GCodeBuffer *, const GDataType *); /* Xxx. */ typedef void (* lgbuf_fc) (GLangOutput *, GCodeBuffer *); diff --git a/src/decomp/output.c b/src/decomp/output.c index 99d1912..698ce0d 100644 --- a/src/decomp/output.c +++ b/src/decomp/output.c @@ -216,7 +216,7 @@ void g_lang_output_write_comp_sign(GLangOutput *output, GBufferLine *line, CompS * * ******************************************************************************/ -GBufferLine *g_lang_output_start_class(GLangOutput *output, GCodeBuffer *buffer, const GOpenidaType *type) +GBufferLine *g_lang_output_start_class(GLangOutput *output, GCodeBuffer *buffer, const GDataType *type) { GBufferLine *result; /* Adresse nouvelle à remonter */ @@ -265,7 +265,7 @@ void g_lang_output_end_class(GLangOutput *output, GCodeBuffer *buffer) * * ******************************************************************************/ -GBufferLine *g_lang_output_start_routine_prototype(GLangOutput *output, GCodeBuffer *buffer, const GOpenidaType *ret) +GBufferLine *g_lang_output_start_routine_prototype(GLangOutput *output, GCodeBuffer *buffer, const GDataType *ret) { GBufferLine *result; /* Adresse nouvelle à remonter */ diff --git a/src/decomp/output.h b/src/decomp/output.h index 6a1c4a1..7eac6d8 100644 --- a/src/decomp/output.h +++ b/src/decomp/output.h @@ -80,13 +80,13 @@ void g_lang_output_write_comp_sign(GLangOutput *, GBufferLine *, CompSignType); /* Débute la définition d'une classe. */ -GBufferLine *g_lang_output_start_class(GLangOutput *, GCodeBuffer *, const GOpenidaType *); +GBufferLine *g_lang_output_start_class(GLangOutput *, GCodeBuffer *, const GDataType *); /* Termine la définition d'une classe. */ void g_lang_output_end_class(GLangOutput *, GCodeBuffer *); /* Définit le prototype d'une routine. */ -GBufferLine *g_lang_output_start_routine_prototype(GLangOutput *, GCodeBuffer *, const GOpenidaType *); +GBufferLine *g_lang_output_start_routine_prototype(GLangOutput *, GCodeBuffer *, const GDataType *); /* Marque la fin du prototype d'une routine. */ void g_lang_output_end_routine_prototype(GLangOutput *, GCodeBuffer *, GBufferLine *); diff --git a/src/format/dex/class.c b/src/format/dex/class.c index cdf6c2c..52389c4 100644 --- a/src/format/dex/class.c +++ b/src/format/dex/class.c @@ -370,7 +370,7 @@ void g_dex_class_decompile(const GDexClass *class, GLangOutput *lang, GCodeBuffe { - GOpenidaType *type; + GDataType *type; size_t i; /* Boucle de parcours */ @@ -392,7 +392,7 @@ GBufferLine *line, GLangOutput *output) //g_buffer_line_insert_text(line, BLC_ASSEMBLY, "{", 3, RTT_SIGNS); - //printf("Output :: %s\n", _g_openida_type_to_string(type, true)); + //printf("Output :: %s\n", _g_data_type_to_string(type, true)); diff --git a/src/format/dex/dex.c b/src/format/dex/dex.c index 7075929..821da7a 100755 --- a/src/format/dex/dex.c +++ b/src/format/dex/dex.c @@ -304,7 +304,7 @@ static void g_dex_format_decompile(const GDexFormat *format, GCodeBuffer *buffer #if 0 - GOpenidaType *get_type_from_dex_pool(const GDexFormat *format, uint16_t index) + GDataType *get_type_from_dex_pool(const GDexFormat *format, uint16_t index) Décrit le type fourni sous forme de caractères. * @@ -315,7 +315,7 @@ static void g_dex_format_decompile(const GDexFormat *format, GCodeBuffer *buffer * * ******************************************************************************/ -char *_g_openida_type_to_string(const GOpenidaType *type, bool simple) +char *_g_data_type_to_string(const GDataType *type, bool simple) #endif diff --git a/src/format/dex/pool.c b/src/format/dex/pool.c index d82144f..9237839 100644 --- a/src/format/dex/pool.c +++ b/src/format/dex/pool.c @@ -84,7 +84,7 @@ const char *get_string_from_dex_pool(const GDexFormat *format, uint32_t index) * * ******************************************************************************/ -GOpenidaType *get_type_from_dex_pool(const GDexFormat *format, uint16_t index) +GDataType *get_type_from_dex_pool(const GDexFormat *format, uint16_t index) { off_t pos; /* Tête de lecture */ type_id_item type_id; /* Définition de la classe */ @@ -141,9 +141,9 @@ GOpenidaType *get_type_from_dex_pool(const GDexFormat *format, uint16_t index) * * ******************************************************************************/ -GOpenidaType *get_class_from_dex_pool(const GDexFormat *format, uint32_t index) +GDataType *get_class_from_dex_pool(const GDexFormat *format, uint32_t index) { - GOpenidaType *result; /* Instance à retourner */ + GDataType *result; /* Instance à retourner */ off_t pos; /* Tête de lecture */ class_def_item class_def; /* Définition de la classe */ @@ -185,9 +185,9 @@ GBinVariable *get_field_from_dex_pool(const GDexFormat *format, uint32_t index) GBinVariable *result; /* Instance à retourner */ off_t pos; /* Tête de lecture */ field_id_item field_id; /* Description du champ */ - GOpenidaType *type; /* Type du champ */ + GDataType *type; /* Type du champ */ const char *name; /* Désignation humaine */ - GOpenidaType *owner; /* Propriétaire du champ */ + GDataType *owner; /* Propriétaire du champ */ if (index >= format->header.field_ids_size) return NULL; @@ -250,7 +250,7 @@ GBinRoutine *get_routine_from_dex_pool(const GDexFormat *format, uint32_t index) method_id_item meth_id; /* Description de la méthode */ - GOpenidaType *type; + GDataType *type; string_id_item str_id; /* Identifiant de chaîne */ string_data_item str_data; /* Description de chaîne */ @@ -281,7 +281,7 @@ GBinRoutine *get_routine_from_dex_pool(const GDexFormat *format, uint32_t index) printf("class is nil\n"); else - printf("class = '%s'\n", g_openida_type_to_string(type)); + printf("class = '%s'\n", g_data_type_to_string(type)); */ /* Nom de la méthode */ diff --git a/src/format/dex/pool.h b/src/format/dex/pool.h index 56fd99c..6894da1 100644 --- a/src/format/dex/pool.h +++ b/src/format/dex/pool.h @@ -34,11 +34,11 @@ const char *get_string_from_dex_pool(const GDexFormat *, uint32_t); /* Extrait une représentation de type d'une table DEX. */ -GOpenidaType *get_type_from_dex_pool(const GDexFormat *, uint16_t); +GDataType *get_type_from_dex_pool(const GDexFormat *, uint16_t); /* Extrait une représentation de classe d'une table DEX. */ -GOpenidaType *get_class_from_dex_pool(const GDexFormat *, uint32_t); +GDataType *get_class_from_dex_pool(const GDexFormat *, uint32_t); diff --git a/src/format/mangling/context-int.h b/src/format/mangling/context-int.h index ba4a1a9..1cf0359 100644 --- a/src/format/mangling/context-int.h +++ b/src/format/mangling/context-int.h @@ -37,7 +37,7 @@ struct _GDemanglingContext union { GBinRoutine *routine; /* Routine décodée */ - GOpenidaType *type; /* Type décodé */ + GDataType *type; /* Type décodé */ }; }; diff --git a/src/format/mangling/context.c b/src/format/mangling/context.c index 05fc9a2..7180995 100644 --- a/src/format/mangling/context.c +++ b/src/format/mangling/context.c @@ -108,7 +108,7 @@ GBinRoutine *g_demangling_context_get_decoded_routine(const GDemanglingContext * * * ******************************************************************************/ -GOpenidaType *g_demangling_context_get_decoded_type(const GDemanglingContext *context) +GDataType *g_demangling_context_get_decoded_type(const GDemanglingContext *context) { return context->type; diff --git a/src/format/mangling/context.h b/src/format/mangling/context.h index c584838..767d231 100644 --- a/src/format/mangling/context.h +++ b/src/format/mangling/context.h @@ -53,7 +53,7 @@ GType g_demangling_context_get_type(void); GBinRoutine *g_demangling_context_get_decoded_routine(const GDemanglingContext *); /* Fournit le type créé à l'issue du codage. */ -GOpenidaType *g_demangling_context_get_decoded_type(const GDemanglingContext *); +GDataType *g_demangling_context_get_decoded_type(const GDemanglingContext *); diff --git a/src/format/mangling/demangler.c b/src/format/mangling/demangler.c index 012c736..52dad54 100644 --- a/src/format/mangling/demangler.c +++ b/src/format/mangling/demangler.c @@ -202,9 +202,9 @@ GBinRoutine *demangle_routine(DemanglerType type, const char *desc) * * ******************************************************************************/ -GOpenidaType *demangle_type(DemanglerType type, const char *desc) +GDataType *demangle_type(DemanglerType type, const char *desc) { - GOpenidaType *result; /* Construction à remonter */ + GDataType *result; /* Construction à remonter */ GDemanglingContext *context; /* Contexte pour le décodage */ result = NULL; diff --git a/src/format/mangling/demangler.h b/src/format/mangling/demangler.h index 7fe5850..8b1c160 100644 --- a/src/format/mangling/demangler.h +++ b/src/format/mangling/demangler.h @@ -47,7 +47,7 @@ GBinRoutine *try_to_demangle_routine(const char *); GBinRoutine *demangle_routine(DemanglerType, const char *); /* Tente de décoder une chaîne de caractères donnée. */ -GOpenidaType *demangle_type(DemanglerType, const char *); +GDataType *demangle_type(DemanglerType, const char *); diff --git a/src/format/mangling/itanium_gram.y b/src/format/mangling/itanium_gram.y index ab59ac7..0fd3b2b 100644 --- a/src/format/mangling/itanium_gram.y +++ b/src/format/mangling/itanium_gram.y @@ -10,6 +10,8 @@ #include "context-int.h" #include "itanium.h" #include "../../common/extstr.h" +#include "../../analysis/types/cse.h" +#include "../../analysis/types/template.h" @@ -87,10 +89,10 @@ static GBinRoutine *g_itanium_dcontext_push_routine(GItaniumDContext *, GBinRout static GBinRoutine *g_itanium_dcontext_pop_routine(GItaniumDContext *); /* Ajoute un élément dans une liste de substitutions. */ -static void g_itanium_dcontext_add_item(GItaniumDContext *, GOpenidaType *); +static void g_itanium_dcontext_add_item(GItaniumDContext *, GDataType *); /* Fournit le nième élément d'une liste de substitutions. */ -static GOpenidaType *g_itanium_dcontext_get_item(GItaniumDContext *, guint); +static GDataType *g_itanium_dcontext_get_item(GItaniumDContext *, guint); /* Autorise ou non le dépilement des opérateurs. */ static void g_itanium_dcontext_update(GItaniumDContext *); @@ -104,7 +106,7 @@ static void g_itanium_dcontext_update(GItaniumDContext *); static void compute_routine_itanium_ret_type(GBinRoutine *); /* Recherche et fait sauter les premiers arguments rencontrés. */ -static void update_itanium_ret_type(GOpenidaType *); +static void update_itanium_ret_type(GDataType *); @@ -164,7 +166,7 @@ char *strmerge(char *str1, const char *sep, char *str2); union { char *str; - void/*GOpenidaType*/ *type; + void/*GDataType*/ *type; }; int/*bool*/ is_string; @@ -175,7 +177,7 @@ char *strmerge(char *str1, const char *sep, char *str2); unsigned int val; short/*s16_t*/ s16_val; - void /*GOpenidaType*/ *type; + void /*GDataType*/ *type; void /*GTemplateType*/ *templtype; void/*simple_variable*/ *simple; @@ -339,7 +341,7 @@ name: { char *tmp; - tmp = g_openida_type_to_string($1); + tmp = g_data_type_to_string($1); $$.type = g_template_type_new(tmp, $2); $$.is_string = false; @@ -350,7 +352,7 @@ name: } //g_template_type_add_params($1, $2); - printf(" [name tmp:: %s]\n", g_openida_type_to_string($$.type)); + printf(" [name tmp:: %s]\n", g_data_type_to_string($$.type)); } ; @@ -374,8 +376,8 @@ nested_name: $$ = ($4 != NULL ? strmerge($3, "::", $4) : $3); printf("passage nested p+uq = '%s'\n", $$); $$ = g_class_enum_type_new(CET_UNKNOWN, $$); g_itanium_dcontext_add_item(context, $$); } - | NN registered_template_prefix template_args EE { $$ = $2; g_template_type_add_params($2, $3); printf(" [nested tmp:: %s]\n", g_openida_type_to_string($$)); } - | NN qualifiers registered_template_prefix template_args EE { $$ = $3; g_template_type_add_params($3, $4); printf(" [nested tmp:: %s]\n", g_openida_type_to_string($$)); } + | NN registered_template_prefix template_args EE { $$ = $2; g_template_type_add_params($2, $3); printf(" [nested tmp:: %s]\n", g_data_type_to_string($$)); } + | NN qualifiers registered_template_prefix template_args EE { $$ = $3; g_template_type_add_params($3, $4); printf(" [nested tmp:: %s]\n", g_data_type_to_string($$)); } ; @@ -386,19 +388,19 @@ registered_prefix: else { g_itanium_dcontext_add_item(context, $1); - $$ = g_openida_type_to_string($1); + $$ = g_data_type_to_string($1); } } | substitution { - $$ = g_openida_type_to_string($1); - printf("prefix substi :: %s\n", g_openida_type_to_string($1)); + $$ = g_data_type_to_string($1); + printf("prefix substi :: %s\n", g_data_type_to_string($1)); } ; prefix: /* vide */ { $$ = NULL; } - | registered_prefix unqualified_name { $$ = ($2 != NULL ? g_class_enum_type_new(CET_CLASS, strmerge($1, "::", $2)) : $1); printf("passage p+uq = '%s'\n", g_openida_type_to_string($$)); } - | registered_template_prefix template_args { $$ = $1; g_template_type_add_params($1, $2); printf("passage p_tmp = '%s'\n", g_openida_type_to_string($$)); } + | registered_prefix unqualified_name { $$ = ($2 != NULL ? g_class_enum_type_new(CET_CLASS, strmerge($1, "::", $2)) : $1); printf("passage p+uq = '%s'\n", g_data_type_to_string($$)); } + | registered_template_prefix template_args { $$ = $1; g_template_type_add_params($1, $2); printf("passage p_tmp = '%s'\n", g_data_type_to_string($$)); } ; registered_template_prefix: @@ -414,12 +416,12 @@ template_prefix: g_itanium_dcontext_add_item(context, g_class_enum_type_new(CET_CLASS, $$)); } | template_param { - $$ = g_openida_type_to_string($1); + $$ = g_data_type_to_string($1); printf("[[ tmp param %s ]]\n", $$); g_object_unref(G_OBJECT($1)); } | substitution { - $$ = g_openida_type_to_string($1); + $$ = g_data_type_to_string($1); printf("template_prefix substi :: %s\n", $$); g_object_unref(G_OBJECT($1)); } @@ -526,20 +528,20 @@ function_type: type: - builtin_type { $$ = $1; printf("builtin '%s'\n", g_openida_type_to_string($1)); } + builtin_type { $$ = $1; printf("builtin '%s'\n", g_data_type_to_string($1)); } | class_enum_type { $$ = $1; printf("type :: %p\n", $1); fflush(NULL); g_itanium_dcontext_add_item(context, $1); } | substitution { $$ = $1; } | template_param { $$ = $1; } | template_template_param template_args { - $$ = g_template_type_new(g_openida_type_to_string($1), NULL); + $$ = g_template_type_new(g_data_type_to_string($1), NULL); g_object_unref($1); g_template_type_add_params($$, $2); - printf(" [type tmp:: %s]\n", g_openida_type_to_string($$)); + printf(" [type tmp:: %s]\n", g_data_type_to_string($$)); } | function_type { $$ = $1; } | qualifiers type { - $$ = g_openida_type_dup($2); - g_openida_type_add_qualifier($$, $1); + $$ = g_data_type_dup($2); + g_data_type_add_qualifier($$, $1); g_itanium_dcontext_add_item(context, $$); } | TP type { $$ = g_encapsulated_type_new(ECT_POINTER, $2); g_itanium_dcontext_add_item(context, $$); } @@ -604,14 +606,14 @@ class_enum_type: template_param: TPARAM_FIRST { - const GOpenidaType *type = g_binary_routine_get_type_from_name(routine); + const GDataType *type = g_binary_routine_get_type_from_name(routine); if (G_IS_TEMPLATE_TYPE(type)) $$ = g_template_type_get_param(G_TEMPLATE_TYPE(type), 0); else $$ = NULL; if ($$ == NULL) YYERROR; if (!G_IS_BASIC_TYPE($$)) g_itanium_dcontext_add_item(context, $$); } | TPARAM_N { - const GOpenidaType *type = g_binary_routine_get_type_from_name(routine); + const GDataType *type = g_binary_routine_get_type_from_name(routine); if (G_IS_TEMPLATE_TYPE(type)) $$ = g_template_type_get_param(G_TEMPLATE_TYPE(type), $1 + 1); else $$ = NULL; @@ -929,11 +931,11 @@ static GBinRoutine *g_itanium_dcontext_pop_routine(GItaniumDContext *context) * * ******************************************************************************/ -static void g_itanium_dcontext_add_item(GItaniumDContext *context, GOpenidaType *type) +static void g_itanium_dcontext_add_item(GItaniumDContext *context, GDataType *type) { g_object_ref(G_OBJECT(type)); - printf(" [[ %u ]] PUSH '%s' (%p)\n", g_slist_length(context->substitutions) - 1, g_openida_type_to_string(type), type); + printf(" [[ %u ]] PUSH '%s' (%p)\n", g_slist_length(context->substitutions) - 1, g_data_type_to_string(type), type); context->substitutions = g_slist_append(context->substitutions, type); @@ -953,11 +955,11 @@ static void g_itanium_dcontext_add_item(GItaniumDContext *context, GOpenidaType * * ******************************************************************************/ -static GOpenidaType *g_itanium_dcontext_get_item(GItaniumDContext *context, guint n) +static GDataType *g_itanium_dcontext_get_item(GItaniumDContext *context, guint n) { printf("get [%u] == %p\n", n, g_slist_nth_data(context->substitutions, n + 1)); - return G_OPENIDA_TYPE(g_slist_nth_data(context->substitutions, n + 1)); + return G_DATA_TYPE(g_slist_nth_data(context->substitutions, n + 1)); } @@ -1072,7 +1074,7 @@ bool demangle_itanium_routine(GItaniumDContext *context, const char *desc) GBinRoutine *routine; /* Routine à construire */ YY_BUFFER_STATE buffer; /* Tampon pour bison */ int ret; /* Bilan de l'appel */ - GOpenidaType *name_type; /* Nom basé sur un type ? */ + GDataType *name_type; /* Nom basé sur un type ? */ routine = g_demangling_context_get_decoded_routine(G_DEMANGLING_CONTEXT(context)); @@ -1113,7 +1115,7 @@ static void compute_routine_itanium_ret_type(GBinRoutine *routine) size_t count; /* Nombre d'arguments présents */ size_t i; /* Boucle de parcours */ GBinVariable *arg; /* Argument de la routine */ - GOpenidaType *type; /* Type associé à l'argument */ + GDataType *type; /* Type associé à l'argument */ /* Traitement récursif des arguments */ @@ -1173,12 +1175,12 @@ static void compute_routine_itanium_ret_type(GBinRoutine *routine) * * ******************************************************************************/ -static void update_itanium_ret_type(GOpenidaType *type) +static void update_itanium_ret_type(GDataType *type) { GTemplateType *template; /* Gabarit à analyser */ size_t max; /* Nombre d'itérations */ size_t i; /* Boucle de parcours */ - GOpenidaType *subtype; /* Type à traiter */ + GDataType *subtype; /* Type à traiter */ GEncapsulatedType *encaps; /* Encapsulation quelconque */ GBinRoutine *routine; /* Routine à traiter */ diff --git a/src/format/mangling/java_gram.y b/src/format/mangling/java_gram.y index 25d5ffb..bbd2de3 100644 --- a/src/format/mangling/java_gram.y +++ b/src/format/mangling/java_gram.y @@ -5,6 +5,7 @@ #include "context-int.h" #include "java.h" +#include "../../analysis/types/cse.h" @@ -53,7 +54,7 @@ static void g_java_dcontext_init(GJavaDContext *); %union { - void /*GOpenidaType*/ *type; + void /*GDataType*/ *type; size_t adeep; /* Dimension d'un tableau */ @@ -125,12 +126,12 @@ full_class_name: TEXT { $$ = g_class_enum_type_new(CET_CLASS, $1); } | full_class_name SLASH TEXT { $$ = g_class_enum_type_new(CET_CLASS, $3); - g_openida_type_set_namespace($$, $1); + g_data_type_set_namespace($$, $1); g_object_unref($1); } | full_class_name DOLLAR TEXT { $$ = g_class_enum_type_new(CET_CLASS, $3); - g_openida_type_set_namespace($$, $1); + g_data_type_set_namespace($$, $1); g_object_unref($1); } ; diff --git a/src/gui/panels/symbols.c b/src/gui/panels/symbols.c index 63864d3..c51b2d1 100644 --- a/src/gui/panels/symbols.c +++ b/src/gui/panels/symbols.c @@ -542,7 +542,7 @@ static GtkTreeIter ensure_symbol_node_exist(GtkTreeStore *store, GtkTreeIter *pa static bool find_parent_for_routine(GtkTreeStore *store, const GBinRoutine *routine, GtkTreeIter *parent) { - GOpenidaType *namespace; /* Espace d'appartenance */ + GDataType *namespace; /* Espace d'appartenance */ char *string; /* Conversion en chaîne */ char *iter; /* Boucle de parcours */ char *token; /* Partie de texte isolée */ @@ -551,7 +551,7 @@ static bool find_parent_for_routine(GtkTreeStore *store, const GBinRoutine *rout namespace = g_binary_routine_get_namespace(routine); if (namespace == NULL) return false; - string = g_openida_type_to_string(namespace); + string = g_data_type_to_string(namespace); for (iter = string; ; iter = NULL) { -- cgit v0.11.2-87-g4458