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

Branch - branch -main

• Show log

  Commit

• Hash : 3a9262cc
  Author :
  Date : 2023-11-04T12:52:46
  

  [sanitize] More hb_barrier() annotations
  

Download

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

• #ifndef OT_LAYOUT_GPOS_PAIRSET_HH
  #define OT_LAYOUT_GPOS_PAIRSET_HH
  
  #include "PairValueRecord.hh"
  
  namespace OT {
  namespace Layout {
  namespace GPOS_impl {
  
  
  template <typename Types>
  struct PairSet : ValueBase
  {
    template <typename Types2>
    friend struct PairPosFormat1_3;
  
    using PairValueRecord = GPOS_impl::PairValueRecord<Types>;
  
    protected:
    HBUINT16              len;    /* Number of PairValueRecords */
    PairValueRecord       firstPairValueRecord;
                                  /* Array of PairValueRecords--ordered
                                   * by GlyphID of the second glyph */
    public:
    DEFINE_SIZE_MIN (2);
  
    static unsigned get_size (unsigned len1, unsigned len2)
    {
      return Types::HBGlyphID::static_size + Value::static_size * (len1 + len2);
    }
    static unsigned get_size (const ValueFormat valueFormats[2])
    {
      unsigned len1 = valueFormats[0].get_len ();
      unsigned len2 = valueFormats[1].get_len ();
      return get_size (len1, len2);
    }
  
    struct sanitize_closure_t
    {
      const ValueFormat *valueFormats;
      unsigned int len1; /* valueFormats[0].get_len() */
      unsigned int stride; /* bytes */
    };
  
    bool sanitize (hb_sanitize_context_t *c, const sanitize_closure_t *closure) const
    {
      TRACE_SANITIZE (this);
      if (!(c->check_struct (this) &&
  	  hb_barrier () &&
            c->check_range (&firstPairValueRecord,
                            len,
                            closure->stride))) return_trace (false);
      hb_barrier ();
  
      unsigned int count = len;
      const PairValueRecord *record = &firstPairValueRecord;
      return_trace (c->lazy_some_gpos ||
  		  (closure->valueFormats[0].sanitize_values_stride_unsafe (c, this, &record->values[0], count, closure->stride) &&
                     closure->valueFormats[1].sanitize_values_stride_unsafe (c, this, &record->values[closure->len1], count, closure->stride)));
    }
  
    bool intersects (const hb_set_t *glyphs,
                     const ValueFormat *valueFormats) const
    {
      unsigned record_size = get_size (valueFormats);
  
      const PairValueRecord *record = &firstPairValueRecord;
      unsigned int count = len;
      for (unsigned int i = 0; i < count; i++)
      {
        if (glyphs->has (record->secondGlyph))
          return true;
        record = &StructAtOffset<const PairValueRecord> (record, record_size);
      }
      return false;
    }
  
    void collect_glyphs (hb_collect_glyphs_context_t *c,
                         const ValueFormat *valueFormats) const
    {
      unsigned record_size = get_size (valueFormats);
  
      const PairValueRecord *record = &firstPairValueRecord;
      c->input->add_array (&record->secondGlyph, len, record_size);
    }
  
    void collect_variation_indices (hb_collect_variation_indices_context_t *c,
                                    const ValueFormat *valueFormats) const
    {
      unsigned record_size = get_size (valueFormats);
  
      const PairValueRecord *record = &firstPairValueRecord;
      unsigned count = len;
      for (unsigned i = 0; i < count; i++)
      {
        if (c->glyph_set->has (record->secondGlyph))
        { record->collect_variation_indices (c, valueFormats, this); }
  
        record = &StructAtOffset<const PairValueRecord> (record, record_size);
      }
    }
  
    bool apply (hb_ot_apply_context_t *c,
                const ValueFormat *valueFormats,
                unsigned int pos) const
    {
      TRACE_APPLY (this);
      hb_buffer_t *buffer = c->buffer;
      unsigned int len1 = valueFormats[0].get_len ();
      unsigned int len2 = valueFormats[1].get_len ();
      unsigned record_size = get_size (len1, len2);
  
      const PairValueRecord *record = hb_bsearch (buffer->info[pos].codepoint,
                                                  &firstPairValueRecord,
                                                  len,
                                                  record_size);
      if (record)
      {
        if (HB_BUFFER_MESSAGE_MORE && c->buffer->messaging ())
        {
  	c->buffer->message (c->font,
  			    "try kerning glyphs at %u,%u",
  			    c->buffer->idx, pos);
        }
  
        bool applied_first = len1 && valueFormats[0].apply_value (c, this, &record->values[0], buffer->cur_pos());
        bool applied_second = len2 && valueFormats[1].apply_value (c, this, &record->values[len1], buffer->pos[pos]);
  
        if (applied_first || applied_second)
  	if (HB_BUFFER_MESSAGE_MORE && c->buffer->messaging ())
  	{
  	  c->buffer->message (c->font,
  			      "kerned glyphs at %u,%u",
  			      c->buffer->idx, pos);
  	}
  
        if (HB_BUFFER_MESSAGE_MORE && c->buffer->messaging ())
        {
  	c->buffer->message (c->font,
  			    "tried kerning glyphs at %u,%u",
  			    c->buffer->idx, pos);
        }
  
        if (applied_first || applied_second)
          buffer->unsafe_to_break (buffer->idx, pos + 1);
  
        if (len2)
        {
  	pos++;
        // https://github.com/harfbuzz/harfbuzz/issues/3824
        // https://github.com/harfbuzz/harfbuzz/issues/3888#issuecomment-1326781116
        buffer->unsafe_to_break (buffer->idx, pos + 1);
        }
  
        buffer->idx = pos;
        return_trace (true);
      }
      buffer->unsafe_to_concat (buffer->idx, pos + 1);
      return_trace (false);
    }
  
    bool subset (hb_subset_context_t *c,
                 const ValueFormat valueFormats[2],
                 const ValueFormat newFormats[2]) const
    {
      TRACE_SUBSET (this);
      auto snap = c->serializer->snapshot ();
  
      auto *out = c->serializer->start_embed (*this);
      if (unlikely (!c->serializer->extend_min (out))) return_trace (false);
      out->len = 0;
  
      const hb_set_t &glyphset = *c->plan->glyphset_gsub ();
      const hb_map_t &glyph_map = *c->plan->glyph_map;
  
      unsigned len1 = valueFormats[0].get_len ();
      unsigned len2 = valueFormats[1].get_len ();
      unsigned record_size = get_size (len1, len2);
  
      typename PairValueRecord::context_t context =
      {
        this,
        valueFormats,
        newFormats,
        len1,
        &glyph_map,
        &c->plan->layout_variation_idx_delta_map
      };
  
      const PairValueRecord *record = &firstPairValueRecord;
      unsigned count = len, num = 0;
      for (unsigned i = 0; i < count; i++)
      {
        if (glyphset.has (record->secondGlyph)
           && record->subset (c, &context)) num++;
        record = &StructAtOffset<const PairValueRecord> (record, record_size);
      }
  
      out->len = num;
      if (!num) c->serializer->revert (snap);
      return_trace (num);
    }
  };
  
  
  }
  }
  }
  
  #endif  // OT_LAYOUT_GPOS_PAIRSET_HH
  

Download