/* Chrysalide - Outil d'analyse de fichiers binaires
* type.h - prototypes pour la manipulation des types en tout genre
*
* Copyright (C) 2010-2012 Cyrille Bagard
*
* This file is part of Chrysalide.
*
* Chrysalide 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.
*
* Chrysalide 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 "type.h"
#include
#include "routine.h"
#include "type-int.h"
#include "../common/extstr.h"
/* ------------------------ REPRESENTATION INTERNE DES TYPES ------------------------ */
/* Initialise la classe des types quelconques. */
static void g_data_type_class_init(GDataTypeClass *);
/* Initialise l'instance d'un type quelconque. */
static void g_data_type_init(GDataType *);
/* -------------------------- COLLECTE ET GESTION DE TYPES -------------------------- */
/* Description de type quelconque (instance) */
struct _GTypesManager
{
GObject parent; /* A laisser en premier */
MemoryDataSize wdsize; /* Taille d'un mot en octet */
};
/* Description de type quelconque (classe) */
struct _GTypesManagerClass
{
GObjectClass parent; /* A laisser en premier */
};
/* Initialise la classe des gestionnaires de types. */
static void g_types_manager_class_init(GTypesManagerClass *);
/* Initialise l'instance d'un gestionnaire de types. */
static void g_types_manager_init(GTypesManager *manager);
/* ---------------------------------------------------------------------------------- */
/* REPRESENTATION INTERNE DES TYPES */
/* ---------------------------------------------------------------------------------- */
/* Indique le type défini pour un type quelconque. */
G_DEFINE_TYPE(GDataType, g_data_type, G_TYPE_OBJECT);
/******************************************************************************
* *
* Paramètres : klass = classe à initialiser. *
* *
* Description : Initialise la classe des types quelconques. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_data_type_class_init(GDataTypeClass *klass)
{
}
/******************************************************************************
* *
* Paramètres : type = instance à initialiser. *
* *
* Description : Initialise l'instance d'un type quelconque. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_data_type_init(GDataType *type)
{
}
/******************************************************************************
* *
* Paramètres : type = type à dupliquer. *
* *
* Description : Crée un copie d'un type existant. *
* *
* Retour : Nouvelle instance de type identique à celle fournie. *
* *
* Remarques : - *
* *
******************************************************************************/
GDataType *g_data_type_dup(const GDataType *type)
{
return type->dup(type);
}
/******************************************************************************
* *
* Paramètres : type = type à mettre à jour. *
* namespace = instance d'appartenance. *
* *
* Description : Définit le groupe d'appartenance d'un type donné. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_data_type_set_namespace(GDataType *type, GDataType *namespace)
{
g_object_ref(G_OBJECT(namespace));
type->namespace = namespace;
}
/******************************************************************************
* *
* Paramètres : type = type à convertir. *
* simple = indique si l'espace de noms doit être exclus ou non.*
* *
* 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_data_type_to_string(const GDataType *type, bool simple)
{
char *result; /* Chaîne à retourner */
const GDataType *parent; /* Espace supérieur */
char *namespace; /* Groupe d'appartenance */
result = type->to_string(type);
if (!simple)
for (parent = type->namespace; parent != NULL; parent = parent->namespace)
{
namespace = g_data_type_to_string(parent);
result = strprep(result, "." /* FIXME */);
result = strprep(result, namespace);
free(namespace);
}
if (type->qualifiers & TQF_RESTRICT)
result = strprep(result, "restrict ");
if (type->qualifiers & TQF_VOLATILE)
result = strprep(result, "volatile ");
if (type->qualifiers & TQF_CONST)
result = strprep(result, "const ");
return result;
}
/******************************************************************************
* *
* Paramètres : type = routine à afficher. *
* lang = langage à utiliser pour la sortie humaine. *
* buffer = tampon mis à disposition pour la sortie. *
* info = nature du cadre de destination. *
* full = besoin de descriptions étendues ? *
* *
* Description : Procède à l'impression de la description d'un type. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_data_type_output(const GDataType *type, GLangOutput *lang, GBufferLine *line, bool info, bool full)
{
type->output(type, lang, line, info, full);
}
/******************************************************************************
* *
* Paramètres : type = instance à mettre à jour. *
* qualifier = nouveau qualificatif pour la variable. *
* *
* Description : Ajoute un qualificatif à une instance de type. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_data_type_add_qualifier(GDataType *type, TypeQualifier qualifier)
{
type->qualifiers |= qualifier;
}
/******************************************************************************
* *
* Paramètres : type = type à analyser. *
* large = doit-on aussi inclure les types 'référence' ? *
* *
* Description : Indique la terminaison de la représentation du type. *
* *
* Retour : true ou false, selon le type fourni. *
* *
* Remarques : - *
* *
******************************************************************************/
bool g_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_get_etype(G_ENCAPSULATED_TYPE(type)))
{
case ECT_POINTER:
result = true;
break;
case ECT_REFERENCE:
case ECT_RVALUE_REF:
result = large;
break;
default:
result = false;
break;
}
return result;
}
/* ---------------------------------------------------------------------------------- */
/* COLLECTE ET GESTION DE TYPES */
/* ---------------------------------------------------------------------------------- */
/* Indique le type défini pour un gestionnaire de types. */
G_DEFINE_TYPE(GTypesManager, g_types_manager, G_TYPE_OBJECT);
/******************************************************************************
* *
* Paramètres : klass = classe à initialiser. *
* *
* Description : Initialise la classe des gestionnaires de types. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_types_manager_class_init(GTypesManagerClass *klass)
{
}
/******************************************************************************
* *
* Paramètres : manager = instance à initialiser. *
* *
* Description : Initialise l'instance d'un gestionnaire de types. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_types_manager_init(GTypesManager *manager)
{
}