From 66b8d57f0c054065894ab3dd0f1640594013e441 Mon Sep 17 00:00:00 2001
From: Cyrille Bagard <nocbos@gmail.com>
Date: Sat, 20 Feb 2021 01:26:09 +0100
Subject: Compute a hash value for data types.

---
 plugins/pychrysalide/analysis/type.c | 100 +++++++++++++++++++++++++++++++++++
 src/analysis/type-int.h              |   4 ++
 src/analysis/type.c                  |  31 +++++++++++
 src/analysis/type.h                  |   3 ++
 src/analysis/types/array.c           |  32 +++++++++++
 src/analysis/types/basic.c           |  27 ++++++++++
 src/analysis/types/cse.c             |  29 ++++++++++
 src/analysis/types/encaps.c          |  31 +++++++++++
 src/analysis/types/expr.c            |  27 ++++++++++
 src/analysis/types/literal.c         |  32 +++++++++++
 src/analysis/types/override.c        |  27 ++++++++++
 src/analysis/types/proto.c           |  34 ++++++++++++
 src/analysis/types/template.c        |  34 ++++++++++++
 tests/analysis/type.py               |  17 ++++++
 14 files changed, 428 insertions(+)

diff --git a/plugins/pychrysalide/analysis/type.c b/plugins/pychrysalide/analysis/type.c
index cd849e4..d2801bf 100644
--- a/plugins/pychrysalide/analysis/type.c
+++ b/plugins/pychrysalide/analysis/type.c
@@ -52,6 +52,9 @@ static PyObject *py_data_type_new(PyTypeObject *, PyObject *, PyObject *);
 /* Initialise la classe des types quelconques. */
 static void py_data_type_init_gclass(GDataTypeClass *, gpointer);
 
+/* Calcule une empreinte pour un type de données. */
+static guint py_data_type_hash_wrapper(const GDataType *);
+
 /* Crée un copie d'un type existant. */
 static GDataType *py_data_type_dup_wrapper(const GDataType *);
 
@@ -81,6 +84,9 @@ static PyObject *py_data_type_to_str(PyObject *);
 /* Crée un copie d'un type existant. */
 static PyObject *py_data_type_dup(PyObject *, PyObject *);
 
+/* Calcule une empreinte pour un type de données. */
+static PyObject *py_data_type_get_hash(PyObject *, void *);
+
 /* Fournit le groupe d'appartenance d'un type donné. */
 static PyObject *py_data_type_get_namespace(PyObject *, void *);
 
