Provided initial features for debugging using GDB.

5 files changed, 354 insertions, 5 deletions

diff --git a/src/common/endianness.c b/src/common/endianness.c
index eecb397..ba72f3d 100755
--- a/src/common/endianness.c
+++ b/src/common/endianness.c
@@ -29,6 +29,226 @@
 
 
 
+/* ---------------------------------------------------------------------------------- */
+/*                             CONVERSION ENTRE BOUTISMES                             */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : value  = valeur d'origine à manipuler.                       *
+*                endian = ordre des bits dans la source.                      *
+*                                                                             *
+*  Description : Adapte un nombre sur 16 bits à un boutisme donné.            *
+*                                                                             *
+*  Retour      : Valeur transformée au besoin.                                *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+uint16_t swap_u16(const uint16_t *value, SourceEndian endian)
+{
+    uint16_t result;                        /* Valeur à retourner          */
+
+    switch (endian)
+    {
+        case SRE_LITTLE:
+
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+
+            result = *value;
+
+#elif __BYTE_ORDER == __BIG_ENDIAN
+
+            result = ((*value >> 0) & 0xff) << 8 | ((*value >> 8) & 0xff) << 0;
+
+#else
+
+#   error "TODO : PDP !"
+
+#endif
+
+            break;
+
+        case SRE_MIDDLE:
+            /* TODO */
+            break;
+
+        case SRE_BIG:
+
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+
+            result = ((*value >> 0) & 0xff) << 8 | ((*value >> 8) & 0xff) << 0;
+
+#elif __BYTE_ORDER == __BIG_ENDIAN
+
+            result = *value;
+
+#else
+
+#   error "TODO : PDP !"
+
+#endif
+
+            break;
+
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : value  = valeur d'origine à manipuler.                       *
+*                endian = ordre des bits dans la source.                      *
+*                                                                             *
+*  Description : Adapte un nombre sur 16 bits à un boutisme donné.            *
+*                                                                             *
+*  Retour      : Valeur transformée au besoin.                                *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+uint32_t swap_u32(const uint32_t *value, SourceEndian endian)
+{
+    uint32_t result;                        /* Valeur à retourner          */
+
+    switch (endian)
+    {
+        case SRE_LITTLE:
+
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+
+            result = *value;
+
+#elif __BYTE_ORDER == __BIG_ENDIAN
+
+            result = ((*value >>  0) & 0xff) << 24 | ((*value >>  8) & 0xff) << 16
+                   | ((*value >> 16) & 0xff) << 8  | ((*value >> 24) & 0xff) << 0;
+
+#else
+
+#   error "TODO : PDP !"
+
+#endif
+
+            break;
+
+        case SRE_MIDDLE:
+            /* TODO */
+            break;
+
+        case SRE_BIG:
+
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+
+            result = ((*value >>  0) & 0xff) << 24 | ((*value >>  8) & 0xff) << 16
+                   | ((*value >> 16) & 0xff) << 8  | ((*value >> 24) & 0xff) << 0;
+
+#elif __BYTE_ORDER == __BIG_ENDIAN
+
+            result = *value;
+
+#else
+
+#   error "TODO : PDP !"
+
+#endif
+
+            break;
+
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : value  = valeur d'origine à manipuler.                       *
+*                endian = ordre des bits dans la source.                      *
+*                                                                             *
+*  Description : Adapte un nombre sur 16 bits à un boutisme donné.            *
+*                                                                             *
+*  Retour      : Valeur transformée au besoin.                                *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+uint64_t swap_u64(const uint64_t *value, SourceEndian endian)
+{
+    uint64_t result;                        /* Valeur à retourner          */
+
+    switch (endian)
+    {
+        case SRE_LITTLE:
+
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+
+            result = *value;
+
+#elif __BYTE_ORDER == __BIG_ENDIAN
+
+            result = ((*value >>  0) & 0xff) << 56 | ((*value >>  8) & 0xff) << 48
+                   | ((*value >> 16) & 0xff) << 40 | ((*value >> 24) & 0xff) << 32
+                   | ((*value >> 32) & 0xff) << 24 | ((*value >> 40) & 0xff) << 16
+                   | ((*value >> 48) & 0xff) << 8  | ((*value >> 56) & 0xff) << 0;
+
+#else
+
+#   error "TODO : PDP !"
+
+#endif
+
+            break;
+
+        case SRE_MIDDLE:
+            /* TODO */
+            break;
+
+        case SRE_BIG:
+
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+
+            result = ((*value >>  0) & 0xff) << 56 | ((*value >>  8) & 0xff) << 48
+                   | ((*value >> 16) & 0xff) << 40 | ((*value >> 24) & 0xff) << 32
+                   | ((*value >> 32) & 0xff) << 24 | ((*value >> 40) & 0xff) << 16
+                   | ((*value >> 48) & 0xff) << 8  | ((*value >> 56) & 0xff) << 0;
+
+#elif __BYTE_ORDER == __BIG_ENDIAN
+
+            result = *value;
+
+#else
+
+#   error "TODO : PDP !"
+
+#endif
+
+            break;
+
+
+    }
+
+    return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                           BOUTISME DES ENTREES / SORTIES                           */
+/* ---------------------------------------------------------------------------------- */
+
+
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : target = lieu d'enregistrement de la lecture. [OUT]          *
diff --git a/src/common/endianness.h b/src/common/endianness.h
index 2af6493..5ceb2ee 100755
--- a/src/common/endianness.h
+++ b/src/common/endianness.h
@@ -43,6 +43,33 @@ typedef enum _SourceEndian
 } SourceEndian;
 
 
+/* --------------------------- CONVERSION ENTRE BOUTISMES --------------------------- */
+
+
+/* Adapte un nombre sur 16 bits à un boutisme donné. */
+uint16_t swap_u16(const uint16_t *, SourceEndian);
+
+/* Adapte un nombre sur 16 bits à un boutisme donné. */
+uint32_t swap_u32(const uint32_t *, SourceEndian);
+
+/* Adapte un nombre sur 16 bits à un boutisme donné. */
+uint64_t swap_u64(const uint64_t *, SourceEndian);
+
+
+#define from_u16(v, e) swap_u16(v, e)
+#define from_u32(v, e) swap_u32(v, e)
+#define from_u64(v, e) swap_u64(v, e)
+
+
+#define to_u16(v, e) swap_u16(v, e)
+#define to_u32(v, e) swap_u32(v, e)
+#define to_u64(v, e) swap_u64(v, e)
+
+
+
+/* ------------------------- BOUTISME DES ENTREES / SORTIES ------------------------- */
+
+
 /* Lit un nombre non signé sur 4 bits. */
 bool read_u4(uint8_t *, const bin_t *, phys_t *, phys_t, bool *);
 
diff --git a/src/common/extstr.c b/src/common/extstr.c
index 087505a..bd561ba 100644
--- a/src/common/extstr.c
+++ b/src/common/extstr.c
@@ -196,13 +196,13 @@ char *strrpl(char *haystack, const char *needle1, const char *needle2)
             haystack = (char *)realloc(haystack, inlen * sizeof(char *));
             found = haystack + index;
 
-            memmove(found + len2, found + len1, inlen + len2 - index);
+            memmove(found + len2, found + len1, inlen - len2 - index);
 
         }
 
         else if (len2 < len1)
         {
-            memmove(found + len2, found + len1, inlen + len2 - index);
+            memmove(found + len2, found + len1, inlen - index - len1);
 
             inlen -= (len1 - len2);
 
diff --git a/src/common/xml.c b/src/common/xml.c
index cbb7a41..0bd4d86 100644
--- a/src/common/xml.c
+++ b/src/common/xml.c
@@ -45,9 +45,8 @@
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : filename = nom du fichier à ouvrir.                          *
-*                xdoc     = structure XML chargée. [OUT]                      *
-*                context  = contexte à utiliser pour les recherches. [OUT]    *
+*  Paramètres  : xdoc    = structure XML chargée. [OUT]                       *
+*                context = contexte à utiliser pour les recherches. [OUT]     *
 *                                                                             *
 *  Description : Crée un nouveau fichier XML.                                 *
 *                                                                             *
@@ -79,6 +78,41 @@ bool create_new_xml_file(xmlDocPtr *xdoc, xmlXPathContextPtr *context)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : content = données XML présentes en mémoire et à charge.      *
+*                length  = quantité de ces données.                           *
+*                xdoc    = structure XML chargée. [OUT]                       *
+*                context = contexte à utiliser pour les recherches. [OUT]     *
+*                                                                             *
+*  Description : Charge un document XML entièrement en mémoire.               *
+*                                                                             *
+*  Retour      : true si l'opération a pu s'effectuer, false sinon.           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool load_xml_from_memory(const char *content, size_t length, xmlDocPtr *xdoc, xmlXPathContextPtr *context)
+{
+    *xdoc = xmlReadMemory(content, length, "noname.xml", NULL, 0);
+
+    if (*xdoc == NULL)
+        return false;
+
+    *context = xmlXPathNewContext(*xdoc);
+
+    if (*context == NULL)
+    {
+        xmlFreeDoc(*xdoc);
+        return false;
+    }
+
+    return true;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : xdoc     = structure XML chargée.                            *
 *                filename = nom du fichier à remplir.                         *
 *                                                                             *
@@ -217,6 +251,65 @@ xmlXPathObjectPtr get_node_xpath_object(xmlXPathContextPtr xpathCtx, const char
 *                                                                             *
 *  Paramètres  : node = noeud dont une propriété est à lire.                  *
 *                                                                             *
+*  Description : Obtient le nom de balise d'un noeud donné.                   *
+*                                                                             *
+*  Retour      : Valeur sous forme de chaîne de caractères ou NULL.           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+char *qck_get_node_name(xmlNodePtr node)
+{
+    char *result;                           /* Valeur en question renvoyée */
+
+    result = NULL;
+
+    if (node != NULL)
+        result = strdup((const char *)node->name);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : xpathCtx = contexte à utiliser pour les recherches.          *
+*                path     = chemin d'accès au noeud visé.                     *
+*                                                                             *
+*  Description : Obtient le nom de balise d'un noeud donné.                   *
+*                                                                             *
+*  Retour      : Valeur sous forme de chaîne de caractères ou NULL.           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+char *get_node_name(xmlXPathContextPtr xpathCtx, const char *path)
+{
+    char *result;                           /* Valeur en question renvoyée */
+    xmlXPathObjectPtr xpathObj;             /* Point de départ XML         */
+
+    result = NULL;
+
+    xpathObj = get_node_xpath_object(xpathCtx, path);
+    if (xpathObj == NULL) return NULL;
+
+    if (xpathObj->nodesetval->nodeNr > 0)
+        result = qck_get_node_name(xpathObj->nodesetval->nodeTab[0]);
+
+    xmlXPathFreeObject(xpathObj);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : node = noeud dont une propriété est à lire.                  *
+*                                                                             *
 *  Description : Obtient une valeur placée entre <...> et </...>.             *
 *                                                                             *
 *  Retour      : Valeur sous forme de chaîne de caractères ou NULL.           *
diff --git a/src/common/xml.h b/src/common/xml.h
index c3e4b56..ed009c6 100644
--- a/src/common/xml.h
+++ b/src/common/xml.h
@@ -37,6 +37,9 @@
 /* Crée un nouveau fichier XML. */
 bool create_new_xml_file(xmlDocPtr *, xmlXPathContextPtr *);
 
+/*  Charge un document XML entièrement en mémoire. */
+bool load_xml_from_memory(const char *, size_t, xmlDocPtr *, xmlXPathContextPtr *);
+
 /* Sauvegarde une structure XML dans un fichier. */
 bool save_xml_file(xmlDocPtr, const char *);
 
@@ -58,6 +61,12 @@ gboolean open_xml_file(const char *filename, xmlDoc **, xmlXPathContextPtr *);
 /* Obtient de façon encadrée l'accès à un noeud défini. */
 xmlXPathObjectPtr get_node_xpath_object(xmlXPathContextPtr, const char *);
 
+/* Obtient le nom de balise d'un noeud donné. */
+char *qck_get_node_name(xmlNodePtr);
+
+/* Obtient le nom de balise d'un noeud donné. */
+char *get_node_name(xmlXPathContextPtr, const char *);
+
 /* Obtient une valeur placée entre <...> et </...>. */
 char *qck_get_node_text_value(xmlNodePtr);