Rewrite core parts of the ROST API.

3 files changed, 121 insertions, 12 deletions

diff --git a/src/common/extstr.c b/src/common/extstr.c
index 3041be0..ac93f5d 100644
--- a/src/common/extstr.c
+++ b/src/common/extstr.c
@@ -24,6 +24,7 @@
 #include "extstr.h"
 
 
+#include <ctype.h>
 #include <malloc.h>
 #include <regex.h>
 #include <stdio.h>
@@ -565,3 +566,106 @@ bool _endswith(const char *str, const char *suffix, const char **end)
     return result;
 
 }
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : haystack    = botte de foin composant l'espace de recherche. *
+*                haystacklen = taille de cet espace.                          *
+*                needle      = aiguille visée, cible des recherches.          *
+*                needlelen   = taille de l'aiguille à rechercher.             *
+*                                                                             *
+*  Description : Recherche une séquence d'octets dans un ensemble de données. *
+*                                                                             *
+*  Retour      : Adresse de l'éventuelle trouvaille ou NULL.                  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+const void *memcasemem(const void *haystack, size_t haystacklen, const void *needle, size_t needlelen)
+{
+    const void *result;                     /* Trouvaille à renvoyer       */
+    const char *_haystack;                  /* Autre version de la botte   */
+    const char *_needle;                    /* Autre version de l'aiguille */
+    size_t i;                               /* Boucle de parcours #1       */
+    size_t k;                               /* Boucle de parcours #2       */
+    int c1;                                 /* Caractère de la chaîne #1   */
+    int c2;                                 /* Caractère de la chaîne #2   */
+
+    result = NULL;
+
+    if (needlelen > haystacklen)
+        goto done;
+
+    _haystack = (const char *)haystack;
+    _needle = (const char *)needle;
+
+    for (i = 0; i <= (haystacklen - needlelen); i++, _haystack++)
+    {
+        for (k = 0; k < needlelen; k++)
+        {
+            c1 = toupper(_haystack[k]);
+            c2 = toupper(_needle[k]);
+
+            if (c1 != c2)
+                break;
+
+        }
+
+        if (k == needlelen)
+        {
+            result = _haystack;
+            break;
+        }
+
+    }
+
+ done:
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : s1 = première séquence d'octets à consulter.                 *
+*                s2 = second séquence d'octets à consulter.                   *
+*                n  = quantité d'octets à comparer.                           *
+*                                                                             *
+*  Description : Compare sans casse deux série d'octets entre elles.          *
+*                                                                             *
+*  Retour      : Status de la comparaison des séries d'octets.                *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+int memcasecmp(const void *s1, const void *s2, size_t n)
+{
+    int result;                             /* Statut à retourner          */
+    size_t i;                               /* Boucle de parcours          */
+    const char *_s1;                        /* Séquence avec taille #1     */
+    const char *_s2;                        /* Séquence avec taille #2     */
+    int c1;                                 /* Caractère de la chaîne #1   */
+    int c2;                                 /* Caractère de la chaîne #2   */
+
+    result = 0;
+
+    _s1 = (const char *)s1;
+    _s2 = (const char *)s2;
+
+    for (i = 0; i < n; i++)
+    {
+        c1 = toupper(_s1[i]);
+        c2 = toupper(_s2[i]);
+
+        result = c1 - c2;
+        if (result != 0) break;
+
+    }
+
+    return result;
+
+}
diff --git a/src/common/extstr.h b/src/common/extstr.h
index c4e671e..a2293be 100644
--- a/src/common/extstr.h
+++ b/src/common/extstr.h
@@ -79,6 +79,12 @@ bool _endswith(const char *, const char *, const char **);
 #define startswith(str, prefix) _startswith(str, prefix, NULL)
 #define endswith(str, suffix) _endswith(str, suffix, NULL)
 
+/* Recherche une séquence d'octets dans un ensemble de données. */
+const void *memcasemem(const void *, size_t, const void *, size_t);
+
+/* Compare sans casse deux série d'octets entre elles. */
+int memcasecmp(const void *, const void *, size_t);
+
 
 
 #endif  /* _COMMON_EXTSTR_H */
diff --git a/src/common/szstr.h b/src/common/szstr.h
index aadbb28..54beb9a 100644
--- a/src/common/szstr.h
+++ b/src/common/szstr.h
@@ -47,6 +47,15 @@ typedef struct _sized_string_t
     }                       \
     while (0)
 
+#define szstrdup(dst, src)                              \
+    do                                                  \
+    {                                                   \
+        (dst)->data = malloc((src)->len);               \
+        memcpy((dst)->data, (src)->data, (src)->len);   \
+        (dst)->len = (src)->len;                        \
+    }                                                   \
+    while (0)
+
 #define exit_szstr(s)           \
     do                          \
     {                           \
@@ -59,18 +68,8 @@ typedef struct _sized_string_t
     while (0)
             
 #define szstrcmp(ss, rs) \
-    strncmp((ss)->data, rs, (ss)->len)
-
-#define szmemcmp(s1, s2)                                        \
-    ({                                                          \
-        int __result;                                           \
-        size_t __n;                                             \
-        __n = (s1)->len < (s2)->len ? (s1)->len : (s2)->len;    \
-        __result = memcmp((s1)->data, (s2)->data, __n);         \
-        if (__result == 0 && (s1)->len != (s2)->len)            \
-            __result = (s1)->len < (s2)->len ? -1 : 1;          \
-        __result;                                               \
-    })
+    strncmp((ss)->data, (rs)/*->data*/, (ss)->len)
+
 
 
 #endif  /* _COMMON_SZSTR_H */