diff --git a/src/hb-ot-glyf-table.hh b/src/hb-ot-glyf-table.hh index a7b934da2..e62015934 100644 --- a/src/hb-ot-glyf-table.hh +++ b/src/hb-ot-glyf-table.hh @@ -213,19 +213,11 @@ struct glyf _fix_component_gids (const hb_subset_plan_t *plan, hb_bytes_t glyph) { - OT::glyf::CompositeGlyphHeader::Iterator iterator; - if (OT::glyf::CompositeGlyphHeader::get_iterator (&glyph, - glyph.length, - &iterator)) + for (auto &item : OT::glyf::get_composite_iterator (glyph)) { - do - { - hb_codepoint_t new_gid; - if (!plan->new_gid_for_old_gid (iterator.current->glyphIndex, - &new_gid)) - continue; - ((OT::glyf::CompositeGlyphHeader *) iterator.current)->glyphIndex = new_gid; - } while (iterator.move_to_next ()); + hb_codepoint_t new_gid; + if (plan->new_gid_for_old_gid (item.glyphIndex, &new_gid)) + ((OT::glyf::CompositeGlyphHeader *) &item)->glyphIndex = new_gid; } } @@ -246,18 +238,15 @@ struct glyf if (!glyph_header.is_composite_glyph ()) return true; // only for composites /* remove WE_HAVE_INSTRUCTIONS from flags in dest */ - OT::glyf::CompositeGlyphHeader::Iterator composite_it; - if (unlikely (!OT::glyf::CompositeGlyphHeader::get_iterator (&glyph, glyph.length, - &composite_it))) - return false; - const OT::glyf::CompositeGlyphHeader *composite_header; - do - { - composite_header = composite_it.current; - OT::HBUINT16 *flags = const_cast (&composite_header->flags); - *flags = (uint16_t) *flags & ~OT::glyf::CompositeGlyphHeader::WE_HAVE_INSTRUCTIONS; - } while (composite_it.move_to_next ()); - return true; + return + + OT::glyf::get_composite_iterator (glyph) + | hb_reduce ([] (bool _, const OT::glyf::CompositeGlyphHeader &item) + { + OT::HBUINT16 *flags = const_cast (&item.flags); + *flags = (uint16_t) *flags & ~OT::glyf::CompositeGlyphHeader::WE_HAVE_INSTRUCTIONS; + return true; + }, false) + ; } static bool @@ -431,60 +420,49 @@ struct glyf } public: - // TODO rewrite using new iterator framework if possible - struct Iterator - { - const char *glyph_start; - const char *glyph_end; - const CompositeGlyphHeader *current; - - bool move_to_next () - { - if (current->flags & CompositeGlyphHeader::MORE_COMPONENTS) - { - const CompositeGlyphHeader *possible = - &StructAfter (*current); - if (unlikely (!in_range (possible))) return false; - current = possible; - return true; - } - return false; - } - - bool in_range (const CompositeGlyphHeader *composite) const - { - return (const char *) composite >= glyph_start - && ((const char *) composite + CompositeGlyphHeader::min_size) <= glyph_end - && ((const char *) composite + composite->get_size ()) <= glyph_end; - } - }; - - static bool get_iterator (const char * glyph_data, - unsigned int length, - CompositeGlyphHeader::Iterator *iterator /* OUT */) - { - const GlyphHeader &glyph_header = *hb_bytes_t (glyph_data, length).as (); - if (!glyph_header.has_data ()) return false; /* Empty glyph; zero extents. */ - - if (glyph_header.is_composite_glyph ()) - { - const CompositeGlyphHeader *possible = - &StructAfter (glyph_header); - - iterator->glyph_start = glyph_data; - iterator->glyph_end = (const char *) glyph_data + length; - if (!iterator->in_range (possible)) - return false; - iterator->current = possible; - return true; - } - - return false; - } - DEFINE_SIZE_MIN (4); }; + struct composite_iter_t : hb_iter_with_fallback_t + { + typedef const CompositeGlyphHeader *__item_t__; + composite_iter_t (hb_bytes_t glyph_, __item_t__ current_) : glyph (glyph_), current (current_) + { if (!in_range (current)) current = nullptr; } + composite_iter_t () : glyph (hb_bytes_t ()), current (nullptr) {} + + const CompositeGlyphHeader &__item__ () const { return *current; } + bool __more__ () const { return current; } + void __next__ () + { + if (!(current->flags & CompositeGlyphHeader::MORE_COMPONENTS)) { current = nullptr; return; } + + const CompositeGlyphHeader *possible = &StructAfter (*current); + if (!in_range (possible)) { current = nullptr; return; } + current = possible; + } + bool operator != (const composite_iter_t& o) const + { return glyph != o.glyph || current != o.current; } + + bool in_range (const CompositeGlyphHeader *composite) const + { + return glyph.sub_array ((const char *) composite - (const char *) &glyph, + CompositeGlyphHeader::min_size).as () != &Null (CompositeGlyphHeader); + } + + private: + hb_bytes_t glyph; + __item_t__ current; + }; + + static composite_iter_t get_composite_iterator (hb_bytes_t glyph) + { + const GlyphHeader &glyph_header = *glyph.as (); + if (!glyph_header.is_composite_glyph ()) return composite_iter_t (); + + return composite_iter_t (glyph, &StructAfter (glyph_header)); + } + struct accelerator_t { void init (hb_face_t *face_) @@ -512,24 +490,18 @@ struct glyf glyf_table.destroy (); } - /* - * Returns true if the referenced glyph is a valid glyph and a composite glyph. - * If true is returned a pointer to the composite glyph will be written into - * composite. - */ - bool get_composite (hb_codepoint_t glyph, - CompositeGlyphHeader::Iterator *composite /* OUT */) const + composite_iter_t get_composite_iter (hb_codepoint_t glyph) const { if (unlikely (!num_glyphs)) - return false; + return composite_iter_t (); unsigned int start_offset, end_offset; if (!get_offsets (glyph, &start_offset, &end_offset)) - return false; /* glyph not found */ + return composite_iter_t (); /* glyph not found */ - return CompositeGlyphHeader::get_iterator ((const char *) this->glyf_table + start_offset, - end_offset - start_offset, - composite); + hb_bytes_t bytes ((const char *) this->glyf_table + start_offset, + end_offset - start_offset); + return get_composite_iterator (bytes); } enum simple_glyph_flag_t @@ -643,36 +615,28 @@ struct glyf return true; } - CompositeGlyphHeader::Iterator composite; - if (get_composite (glyph, &composite)) + const GlyphHeader &glyph_header = StructAtOffset (glyf_table, start_offset); + if (glyph_header.is_composite_glyph ()) { + hb_bytes_t bytes ((const char *) this->glyf_table + start_offset, + end_offset - start_offset); /* For a composite glyph, add one pseudo point for each component */ - do { num_points++; } while (composite.move_to_next()); + num_points += hb_len (get_composite_iterator (bytes)); points_.resize (num_points + PHANTOM_COUNT); for (unsigned int i = 0; i < points_.length; i++) points_[i].init (); return true; } - const GlyphHeader &glyph_header = StructAtOffset (glyf_table, start_offset); - int num_contours = glyph_header.numberOfContours; const HBUINT16 *end_pts = &StructAfter (glyph_header); range_checker_t checker (glyf_table, start_offset, end_offset); num_points = 0; + int num_contours = glyph_header.numberOfContours; if (glyph_header.is_simple_glyph ()) { if (unlikely (!checker.in_range (&end_pts[num_contours + 1]))) return false; num_points = end_pts[glyph_header.numberOfContours - 1] + 1; } - else if (glyph_header.is_composite_glyph ()) - { - CompositeGlyphHeader::Iterator composite; - if (unlikely (!get_composite (glyph, &composite))) return false; - do - { - num_points++; - } while (composite.move_to_next()); - } points_.resize (num_points + PHANTOM_COUNT); for (unsigned int i = 0; i < points_.length; i++) points_[i].init (); @@ -685,7 +649,7 @@ struct glyf end_points_[i] = end_pts[i]; /* Skip instructions */ - const HBUINT8 *p = &StructAtOffset (&end_pts[num_contours+1], + const HBUINT8 *p = &StructAtOffset (&end_pts[num_contours + 1], end_pts[num_contours]); /* Read flags */ @@ -744,40 +708,45 @@ struct glyf if (unlikely (!face->table.gvar->apply_deltas_to_points (glyph, coords, coord_count, points.as_array (), end_points.as_array ()))) return false; unsigned int comp_index = 0; - CompositeGlyphHeader::Iterator composite; - if (!get_composite (glyph, &composite)) + unsigned int start_offset, end_offset; + if (unlikely (!get_offsets (glyph, &start_offset, &end_offset))) return false; + hb_bytes_t bytes ((const char *) this->glyf_table + start_offset, + end_offset - start_offset); + const GlyphHeader &glyph_header = *bytes.as (); + if (glyph_header.is_simple_glyph ()) { /* simple glyph */ all_points.extend (points.as_array ()); } - else + else if (glyph_header.is_composite_glyph ()) { /* composite glyph */ - do + for (auto &item : get_composite_iterator (bytes)) { contour_point_vector_t comp_points; - if (unlikely (!get_points_var (composite.current->glyphIndex, coords, coord_count, + if (unlikely (!get_points_var (item.glyphIndex, coords, coord_count, comp_points, depth)) - || comp_points.length < PHANTOM_COUNT) return false; + || comp_points.length < PHANTOM_COUNT) + return false; /* Copy phantom points from component if USE_MY_METRICS flag set */ - if (composite.current->flags & CompositeGlyphHeader::USE_MY_METRICS) + if (item.flags & CompositeGlyphHeader::USE_MY_METRICS) for (unsigned int i = 0; i < PHANTOM_COUNT; i++) phantoms[i] = comp_points[comp_points.length - PHANTOM_COUNT + i]; /* Apply component transformation & translation */ - composite.current->transform_points (comp_points); + item.transform_points (comp_points); /* Apply translatation from gvar */ comp_points.translate (points[comp_index]); - if (composite.current->is_anchored ()) + if (item.is_anchored ()) { unsigned int p1, p2; - composite.current->get_anchor_points (p1, p2); + item.get_anchor_points (p1, p2); if (likely (p1 < all_points.length && p2 < comp_points.length)) { - contour_point_t delta; + contour_point_t delta; delta.init (all_points[p1].x - comp_points[p2].x, all_points[p1].y - comp_points[p2].y); @@ -788,10 +757,11 @@ struct glyf all_points.extend (comp_points.sub_array (0, comp_points.length - PHANTOM_COUNT)); comp_index++; - } while (composite.move_to_next()); + } all_points.extend (phantoms); } + else return false; return true; } @@ -975,15 +945,10 @@ struct glyf unsigned int start = glyph.length; unsigned int end = glyph.length; unsigned int glyph_offset = &glyph - glyf_table; - CompositeGlyphHeader::Iterator composite_it; - if (unlikely (!CompositeGlyphHeader::get_iterator (&glyph, glyph.length, - &composite_it))) - return false; - const CompositeGlyphHeader *last; - do - { - last = composite_it.current; - } while (composite_it.move_to_next ()); + const CompositeGlyphHeader *last = nullptr; + for (auto &item : get_composite_iterator (glyph)) + last = &item; + if (unlikely (!last)) return false; if ((uint16_t) last->flags & CompositeGlyphHeader::WE_HAVE_INSTRUCTIONS) start = ((char *) last - (char *) glyf_table->dataZ.arrayZ) diff --git a/src/hb-subset-plan.cc b/src/hb-subset-plan.cc index 655911368..71ab96f79 100644 --- a/src/hb-subset-plan.cc +++ b/src/hb-subset-plan.cc @@ -45,14 +45,8 @@ _add_gid_and_children (const OT::glyf::accelerator_t &glyf, hb_set_add (gids_to_retain, gid); - OT::glyf::CompositeGlyphHeader::Iterator composite; - if (glyf.get_composite (gid, &composite)) - { - do - { - _add_gid_and_children (glyf, (hb_codepoint_t) composite.current->glyphIndex, gids_to_retain); - } while (composite.move_to_next()); - } + for (auto &item : glyf.get_composite_iter (gid)) + _add_gid_and_children (glyf, item.glyphIndex, gids_to_retain); } #ifndef HB_NO_SUBSET_CFF