@@ -187,6 +193,7 @@ static PyObject *py_data_type_new(PyTypeObject *type, PyObject *args, PyObject *
 
 static void py_data_type_init_gclass(GDataTypeClass *class, gpointer unused)
 {
+    class->hash = py_data_type_hash_wrapper;
     class->dup = py_data_type_dup_wrapper;
     class->to_string = py_data_type_to_string_wrapper;
 
@@ -199,6 +206,58 @@ static void py_data_type_init_gclass(GDataTypeClass *class, gpointer unused)
 
 /******************************************************************************
 *                                                                             *
+*  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 py_data_type_hash_wrapper(const GDataType *type)
+{
+    guint result;                           /* Empreinte à renvoyer        */
+    PyObject *pyobj;                        /* Objet Python concerné       */
+    PyObject *pyret;                        /* Bilan de consultation       */
+
+#define DATA_TYPE_HASH_WRAPPER PYTHON_WRAPPER_DEF               \
+(                                                               \
+    _hash, "$self, /",                                          \
+    METH_NOARGS,                                                \
+    "Abstract method used to create a hash of the data type.\n" \
+    "\n"                                                        \
+    "The returned value has to be a 32-bit integer."            \
+)
+
+    result = 0;
+
+    pyobj = pygobject_new(G_OBJECT(type));
+
+    if (has_python_method(pyobj, "_hash"))
+    {
+        pyret = run_python_method(pyobj, "_hash", NULL);
+
+        if (pyret != NULL)
+        {
+            if (PyLong_Check(pyret))
+                result = PyLong_AsUnsignedLong(pyret);
+        }
+
+        Py_XDECREF(pyret);
+
+    }
+
+    Py_DECREF(pyobj);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : type = type à dupliquer.                                     *
 *                                                                             *
 *  Description : Crée un copie d'un type existant.                            *
@@ -496,6 +555,7 @@ static int py_data_type_init(PyObject *self, PyObject *args, PyObject *kwds)
     "    DataType()"                                                    \
     "\n"                                                                \
     "The following methods have to be defined for new classes:\n"       \
+    "* pychrysalide.analysis.DataType._hash();\n"                       \
     "* pychrysalide.analysis.DataType._dup();\n"                        \
     "* pychrysalide.analysis.DataType._to_string()."                    \
     "\n"                                                                \
@@ -606,6 +666,44 @@ static PyObject *py_data_type_dup(PyObject *self, PyObject *args)
 *  Paramètres  : self    = objet Python concerné par l'appel.                 *
 *                closure = non utilisé ici.                                   *
 *                                                                             *
+*  Description : Calcule une empreinte pour un type de données.               *
+*                                                                             *
+*  Retour      : Valeur arbitraire sur 32 bits, idéalement unique par type.   *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PyObject *py_data_type_get_hash(PyObject *self, void *closure)
+{
+    PyObject *result;                       /* Valeur à retourner          */
+    GDataType *type;                        /* Elément à consulter         */
+    guint hash;                             /* Empreinte à transmettre     */
+
+#define DATA_TYPE_HASH_ATTRIB PYTHON_GET_DEF_FULL       \
+(                                                       \
+    hash, py_data_type,                                 \
+    "Hash value for the type, as a 32-bit integer.\n"   \
+    "\n"                                                \
+    "Each proporty change implies a hash change."       \
+)
+
+    type = G_DATA_TYPE(pygobject_get(self));
+
+    hash = g_data_type_hash(type);
+
+    result = PyLong_FromUnsignedLong(hash);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : self    = objet Python concerné par l'appel.                 *
+*                closure = non utilisé ici.                                   *
+*                                                                             *
 *  Description : Fournit le groupe d'appartenance d'un type donné.            *
 *                                                                             *
 *  Retour      : Eventuelle instance d'appartenance ou None.                  *
@@ -913,6 +1011,7 @@ static PyObject *py_data_type_is_reference(PyObject *self, void *closure)
 PyTypeObject *get_python_data_type_type(void)
 {
     static PyMethodDef py_data_type_methods[] = {
+        DATA_TYPE_HASH_WRAPPER,
         DATA_TYPE_DUP_WRAPPER,
         DATA_TYPE_TO_STRING_WRAPPER,
         DATA_TYPE_HANDLE_NAMESPACES_WRAPPER,
@@ -922,6 +1021,7 @@ PyTypeObject *get_python_data_type_type(void)
     };
 
     static PyGetSetDef py_data_type_getseters[] = {
+        DATA_TYPE_HASH_ATTRIB,
         DATA_TYPE_NAMESPACE_ATTRIB,
         DATA_TYPE_QUALIFIERS_ATTRIB,
         DATA_TYPE_NAMESPACES_ATTRIB,
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.                            *
diff --git a/tests/analysis/type.py b/tests/analysis/type.py
index 5106cbc..b690a55 100644
--- a/tests/analysis/type.py
+++ b/tests/analysis/type.py
@@ -90,3 +90,20 @@ class TestDataType(ChrysalideTestCase):
         self.assertEqual(str(tp), 'NS.TP')
 
         self.assertEqual(tp.namespace, (ns, '.'))
+
+
+    def testTypeHash(self):
+        """Hash a user-defined type."""
+
+        class MyUserType(DataType):
+
+            def __init__(self, name):
+                super(MyUserType, self).__init__()
+                self._name = name
+
+            def _hash(self):
+                return hash(self._name)
+
+        tp = MyUserType('random')
+
+        self.assertEqual(tp.hash, hash('random') & ((1 << 32) - 1))
-- 
cgit v0.11.2-87-g4458