Roll HarfBuzz to 0.9.32

third_party/harfbuzz-ng/src/hb-ot-layout-gsubgpos-private.hh

 /*
  * Copyright © 2007,2008,2009,2010  Red Hat, Inc.
  * Copyright © 2010,2012  Google, Inc.
  *
  *  This is part of HarfBuzz, a text shaping library.
  *
  * Permission is hereby granted, without written agreement and without
  * license or royalty fees, to use, copy, modify, and distribute this
  * software and its documentation for any purpose, provided that the
  * above copyright notice and the following two paragraphs appear in
@@ skipping 331 matching lines @@
     enum may_skip_t {
       SKIP_NO,
       SKIP_YES,
       SKIP_MAYBE
     };
 
     inline may_skip_t
     may_skip (const hb_apply_context_t *c,
               const hb_glyph_info_t    &info) const
     {
-      unsigned int property;
-
-      property = _hb_glyph_info_get_glyph_props (&info);
-
-      if (!c->match_properties (info.codepoint, property, lookup_props))
+      if (!c->check_glyph_property (&info, lookup_props))
         return SKIP_YES;
 
       if (unlikely (_hb_glyph_info_is_default_ignorable (&info) &&
                     (ignore_zwnj || !_hb_glyph_info_is_zwnj (&info)) &&
                     (ignore_zwj || !_hb_glyph_info_is_zwj (&info)) &&
                     !_hb_glyph_info_ligated (&info)))
         return SKIP_MAYBE;
 
       return SKIP_NO;
     }
@@ skipping 113 matching lines @@
     inline void reject (void) { num_items++; }
     inline bool prev (void)
     {
       assert (num_items > 0);
       while (!has_no_chance ())
       {
         idx--;
         const hb_glyph_info_t &info = c->buffer->out_info[idx];
 
         matcher_t::may_skip_t skip = matcher.may_skip (c, info);
-
         if (unlikely (skip == matcher_t::SKIP_YES))
           continue;
 
         matcher_t::may_match_t match = matcher.may_match (info, match_glyph_data);
         if (match == matcher_t::MATCH_YES ||
             (match == matcher_t::MATCH_MAYBE &&
              skip == matcher_t::SKIP_NO))
         {
           num_items--;
           match_glyph_data++;
@@ skipping 30 matching lines @@
      * "ignore marks of attachment type different than
      * the attachment type specified."
      */
     if (lookup_props & LookupFlag::MarkAttachmentType)
       return (lookup_props & LookupFlag::MarkAttachmentType) == (glyph_props & LookupFlag::MarkAttachmentType);
 
     return true;
   }
 
   inline bool
-  match_properties (hb_codepoint_t  glyph,
-                    unsigned int    glyph_props,
-                    unsigned int    lookup_props) const
+  check_glyph_property (const hb_glyph_info_t *info,
+                        unsigned int  lookup_props) const
   {
+    hb_codepoint_t glyph = info->codepoint;
+    unsigned int glyph_props = _hb_glyph_info_get_glyph_props (info);
+
     /* Not covered, if, for example, glyph class is ligature and
      * lookup_props includes LookupFlags::IgnoreLigatures
      */
     if (glyph_props & lookup_props & LookupFlag::IgnoreFlags)
       return false;
 
     if (unlikely (glyph_props & HB_OT_LAYOUT_GLYPH_PROPS_MARK))
       return match_properties_mark (glyph, glyph_props, lookup_props);
 
     return true;
   }
 
-  inline bool
-  check_glyph_property (hb_glyph_info_t *info,
-                        unsigned int  lookup_props) const
-  {
-    unsigned int property;
-
-    property = _hb_glyph_info_get_glyph_props (info);
-
-    return match_properties (info->codepoint, property, lookup_props);
-  }
-
   inline void _set_glyph_props (hb_codepoint_t glyph_index,
                           unsigned int class_guess = 0,
-                          bool ligature = false) const
+                          bool ligature = false,
+                          bool component = false) const
   {
     unsigned int add_in = _hb_glyph_info_get_glyph_props (&buffer->cur()) &
                           HB_OT_LAYOUT_GLYPH_PROPS_PRESERVE;
     add_in |= HB_OT_LAYOUT_GLYPH_PROPS_SUBSTITUTED;
     if (ligature)
+    {
       add_in |= HB_OT_LAYOUT_GLYPH_PROPS_LIGATED;
+      /* In the only place that the MULTIPLIED bit is used, Uniscribe
+       * seems to only care about the "last" transformation between
+       * Ligature and Multiple substitions.  Ie. if you ligate, expand,
+       * and ligate again, it forgives the multiplication and acts as
+       * if only ligation happened.  As such, clear MULTIPLIED bit.
+       */
+      add_in &= ~HB_OT_LAYOUT_GLYPH_PROPS_MULTIPLIED;
+    }
+    if (component)
+      add_in |= HB_OT_LAYOUT_GLYPH_PROPS_MULTIPLIED;
     if (likely (has_glyph_classes))
       _hb_glyph_info_set_glyph_props (&buffer->cur(), add_in | gdef.get_glyph_props (glyph_index));
     else if (class_guess)
       _hb_glyph_info_set_glyph_props (&buffer->cur(), add_in | class_guess);
   }
 
   inline void replace_glyph (hb_codepoint_t glyph_index) const
   {
     _set_glyph_props (glyph_index);
     buffer->replace_glyph (glyph_index);
   }
   inline void replace_glyph_inplace (hb_codepoint_t glyph_index) const
   {
     _set_glyph_props (glyph_index);
     buffer->cur().codepoint = glyph_index;
   }
   inline void replace_glyph_with_ligature (hb_codepoint_t glyph_index,
                                            unsigned int class_guess) const
   {
     _set_glyph_props (glyph_index, class_guess, true);
     buffer->replace_glyph (glyph_index);
   }
