src/gob-strcase.c

   1 /* c-strcasecmp.c -- case insensitive string comparator in C locale
   2    Copyright (C) 1998-1999, 2005-2006, 2009-2021 Free Software Foundation, Inc.
   3
   4    Character handling in C locale.
   5    Copyright (C) 2000-2003, 2006, 2008-2021 Free Software Foundation, Inc.
   6
   7    Stripped down copy of gnulib c-ctype and c-strcasecmp modules for
   8    conditional fallback use.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2, or (at your option)
  13    any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, see <https://www.gnu.org/licenses/>.  */
  22
  23 #include <config.h>
  24 #include <limits.h>
  25
  26 #undef HAVE_G_ASCII_STRCASECMP
  27 #include "util.h"
  28
  29 /* The functions defined in this file assume the "C" locale and a character
  30    set without diacritics (ASCII-US or EBCDIC-US or something like that).
  31    Even if the "C" locale on a particular system is an extension of the ASCII
  32    character set (like on BeOS, where it is UTF-8, or on AmigaOS, where it
  33    is ISO-8859-1), the functions in this file recognize only the ASCII
  34    characters.  */
  35
  36 #if (' ' == 32) && ('!' == 33) && ('"' == 34) && ('#' == 35) \
  37     && ('%' == 37) && ('&' == 38) && ('\'' == 39) && ('(' == 40) \
  38     && (')' == 41) && ('*' == 42) && ('+' == 43) && (',' == 44) \
  39     && ('-' == 45) && ('.' == 46) && ('/' == 47) && ('0' == 48) \
  40     && ('1' == 49) && ('2' == 50) && ('3' == 51) && ('4' == 52) \
  41     && ('5' == 53) && ('6' == 54) && ('7' == 55) && ('8' == 56) \
  42     && ('9' == 57) && (':' == 58) && (';' == 59) && ('<' == 60) \
  43     && ('=' == 61) && ('>' == 62) && ('?' == 63) && ('A' == 65) \
  44     && ('B' == 66) && ('C' == 67) && ('D' == 68) && ('E' == 69) \
  45     && ('F' == 70) && ('G' == 71) && ('H' == 72) && ('I' == 73) \
  46     && ('J' == 74) && ('K' == 75) && ('L' == 76) && ('M' == 77) \
  47     && ('N' == 78) && ('O' == 79) && ('P' == 80) && ('Q' == 81) \
  48     && ('R' == 82) && ('S' == 83) && ('T' == 84) && ('U' == 85) \
  49     && ('V' == 86) && ('W' == 87) && ('X' == 88) && ('Y' == 89) \
  50     && ('Z' == 90) && ('[' == 91) && ('\\' == 92) && (']' == 93) \
  51     && ('^' == 94) && ('_' == 95) && ('a' == 97) && ('b' == 98) \
  52     && ('c' == 99) && ('d' == 100) && ('e' == 101) && ('f' == 102) \
  53     && ('g' == 103) && ('h' == 104) && ('i' == 105) && ('j' == 106) \
  54     && ('k' == 107) && ('l' == 108) && ('m' == 109) && ('n' == 110) \
  55     && ('o' == 111) && ('p' == 112) && ('q' == 113) && ('r' == 114) \
  56     && ('s' == 115) && ('t' == 116) && ('u' == 117) && ('v' == 118) \
  57     && ('w' == 119) && ('x' == 120) && ('y' == 121) && ('z' == 122) \
  58     && ('{' == 123) && ('|' == 124) && ('}' == 125) && ('~' == 126)
  59 /* The character set is ASCII or one of its variants or extensions, not EBCDIC.
  60    Testing the value of '\n' and '\r' is not relevant.  */
  61 # define C_CTYPE_ASCII 1
  62 #elif ! (' ' == '\x40' && '0' == '\xf0'                     \
  63          && 'A' == '\xc1' && 'J' == '\xd1' && 'S' == '\xe2' \
  64          && 'a' == '\x81' && 'j' == '\x91' && 's' == '\xa2')
  65 # error "Only ASCII and EBCDIC are supported"
  66 #endif
  67
  68 #if 'A' < 0
  69 # error "EBCDIC and char is signed -- not supported"
  70 #endif
  71
  72 /* Cases for lowercase hex letters, and lowercase letters, all offset by N.  */
  73
  74 #define C_CTYPE_LOWER_A_THRU_F_N(N) \
  75    case 'a' + (N): case 'b' + (N): case 'c' + (N): case 'd' + (N): \
  76    case 'e' + (N): case 'f' + (N)
  77 #define C_CTYPE_LOWER_N(N) \
  78    C_CTYPE_LOWER_A_THRU_F_N(N): \
  79    case 'g' + (N): case 'h' + (N): case 'i' + (N): case 'j' + (N): \
  80    case 'k' + (N): case 'l' + (N): case 'm' + (N): case 'n' + (N): \
  81    case 'o' + (N): case 'p' + (N): case 'q' + (N): case 'r' + (N): \
  82    case 's' + (N): case 't' + (N): case 'u' + (N): case 'v' + (N): \
  83    case 'w' + (N): case 'x' + (N): case 'y' + (N): case 'z' + (N)
  84
  85 #define C_CTYPE_LOWER C_CTYPE_LOWER_N(0)
  86 #define C_CTYPE_UPPER C_CTYPE_LOWER_N ('A' - 'a')
  87
  88
  89 /* Function definitions.  */
  90
  91 /* Unlike the functions in <ctype.h>, which require an argument in the range
  92    of the 'unsigned char' type, the functions here operate on values that are
  93    in the 'unsigned char' range or in the 'char' range.  In other words,
  94    when you have a 'char' value, you need to cast it before using it as
  95    argument to a <ctype.h> function:
  96
  97          const char *s = ...;
  98          if (isalpha ((unsigned char) *s)) ...
  99
 100    but you don't need to cast it for the functions defined in this file:
 101
 102          const char *s = ...;
 103          if (c_isalpha (*s)) ...
 104  */
 105
 106 static int c_tolower(int c)
 107 {
 108         switch (c) {
 109         C_CTYPE_UPPER:
 110                 return c - 'A' + 'a';
 111         default:
 112                 return c;
 113         }
 114 }
 115
 116 static int c_toupper(int c)
 117 {
 118         switch (c) {
 119         C_CTYPE_LOWER:
 120                 return c - 'a' + 'A';
 121         default:
 122                 return c;
 123         }
 124 }
 125
 126 char *gob_strup(char *str)
 127 {
 128         char *s;
 129
 130         for (s = str; *s; s++)
 131                 *s = c_toupper(*s);
 132
 133         return str;
 134 }
 135
 136 char *gob_strdown(char *str)
 137 {
 138         char *s;
 139
 140         for (s = str; *s; s++)
 141                 *s = c_tolower(*s);
 142
 143         return str;
 144 }
 145
 146 int gob_strcasecmp(const char *s1, const char *s2)
 147 {
 148         register const unsigned char *p1 = (const unsigned char *)s1;
 149         register const unsigned char *p2 = (const unsigned char *)s2;
 150         unsigned char c1, c2;
 151
 152         if (p1 == p2)
 153                 return 0;
 154
 155         do {
 156                 c1 = c_tolower (*p1);
 157                 c2 = c_tolower (*p2);
 158
 159                 if (c1 == '\0')
 160                         break;
 161
 162                 ++p1;
 163                 ++p2;
 164         } while (c1 == c2);
 165
 166         if (UCHAR_MAX <= INT_MAX) {
 167                 return c1 - c2;
 168         } else {
 169                 /*
 170                  * On machines where 'char' and 'int' are types of the
 171                  * same size, the difference of two 'unsigned char' values
 172                  * - including the sign bit - doesn't fit in an 'int'.
 173                  */
 174                 return _GL_CMP (c1, c2);
 175         }
 176 }