summaryrefslogtreecommitdiff
path: root/src/analysis
diff options
context:
space:
mode:
Diffstat (limited to 'src/analysis')
-rw-r--r--src/analysis/type-int.h4
-rw-r--r--src/analysis/type.c31
-rw-r--r--src/analysis/type.h3
-rw-r--r--src/analysis/types/array.c32
-rw-r--r--src/analysis/types/basic.c27
-rw-r--r--src/analysis/types/cse.c29
-rw-r--r--src/analysis/types/encaps.c31
-rw-r--r--src/analysis/types/expr.c27
-rw-r--r--src/analysis/types/literal.c32
-rw-r--r--src/analysis/types/override.c27
-rw-r--r--src/analysis/types/proto.c34
-rw-r--r--src/analysis/types/template.c34
12 files changed, 311 insertions, 0 deletions
diff --git a/src/analysis/type-int.h b/src/analysis/type-int.h
index f553bf3..2c70c7b 100644
--- a/src/analysis/type-int.h
+++ b/src/analysis/type-int.h
@@ -29,6 +29,9 @@
+/* Calcule une empreinte pour un type de données. */
+typedef guint (* type_hash_fc) (const GDataType *);
+
/* Décrit le type fourni sous forme de caractères. */
typedef GDataType * (* type_dup_fc) (const GDataType *);
@@ -63,6 +66,7 @@ struct _GDataTypeClass
{
GObjectClass parent; /* A laisser en premier */
+ type_hash_fc hash; /* Prise d'empreinte */
type_dup_fc dup; /* Copie d'instance existante */
type_to_string_fc to_string; /* Conversion au format texte */
diff --git a/src/analysis/type.c b/src/analysis/type.c
index 9a8e85b..350b4e2 100644
--- a/src/analysis/type.c
+++ b/src/analysis/type.c
@@ -138,6 +138,37 @@ static void g_data_type_finalize(GDataType *type)
/******************************************************************************
* *
+* Paramètres : type = type à consulter. *
+* *
+* Description : Calcule une empreinte pour un type de données. *
+* *
+* Retour : Valeur arbitraire sur 32 bits, idéalement unique par type. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+guint g_data_type_hash(const GDataType *type)
+{
+ guint result; /* Empreinte à renvoyer */
+ GDataTypeClass *class; /* Classe du type */
+
+ class = G_DATA_TYPE_GET_CLASS(type);
+
+ result = class->hash(type);
+
+ result ^= g_int_hash((gint []){ g_data_type_get_qualifiers(type) });
+
+ if (type->namespace != NULL)
+ result ^= g_data_type_hash(type->namespace);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : type = type à dupliquer. *
* *
* Description : Crée un copie d'un type existant. *
diff --git a/src/analysis/type.h b/src/analysis/type.h
index 000c557..8fccbb5 100644
--- a/src/analysis/type.h
+++ b/src/analysis/type.h
@@ -63,6 +63,9 @@ typedef enum _TypeQualifier
/* Indique le type défini pour un type quelconque. */
GType g_data_type_get_type(void);
+/* Calcule une empreinte pour un type de données. */
+guint g_data_type_hash(const GDataType *);
+
/* Crée un copie d'un type existant. */
GDataType *g_data_type_dup(const GDataType *);
diff --git a/src/analysis/types/array.c b/src/analysis/types/array.c
index 5aea07b..5ea4179 100644
--- a/src/analysis/types/array.c
+++ b/src/analysis/types/array.c
@@ -72,6 +72,9 @@ static void g_array_type_dispose(GArrayType *);
/* Procède à la libération totale de la mémoire. */
static void g_array_type_finalize(GArrayType *);
+/* Calcule une empreinte pour un type de données. */
+static guint g_array_type_hash(const GArrayType *);
+
/* Crée un copie d'un type existant. */
static GDataType *g_array_type_dup(const GArrayType *);
@@ -108,6 +111,7 @@ static void g_array_type_class_init(GArrayTypeClass *klass)
type = G_DATA_TYPE_CLASS(klass);
+ type->hash = (type_hash_fc)g_array_type_hash;
type->dup = (type_dup_fc)g_array_type_dup;
type->to_string = (type_to_string_fc)g_array_type_to_string;
@@ -206,6 +210,34 @@ GDataType *g_array_type_new(GDataType *members)
/******************************************************************************
* *
+* Paramètres : type = type à consulter. *
+* *
+* Description : Calcule une empreinte pour un type de données. *
+* *
+* Retour : Valeur arbitraire sur 32 bits, idéalement unique par type. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static guint g_array_type_hash(const GArrayType *type)
+{
+ guint result; /* Empreinte à renvoyer */
+
+ if (type->numbered)
+ result = g_int_hash((gint []){ type->dim_number });
+ else
+ result = g_str_hash(type->dim_expr);
+
+ result ^= g_data_type_hash(type->members);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : type = type à dupliquer. *
* *
* Description : Crée un copie d'un type existant. *
diff --git a/src/analysis/types/basic.c b/src/analysis/types/basic.c
index a907f2d..038bfb0 100644
--- a/src/analysis/types/basic.c
+++ b/src/analysis/types/basic.c
@@ -61,6 +61,9 @@ static void g_basic_type_dispose(GBasicType *);
/* Procède à la libération totale de la mémoire. */
static void g_basic_type_finalize(GBasicType *);
+/* Calcule une empreinte pour un type de données. */
+static guint g_basic_type_hash(const GBasicType *);
+
/* Crée un copie d'un type existant. */
static GDataType *g_basic_type_dup(const GBasicType *);
@@ -97,6 +100,7 @@ static void g_basic_type_class_init(GBasicTypeClass *klass)
type = G_DATA_TYPE_CLASS(klass);
+ type->hash = (type_hash_fc)g_basic_type_hash;
type->dup = (type_dup_fc)g_basic_type_dup;
type->to_string = (type_to_string_fc)g_basic_type_to_string;
@@ -187,6 +191,29 @@ GDataType *g_basic_type_new(BaseType type)
/******************************************************************************
* *
+* Paramètres : type = type à consulter. *
+* *
+* Description : Calcule une empreinte pour un type de données. *
+* *
+* Retour : Valeur arbitraire sur 32 bits, idéalement unique par type. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static guint g_basic_type_hash(const GBasicType *type)
+{
+ guint result; /* Empreinte à renvoyer */
+
+ result = g_int_hash((gint []){ g_basic_type_get_base(type) });
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : type = type à dupliquer. *
* *
* Description : Crée un copie d'un type existant. *
diff --git a/src/analysis/types/cse.c b/src/analysis/types/cse.c
index 9f9adcd..c79ea72 100644
--- a/src/analysis/types/cse.c
+++ b/src/analysis/types/cse.c
@@ -62,6 +62,9 @@ static void g_class_enum_type_dispose(GClassEnumType *);
/* Procède à la libération totale de la mémoire. */
static void g_class_enum_type_finalize(GClassEnumType *);
+/* Calcule une empreinte pour un type de données. */
+static guint g_class_enum_type_hash(const GClassEnumType *);
+
/* Crée un copie d'un type existant. */
static GDataType *g_class_enum_type_dup(const GClassEnumType *);
@@ -98,6 +101,7 @@ static void g_class_enum_type_class_init(GClassEnumTypeClass *klass)
type = G_DATA_TYPE_CLASS(klass);
+ type->hash = (type_hash_fc)g_class_enum_type_hash;
type->dup = (type_dup_fc)g_class_enum_type_dup;
type->to_string = (type_to_string_fc)g_class_enum_type_to_string;
@@ -194,6 +198,31 @@ GDataType *g_class_enum_type_new(ClassEnumKind kind, char *name)
/******************************************************************************
* *
+* Paramètres : type = type à consulter. *
+* *
+* Description : Calcule une empreinte pour un type de données. *
+* *
+* Retour : Valeur arbitraire sur 32 bits, idéalement unique par type. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static guint g_class_enum_type_hash(const GClassEnumType *type)
+{
+ guint result; /* Empreinte à renvoyer */
+
+ result = g_int_hash((gint []){ g_class_enum_type_get_kind(type) });
+
+ result ^= g_str_hash(type->name);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : type = type à dupliquer. *
* *
* Description : Crée un copie d'un type existant. *
diff --git a/src/analysis/types/encaps.c b/src/analysis/types/encaps.c
index d59516d..8e2641f 100644
--- a/src/analysis/types/encaps.c
+++ b/src/analysis/types/encaps.c
@@ -65,6 +65,9 @@ static void g_encapsulated_type_dispose(GEncapsulatedType *);
/* Procède à la libération totale de la mémoire. */
static void g_encapsulated_type_finalize(GEncapsulatedType *);
+/* Calcule une empreinte pour un type de données. */
+static guint g_encapsulated_type_hash(const GEncapsulatedType *);
+
/* Crée un copie d'un type existant. */
static GDataType *g_encapsulated_type_dup(const GEncapsulatedType *);
@@ -107,6 +110,7 @@ static void g_encapsulated_type_class_init(GEncapsulatedTypeClass *klass)
type = G_DATA_TYPE_CLASS(klass);
+ type->hash = (type_hash_fc)g_encapsulated_type_hash;
type->dup = (type_dup_fc)g_encapsulated_type_dup;
type->to_string = (type_to_string_fc)g_encapsulated_type_to_string;
@@ -208,6 +212,33 @@ GDataType *g_encapsulated_type_new(EncapsulationType type, GDataType *child)
/******************************************************************************
* *
+* Paramètres : type = type à consulter. *
+* *
+* Description : Calcule une empreinte pour un type de données. *
+* *
+* Retour : Valeur arbitraire sur 32 bits, idéalement unique par type. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static guint g_encapsulated_type_hash(const GEncapsulatedType *type)
+{
+ guint result; /* Empreinte à renvoyer */
+
+ result = g_int_hash((gint []){ g_encapsulated_type_get_etype(type) });
+
+ result ^= g_data_type_hash(type->child);
+
+ result ^= g_int_hash((gint []){ g_encapsulated_type_get_dimension(type) });
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : type = type à dupliquer. *
* *
* Description : Crée un copie d'un type existant. *
diff --git a/src/analysis/types/expr.c b/src/analysis/types/expr.c
index 02005f4..1119ab6 100644
--- a/src/analysis/types/expr.c
+++ b/src/analysis/types/expr.c
@@ -61,6 +61,9 @@ static void g_expr_type_dispose(GExprType *);
/* Procède à la libération totale de la mémoire. */
static void g_expr_type_finalize(GExprType *);
+/* Calcule une empreinte pour un type de données. */
+static guint g_expr_type_hash(const GExprType *);
+
/* Crée un copie d'un type existant. */
static GDataType *g_expr_type_dup(const GExprType *);
@@ -97,6 +100,7 @@ static void g_expr_type_class_init(GExprTypeClass *klass)
type = G_DATA_TYPE_CLASS(klass);
+ type->hash = (type_hash_fc)g_expr_type_hash;
type->dup = (type_dup_fc)g_expr_type_dup;
type->to_string = (type_to_string_fc)g_expr_type_to_string;
@@ -190,6 +194,29 @@ GDataType *g_expr_type_new(const char *value)
/******************************************************************************
* *
+* Paramètres : type = type à consulter. *
+* *
+* Description : Calcule une empreinte pour un type de données. *
+* *
+* Retour : Valeur arbitraire sur 32 bits, idéalement unique par type. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static guint g_expr_type_hash(const GExprType *type)
+{
+ guint result; /* Empreinte à renvoyer */
+
+ result = g_str_hash(type->value);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : type = type à dupliquer. *
* *
* Description : Crée un copie d'un type existant. *
diff --git a/src/analysis/types/literal.c b/src/analysis/types/literal.c
index 3a9e5cf..addab5a 100644
--- a/src/analysis/types/literal.c
+++ b/src/analysis/types/literal.c
@@ -64,6 +64,9 @@ static void g_literal_type_dispose(GLiteralType *);
/* Procède à la libération totale de la mémoire. */
static void g_literal_type_finalize(GLiteralType *);
+/* Calcule une empreinte pour un type de données. */
+static guint g_literal_type_hash(const GLiteralType *);
+
/* Crée un copie d'un type existant. */
static GDataType *g_literal_type_dup(const GLiteralType *);
@@ -100,6 +103,7 @@ static void g_literal_type_class_init(GLiteralTypeClass *klass)
type = G_DATA_TYPE_CLASS(klass);
+ type->hash = (type_hash_fc)g_literal_type_hash;
type->dup = (type_dup_fc)g_literal_type_dup;
type->to_string = (type_to_string_fc)g_literal_type_to_string;
@@ -202,6 +206,34 @@ GDataType *g_literal_type_new(GDataType *orig, const literal_value *value)
/******************************************************************************
* *
+* Paramètres : type = type à consulter. *
+* *
+* Description : Calcule une empreinte pour un type de données. *
+* *
+* Retour : Valeur arbitraire sur 32 bits, idéalement unique par type. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static guint g_literal_type_hash(const GLiteralType *type)
+{
+ guint result; /* Empreinte à renvoyer */
+
+ result = g_data_type_hash(type->orig);
+
+ if (g_basic_type_get_base(G_BASIC_TYPE(type->orig)) == BTP_FLOAT)
+ result ^= g_double_hash((gdouble []){ type->value.float_val });
+ else
+ result ^= g_int_hash((gint []){ type->value.int_val });
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : type = type à dupliquer. *
* *
* Description : Crée un copie d'un type existant. *
diff --git a/src/analysis/types/override.c b/src/analysis/types/override.c
index a535e80..841f10c 100644
--- a/src/analysis/types/override.c
+++ b/src/analysis/types/override.c
@@ -65,6 +65,9 @@ static void g_override_type_dispose(GOverrideType *);
/* Procède à la libération totale de la mémoire. */
static void g_override_type_finalize(GOverrideType *);
+/* Calcule une empreinte pour un type de données. */
+static guint g_override_type_hash(const GOverrideType *);
+
/* Crée un copie d'un type existant. */
static GDataType *g_override_type_dup(const GOverrideType *);
@@ -101,6 +104,7 @@ static void g_override_type_class_init(GOverrideTypeClass *klass)
type = G_DATA_TYPE_CLASS(klass);
+ type->hash = (type_hash_fc)g_override_type_hash;
type->dup = (type_dup_fc)g_override_type_dup;
type->to_string = (type_to_string_fc)g_override_type_to_string;
@@ -229,6 +233,29 @@ GDataType *g_override_type_new_with_covariant(GDataType *base, const call_offset
/******************************************************************************
* *
+* Paramètres : type = type à consulter. *
+* *
+* Description : Calcule une empreinte pour un type de données. *
+* *
+* Retour : Valeur arbitraire sur 32 bits, idéalement unique par type. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static guint g_override_type_hash(const GOverrideType *type)
+{
+ guint result; /* Empreinte à renvoyer */
+
+ result = g_data_type_hash(type->base);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : type = type à dupliquer. *
* *
* Description : Crée un copie d'un type existant. *
diff --git a/src/analysis/types/proto.c b/src/analysis/types/proto.c
index 8d5b897..135c15a 100644
--- a/src/analysis/types/proto.c
+++ b/src/analysis/types/proto.c
@@ -66,6 +66,9 @@ static void g_proto_type_dispose(GProtoType *);
/* Procède à la libération totale de la mémoire. */
static void g_proto_type_finalize(GProtoType *);
+/* Calcule une empreinte pour un type de données. */
+static guint g_proto_type_hash(const GProtoType *);
+
/* Crée un copie d'un type existant. */
static GDataType *g_proto_type_dup(const GProtoType *);
@@ -105,6 +108,7 @@ static void g_proto_type_class_init(GProtoTypeClass *klass)
type = G_DATA_TYPE_CLASS(klass);
+ type->hash = (type_hash_fc)g_proto_type_hash;
type->dup = (type_dup_fc)g_proto_type_dup;
type->to_string = (type_to_string_fc)g_proto_type_to_string;
@@ -209,6 +213,36 @@ GDataType *g_proto_type_new(void)
/******************************************************************************
* *
+* Paramètres : type = type à consulter. *
+* *
+* Description : Calcule une empreinte pour un type de données. *
+* *
+* Retour : Valeur arbitraire sur 32 bits, idéalement unique par type. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static guint g_proto_type_hash(const GProtoType *type)
+{
+ guint result; /* Empreinte à renvoyer */
+ size_t i; /* Boucle de parcours */
+
+ if (type->ret_type == NULL)
+ result = 0;
+ else
+ result = g_data_type_hash(type->ret_type);
+
+ for (i = 0; i < type->count; i++)
+ result ^= g_data_type_hash(type->args[i]);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : type = type à dupliquer. *
* *
* Description : Crée un copie d'un type existant. *
diff --git a/src/analysis/types/template.c b/src/analysis/types/template.c
index 75879f4..3a58169 100644
--- a/src/analysis/types/template.c
+++ b/src/analysis/types/template.c
@@ -66,6 +66,9 @@ static void g_template_type_dispose(GTemplateType *);
/* Procède à la libération totale de la mémoire. */
static void g_template_type_finalize(GTemplateType *);
+/* Calcule une empreinte pour un type de données. */
+static guint g_template_type_hash(const GTemplateType *);
+
/* Crée un copie d'un type existant. */
static GDataType *g_template_type_dup(const GTemplateType *);
@@ -102,6 +105,7 @@ static void g_template_type_class_init(GTemplateTypeClass *klass)
type = G_DATA_TYPE_CLASS(klass);
+ type->hash = (type_hash_fc)g_template_type_hash;
type->dup = (type_dup_fc)g_template_type_dup;
type->to_string = (type_to_string_fc)g_template_type_to_string;
@@ -253,6 +257,36 @@ void g_template_type_set_name(GTemplateType *type, const char *name)
/******************************************************************************
* *
+* Paramètres : type = type à consulter. *
+* *
+* Description : Calcule une empreinte pour un type de données. *
+* *
+* Retour : Valeur arbitraire sur 32 bits, idéalement unique par type. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static guint g_template_type_hash(const GTemplateType *type)
+{
+ guint result; /* Empreinte à renvoyer */
+ size_t i; /* Boucle de parcours */
+
+ if (type->name == NULL)
+ result = 0;
+ else
+ result = g_str_hash(type->name);
+
+ for (i = 0; i < type->count; i++)
+ result ^= g_data_type_hash(type->params[i]);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : type = type à dupliquer. *
* *
* Description : Crée un copie d'un type existant. *
generated by cgit v0.11.2-87-g4458 at 2024-12-25 17:13:36 (GMT)