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 <stdint.h>
  20 #include "ucdn.h"
  21
  22 typedef struct {
  23     unsigned char category;
  24     unsigned char combining;
  25     unsigned char bidi_class;
  26     unsigned char east_asian_width;
  27     unsigned char script;
  28     unsigned char linebreak_class;
  29 } UCDRecord;
  30
  31 typedef struct {
  32     unsigned short from, to;
  33 } MirrorPair;
  34
  35 typedef struct {
  36   unsigned short from, to;
  37   unsigned char type;
  38 } BracketPair;
  39
  40 typedef struct {
  41     unsigned int start;
  42     short count, index;
  43 } Reindex;
  44
  45 #include "ucdn_db.h"
  46
  47 /* constants required for Hangul (de)composition */
  48 #define SBASE 0xAC00
  49 #define LBASE 0x1100
  50 #define VBASE 0x1161
  51 #define TBASE 0x11A7
  52 #define SCOUNT 11172
  53 #define LCOUNT 19
  54 #define VCOUNT 21
  55 #define TCOUNT 28
  56 #define NCOUNT (VCOUNT * TCOUNT)
  57
  58 static const UCDRecord *get_ucd_record(uint32_t code)
  59 {
  60     int index, offset;
  61
  62     if (code >= 0x110000)
  63         index = 0;
  64     else {
  65         index  = index0[code >> (SHIFT1+SHIFT2)] << SHIFT1;
  66         offset = (code >> SHIFT2) & ((1<<SHIFT1) - 1);
  67         index  = index1[index + offset] << SHIFT2;
  68         offset = code & ((1<<SHIFT2) - 1);
  69         index  = index2[index + offset];
  70     }
  71
  72     return &ucd_records[index];
  73 }
  74
  75 static const unsigned short *get_decomp_record(uint32_t code)
  76 {
  77     int index, offset;
  78
  79     if (code >= 0x110000)
  80         index = 0;
  81     else {
  82         index  = decomp_index0[code >> (DECOMP_SHIFT1+DECOMP_SHIFT2)]
  83             << DECOMP_SHIFT1;
  84         offset = (code >> DECOMP_SHIFT2) & ((1<<DECOMP_SHIFT1) - 1);
  85         index  = decomp_index1[index + offset] << DECOMP_SHIFT2;
  86         offset = code & ((1<<DECOMP_SHIFT2) - 1);
  87         index  = decomp_index2[index + offset];
  88     }
  89
  90     return &decomp_data[index];
  91 }
  92
  93 static int compare_reindex(const void *a, const void *b)
  94 {
  95     Reindex *ra = (Reindex *)a;
  96     Reindex *rb = (Reindex *)b;
  97
  98     if (ra->start < rb->start)
  99         return -1;
 100     else if (ra->start > (rb->start + rb->count))
 101         return 1;
 102     else
 103         return 0;
 104 }
 105
 106 static int get_comp_index(uint32_t code, const Reindex *idx, size_t len)
 107 {
 108     Reindex *res;
 109     Reindex r = {0, 0, 0};
 110     r.start = code;
 111     res = (Reindex *) bsearch(&r, idx, len, sizeof(Reindex), compare_reindex);
 112
 113     if (res != NULL)
 114         return res->index + (code - res->start);
 115     else
 116         return -1;
 117 }
 118
 119 static int compare_mp(const void *a, const void *b)
 120 {
 121     MirrorPair *mpa = (MirrorPair *)a;
 122     MirrorPair *mpb = (MirrorPair *)b;
 123     return mpa->from - mpb->from;
 124 }
 125
 126 static int compare_bp(const void *a, const void *b)
 127 {
 128     BracketPair *bpa = (BracketPair *)a;
 129     BracketPair *bpb = (BracketPair *)b;
 130     return bpa->from - bpb->from;
 131 }
 132
 133 static BracketPair *search_bp(uint32_t code)
 134 {
 135     BracketPair bp = {0,0,2};
 136     BracketPair *res;
 137
 138     bp.from = code;
 139     res = (BracketPair *) bsearch(&bp, bracket_pairs, BIDI_BRACKET_LEN,
 140                                  sizeof(BracketPair), compare_bp);
 141     return res;
 142 }
 143
 144 static int hangul_pair_decompose(uint32_t code, uint32_t *a, uint32_t *b)
 145 {
 146     int si = code - SBASE;
 147
 148     if (si < 0 || si >= SCOUNT)
 149         return 0;
 150
 151     if (si % TCOUNT) {
 152         /* LV,T */
 153         *a = SBASE + (si / TCOUNT) * TCOUNT;
 154         *b = TBASE + (si % TCOUNT);
 155         return 3;
 156     } else {
 157         /* L,V */
 158         *a = LBASE + (si / NCOUNT);
 159         *b = VBASE + (si % NCOUNT) / TCOUNT;
 160         return 2;
 161     }
 162 }
 163
 164 static int hangul_pair_compose(uint32_t *code, uint32_t a, uint32_t b)
 165 {
 166     if (a >= SBASE && a < (SBASE + SCOUNT) && b >= TBASE && b < (TBASE + TCOUNT)) {
 167         /* LV,T */
 168         *code = a + (b - TBASE);
 169         return 3;
 170     } else if (a >= LBASE && a < (LBASE + LCOUNT) && b >= VBASE && b < (VBASE + VCOUNT)) {
 171         /* L,V */
 172         int li = a - LBASE;
 173         int vi = b - VBASE;
 174         *code = SBASE + li * NCOUNT + vi * TCOUNT;
 175         return 2;
 176     } else {
 177         return 0;
 178     }
 179 }
 180
 181 static uint32_t decode_utf16(const unsigned short **code_ptr)
 182 {
 183     const unsigned short *code = *code_ptr;
 184
 185     if (code[0] < 0xd800 || code[0] > 0xdc00) {
 186         *code_ptr += 1;
 187         return (uint32_t)code[0];
 188     } else {
 189         *code_ptr += 2;
 190         return 0x10000 + ((uint32_t)code[1] - 0xdc00) +
 191             (((uint32_t)code[0] - 0xd800) << 10);
 192     }
 193 }
 194
 195 const char *ucdn_get_unicode_version(void)
 196 {
 197     return UNIDATA_VERSION;
 198 }
 199
 200 int ucdn_get_combining_class(uint32_t code)
 201 {
 202     return get_ucd_record(code)->combining;
 203 }
 204
 205 int ucdn_get_east_asian_width(uint32_t code)
 206 {
 207     return get_ucd_record(code)->east_asian_width;
 208 }
 209
 210 int ucdn_get_general_category(uint32_t code)
 211 {
 212     return get_ucd_record(code)->category;
 213 }
 214
 215 int ucdn_get_bidi_class(uint32_t code)
 216 {
 217     return get_ucd_record(code)->bidi_class;
 218 }
 219
 220 int ucdn_get_mirrored(uint32_t code)
 221 {
 222     return ucdn_mirror(code) != code;
 223 }
 224
 225 int ucdn_get_script(uint32_t code)
 226 {
 227     return get_ucd_record(code)->script;
 228 }
 229
 230 int ucdn_get_linebreak_class(uint32_t code)
 231 {
 232     return get_ucd_record(code)->linebreak_class;
 233 }
 234
 235 int ucdn_get_resolved_linebreak_class(uint32_t code)
 236 {
 237     const UCDRecord *record = get_ucd_record(code);
 238
 239     switch (record->linebreak_class)
 240     {
 241     case UCDN_LINEBREAK_CLASS_AI:
 242     case UCDN_LINEBREAK_CLASS_SG:
 243     case UCDN_LINEBREAK_CLASS_XX:
 244         return UCDN_LINEBREAK_CLASS_AL;
 245
 246     case UCDN_LINEBREAK_CLASS_SA:
 247         if (record->category == UCDN_GENERAL_CATEGORY_MC ||
 248                 record->category == UCDN_GENERAL_CATEGORY_MN)
 249             return UCDN_LINEBREAK_CLASS_CM;
 250         return UCDN_LINEBREAK_CLASS_AL;
 251
 252     case UCDN_LINEBREAK_CLASS_CJ:
 253         return UCDN_LINEBREAK_CLASS_NS;
 254
 255     case UCDN_LINEBREAK_CLASS_CB:
 256         return UCDN_LINEBREAK_CLASS_B2;
 257
 258     case UCDN_LINEBREAK_CLASS_NL:
 259         return UCDN_LINEBREAK_CLASS_BK;
 260
 261     default:
 262         return record->linebreak_class;
 263     }
 264 }
 265
 266 uint32_t ucdn_mirror(uint32_t code)
 267 {
 268     MirrorPair mp = {0};
 269     MirrorPair *res;
 270
 271     mp.from = code;
 272     res = (MirrorPair *) bsearch(&mp, mirror_pairs, BIDI_MIRROR_LEN,
 273                                 sizeof(MirrorPair), compare_mp);
 274
 275     if (res == NULL)
 276         return code;
 277     else
 278         return res->to;
 279 }
 280
 281 uint32_t ucdn_paired_bracket(uint32_t code)
 282 {
 283     BracketPair *res = search_bp(code);
 284     if (res == NULL)
 285         return code;
 286     else
 287         return res->to;
 288 }
 289
 290 int ucdn_paired_bracket_type(uint32_t code)
 291 {
 292     BracketPair *res = search_bp(code);
 293     if (res == NULL)
 294         return UCDN_BIDI_PAIRED_BRACKET_TYPE_NONE;
 295     else
 296         return res->type;
 297 }
 298
 299 int ucdn_decompose(uint32_t code, uint32_t *a, uint32_t *b)
 300 {
 301     const unsigned short *rec;
 302     int len;
 303
 304     if (hangul_pair_decompose(code, a, b))
 305         return 1;
 306
 307     rec = get_decomp_record(code);
 308     len = rec[0] >> 8;
 309
 310     if ((rec[0] & 0xff) != 0 || len == 0)
 311         return 0;
 312
 313     rec++;
 314     *a = decode_utf16(&rec);
 315     if (len > 1)
 316         *b = decode_utf16(&rec);
 317     else
 318         *b = 0;
 319
 320     return 1;
 321 }
 322
 323 int ucdn_compose(uint32_t *code, uint32_t a, uint32_t b)
 324 {
 325     int l, r, index, indexi, offset;
 326
 327     if (hangul_pair_compose(code, a, b))
 328         return 1;
 329
 330     l = get_comp_index(a, nfc_first, sizeof(nfc_first) / sizeof(Reindex));
 331     r = get_comp_index(b, nfc_last, sizeof(nfc_last) / sizeof(Reindex));
 332
 333     if (l < 0 || r < 0)
 334         return 0;
 335
 336     indexi = l * TOTAL_LAST + r;
 337     index  = comp_index0[indexi >> (COMP_SHIFT1+COMP_SHIFT2)] << COMP_SHIFT1;
 338     offset = (indexi >> COMP_SHIFT2) & ((1<<COMP_SHIFT1) - 1);
 339     index  = comp_index1[index + offset] << COMP_SHIFT2;
 340     offset = indexi & ((1<<COMP_SHIFT2) - 1);
 341     *code  = comp_data[index + offset];
 342
 343     return *code != 0;
 344 }
 345
 346 int ucdn_compat_decompose(uint32_t code, uint32_t *decomposed)
 347 {
 348     int i, len;
 349     const unsigned short *rec = get_decomp_record(code);
 350     len = rec[0] >> 8;
 351
 352     if (len == 0)
 353         return 0;
 354
 355     rec++;
 356     for (i = 0; i < len; i++)
 357         decomposed[i] = decode_utf16(&rec);
 358
 359     return len;
 360 }