kc3-lang/harfbuzz/src/hb-ucdn/ucdn.c

• Show log

  Commit

• Hash : 0faa16a2
  Author :
  Date : 2017-10-02T17:15:46
  

  [ucdn] Update to Unicode 10
  
  Update to commit c000ebf79c095a7d58cf90090bde5715592c4834
  plus this bug-fix: https://github.com/grigorig/ucdn/issues/18
  

Download

• src/hb-ucdn/ucdn.c

• /*
   * Copyright (C) 2012 Grigori Goronzy <greg@kinoho.net>
   *
   * Permission to use, copy, modify, and/or distribute this software for any
   * purpose with or without fee is hereby granted, provided that the above
   * copyright notice and this permission notice appear in all copies.
   *
   * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
   * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
   * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
   * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
   */
  
  #include <stdio.h>
  #include <stdlib.h>
  #include <stdint.h>
  #include "ucdn.h"
  
  typedef struct {
      unsigned char category;
      unsigned char combining;
      unsigned char bidi_class;
      unsigned char east_asian_width;
      unsigned char script;
      unsigned char linebreak_class;
  } UCDRecord;
  
  typedef struct {
      unsigned short from, to;
  } MirrorPair;
  
  typedef struct {
    unsigned short from, to;
    unsigned char type;
  } BracketPair;
  
  typedef struct {
      unsigned int start;
      short count, index;
  } Reindex;
  
  #include "ucdn_db.h"
  
  /* constants required for Hangul (de)composition */
  #define SBASE 0xAC00
  #define LBASE 0x1100
  #define VBASE 0x1161
  #define TBASE 0x11A7
  #define SCOUNT 11172
  #define LCOUNT 19
  #define VCOUNT 21
  #define TCOUNT 28
  #define NCOUNT (VCOUNT * TCOUNT)
  
  static const UCDRecord *get_ucd_record(uint32_t code)
  {
      int index, offset;
  
      if (code >= 0x110000)
          index = 0;
      else {
          index  = index0[code >> (SHIFT1+SHIFT2)] << SHIFT1;
          offset = (code >> SHIFT2) & ((1<<SHIFT1) - 1);
          index  = index1[index + offset] << SHIFT2;
          offset = code & ((1<<SHIFT2) - 1);
          index  = index2[index + offset];
      }
  
      return &ucd_records[index];
  }
  
  static const unsigned short *get_decomp_record(uint32_t code)
  {
      int index, offset;
  
      if (code >= 0x110000)
          index = 0;
      else {
          index  = decomp_index0[code >> (DECOMP_SHIFT1+DECOMP_SHIFT2)]
              << DECOMP_SHIFT1;
          offset = (code >> DECOMP_SHIFT2) & ((1<<DECOMP_SHIFT1) - 1);
          index  = decomp_index1[index + offset] << DECOMP_SHIFT2;
          offset = code & ((1<<DECOMP_SHIFT2) - 1);
          index  = decomp_index2[index + offset];
      }
  
      return &decomp_data[index];
  }
  
  static int compare_reindex(const void *a, const void *b)
  {
      Reindex *ra = (Reindex *)a;
      Reindex *rb = (Reindex *)b;
  
      if (ra->start < rb->start)
          return -1;
      else if (ra->start > (rb->start + rb->count))
          return 1;
      else
          return 0;
  }
  
  static int get_comp_index(uint32_t code, const Reindex *idx, size_t len)
  {
      Reindex *res;
      Reindex r = {0, 0, 0};
      r.start = code;
      res = (Reindex *) bsearch(&r, idx, len, sizeof(Reindex), compare_reindex);
  
      if (res != NULL)
          return res->index + (code - res->start);
      else
          return -1;
  }
  
  static int compare_mp(const void *a, const void *b)
  {
      MirrorPair *mpa = (MirrorPair *)a;
      MirrorPair *mpb = (MirrorPair *)b;
      return mpa->from - mpb->from;
  }
  
  static int compare_bp(const void *a, const void *b)
  {
      BracketPair *bpa = (BracketPair *)a;
      BracketPair *bpb = (BracketPair *)b;
      return bpa->from - bpb->from;
  }
  
  static BracketPair *search_bp(uint32_t code)
  {
      BracketPair bp = {0,0,2};
      BracketPair *res;
  
      bp.from = code;
      res = (BracketPair *) bsearch(&bp, bracket_pairs, BIDI_BRACKET_LEN,
                                   sizeof(BracketPair), compare_bp);
      return res;
  }
  
  static int hangul_pair_decompose(uint32_t code, uint32_t *a, uint32_t *b)
  {
      int si = code - SBASE;
  
      if (si < 0 || si >= SCOUNT)
          return 0;
  
      if (si % TCOUNT) {
          /* LV,T */
          *a = SBASE + (si / TCOUNT) * TCOUNT;
          *b = TBASE + (si % TCOUNT);
          return 3;
      } else {
          /* L,V */
          *a = LBASE + (si / NCOUNT);
          *b = VBASE + (si % NCOUNT) / TCOUNT;
          return 2;
      }
  }
  
  static int hangul_pair_compose(uint32_t *code, uint32_t a, uint32_t b)
  {
      if (a >= SBASE && a < (SBASE + SCOUNT) && b >= TBASE && b < (TBASE + TCOUNT)) {
          /* LV,T */
          *code = a + (b - TBASE);
          return 3;
      } else if (a >= LBASE && a < (LBASE + LCOUNT) && b >= VBASE && b < (VBASE + VCOUNT)) {
          /* L,V */
          int li = a - LBASE;
          int vi = b - VBASE;
          *code = SBASE + li * NCOUNT + vi * TCOUNT;
          return 2;
      } else {
          return 0;
      }
  }
  
  static uint32_t decode_utf16(const unsigned short **code_ptr)
  {
      const unsigned short *code = *code_ptr;
  
      if (code[0] < 0xd800 || code[0] > 0xdc00) {
          *code_ptr += 1;
          return (uint32_t)code[0];
      } else {
          *code_ptr += 2;
          return 0x10000 + ((uint32_t)code[1] - 0xdc00) +
              (((uint32_t)code[0] - 0xd800) << 10);
      }
  }
  
  const char *ucdn_get_unicode_version(void)
  {
      return UNIDATA_VERSION;
  }
  
  int ucdn_get_combining_class(uint32_t code)
  {
      return get_ucd_record(code)->combining;
  }
  
  int ucdn_get_east_asian_width(uint32_t code)
  {
      return get_ucd_record(code)->east_asian_width;
  }
  
  int ucdn_get_general_category(uint32_t code)
  {
      return get_ucd_record(code)->category;
  }
  
  int ucdn_get_bidi_class(uint32_t code)
  {
      return get_ucd_record(code)->bidi_class;
  }
  
  int ucdn_get_mirrored(uint32_t code)
  {
      return ucdn_mirror(code) != code;
  }
  
  int ucdn_get_script(uint32_t code)
  {
      return get_ucd_record(code)->script;
  }
  
  int ucdn_get_linebreak_class(uint32_t code)
  {
      return get_ucd_record(code)->linebreak_class;
  }
  
  int ucdn_get_resolved_linebreak_class(uint32_t code)
  {
      const UCDRecord *record = get_ucd_record(code);
  
      switch (record->linebreak_class)
      {
      case UCDN_LINEBREAK_CLASS_AI:
      case UCDN_LINEBREAK_CLASS_SG:
      case UCDN_LINEBREAK_CLASS_XX:
          return UCDN_LINEBREAK_CLASS_AL;
  
      case UCDN_LINEBREAK_CLASS_SA:
          if (record->category == UCDN_GENERAL_CATEGORY_MC ||
                  record->category == UCDN_GENERAL_CATEGORY_MN)
              return UCDN_LINEBREAK_CLASS_CM;
          return UCDN_LINEBREAK_CLASS_AL;
  
      case UCDN_LINEBREAK_CLASS_CJ:
          return UCDN_LINEBREAK_CLASS_NS;
  
      case UCDN_LINEBREAK_CLASS_CB:
          return UCDN_LINEBREAK_CLASS_B2;
  
      case UCDN_LINEBREAK_CLASS_NL:
          return UCDN_LINEBREAK_CLASS_BK;
  
      default:
          return record->linebreak_class;
      }
  }
  
  uint32_t ucdn_mirror(uint32_t code)
  {
      MirrorPair mp = {0};
      MirrorPair *res;
  
      mp.from = code;
      res = (MirrorPair *) bsearch(&mp, mirror_pairs, BIDI_MIRROR_LEN,
                                  sizeof(MirrorPair), compare_mp);
  
      if (res == NULL)
          return code;
      else
          return res->to;
  }
  
  uint32_t ucdn_paired_bracket(uint32_t code)
  {
      BracketPair *res = search_bp(code);
      if (res == NULL)
          return code;
      else
          return res->to;
  }
  
  int ucdn_paired_bracket_type(uint32_t code)
  {
      BracketPair *res = search_bp(code);
      if (res == NULL)
          return UCDN_BIDI_PAIRED_BRACKET_TYPE_NONE;
      else
          return res->type;
  }
  
  int ucdn_decompose(uint32_t code, uint32_t *a, uint32_t *b)
  {
      const unsigned short *rec;
      int len;
  
      if (hangul_pair_decompose(code, a, b))
          return 1;
  
      rec = get_decomp_record(code);
      len = rec[0] >> 8;
  
      if ((rec[0] & 0xff) != 0 || len == 0)
          return 0;
  
      rec++;
      *a = decode_utf16(&rec);
      if (len > 1)
          *b = decode_utf16(&rec);
      else
          *b = 0;
  
      return 1;
  }
  
  int ucdn_compose(uint32_t *code, uint32_t a, uint32_t b)
  {
      int l, r, index, indexi, offset;
  
      if (hangul_pair_compose(code, a, b))
          return 1;
  
      l = get_comp_index(a, nfc_first, sizeof(nfc_first) / sizeof(Reindex));
      r = get_comp_index(b, nfc_last, sizeof(nfc_last) / sizeof(Reindex));
  
      if (l < 0 || r < 0)
          return 0;
  
      indexi = l * TOTAL_LAST + r;
      index  = comp_index0[indexi >> (COMP_SHIFT1+COMP_SHIFT2)] << COMP_SHIFT1;
      offset = (indexi >> COMP_SHIFT2) & ((1<<COMP_SHIFT1) - 1);
      index  = comp_index1[index + offset] << COMP_SHIFT2;
      offset = indexi & ((1<<COMP_SHIFT2) - 1);
      *code  = comp_data[index + offset];
  
      return *code != 0;
  }
  
  int ucdn_compat_decompose(uint32_t code, uint32_t *decomposed)
  {
      int i, len;
      const unsigned short *rec = get_decomp_record(code);
      len = rec[0] >> 8;
  
      if (len == 0)
          return 0;
  
      rec++;
      for (i = 0; i < len; i++)
          decomposed[i] = decode_utf16(&rec);
  
      return len;
  }
  

Download