kc3-lang/harfbuzz/src/OT/Layout/GPOS/MarkArray.hh

Branch - branch -main

• Show log

  Commit

• Hash : 7989702a
  Author :
  Date : 2023-08-06T14:17:50
  

  Audit and fix up serialize_subset uses
  
  Fixes https://github.com/harfbuzz/harfbuzz/issues/4362
  

Download

• src/OT/Layout/GPOS/MarkArray.hh

• #ifndef OT_LAYOUT_GPOS_MARKARRAY_HH
  #define OT_LAYOUT_GPOS_MARKARRAY_HH
  
  #include "AnchorMatrix.hh"
  #include "MarkRecord.hh"
  
  namespace OT {
  namespace Layout {
  namespace GPOS_impl {
  
  struct MarkArray : Array16Of<MarkRecord>        /* Array of MarkRecords--in Coverage order */
  {
    bool sanitize (hb_sanitize_context_t *c) const
    {
      TRACE_SANITIZE (this);
      return_trace (Array16Of<MarkRecord>::sanitize (c, this));
    }
  
    bool apply (hb_ot_apply_context_t *c,
                unsigned int mark_index, unsigned int glyph_index,
                const AnchorMatrix &anchors, unsigned int class_count,
                unsigned int glyph_pos) const
    {
      TRACE_APPLY (this);
      hb_buffer_t *buffer = c->buffer;
      const MarkRecord &record = Array16Of<MarkRecord>::operator[](mark_index);
      unsigned int mark_class = record.klass;
  
      const Anchor& mark_anchor = this + record.markAnchor;
      bool found;
      const Anchor& glyph_anchor = anchors.get_anchor (c, glyph_index, mark_class, class_count, &found);
      /* If this subtable doesn't have an anchor for this base and this class,
       * return false such that the subsequent subtables have a chance at it. */
      if (unlikely (!found)) return_trace (false);
  
      float mark_x, mark_y, base_x, base_y;
  
      buffer->unsafe_to_break (glyph_pos, buffer->idx + 1);
      mark_anchor.get_anchor (c, buffer->cur().codepoint, &mark_x, &mark_y);
      glyph_anchor.get_anchor (c, buffer->info[glyph_pos].codepoint, &base_x, &base_y);
  
      if (HB_BUFFER_MESSAGE_MORE && c->buffer->messaging ())
      {
        c->buffer->message (c->font,
  			  "attaching mark glyph at %u to glyph at %u",
  			  c->buffer->idx, glyph_pos);
      }
  
      hb_glyph_position_t &o = buffer->cur_pos();
      o.x_offset = roundf (base_x - mark_x);
      o.y_offset = roundf (base_y - mark_y);
      o.attach_type() = ATTACH_TYPE_MARK;
      o.attach_chain() = (int) glyph_pos - (int) buffer->idx;
      buffer->scratch_flags |= HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_ATTACHMENT;
  
      if (HB_BUFFER_MESSAGE_MORE && c->buffer->messaging ())
      {
        c->buffer->message (c->font,
  			  "attached mark glyph at %u to glyph at %u",
  			  c->buffer->idx, glyph_pos);
      }
  
      buffer->idx++;
      return_trace (true);
    }
  
    template <typename Iterator,
        hb_requires (hb_is_iterator (Iterator))>
    bool subset (hb_subset_context_t *c,
                 Iterator             coverage,
                 const hb_map_t      *klass_mapping) const
    {
      TRACE_SUBSET (this);
      const hb_set_t &glyphset = *c->plan->glyphset_gsub ();
  
      auto* out = c->serializer->start_embed (this);
      if (unlikely (!c->serializer->extend_min (out))) return_trace (false);
  
      auto mark_iter =
      + hb_zip (coverage, this->iter ())
      | hb_filter (glyphset, hb_first)
      | hb_map (hb_second)
      ;
  
      bool ret = false;
      unsigned new_length = 0;
      for (const auto& mark_record : mark_iter) {
        ret |= mark_record.subset (c, this, klass_mapping);
        new_length++;
      }
  
      if (unlikely (!c->serializer->check_assign (out->len, new_length,
                                                  HB_SERIALIZE_ERROR_ARRAY_OVERFLOW)))
        return_trace (false);
  
      return_trace (ret);
    }
  };
  
  HB_INTERNAL inline
  void Markclass_closure_and_remap_indexes (const Coverage  &mark_coverage,
                                            const MarkArray &mark_array,
                                            const hb_set_t  &glyphset,
                                            hb_map_t*        klass_mapping /* INOUT */)
  {
    hb_set_t orig_classes;
  
    + hb_zip (mark_coverage, mark_array)
    | hb_filter (glyphset, hb_first)
    | hb_map (hb_second)
    | hb_map (&MarkRecord::get_class)
    | hb_sink (orig_classes)
    ;
  
    unsigned idx = 0;
    for (auto klass : orig_classes.iter ())
    {
      if (klass_mapping->has (klass)) continue;
      klass_mapping->set (klass, idx);
      idx++;
    }
  }
  
  }
  }
  }
  
  #endif /* OT_LAYOUT_GPOS_MARKARRAY_HH */
  

Download