src/character.h

   1 /* character.h -- header file for the character module.
   2    Copyright (C) 2003, 2004
   3      National Institute of Advanced Industrial Science and Technology (AIST)
   4      Registration Number H15PRO112
   5
   6    This file is part of the m17n library.
   7
   8    The m17n library is free software; you can redistribute it and/or
   9    modify it under the terms of the GNU Lesser General Public License
  10    as published by the Free Software Foundation; either version 2.1 of
  11    the License, or (at your option) any later version.
  12
  13    The m17n library is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16    Lesser General Public License for more details.
  17
  18    You should have received a copy of the GNU Lesser General Public
  19    License along with the m17n library; if not, write to the Free
  20    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  21    02111-1307, USA.  */
  22
  23 #ifndef _M17N_CHARACTER_H_
  24 #define _M17N_CHARACTER_H_
  25
  26 /*  UTF-8 format
  27
  28          0-7F           0xxxxxxx
  29         80-7FF          110xxxxx 10xxxxxx
  30        800-FFFF         1110xxxx 10xxxxxx 10xxxxxx
  31      10000-1FFFFF       11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
  32     200000-3FFFFFF      111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
  33    4000000-7FFFFFFF     1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
  34
  35    Unicode range:
  36      0-10FFFF   0 - 11110uuu 10uuxxxx 10xxxxxx 10xxxxxx (uuuuu <= 0x10)
  37
  38 */
  39
  40 #define MAX_UTF8_CHAR_BYTES 6
  41 #define MAX_UNICODE_CHAR_BYTES 4
  42
  43 /* Return how many units (char, short, or int) C will occupy in
  44    MText->data.  */
  45
  46 #define CHAR_UNITS_ASCII(c) ((c) < 0x80)
  47
  48 #define CHAR_UNITS_UTF8(c)      \
  49   ((c) < 0x80 ? 1               \
  50    : (c) < 0x800 ? 2            \
  51    : (c) < 0x10000 ? 3          \
  52    : (c) < 0x200000 ? 4         \
  53    : (c) < 0x4000000 ? 5        \
  54    : 6)
  55
  56 #define CHAR_UNITS_UTF16(c)     \
  57   ((c) < 0x10000 ? 1            \
  58    : (c) < 0x110000 ? 2         \
  59    : 0)
  60
  61
  62 #define CHAR_UNITS_UTF32(c) 1
  63
  64 #define CHAR_UNITS(c, format)                                   \
  65   ((c) < 0x80 ? 1                                               \
  66    : (format) == MTEXT_FORMAT_UTF8 ? CHAR_UNITS_UTF8 (c)        \
  67    : (format) == MTEXT_FORMAT_UTF16 ? CHAR_UNITS_UTF16 (c)      \
  68    : (format) == MTEXT_FORMAT_ASCII ? 0                         \
  69    : CHAR_UNITS_UTF32 (c))
  70
  71 #define CHAR_BYTES CHAR_UNITS_UTF8
  72
  73 #define CHAR_UNITS_AT_UTF8(p)   \
  74   (!(*(p) & 0x80) ? 1           \
  75    : !(*(p) & 0x20) ? 2         \
  76    : !(*(p) & 0x10) ? 3         \
  77    : !(*(p) & 0x08) ? 4         \
  78    : !(*(p) & 0x04) ? 5         \
  79    : !(*(p) & 0x02) ? 6         \
  80    : 0)
  81
  82 #define CHAR_UNITS_AT_UTF16(p)                  \
  83   (2 - (*(unsigned short *) (p) < 0xD800        \
  84         || *(unsigned short *) (p) >= 0xDC00))
  85
  86 #define CHAR_UNITS_AT(c, format)                                \
  87   ((format) == MTEXT_FORMAT_UTF16 ? CHAR_UNITS_AT_UTF16 (c)     \
  88    : (format) == MTEXT_FORMAT_UTF8 ? CHAR_UNITS_AT_UTF8 (c)     \
  89    : 1)
  90
  91 #define CHAR_BYTES_AT CHAR_UNITS_AT_UTF8
  92
  93 #define CHAR_UNITS_BY_HEAD_UTF8(c)      \
  94   (!((c) & 0x80) ? 1                    \
  95    : !((c) & 0x20) ? 2                  \
  96    : !((c) & 0x10) ? 3                  \
  97    : !((c) & 0x08) ? 4                  \
  98    : !((c) & 0x04) ? 5                  \
  99    : !((c) & 0x02) ? 6                  \
 100    : 0)
 101
 102 #define CHAR_UNITS_BY_HEAD_UTF16(c)     \
 103   (2 - ((unsigned short) (c) < 0xD800 || (unsigned short) (c) >= 0xDC00))
 104
 105 #define CHAR_UNITS_BY_HEAD(c, format)                                   \
 106   ((format) == MTEXT_FORMAT_UTF16 ? CHAR_UNITS_BY_HEAD_UTF16 (c)        \
 107    : (format) == MTEXT_FORMAT_UTF8 ? CHAR_UNITS_BY_HEAD_UTF8 (c)        \
 108    : 1)
 109
 110 #define CHAR_BYTES_BY_HEAD CHAR_UNITS_BY_HEAD_UTF8
 111
 112 #define STRING_CHAR_UTF8(p)                             \
 113   (!((p)[0] & 0x80) ? (p)[0]                            \
 114    : !((p)[0] & 0x20) ? ((((p)[0] & 0x1F) << 6)         \
 115                          | ((p)[1] & 0x3F))             \
 116    : !((p)[0] & 0x10) ? ((((p)[0] & 0x0F) << 12)        \
 117                          | (((p)[1] & 0x3F) << 6)       \
 118                          | ((p)[2] & 0x3F))             \
 119    : !((p)[0] & 0x08) ? ((((p)[0] & 0x07) << 18)        \
 120                          | (((p)[1] & 0x3F) << 12)      \
 121                          | (((p)[2] & 0x3F) << 6)       \
 122                          | ((p)[3] & 0x3F))             \
 123    : !((p)[0] & 0x04) ? ((((p)[0] & 0x03) << 24)        \
 124                          | (((p)[1] & 0x3F) << 18)      \
 125                          | (((p)[2] & 0x3F) << 12)      \
 126                          | (((p)[3] & 0x3F) << 6)       \
 127                          | ((p)[4] & 0x3F))             \
 128    : ((((p)[0] & 0x01) << 30)                           \
 129       | (((p)[1] & 0x3F) << 24)                         \
 130       | (((p)[2] & 0x3F) << 18)                         \
 131       | (((p)[3] & 0x3F) << 12)                         \
 132       | (((p)[4] & 0x3F) << 6)                          \
 133       | ((p)[5] & 0x3F)))
 134
 135 #define STRING_CHAR_UTF16(p)                                               \
 136   (((unsigned short) (p)[0] < 0xD800 || (unsigned short) (p)[0] >= 0xDC00) \
 137    ? (p)[0]                                                                \
 138    : ((((p)[0] - 0xD800) << 10) + ((p)[1] - 0xDC00) + 0x10000))
 139
 140
 141 #define STRING_CHAR STRING_CHAR_UTF8
 142
 143
 144 #define STRING_CHAR_ADVANCE_UTF8(p)                     \
 145   (!(*(p) & 0x80) ? *(p)++                              \
 146    : !(*(p) & 0x20) ? (((*(p)++ & 0x1F) << 6)           \
 147                        | (*(p)++ & 0x3F))               \
 148    : !(*(p) & 0x10) ? (((*(p)++ & 0x0F) << 12)          \
 149                        | ((*(p)++ & 0x3F) << 6)         \
 150                        | (*(p)++ & 0x3F))               \
 151    : !(*(p) & 0x08) ? (((*(p)++ & 0x07) << 18)          \
 152                        | ((*(p)++ & 0x3F) << 12)        \
 153                        | ((*(p)++ & 0x3F) << 6)         \
 154                        | (*(p)++ & 0x3F))               \
 155    : !(*(p) & 0x04) ? (((*(p)++ & 0x03) << 24)          \
 156                        | ((*(p)++ & 0x3F) << 18)        \
 157                        | ((*(p)++ & 0x3F) << 12)        \
 158                        | ((*(p)++ & 0x3F) << 6)         \
 159                        | (*(p)++ & 0x3F))               \
 160    : (((*(p)++ & 0x01) << 30)                           \
 161       | ((*(p)++ & 0x3F) << 24)                         \
 162       | ((*(p)++ & 0x3F) << 18)                         \
 163       | ((*(p)++ & 0x3F) << 12)                         \
 164       | ((*(p)++ & 0x3F) << 6)                          \
 165       | (*(p)++ & 0x3F)))
 166
 167 #define STRING_CHAR_ADVANCE_UTF16(p)                                       \
 168   (((unsigned short) (p)[0] < 0xD800 || (unsigned short) (p)[0] >= 0xDC00) \
 169    ? *(p)++                                                                \
 170    : (((*(p)++ - 0xD800) << 10) + (*(p)++ - 0xDC00) + 0x10000))
 171
 172 #define STRING_CHAR_ADVANCE STRING_CHAR_ADVANCE_UTF8
 173
 174 #define STRING_CHAR_AND_UNITS_UTF8(p, bytes)            \
 175   (!((p)[0] & 0x80) ? ((bytes) = 1, (p)[0])             \
 176    : !((p)[0] & 0x20) ? ((bytes) = 2,                   \
 177                          ((((p)[0] & 0x1F) << 6)        \
 178                           | ((p)[1] & 0x3F)))           \
 179    : !((p)[0] & 0x10) ? ((bytes) = 3,                   \
 180                          ((((p)[0] & 0x0F) << 12)       \
 181                           | (((p)[1] & 0x3F) << 6)      \
 182                           | ((p)[2] & 0x3F)))           \
 183    : !((p)[0] & 0x08) ? ((bytes) = 4,                   \
 184                          ((((p)[0] & 0x07) << 18)       \
 185                           | (((p)[1] & 0x3F) << 12)     \
 186                           | (((p)[2] & 0x3F) << 6)      \
 187                           | ((p)[3] & 0x3F)))           \
 188    : !((p)[0] & 0x04) ? ((bytes) = 5,                   \
 189                          ((((p)[0] & 0x03) << 24)       \
 190                           | (((p)[1] & 0x3F) << 18)     \
 191                           | (((p)[2] & 0x3F) << 12)     \
 192                           | (((p)[3] & 0x3F) << 6)      \
 193                           | ((p)[4] & 0x3F)))           \
 194    : ((bytes) = 6,                                      \
 195       ((((p)[0] & 0x01) << 30)                          \
 196        | (((p)[1] & 0x3F) << 24)                        \
 197        | (((p)[2] & 0x3F) << 18)                        \
 198        | (((p)[3] & 0x3F) << 12)                        \
 199        | (((p)[4] & 0x3F) << 6)                         \
 200        | ((p)[5] & 0x3F))))
 201
 202 #define STRING_CHAR_AND_UNITS_UTF16(p, units)                              \
 203   (((unsigned short) (p)[0] < 0xD800 || (unsigned short) (p)[0] >= 0xDC00) \
 204    ? ((units) = 1, (p)[0])                                                 \
 205    : ((units) = 2,                                                         \
 206       (((p)[0] - 0xD800) << 10) + ((p)[1] - 0xDC00) + 0x10000))
 207
 208 #define STRING_CHAR_AND_UNITS(p, units, format) \
 209   ((format) == MTEXT_FORMAT_UTF16               \
 210    ? STRING_CHAR_AND_UNITS_UTF16 (p, units)     \
 211    : (format) == MTEXT_FORMAT_UTF8              \
 212    ? STRING_CHAR_AND_UNITS_UTF8 (p, units)      \
 213    : ((units) = 1, (p)[0]))
 214
 215
 216 #define STRING_CHAR_AND_BYTES STRING_CHAR_AND_UNITS_UTF8
 217
 218 #define CHAR_STRING_UTF8(c, p)                                          \
 219   ((c) < 0x80                                                           \
 220    ? ((p)[0] = (c), 1)                                                  \
 221    : (c) < 0x800 ? ((p)[0] = (0xC0 | ((c) >> 6)),                       \
 222                     (p)[1] = (0x80 | ((c) & 0x3F)),                     \
 223                     2)                                                  \
 224    : (c) < 0x10000 ? ((p)[0] = (0xE0 | ((c) >> 12)),                    \
 225                       (p)[1] = (0x80 | (((c) >> 6) & 0x3F)),            \
 226                       (p)[2] = (0x80 | ((c) & 0x3F)),                   \
 227                       3)                                                \
 228    : (c) < 0x200000 ? ((p)[0] = (0xF0 | ((c) >> 18)),                   \
 229                        (p)[1] = (0x80 | (((c) >> 12) & 0x3F)),          \
 230                        (p)[2] = (0x80 | (((c) >> 6) & 0x3F)),           \
 231                        (p)[3] = (0x80 | ((c) & 0x3F)),                  \
 232                        4)                                               \
 233    : (c) < 0x4000000 ? ((p)[0] = 0xF8,                                  \
 234                         (p)[1] = (0x80 | ((c) >> 18)),                  \
 235                         (p)[2] = (0x80 | (((c) >> 12) & 0x3F)),         \
 236                         (p)[3] = (0x80 | (((c) >> 6) & 0x3F)),          \
 237                         (p)[4] = (0x80 | ((c) & 0x3F)),                 \
 238                         5)                                              \
 239    : ((p)[0] = (0xFC | ((c) >> 30)),                                    \
 240       (p)[1] = (0x80 | (((c) >> 24) & 0x3F)),                           \
 241       (p)[2] = (0x80 | (((c) >> 18) & 0x3F)),                           \
 242       (p)[3] = (0x80 | (((c) >> 12) & 0x3F)),                           \
 243       (p)[4] = (0x80 | (((c) >> 6) & 0x3F)),                            \
 244       (p)[5] = (0x80 | ((c) & 0x3F)),                                   \
 245       6))
 246
 247 #define CHAR_STRING_UTF16(c, p)                 \
 248   ((c) < 0x10000 ? (p)[0] = (c), 1                      \
 249    ? (p[0] = (((c) - 0x10000) >> 10) + 0xD800,          \
 250       p[1] = (((c) - 0x10000) & 0x3FF) + 0xDC00,        \
 251       2))
 252
 253 #define CHAR_STRING CHAR_STRING_UTF8
 254
 255 #define CHAR_HEAD_P_UTF8(p)     \
 256   ((*(p) & 0xC0) != 0x80)
 257
 258 #define CHAR_HEAD_P_UTF16(p)            \
 259   (*(unsigned short *) (p) < 0xDC00     \
 260    || *(unsigned short *) (p) >= 0xE000)
 261
 262 #define CHAR_HEAD_P CHAR_HEAD_P_UTF8
 263
 264 /** Locale-safe version of tolower ().  It works only for an ASCII
 265     character.  */
 266 #define TOLOWER(c)  (((c) >= 'A' && (c) <= 'Z') ? (c) + 32 : (c))
 267
 268 /** Locale-safe version of toupper ().  It works only for an ASCII
 269     character.  */
 270 #define TOUPPER(c)  (((c) >= 'a' && (c) <= 'z') ? (c) - 32 : (c))
 271
 272 /** Locale-safe version of isupper ().  It works only for an ASCII
 273     character.  */
 274 #define ISUPPER(c) ((c) >= 'A' && (c) <= 'Z')
 275
 276 /** Locale-safe version of isalnum ().  It works only for an ASCII
 277     character.  */
 278 #define ISALNUM(c)                      \
 279   (((c) >= 'A' && (c) <= 'Z')           \
 280    || ((c) >= 'a' && (c) <= 'z')        \
 281    || ((c) >= '0' && (c) <= '9'))
 282
 283 #endif /* not _M17N_CHARACTER_H_ */