Rewrite core parts of the ROST API.

1 files changed, 104 insertions, 0 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;
+
+}