lib/mbsncasecmp.c

   1 /* Case-insensitive string comparison function.
   2    Copyright (C) 1998-1999, 2005-2024 Free Software Foundation, Inc.
   3    Written by Bruno Haible <bruno@clisp.org>, 2005,
   4    based on earlier glibc code.
   5
   6    This file is free software: you can redistribute it and/or modify
   7    it under the terms of the GNU Lesser General Public License as
   8    published by the Free Software Foundation, either version 3 of the
   9    License, or (at your option) any later version.
  10
  11    This file is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public License
  17    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  18
  19 #include <config.h>
  20
  21 /* Specification.  */
  22 #include <string.h>
  23
  24 #include <ctype.h>
  25 #include <limits.h>
  26 #include <stdlib.h>
  27
  28 #if GNULIB_MCEL_PREFER
  29 # include "mcel.h"
  30 #else
  31 # include "mbuiterf.h"
  32 #endif
  33
  34 /* Compare the initial segment of the character string S1 consisting of at most
  35    N characters with the initial segment of the character string S2 consisting
  36    of at most N characters, ignoring case, returning less than, equal to or
  37    greater than zero if the initial segment of S1 is lexicographically less
  38    than, equal to or greater than the initial segment of S2.
  39    Note: This function may, in multibyte locales, return 0 for initial segments
  40    of different lengths!  */
  41 int
  42 mbsncasecmp (const char *s1, const char *s2, size_t n)
  43 {
  44   if (s1 == s2 || n == 0)
  45     return 0;
  46
  47   const char *iter1 = s1;
  48   const char *iter2 = s2;
  49
  50   /* Be careful not to look at the entire extent of s1 or s2 until needed.
  51      This is useful because when two strings differ, the difference is
  52      most often already in the very few first characters.  */
  53   if (MB_CUR_MAX > 1)
  54     {
  55 #if GNULIB_MCEL_PREFER
  56       while (true)
  57         {
  58           mcel_t g1 = mcel_scanz (iter1); iter1 += g1.len;
  59           mcel_t g2 = mcel_scanz (iter2); iter2 += g2.len;
  60           int cmp = mcel_tocmp (c32tolower, g1, g2);
  61           n--;
  62           if (cmp | !n | !g1.ch)
  63             return cmp;
  64         }
  65 #else
  66       mbuif_state_t state1;
  67       mbuif_init (state1);
  68
  69       mbuif_state_t state2;
  70       mbuif_init (state2);
  71
  72       while (mbuif_avail (state1, iter1) && mbuif_avail (state2, iter2))
  73         {
  74           mbchar_t cur1 = mbuif_next (state1, iter1);
  75           mbchar_t cur2 = mbuif_next (state2, iter2);
  76           int cmp = mb_casecmp (cur1, cur2);
  77
  78           if (cmp != 0)
  79             return cmp;
  80
  81           if (--n == 0)
  82             return 0;
  83
  84           iter1 += mb_len (cur1);
  85           iter2 += mb_len (cur2);
  86         }
  87       if (mbuif_avail (state1, iter1))
  88         /* s2 terminated before s1 and n.  */
  89         return 1;
  90       if (mbuif_avail (state2, iter2))
  91         /* s1 terminated before s2 and n.  */
  92         return -1;
  93       return 0;
  94 #endif
  95     }
  96   else
  97     for (;;)
  98       {
  99         unsigned char c1 = *iter1++;
 100         unsigned char c2 = *iter2++;
 101         /* On machines where 'char' and 'int' are types of the same size, the
 102            difference of two 'unsigned char' values - including the sign bit -
 103            doesn't fit in an 'int'.  */
 104         int cmp = UCHAR_MAX <= INT_MAX ? c1 - c2 : _GL_CMP (c1, c2);
 105         if (cmp != 0)
 106           {
 107             c1 = tolower (c1);
 108             if (c1 == c2)
 109               cmp = 0;
 110             else
 111               {
 112                 c2 = tolower (c2);
 113                 cmp = UCHAR_MAX <= INT_MAX ? c1 - c2 : _GL_CMP (c1, c2);
 114               }
 115           }
 116         if (cmp | !c1 | !--n)
 117           return cmp;
 118       }
 119 }