/* OpenIDA - Outil d'analyse de fichiers binaires
* variable.h - prototypes pour la manipulation des variables en tout genre
*
* Copyright (C) 2010 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_TYPE_H
#define _ANALYSIS_TYPE_H
#include
#include
#include
#include "../arch/archbase.h"
/* ------------------------ REPRESENTATION INTERNE DES TYPES ------------------------ */
#define G_TYPE_OPENIDA_TYPE g_openida_type_get_type()
#define G_OPENIDA_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_openida_type_get_type(), GOpenidaType))
#define G_IS_OPENIDA_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_openida_type_get_type()))
#define G_OPENIDA_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_OPENIDA_TYPE, GOpenidaTypeClass))
#define G_IS_OPENIDA_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_OPENIDA_TYPE))
#define G_OPENIDA_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_OPENIDA_TYPE, GOpenidaTypeClass))
/* Description de type quelconque (instance) */
typedef struct _GOpenidaType GOpenidaType;
/* Description de type quelconque (classe) */
typedef struct _GOpenidaTypeClass GOpenidaTypeClass;
/* Qualificatifs de variables */
typedef enum _TypeQualifier
{
TQF_RESTRICT = (1 << 0), /* restrict (C99) */
TQF_VOLATILE = (1 << 1), /* volatile */
TQF_CONST = (1 << 2) /* const */
} TypeQualifier;
/* Indique le type défini pour un type quelconque. */
GType g_openida_type_get_type(void);
/* Crée un copie d'un type existant. */
GOpenidaType *g_openida_type_dup(const GOpenidaType *);
/* Définit le groupe d'appartenance d'un type donné. */
void g_openida_type_set_namespace(GOpenidaType *, GOpenidaType *);
/* Décrit le type fourni sous forme de caractères. */
char *_g_openida_type_to_string(const GOpenidaType *, bool);
#define g_openida_type_to_string(t) _g_openida_type_to_string((t), false)
/* Ajoute un qualificatif à une instance de type. */
void g_openida_type_add_qualifier(GOpenidaType *, TypeQualifier);
/* Indique la terminaison de la représentation du type. */
bool g_openida_type_is_pointer(const GOpenidaType *, bool);
/* ---------------------------- TYPES DE DONNEES SIMPLES ---------------------------- */
/* Liste des types de base existants */
typedef enum _BaseType
{
BTP_VOID, /* void */
BTP_WCHAR_T, /* wchar_t */
BTP_BOOL, /* bool */
BTP_CHAR, /* char */
BTP_SCHAR, /* signed char */
BTP_UCHAR, /* unsigned char */
BTP_SHORT, /* short */
BTP_USHORT, /* unsigned short */
BTP_INT, /* int */
BTP_UINT, /* unsigned int */
BTP_LONG, /* long */
BTP_ULONG, /* unsigned long */
BTP_LONG_LONG, /* long long, __int64 */
BTP_ULONG_LONG, /* unsigned long long, __int64 */
BTP_INT128, /* __int128 */
BTP_UINT128, /* unsigned __int128 */
BTP_FLOAT, /* float */
BTP_DOUBLE, /* double */
BTP_LONG_DOUBLE, /* long double, __float80 */
BTP_FLOAT128, /* __float128 */
BTP_ELLIPSIS, /* ... */
BTP_754R_64, /* IEEE 754r float (64 bits) */
BTP_754R_128, /* IEEE 754r float (128 bits) */
BTP_754R_32, /* IEEE 754r float (32 bits) */
BTP_754R_16, /* IEEE 754r float (16 bits) */
BTP_CHAR32_T, /* char32_t */
BTP_CHAR16_T, /* char16_t */
BTP_OTHER /* Extension utilisateur */
} BaseType;
#define G_TYPE_BASIC_TYPE g_basic_type_get_type()
#define G_BASIC_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_basic_type_get_type(), GBasicType))
#define G_IS_BASIC_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_basic_type_get_type()))
#define G_BASIC_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_BASIC_TYPE, GBasicTypeClass))
#define G_IS_BASIC_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_BASIC_TYPE))
#define G_BASIC_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_BASIC_TYPE, GBasicTypeClass))
/* Description de type basique (instance) */
typedef struct _GBasicType GBasicType;
/* Description de type basique (classe) */
typedef struct _GBasicTypeClass GBasicTypeClass;
/* Indique le type défini pour un type basique. */
GType g_basic_type_get_type(void);
/* Crée une représentation de type basique. */
GOpenidaType *g_basic_type_new(BaseType);
/* -------------------------- VARIABLES DEPENDANT D'AUTRES -------------------------- */
#define G_TYPE_ENCAPSULATED_TYPE g_encapsulated_type_get_type()
#define G_ENCAPSULATED_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_encapsulated_type_get_type(), GEncapsulatedType))
#define G_IS_ENCAPSULATED_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_encapsulated_type_get_type()))
#define G_ENCAPSULATED_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_ENCAPSULATED_TYPE, GEncapsulatedTypeClass))
#define G_IS_ENCAPSULATED_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_ENCAPSULATED_TYPE))
#define G_ENCAPSULATED_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_ENCAPSULATED_TYPE, GEncapsulatedTypeClass))
/* Description de type encapsulé (instance) */
typedef struct _GEncapsulatedType GEncapsulatedType;
/* Description de type encapsulé (classe) */
typedef struct _GEncapsulatedTypeClass GEncapsulatedTypeClass;
/* Cas d'encapsulation possibles */
typedef enum _EncapsulationType
{
ECT_POINTER, /* Pointeur */
ECT_REFERENCE, /* Référence */
ECT_RVALUE_REF, /* Référence ?? (C++0x) */
ECT_COMPLEX, /* Complexe (C 2000) */
ECT_IMAGINARY, /* Imaginaire (C 2000) */
ECT_ROUTINE /* Pointeur vers une routine */
} EncapsulationType;
/* Indique le type défini pour un type encapsulé. */
GType g_encapsulated_type_get_type(void);
/* Crée une représentation de variable dérivée. */
GOpenidaType *g_encapsulated_type_new(EncapsulationType, ...);
/* 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 -------------------------- */
#define G_TYPE_TYPES_MANAGER g_types_manager_get_type()
#define G_TYPES_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_types_manager_get_type(), GTypesManager))
#define G_IS_TYPES_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_types_manager_get_type()))
#define G_TYPES_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_TYPES_MANAGER, GTypesManagerClass))
#define G_IS_TYPES_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_TYPES_MANAGER))
#define G_TYPES_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_TYPES_MANAGER, GTypesManagerClass))
/* Description d'un gestionnaire de types (instance) */
typedef struct _GTypesManager GTypesManager;
/* Description d'un gestionnaire de types (classe) */
typedef struct _GTypesManagerClass GTypesManagerClass;
/* Indique le type défini pour un gestionnaire de types. */
GType g_types_manager_get_type(void);
#endif /* _ANALYSIS_TYPE_H */