Edit

kc3-lang/harfbuzz/src/hb-ucd.cc

Branch :

  • Show log

    Commit

  • Author : Behdad Esfahbod
    Date : 2022-11-20 13:54:56
    Hash : 76ce390b
    Message : [ucd] Document algorithms

  • src/hb-ucd.cc
  • /*
     * 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 "hb.hh"
    #include "hb-unicode.hh"
    #include "hb-machinery.hh"
    
    #include "hb-ucd-table.hh"
    
    static hb_unicode_combining_class_t
    hb_ucd_combining_class (hb_unicode_funcs_t *ufuncs HB_UNUSED,
    			hb_codepoint_t unicode,
    			void *user_data HB_UNUSED)
    {
      return (hb_unicode_combining_class_t) _hb_ucd_ccc (unicode);
    }
    
    static hb_unicode_general_category_t
    hb_ucd_general_category (hb_unicode_funcs_t *ufuncs HB_UNUSED,
    			 hb_codepoint_t unicode,
    			 void *user_data HB_UNUSED)
    {
      return (hb_unicode_general_category_t) _hb_ucd_gc (unicode);
    }
    
    static hb_codepoint_t
    hb_ucd_mirroring (hb_unicode_funcs_t *ufuncs HB_UNUSED,
    		  hb_codepoint_t unicode,
    		  void *user_data HB_UNUSED)
    {
      return unicode + _hb_ucd_bmg (unicode);
    }
    
    static hb_script_t
    hb_ucd_script (hb_unicode_funcs_t *ufuncs HB_UNUSED,
    	       hb_codepoint_t unicode,
    	       void *user_data HB_UNUSED)
    {
      return _hb_ucd_sc_map[_hb_ucd_sc (unicode)];
    }
    
    
    #define SBASE 0xAC00u
    #define LBASE 0x1100u
    #define VBASE 0x1161u
    #define TBASE 0x11A7u
    #define SCOUNT 11172u
    #define LCOUNT 19u
    #define VCOUNT 21u
    #define TCOUNT 28u
    #define NCOUNT (VCOUNT * TCOUNT)
    
    static inline bool
    _hb_ucd_decompose_hangul (hb_codepoint_t ab, hb_codepoint_t *a, hb_codepoint_t *b)
    {
      unsigned si = ab - SBASE;
    
      if (si >= SCOUNT)
        return false;
    
      if (si % TCOUNT)
      {
        /* LV,T */
        *a = SBASE + (si / TCOUNT) * TCOUNT;
        *b = TBASE + (si % TCOUNT);
        return true;
      } else {
        /* L,V */
        *a = LBASE + (si / NCOUNT);
        *b = VBASE + (si % NCOUNT) / TCOUNT;
        return true;
      }
    }
    
    static inline bool
    _hb_ucd_compose_hangul (hb_codepoint_t a, hb_codepoint_t b, hb_codepoint_t *ab)
    {
      if (a >= SBASE && a < (SBASE + SCOUNT) && b > TBASE && b < (TBASE + TCOUNT) &&
        !((a - SBASE) % TCOUNT))
      {
        /* LV,T */
        *ab = a + (b - TBASE);
        return true;
      }
      else if (a >= LBASE && a < (LBASE + LCOUNT) && b >= VBASE && b < (VBASE + VCOUNT))
      {
        /* L,V */
        int li = a - LBASE;
        int vi = b - VBASE;
        *ab = SBASE + li * NCOUNT + vi * TCOUNT;
        return true;
      }
      else
        return false;
    }
    
    static int
    _cmp_pair (const void *_key, const void *_item)
    {
      uint64_t& a = * (uint64_t*) _key;
      uint64_t b = (* (uint64_t*) _item) & HB_CODEPOINT_ENCODE3(0x1FFFFFu, 0x1FFFFFu, 0);
    
      return a < b ? -1 : a > b ? +1 : 0;
    }
    static int
    _cmp_pair_11_7_14 (const void *_key, const void *_item)
    {
      uint32_t& a = * (uint32_t*) _key;
      uint32_t b = (* (uint32_t*) _item) & HB_CODEPOINT_ENCODE3_11_7_14(0x1FFFFFu, 0x1FFFFFu, 0);
    
      return a < b ? -1 : a > b ? +1 : 0;
    }
    
    static hb_bool_t
    hb_ucd_compose (hb_unicode_funcs_t *ufuncs HB_UNUSED,
    		hb_codepoint_t a, hb_codepoint_t b, hb_codepoint_t *ab,
    		void *user_data HB_UNUSED)
    {
      // Hangul is handled algorithmically.
      if (_hb_ucd_compose_hangul (a, b, ab)) return true;
    
      hb_codepoint_t u = 0;
    
      if ((a & 0xFFFFF800u) == 0x0000u && (b & 0xFFFFFF80) == 0x0300u)
      {
        /* If "a" is small enough and "b" is in the U+0300 range,
         * the composition data is encoded in a 32bit array sorted
         * by "a,b" pair. */
        uint32_t k = HB_CODEPOINT_ENCODE3_11_7_14 (a, b, 0);
        const uint32_t *v = hb_bsearch (k,
    				    _hb_ucd_dm2_u32_map,
    				    ARRAY_LENGTH (_hb_ucd_dm2_u32_map),
    				    sizeof (*_hb_ucd_dm2_u32_map),
    				    _cmp_pair_11_7_14);
        if (likely (!v)) return false;
        u = HB_CODEPOINT_DECODE3_11_7_14_3 (*v);
      }
      else
      {
        /* Otherwise it is stored in a 64bit array sorted by
         * "a,b" pair. */
        uint64_t k = HB_CODEPOINT_ENCODE3 (a, b, 0);
        const uint64_t *v = hb_bsearch (k,
    				    _hb_ucd_dm2_u64_map,
    				    ARRAY_LENGTH (_hb_ucd_dm2_u64_map),
    				    sizeof (*_hb_ucd_dm2_u64_map),
    				    _cmp_pair);
        if (likely (!v)) return false;
        u = HB_CODEPOINT_DECODE3_3 (*v);
      }
    
      if (unlikely (!u)) return false;
      *ab = u;
      return true;
    }
    
    static hb_bool_t
    hb_ucd_decompose (hb_unicode_funcs_t *ufuncs HB_UNUSED,
    		  hb_codepoint_t ab, hb_codepoint_t *a, hb_codepoint_t *b,
    		  void *user_data HB_UNUSED)
    {
      if (_hb_ucd_decompose_hangul (ab, a, b)) return true;
    
      unsigned i = _hb_ucd_dm (ab);
    
      /* If no data, there's no decomposition. */
      if (likely (!i)) return false;
      i--;
    
      /* Check if it's a single-character decomposition. */
      if (i < ARRAY_LENGTH (_hb_ucd_dm1_p0_map) + ARRAY_LENGTH (_hb_ucd_dm1_p2_map))
      {
        /* Single-character decompositions currently are only in plane 0 or plane 2. */
        if (i < ARRAY_LENGTH (_hb_ucd_dm1_p0_map))
        {
          /* Plane 0. */
          *a = _hb_ucd_dm1_p0_map[i];
        }
        else
        {
          /* Plane 2. */
          i -= ARRAY_LENGTH (_hb_ucd_dm1_p0_map);
          *a = 0x20000 | _hb_ucd_dm1_p2_map[i];
        }
        *b = 0;
        return true;
      }
      i -= ARRAY_LENGTH (_hb_ucd_dm1_p0_map) + ARRAY_LENGTH (_hb_ucd_dm1_p2_map);
    
      /* Otherwise they are encoded either in a 32bit array or a 64bit array. */
      if (i < ARRAY_LENGTH (_hb_ucd_dm2_u32_map))
      {
        /* 32bit array. */
        uint32_t v = _hb_ucd_dm2_u32_map[i];
        *a = HB_CODEPOINT_DECODE3_11_7_14_1 (v);
        *b = HB_CODEPOINT_DECODE3_11_7_14_2 (v);
        return true;
      }
      i -= ARRAY_LENGTH (_hb_ucd_dm2_u32_map);
    
      /* 64bit array. */
      uint64_t v = _hb_ucd_dm2_u64_map[i];
      *a = HB_CODEPOINT_DECODE3_1 (v);
      *b = HB_CODEPOINT_DECODE3_2 (v);
      return true;
    }
    
    
    static void free_static_ucd_funcs ();
    
    static struct hb_ucd_unicode_funcs_lazy_loader_t : hb_unicode_funcs_lazy_loader_t<hb_ucd_unicode_funcs_lazy_loader_t>
    {
      static hb_unicode_funcs_t *create ()
      {
        hb_unicode_funcs_t *funcs = hb_unicode_funcs_create (nullptr);
    
        hb_unicode_funcs_set_combining_class_func (funcs, hb_ucd_combining_class, nullptr, nullptr);
        hb_unicode_funcs_set_general_category_func (funcs, hb_ucd_general_category, nullptr, nullptr);
        hb_unicode_funcs_set_mirroring_func (funcs, hb_ucd_mirroring, nullptr, nullptr);
        hb_unicode_funcs_set_script_func (funcs, hb_ucd_script, nullptr, nullptr);
        hb_unicode_funcs_set_compose_func (funcs, hb_ucd_compose, nullptr, nullptr);
        hb_unicode_funcs_set_decompose_func (funcs, hb_ucd_decompose, nullptr, nullptr);
    
        hb_unicode_funcs_make_immutable (funcs);
    
        hb_atexit (free_static_ucd_funcs);
    
        return funcs;
      }
    } static_ucd_funcs;
    
    static inline
    void free_static_ucd_funcs ()
    {
      static_ucd_funcs.free_instance ();
    }
    
    hb_unicode_funcs_t *
    hb_ucd_get_unicode_funcs ()
    {
    #ifdef HB_NO_UCD
      return hb_unicode_funcs_get_empty ();
    #endif
      return static_ucd_funcs.get_unconst ();
    }