src/hb-ucdn/ucdn.c

   1 /*
   2  * Copyright (C) 2012 Grigori Goronzy <greg@kinoho.net>
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include "ucdn.h"
  20
  21 typedef struct {
  22     unsigned char category;
  23     unsigned char combining;
  24     unsigned char bidi_class;
  25     unsigned char mirrored;
  26     unsigned char east_asian_width;
  27     unsigned char normalization_check;
  28     unsigned char script;
  29 } UCDRecord;
  30
  31 typedef struct {
  32     unsigned short from, to;
  33 } MirrorPair;
  34
  35 typedef struct {
  36     unsigned int start;
  37     short count, index;
  38 } Reindex;
  39
  40 #include "unicodedata_db.h"
  41
  42 /* constants required for Hangul (de)composition */
  43 #define SBASE 0xAC00
  44 #define LBASE 0x1100
  45 #define VBASE 0x1161
  46 #define TBASE 0x11A7
  47 #define SCOUNT 11172
  48 #define LCOUNT 19
  49 #define VCOUNT 21
  50 #define TCOUNT 28
  51 #define NCOUNT (VCOUNT * TCOUNT)
  52
  53 static const UCDRecord *get_ucd_record(uint32_t code)
  54 {
  55     int index, offset;
  56
  57     if (code >= 0x110000)
  58         index = 0;
  59     else {
  60         index  = index0[code >> (SHIFT1+SHIFT2)] << SHIFT1;
  61         offset = (code >> SHIFT2) & ((1<<SHIFT1) - 1);
  62         index  = index1[index + offset] << SHIFT2;
  63         offset = code & ((1<<SHIFT2) - 1);
  64         index  = index2[index + offset];
  65     }
  66
  67     return &ucd_records[index];
  68 }
  69
  70 static const unsigned short *get_decomp_record(uint32_t code)
  71 {
  72     int index, offset;
  73
  74     if (code >= 0x110000)
  75         index = 0;
  76     else {
  77         index  = decomp_index0[code >> (DECOMP_SHIFT1+DECOMP_SHIFT2)]
  78             << DECOMP_SHIFT1;
  79         offset = (code >> DECOMP_SHIFT2) & ((1<<DECOMP_SHIFT1) - 1);
  80         index  = decomp_index1[index + offset] << DECOMP_SHIFT2;
  81         offset = code & ((1<<DECOMP_SHIFT2) - 1);
  82         index  = decomp_index2[index + offset];
  83     }
  84
  85     return &decomp_data[index];
  86 }
  87
  88 static int get_comp_index(uint32_t code, const Reindex *idx)
  89 {
  90     int i;
  91
  92     for (i = 0; idx[i].start; i++) {
  93         const Reindex *cur = &idx[i];
  94         if (code < cur->start)
  95             return -1;
  96         if (code <= cur->start + cur->count) {
  97             return cur->index + (code - cur->start);
  98         }
  99     }
 100
 101     return -1;
 102 }
 103
 104 static int compare_mp(const void *a, const void *b)
 105 {
 106     MirrorPair *mpa = (MirrorPair *)a;
 107     MirrorPair *mpb = (MirrorPair *)b;
 108     return mpa->from - mpb->from;
 109 }
 110
 111 static int hangul_pair_decompose(uint32_t code, uint32_t *a, uint32_t *b)
 112 {
 113     int si = code - SBASE;
 114
 115     if (si < 0 || si >= SCOUNT)
 116         return 0;
 117
 118     if (si % TCOUNT) {
 119         /* LV,T */
 120         *a = SBASE + (si / TCOUNT) * TCOUNT;
 121         *b = TBASE + (si % TCOUNT);
 122         return 3;
 123     } else {
 124         /* L,V */
 125         *a = LBASE + (si / NCOUNT);
 126         *b = VBASE + (si % NCOUNT) / TCOUNT;
 127         return 2;
 128     }
 129 }
 130
 131 static int hangul_pair_compose(uint32_t *code, uint32_t a, uint32_t b)
 132 {
 133     if (b < VBASE || b >= (TBASE + TCOUNT))
 134         return 0;
 135
 136     if ((a < LBASE || a >= (LBASE + LCOUNT))
 137             && (a < SBASE || a >= (SBASE + SCOUNT)))
 138         return 0;
 139
 140     if (a >= SBASE) {
 141         /* LV,T */
 142         *code = a + (b - TBASE);
 143         return 3;
 144     } else {
 145         /* L,V */
 146         int li = a - LBASE;
 147         int vi = b - VBASE;
 148         *code = SBASE + li * NCOUNT + vi * TCOUNT;
 149         return 2;
 150     }
 151 }
 152
 153 static uint32_t decode_utf16(const unsigned short **code_ptr)
 154 {
 155     const unsigned short *code = *code_ptr;
 156
 157     if ((code[0] & 0xd800) != 0xd800) {
 158         *code_ptr += 1;
 159         return (uint32_t)code[0];
 160     } else {
 161         *code_ptr += 2;
 162         return 0x10000 + ((uint32_t)code[1] - 0xdc00) +
 163             (((uint32_t)code[0] - 0xd800) << 10);
 164     }
 165 }
 166
 167 const char *ucdn_get_unicode_version(void)
 168 {
 169     return UNIDATA_VERSION;
 170 }
 171
 172 int ucdn_get_combining_class(uint32_t code)
 173 {
 174     return get_ucd_record(code)->combining;
 175 }
 176
 177 int ucdn_get_east_asian_width(uint32_t code)
 178 {
 179     return get_ucd_record(code)->east_asian_width;
 180 }
 181
 182 int ucdn_get_general_category(uint32_t code)
 183 {
 184     return get_ucd_record(code)->category;
 185 }
 186
 187 int ucdn_get_bidi_class(uint32_t code)
 188 {
 189     return get_ucd_record(code)->bidi_class;
 190 }
 191
 192 int ucdn_get_mirrored(uint32_t code)
 193 {
 194     return get_ucd_record(code)->mirrored;
 195 }
 196
 197 int ucdn_get_script(uint32_t code)
 198 {
 199     return get_ucd_record(code)->script;
 200 }
 201
 202 uint32_t ucdn_mirror(uint32_t code)
 203 {
 204     MirrorPair mp = {0};
 205     MirrorPair *res;
 206
 207     if (get_ucd_record(code)->mirrored == 0)
 208         return code;
 209
 210     mp.from = code;
 211     res = bsearch(&mp, mirror_pairs, BIDI_MIRROR_LEN, sizeof(MirrorPair),
 212             compare_mp);
 213
 214     if (res == NULL)
 215         return code;
 216     else
 217         return res->to;
 218 }
 219
 220 int ucdn_decompose(uint32_t code, uint32_t *a, uint32_t *b)
 221 {
 222     const unsigned short *rec;
 223     int len;
 224
 225     if (hangul_pair_decompose(code, a, b))
 226         return 1;
 227
 228     rec = get_decomp_record(code);
 229     len = rec[0] >> 8;
 230
 231     if ((rec[0] & 0xff) != 0 || len == 0)
 232         return 0;
 233
 234     rec++;
 235     *a = decode_utf16(&rec);
 236     if (len > 1)
 237         *b = decode_utf16(&rec);
 238     else
 239         *b = 0;
 240
 241     return 1;
 242 }
 243
 244 int ucdn_compose(uint32_t *code, uint32_t a, uint32_t b)
 245 {
 246     int l, r, index, indexi, offset;
 247
 248     if (hangul_pair_compose(code, a, b))
 249         return 1;
 250
 251     l = get_comp_index(a, nfc_first);
 252     r = get_comp_index(b, nfc_last);
 253
 254     if (l < 0 || r < 0)
 255         return 0;
 256
 257     indexi = l * TOTAL_LAST + r;
 258     index  = comp_index0[indexi >> (COMP_SHIFT1+COMP_SHIFT2)] << COMP_SHIFT1;
 259     offset = (indexi >> COMP_SHIFT2) & ((1<<COMP_SHIFT1) - 1);
 260     index  = comp_index1[index + offset] << COMP_SHIFT2;
 261     offset = indexi & ((1<<COMP_SHIFT2) - 1);
 262     *code  = comp_data[index + offset];
 263
 264     return *code != 0;
 265 }
 266
 267 int ucdn_compat_decompose(uint32_t code, uint32_t *decomposed)
 268 {
 269     int i, len;
 270     const unsigned short *rec = get_decomp_record(code);
 271     len = rec[0] >> 8;
 272
 273     if (len == 0)
 274         return 0;
 275
 276     rec++;
 277     for (i = 0; i < len; i++)
 278         decomposed[i] = decode_utf16(&rec);
 279
 280     return len;
 281 }