-  inline void output_glyph (hb_codepoint_t glyph_index,
-                            unsigned int class_guess) const
+  inline void output_glyph_for_component (hb_codepoint_t glyph_index,
+                                          unsigned int class_guess) const
   {
-    _set_glyph_props (glyph_index, class_guess);
+    _set_glyph_props (glyph_index, class_guess, false, true);
     buffer->output_glyph (glyph_index);
   }
 };
 
 
 
 typedef bool (*intersects_func_t) (hb_set_t *glyphs, const USHORT &value, const void *data);
 typedef void (*collect_glyphs_func_t) (hb_set_t *glyphs, const USHORT &value, const void *data);
 typedef bool (*match_func_t) (hb_codepoint_t glyph_id, const USHORT &value, const void *data);
 
@@ skipping 262 matching lines @@
     /* Re-adjust components for any marks following. */
     for (unsigned int i = buffer->idx; i < buffer->len; i++) {
       if (last_lig_id == _hb_glyph_info_get_lig_id (&buffer->info[i])) {
         unsigned int new_lig_comp = components_so_far - last_num_components +
                                     MIN (MAX (_hb_glyph_info_get_lig_comp (&buffer->info[i]), 1u), last_num_components);
         _hb_glyph_info_set_lig_props_for_mark (&buffer->info[i], lig_id, new_lig_comp);
       } else
         break;
     }
   }
+  TRACE_RETURN (true);
 }
 
 static inline bool match_backtrack (hb_apply_context_t *c,
                                     unsigned int count,
                                     const USHORT backtrack[],
                                     match_func_t match_func,
                                     const void *match_data)
 {
   TRACE_APPLY (NULL);
 
@@ skipping 92 matching lines @@
       continue;
 
     unsigned int new_len = buffer->backtrack_len () + buffer->lookahead_len ();
     int delta = new_len - orig_len;
 
     if (!delta)
         continue;
 
     /* Recursed lookup changed buffer len.  Adjust. */
 
-    /* end can't go back past the current match position. */
+    /* end can't go back past the current match position.
+     * Note: this is only true because we do NOT allow MultipleSubst
+     * with zero sequence len. */
     end = MAX ((int) match_positions[idx] + 1, int (end) + delta);
 
     unsigned int next = idx + 1; /* next now is the position after the recursed lookup. */
 
     if (delta > 0)
     {
       if (unlikely (delta + count > MAX_CONTEXT_LENGTH))
         break;
     }
     else
@@ skipping 1238 matching lines @@
                                        unsigned int *script_count /* IN/OUT */,
                                        hb_tag_t     *script_tags /* OUT */) const
   { return (this+scriptList).get_tags (start_offset, script_count, script_tags); }
   inline const Script& get_script (unsigned int i) const
   { return (this+scriptList)[i]; }
   inline bool find_script_index (hb_tag_t tag, unsigned int *index) const
   { return (this+scriptList).find_index (tag, index); }
 
   inline unsigned int get_feature_count (void) const
   { return (this+featureList).len; }
-  inline const Tag& get_feature_tag (unsigned int i) const
-  { return (this+featureList).get_tag (i); }
+  inline hb_tag_t get_feature_tag (unsigned int i) const
+  { return i == Index::NOT_FOUND_INDEX ? HB_TAG_NONE : (this+featureList).get_tag (i); }
   inline unsigned int get_feature_tags (unsigned int start_offset,
                                         unsigned int *feature_count /* IN/OUT */,
                                         hb_tag_t     *feature_tags /* OUT */) const
   { return (this+featureList).get_tags (start_offset, feature_count, feature_tags); }
   inline const Feature& get_feature (unsigned int i) const
   { return (this+featureList)[i]; }
   inline bool find_feature_index (hb_tag_t tag, unsigned int *index) const
   { return (this+featureList).find_index (tag, index); }
 
   inline unsigned int get_lookup_count (void) const
   { return (this+lookupList).len; }
   inline const Lookup& get_lookup (unsigned int i) const
   { return (this+lookupList)[i]; }
 
   inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE (this);
     return TRACE_RETURN (version.sanitize (c) && likely (version.major == 1) &&
                          scriptList.sanitize (c, this) &&
                          featureList.sanitize (c, this) &&
                          lookupList.sanitize (c, this));
   }
 
   protected:
   FixedVersion  version;        /* Version of the GSUB/GPOS table--initially set
-                                 * to 0x00010000 */
+                                 * to 0x00010000u */
   OffsetTo<ScriptList>
                 scriptList;     /* ScriptList table */
   OffsetTo<FeatureList>
                 featureList;    /* FeatureList table */
   OffsetTo<LookupList>
                 lookupList;     /* LookupList table */
   public:
   DEFINE_SIZE_STATIC (10);
 };
 
 
 } /* namespace OT */
 
 
 #endif /* HB_OT_LAYOUT_GSUBGPOS_PRIVATE_HH */