gl/c-ctype.h

   1 /* Character handling in C locale.
   2
   3    These functions work like the corresponding functions in <ctype.h>,
   4    except that they have the C (POSIX) locale hardwired, whereas the
   5    <ctype.h> functions' behaviour depends on the current locale set via
   6    setlocale.
   7
   8    Copyright (C) 2000-2003, 2006, 2008-2012 Free Software Foundation, Inc.
   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 3 of the License, or
  13 (at your option) 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 <http://www.gnu.org/licenses/>.  */
  22
  23 #ifndef C_CTYPE_H
  24 #define C_CTYPE_H
  25
  26 #include <stdbool.h>
  27
  28
  29 #ifdef __cplusplus
  30 extern "C" {
  31 #endif
  32
  33
  34 /* The functions defined in this file assume the "C" locale and a character
  35    set without diacritics (ASCII-US or EBCDIC-US or something like that).
  36    Even if the "C" locale on a particular system is an extension of the ASCII
  37    character set (like on BeOS, where it is UTF-8, or on AmigaOS, where it
  38    is ISO-8859-1), the functions in this file recognize only the ASCII
  39    characters.  */
  40
  41
  42 /* Check whether the ASCII optimizations apply. */
  43
  44 /* ANSI C89 (and ISO C99 5.2.1.3 too) already guarantees that
  45    '0', '1', ..., '9' have consecutive integer values.  */
  46 #define C_CTYPE_CONSECUTIVE_DIGITS 1
  47
  48 #if ('A' <= 'Z') \
  49     && ('A' + 1 == 'B') && ('B' + 1 == 'C') && ('C' + 1 == 'D') \
  50     && ('D' + 1 == 'E') && ('E' + 1 == 'F') && ('F' + 1 == 'G') \
  51     && ('G' + 1 == 'H') && ('H' + 1 == 'I') && ('I' + 1 == 'J') \
  52     && ('J' + 1 == 'K') && ('K' + 1 == 'L') && ('L' + 1 == 'M') \
  53     && ('M' + 1 == 'N') && ('N' + 1 == 'O') && ('O' + 1 == 'P') \
  54     && ('P' + 1 == 'Q') && ('Q' + 1 == 'R') && ('R' + 1 == 'S') \
  55     && ('S' + 1 == 'T') && ('T' + 1 == 'U') && ('U' + 1 == 'V') \
  56     && ('V' + 1 == 'W') && ('W' + 1 == 'X') && ('X' + 1 == 'Y') \
  57     && ('Y' + 1 == 'Z')
  58 #define C_CTYPE_CONSECUTIVE_UPPERCASE 1
  59 #endif
  60
  61 #if ('a' <= 'z') \
  62     && ('a' + 1 == 'b') && ('b' + 1 == 'c') && ('c' + 1 == 'd') \
  63     && ('d' + 1 == 'e') && ('e' + 1 == 'f') && ('f' + 1 == 'g') \
  64     && ('g' + 1 == 'h') && ('h' + 1 == 'i') && ('i' + 1 == 'j') \
  65     && ('j' + 1 == 'k') && ('k' + 1 == 'l') && ('l' + 1 == 'm') \
  66     && ('m' + 1 == 'n') && ('n' + 1 == 'o') && ('o' + 1 == 'p') \
  67     && ('p' + 1 == 'q') && ('q' + 1 == 'r') && ('r' + 1 == 's') \
  68     && ('s' + 1 == 't') && ('t' + 1 == 'u') && ('u' + 1 == 'v') \
  69     && ('v' + 1 == 'w') && ('w' + 1 == 'x') && ('x' + 1 == 'y') \
  70     && ('y' + 1 == 'z')
  71 #define C_CTYPE_CONSECUTIVE_LOWERCASE 1
  72 #endif
  73
  74 #if (' ' == 32) && ('!' == 33) && ('"' == 34) && ('#' == 35) \
  75     && ('%' == 37) && ('&' == 38) && ('\'' == 39) && ('(' == 40) \
  76     && (')' == 41) && ('*' == 42) && ('+' == 43) && (',' == 44) \
  77     && ('-' == 45) && ('.' == 46) && ('/' == 47) && ('0' == 48) \
  78     && ('1' == 49) && ('2' == 50) && ('3' == 51) && ('4' == 52) \
  79     && ('5' == 53) && ('6' == 54) && ('7' == 55) && ('8' == 56) \
  80     && ('9' == 57) && (':' == 58) && (';' == 59) && ('<' == 60) \
  81     && ('=' == 61) && ('>' == 62) && ('?' == 63) && ('A' == 65) \
  82     && ('B' == 66) && ('C' == 67) && ('D' == 68) && ('E' == 69) \
  83     && ('F' == 70) && ('G' == 71) && ('H' == 72) && ('I' == 73) \
  84     && ('J' == 74) && ('K' == 75) && ('L' == 76) && ('M' == 77) \
  85     && ('N' == 78) && ('O' == 79) && ('P' == 80) && ('Q' == 81) \
  86     && ('R' == 82) && ('S' == 83) && ('T' == 84) && ('U' == 85) \
  87     && ('V' == 86) && ('W' == 87) && ('X' == 88) && ('Y' == 89) \
  88     && ('Z' == 90) && ('[' == 91) && ('\\' == 92) && (']' == 93) \
  89     && ('^' == 94) && ('_' == 95) && ('a' == 97) && ('b' == 98) \
  90     && ('c' == 99) && ('d' == 100) && ('e' == 101) && ('f' == 102) \
  91     && ('g' == 103) && ('h' == 104) && ('i' == 105) && ('j' == 106) \
  92     && ('k' == 107) && ('l' == 108) && ('m' == 109) && ('n' == 110) \
  93     && ('o' == 111) && ('p' == 112) && ('q' == 113) && ('r' == 114) \
  94     && ('s' == 115) && ('t' == 116) && ('u' == 117) && ('v' == 118) \
  95     && ('w' == 119) && ('x' == 120) && ('y' == 121) && ('z' == 122) \
  96     && ('{' == 123) && ('|' == 124) && ('}' == 125) && ('~' == 126)
  97 /* The character set is ASCII or one of its variants or extensions, not EBCDIC.
  98    Testing the value of '\n' and '\r' is not relevant.  */
  99 #define C_CTYPE_ASCII 1
 100 #endif
 101
 102
 103 /* Function declarations. */
 104
 105 /* Unlike the functions in <ctype.h>, which require an argument in the range
 106    of the 'unsigned char' type, the functions here operate on values that are
 107    in the 'unsigned char' range or in the 'char' range.  In other words,
 108    when you have a 'char' value, you need to cast it before using it as
 109    argument to a <ctype.h> function:
 110
 111          const char *s = ...;
 112          if (isalpha ((unsigned char) *s)) ...
 113
 114    but you don't need to cast it for the functions defined in this file:
 115
 116          const char *s = ...;
 117          if (c_isalpha (*s)) ...
 118  */
 119
 120 extern bool c_isascii (int c) _GL_ATTRIBUTE_CONST; /* not locale dependent */
 121
 122 extern bool c_isalnum (int c) _GL_ATTRIBUTE_CONST;
 123 extern bool c_isalpha (int c) _GL_ATTRIBUTE_CONST;
 124 extern bool c_isblank (int c) _GL_ATTRIBUTE_CONST;
 125 extern bool c_iscntrl (int c) _GL_ATTRIBUTE_CONST;
 126 extern bool c_isdigit (int c) _GL_ATTRIBUTE_CONST;
 127 extern bool c_islower (int c) _GL_ATTRIBUTE_CONST;
 128 extern bool c_isgraph (int c) _GL_ATTRIBUTE_CONST;
 129 extern bool c_isprint (int c) _GL_ATTRIBUTE_CONST;
 130 extern bool c_ispunct (int c) _GL_ATTRIBUTE_CONST;
 131 extern bool c_isspace (int c) _GL_ATTRIBUTE_CONST;
 132 extern bool c_isupper (int c) _GL_ATTRIBUTE_CONST;
 133 extern bool c_isxdigit (int c) _GL_ATTRIBUTE_CONST;
 134
 135 extern int c_tolower (int c) _GL_ATTRIBUTE_CONST;
 136 extern int c_toupper (int c) _GL_ATTRIBUTE_CONST;
 137
 138
 139 #if defined __GNUC__ && defined __OPTIMIZE__ && !defined __OPTIMIZE_SIZE__ && !defined NO_C_CTYPE_MACROS
 140
 141 /* ASCII optimizations. */
 142
 143 #undef c_isascii
 144 #define c_isascii(c) \
 145   ({ int __c = (c); \
 146      (__c >= 0x00 && __c <= 0x7f); \
 147    })
 148
 149 #if C_CTYPE_CONSECUTIVE_DIGITS \
 150     && C_CTYPE_CONSECUTIVE_UPPERCASE && C_CTYPE_CONSECUTIVE_LOWERCASE
 151 #if C_CTYPE_ASCII
 152 #undef c_isalnum
 153 #define c_isalnum(c) \
 154   ({ int __c = (c); \
 155      ((__c >= '0' && __c <= '9') \
 156       || ((__c & ~0x20) >= 'A' && (__c & ~0x20) <= 'Z')); \
 157    })
 158 #else
 159 #undef c_isalnum
 160 #define c_isalnum(c) \
 161   ({ int __c = (c); \
 162      ((__c >= '0' && __c <= '9') \
 163       || (__c >= 'A' && __c <= 'Z') \
 164       || (__c >= 'a' && __c <= 'z')); \
 165    })
 166 #endif
 167 #endif
 168
 169 #if C_CTYPE_CONSECUTIVE_UPPERCASE && C_CTYPE_CONSECUTIVE_LOWERCASE
 170 #if C_CTYPE_ASCII
 171 #undef c_isalpha
 172 #define c_isalpha(c) \
 173   ({ int __c = (c); \
 174      ((__c & ~0x20) >= 'A' && (__c & ~0x20) <= 'Z'); \
 175    })
 176 #else
 177 #undef c_isalpha
 178 #define c_isalpha(c) \
 179   ({ int __c = (c); \
 180      ((__c >= 'A' && __c <= 'Z') || (__c >= 'a' && __c <= 'z')); \
 181    })
 182 #endif
 183 #endif
 184
 185 #undef c_isblank
 186 #define c_isblank(c) \
 187   ({ int __c = (c); \
 188      (__c == ' ' || __c == '\t'); \
 189    })
 190
 191 #if C_CTYPE_ASCII
 192 #undef c_iscntrl
 193 #define c_iscntrl(c) \
 194   ({ int __c = (c); \
 195      ((__c & ~0x1f) == 0 || __c == 0x7f); \
 196    })
 197 #endif
 198
 199 #if C_CTYPE_CONSECUTIVE_DIGITS
 200 #undef c_isdigit
 201 #define c_isdigit(c) \
 202   ({ int __c = (c); \
 203      (__c >= '0' && __c <= '9'); \
 204    })
 205 #endif
 206
 207 #if C_CTYPE_CONSECUTIVE_LOWERCASE
 208 #undef c_islower
 209 #define c_islower(c) \
 210   ({ int __c = (c); \
 211      (__c >= 'a' && __c <= 'z'); \
 212    })
 213 #endif
 214
 215 #if C_CTYPE_ASCII
 216 #undef c_isgraph
 217 #define c_isgraph(c) \
 218   ({ int __c = (c); \
 219      (__c >= '!' && __c <= '~'); \
 220    })
 221 #endif
 222
 223 #if C_CTYPE_ASCII
 224 #undef c_isprint
 225 #define c_isprint(c) \
 226   ({ int __c = (c); \
 227      (__c >= ' ' && __c <= '~'); \
 228    })
 229 #endif
 230
 231 #if C_CTYPE_ASCII
 232 #undef c_ispunct
 233 #define c_ispunct(c) \
 234   ({ int _c = (c); \
 235      (c_isgraph (_c) && ! c_isalnum (_c)); \
 236    })
 237 #endif
 238
 239 #undef c_isspace
 240 #define c_isspace(c) \
 241   ({ int __c = (c); \
 242      (__c == ' ' || __c == '\t' \
 243       || __c == '\n' || __c == '\v' || __c == '\f' || __c == '\r'); \
 244    })
 245
 246 #if C_CTYPE_CONSECUTIVE_UPPERCASE
 247 #undef c_isupper
 248 #define c_isupper(c) \
 249   ({ int __c = (c); \
 250      (__c >= 'A' && __c <= 'Z'); \
 251    })
 252 #endif
 253
 254 #if C_CTYPE_CONSECUTIVE_DIGITS \
 255     && C_CTYPE_CONSECUTIVE_UPPERCASE && C_CTYPE_CONSECUTIVE_LOWERCASE
 256 #if C_CTYPE_ASCII
 257 #undef c_isxdigit
 258 #define c_isxdigit(c) \
 259   ({ int __c = (c); \
 260      ((__c >= '0' && __c <= '9') \
 261       || ((__c & ~0x20) >= 'A' && (__c & ~0x20) <= 'F')); \
 262    })
 263 #else
 264 #undef c_isxdigit
 265 #define c_isxdigit(c) \
 266   ({ int __c = (c); \
 267      ((__c >= '0' && __c <= '9') \
 268       || (__c >= 'A' && __c <= 'F') \
 269       || (__c >= 'a' && __c <= 'f')); \
 270    })
 271 #endif
 272 #endif
 273
 274 #if C_CTYPE_CONSECUTIVE_UPPERCASE && C_CTYPE_CONSECUTIVE_LOWERCASE
 275 #undef c_tolower
 276 #define c_tolower(c) \
 277   ({ int __c = (c); \
 278      (__c >= 'A' && __c <= 'Z' ? __c - 'A' + 'a' : __c); \
 279    })
 280 #undef c_toupper
 281 #define c_toupper(c) \
 282   ({ int __c = (c); \
 283      (__c >= 'a' && __c <= 'z' ? __c - 'a' + 'A' : __c); \
 284    })
 285 #endif
 286
 287 #endif /* optimizing for speed */
 288
 289
 290 #ifdef __cplusplus
 291 }
 292 #endif
 293
 294 #endif /* C_CTYPE_H */