jdk-sandbox: comparison src/java.desktop/share/native/libfontmanager/harfbuzz/hb-ot-cmap-table.hh

equal deleted inserted replaced

-:aa0a35b071fb
+:f5b95be8b6e2
 #ifndef HB_OT_CMAP_TABLE_HH
 #define HB_OT_CMAP_TABLE_HH
 #include "hb-open-type-private.hh"
+#include "hb-set-private.hh"
 #include "hb-subset-plan.hh"
+/*
+* cmap -- Character to Glyph Index Mapping
+* https://docs.microsoft.com/en-us/typography/opentype/spec/cmap
+*/
+#define HB_OT_TAG_cmap HB_TAG('c','m','a','p')
 namespace OT {
-/*
-* cmap -- Character To Glyph Index Mapping Table
-*/
-#define HB_OT_TAG_cmap HB_TAG('c','m','a','p')
 struct CmapSubtableFormat0
 {
 inline bool get_glyph (hb_codepoint_t codepoint, hb_codepoint_t *glyph) const
 return_trace (c->check_struct (this));
 }
 protected:
 HBUINT16      format;         /* Format number is set to 0. */
-HBUINT16      lengthZ;        /* Byte length of this subtable. */
+HBUINT16      length;         /* Byte length of this subtable. */
-HBUINT16      languageZ;      /* Ignore. */
+HBUINT16      language;       /* Ignore. */
 HBUINT8       glyphIdArray[256];/* An array that maps character
 * code to glyph index values. */
 public:
 DEFINE_SIZE_STATIC (6 + 256);
 };
 struct CmapSubtableFormat4
 {
+struct segment_plan
+{
+HBUINT16 start_code;
+HBUINT16 end_code;
+bool use_delta;
+};
+bool serialize (hb_serialize_context_t *c,
+const hb_subset_plan_t *plan,
+const hb_vector_t<segment_plan> &segments)
+{
+TRACE_SERIALIZE (this);
+if (unlikely (!c->extend_min (*this))) return_trace (false);
+this->format.set (4);
+this->length.set (get_sub_table_size (segments));
+this->segCountX2.set (segments.len * 2);
+this->entrySelector.set (MAX (1u, _hb_bit_storage (segments.len)) - 1);
+this->searchRange.set (2 * (1u << this->entrySelector));
+this->rangeShift.set (segments.len * 2 > this->searchRange
+? 2 * segments.len - this->searchRange
+: 0);
+HBUINT16 *end_count = c->allocate_size<HBUINT16> (HBUINT16::static_size * segments.len);
+c->allocate_size<HBUINT16> (HBUINT16::static_size); // 2 bytes of padding.
+HBUINT16 *start_count = c->allocate_size<HBUINT16> (HBUINT16::static_size * segments.len);
+HBINT16 *id_delta = c->allocate_size<HBINT16> (HBUINT16::static_size * segments.len);
+HBUINT16 *id_range_offset = c->allocate_size<HBUINT16> (HBUINT16::static_size * segments.len);
+if (id_range_offset == nullptr)
+return_trace (false);
+for (unsigned int i = 0; i < segments.len; i++)
+{
+end_count[i].set (segments[i].end_code);
+start_count[i].set (segments[i].start_code);
+if (segments[i].use_delta)
+{
+hb_codepoint_t cp = segments[i].start_code;
+hb_codepoint_t start_gid = 0;
+if (unlikely (!plan->new_gid_for_codepoint (cp, &start_gid) && cp != 0xFFFF))
+return_trace (false);
+id_delta[i].set (start_gid - segments[i].start_code);
+} else {
+id_delta[i].set (0);
+unsigned int num_codepoints = segments[i].end_code - segments[i].start_code + 1;
+HBUINT16 *glyph_id_array = c->allocate_size<HBUINT16> (HBUINT16::static_size * num_codepoints);
+if (glyph_id_array == nullptr)
+return_trace (false);
+// From the cmap spec:
+//
+// id_range_offset[i]/2
+// + (cp - segments[i].start_code)
+// + (id_range_offset + i)
+// =
+// glyph_id_array + (cp - segments[i].start_code)
+//
+// So, solve for id_range_offset[i]:
+//
+// id_range_offset[i]
+// =
+// 2 * (glyph_id_array - id_range_offset - i)
+id_range_offset[i].set (2 * (
+glyph_id_array - id_range_offset - i));
+for (unsigned int j = 0; j < num_codepoints; j++)
+{
+hb_codepoint_t cp = segments[i].start_code + j;
+hb_codepoint_t new_gid;
+if (unlikely (!plan->new_gid_for_codepoint (cp, &new_gid)))
+return_trace (false);
+glyph_id_array[j].set (new_gid);
+}
+}
+}
+return_trace (true);
+}
+static inline size_t get_sub_table_size (const hb_vector_t<segment_plan> &segments)
+{
+size_t segment_size = 0;
+for (unsigned int i = 0; i < segments.len; i++)
+{
+// Parallel array entries
+segment_size +=
+2  // end count
++ 2  // start count
++ 2  // delta
++ 2; // range offset
+if (!segments[i].use_delta)
+// Add bytes for the glyph index array entries for this segment.
+segment_size += (segments[i].end_code - segments[i].start_code + 1) * 2;
+}
+return min_size
++ 2 // Padding
++ segment_size;
+}
+static inline bool create_sub_table_plan (const hb_subset_plan_t *plan,
+hb_vector_t<segment_plan> *segments)
+{
+segment_plan *segment = nullptr;
+hb_codepoint_t last_gid = 0;
+hb_codepoint_t cp = HB_SET_VALUE_INVALID;
+while (plan->unicodes->next (&cp)) {
+hb_codepoint_t new_gid;
+if (unlikely (!plan->new_gid_for_codepoint (cp, &new_gid)))
+{
+DEBUG_MSG(SUBSET, nullptr, "Unable to find new gid for %04x", cp);
+return false;
+}
+if (cp > 0xFFFF) {
+// We are now outside of unicode BMP, stop adding to this cmap.
+break;
+}
+if (!segment
+|| cp != segment->end_code + 1u)
+{
+segment = segments->push ();
+segment->start_code.set (cp);
+segment->end_code.set (cp);
+segment->use_delta = true;
+} else {
+segment->end_code.set (cp);
+if (last_gid + 1u != new_gid)
+// gid's are not consecutive in this segment so delta
+// cannot be used.
+segment->use_delta = false;
+}
+last_gid = new_gid;
+}
+// There must be a final entry with end_code == 0xFFFF. Check if we need to add one.
+if (segment == nullptr || segment->end_code != 0xFFFF)
+{
+segment = segments->push ();
+segment->start_code.set (0xFFFF);
+segment->end_code.set (0xFFFF);
+segment->use_delta = true;
+}
+return true;
+}
 struct accelerator_t
 {
 inline void init (const CmapSubtableFormat4 *subtable)
 {
 segCount = subtable->segCountX2 / 2;
 *glyph = gid & 0xFFFFu;
 return true;
 }
+static inline void get_all_codepoints_func (const void *obj, hb_set_t *out)
+{
+const accelerator_t *thiz = (const accelerator_t *) obj;
+for (unsigned int i = 0; i < thiz->segCount; i++)
+{
+if (thiz->startCount[i] != 0xFFFFu
+|| thiz->endCount[i] != 0xFFFFu) // Skip the last segment (0xFFFF)
+hb_set_add_range (out, thiz->startCount[i], thiz->endCount[i]);
+}
+}
 const HBUINT16 *endCount;
 const HBUINT16 *startCount;
 const HBUINT16 *idDelta;
 const HBUINT16 *idRangeOffset;
 const HBUINT16 *glyphIdArray;
 }
 return_trace (16 + 4 * (unsigned int) segCountX2 <= length);
 }
 protected:
 HBUINT16      format;         /* Format number is set to 4. */
 HBUINT16      length;         /* This is the length in bytes of the
 * subtable. */
-HBUINT16      languageZ;      /* Ignore. */
+HBUINT16      language;       /* Ignore. */
 HBUINT16      segCountX2;     /* 2 x segCount. */
-HBUINT16      searchRangeZ;   /* 2 * (2**floor(log2(segCount))) */
+HBUINT16      searchRange;    /* 2 * (2**floor(log2(segCount))) */
-HBUINT16      entrySelectorZ; /* log2(searchRange/2) */
+HBUINT16      entrySelector;  /* log2(searchRange/2) */
-HBUINT16      rangeShiftZ;    /* 2 x segCount - searchRange */
+HBUINT16      rangeShift;     /* 2 x segCount - searchRange */
 HBUINT16      values[VAR];
 #if 0
 HBUINT16      endCount[segCount];     /* End characterCode for each segment,
 * last=0xFFFFu. */
 struct CmapSubtableLongGroup
 {
 friend struct CmapSubtableFormat12;
 friend struct CmapSubtableFormat13;
+template<typename U>
+friend struct CmapSubtableLongSegmented;
 friend struct cmap;
 int cmp (hb_codepoint_t codepoint) const
 {
 if (codepoint < startCharCode) return -1;
 return_trace (c->check_struct (this) && glyphIdArray.sanitize (c));
 }
 protected:
 UINT          formatReserved; /* Subtable format and (maybe) padding. */
-UINT          lengthZ;        /* Byte length of this subtable. */
+UINT          length;         /* Byte length of this subtable. */
-UINT          languageZ;      /* Ignore. */
+UINT          language;       /* Ignore. */
 UINT          startCharCode;  /* First character code covered. */
 ArrayOf<GlyphID, UINT>
 glyphIdArray;   /* Array of glyph index values for character
 * codes in the range. */
 public:
 return false;
 *glyph = T::group_get_glyph (groups[i], codepoint);
 return true;
 }
+inline void get_all_codepoints (hb_set_t *out) const
+{
+for (unsigned int i = 0; i < this->groups.len; i++) {
+hb_set_add_range (out,
+this->groups[i].startCharCode,
+this->groups[i].endCharCode);
+}
+}
 inline bool sanitize (hb_sanitize_context_t *c) const
 {
 TRACE_SANITIZE (this);
 return_trace (c->check_struct (this) && groups.sanitize (c));
 }
 inline bool serialize (hb_serialize_context_t *c,
-hb_prealloced_array_t<CmapSubtableLongGroup> &group_data)
+const hb_vector_t<CmapSubtableLongGroup> &group_data)
 {
 TRACE_SERIALIZE (this);
 if (unlikely (!c->extend_min (*this))) return_trace (false);
-Supplier<CmapSubtableLongGroup> supplier (group_data.array, group_data.len);
+Supplier<CmapSubtableLongGroup> supplier (group_data.arrayZ, group_data.len);
 if (unlikely (!groups.serialize (c, supplier, group_data.len))) return_trace (false);
 return true;
 }
 protected:
 HBUINT16      format;         /* Subtable format; set to 12. */
-HBUINT16      reservedZ;      /* Reserved; set to 0. */
+HBUINT16      reserved;       /* Reserved; set to 0. */
-HBUINT32              lengthZ;        /* Byte length of this subtable. */
+HBUINT32      length;         /* Byte length of this subtable. */
-HBUINT32              languageZ;      /* Ignore. */
+HBUINT32      language;       /* Ignore. */
 SortedArrayOf<CmapSubtableLongGroup, HBUINT32>
 groups;         /* Groupings. */
 public:
 DEFINE_SIZE_ARRAY (16, groups);
 };
 struct CmapSubtableFormat12 : CmapSubtableLongSegmented<CmapSubtableFormat12>
 {
 static inline hb_codepoint_t group_get_glyph (const CmapSubtableLongGroup &group,
 hb_codepoint_t u)
 { return group.glyphID + (u - group.startCharCode); }
+bool serialize (hb_serialize_context_t *c,
+const hb_vector_t<CmapSubtableLongGroup> &groups)
+{
+if (unlikely (!c->extend_min (*this))) return false;
+this->format.set (12);
+this->reserved.set (0);
+this->length.set (get_sub_table_size (groups));
+return CmapSubtableLongSegmented<CmapSubtableFormat12>::serialize (c, groups);
+}
+static inline size_t get_sub_table_size (const hb_vector_t<CmapSubtableLongGroup> &groups)
+{
+return 16 + 12 * groups.len;
+}
+static inline bool create_sub_table_plan (const hb_subset_plan_t *plan,
+hb_vector_t<CmapSubtableLongGroup> *groups)
+{
+CmapSubtableLongGroup *group = nullptr;
+hb_codepoint_t cp = HB_SET_VALUE_INVALID;
+while (plan->unicodes->next (&cp)) {
+hb_codepoint_t new_gid;
+if (unlikely (!plan->new_gid_for_codepoint (cp, &new_gid)))
+{
+DEBUG_MSG(SUBSET, nullptr, "Unable to find new gid for %04x", cp);
+return false;
+}
+if (!group || !_is_gid_consecutive (group, cp, new_gid))
+{
+group = groups->push ();
+group->startCharCode.set (cp);
+group->endCharCode.set (cp);
+group->glyphID.set (new_gid);
+} else
+{
+group->endCharCode.set (cp);
+}
+}
+DEBUG_MSG(SUBSET, nullptr, "cmap");
+for (unsigned int i = 0; i < groups->len; i++) {
+CmapSubtableLongGroup& group = (*groups)[i];
+DEBUG_MSG(SUBSET, nullptr, "  %d: U+%04X-U+%04X, gid %d-%d", i, (uint32_t) group.startCharCode, (uint32_t) group.endCharCode, (uint32_t) group.glyphID, (uint32_t) group.glyphID + ((uint32_t) group.endCharCode - (uint32_t) group.startCharCode));
+}
+return true;
+}
+private:
+static inline bool _is_gid_consecutive (CmapSubtableLongGroup *group,
+hb_codepoint_t cp,
+hb_codepoint_t new_gid)
+{
+return (cp - 1 == group->endCharCode) &&
+new_gid == group->glyphID + (cp - group->startCharCode);
+}
 };
 struct CmapSubtableFormat13 : CmapSubtableLongSegmented<CmapSubtableFormat13>
 {
 static inline hb_codepoint_t group_get_glyph (const CmapSubtableLongGroup &group,
 {
 TRACE_SANITIZE (this);
 return_trace (c->check_struct (this));
 }
-UINT24        startUnicodeValue;      /* First value in this range. */
+HBUINT24      startUnicodeValue;      /* First value in this range. */
 HBUINT8               additionalCount;        /* Number of additional values in this
 * range. */
 public:
 DEFINE_SIZE_STATIC (4);
 };
 {
 TRACE_SANITIZE (this);
 return_trace (c->check_struct (this));
 }
-UINT24        unicodeValue;   /* Base Unicode value of the UVS */
+HBUINT24      unicodeValue;   /* Base Unicode value of the UVS */
 GlyphID       glyphID;        /* Glyph ID of the UVS */
 public:
 DEFINE_SIZE_STATIC (5);
 };
 return_trace (c->check_struct (this) &&
 defaultUVS.sanitize (c, base) &&
 nonDefaultUVS.sanitize (c, base));
 }
-UINT24        varSelector;    /* Variation selector. */
+HBUINT24      varSelector;    /* Variation selector. */
 LOffsetTo<DefaultUVS>
 defaultUVS;     /* Offset to Default UVS Table. May be 0. */
 LOffsetTo<NonDefaultUVS>
 nonDefaultUVS;  /* Offset to Non-Default UVS Table. May be 0. */
 public:
 record.sanitize (c, this));
 }
 protected:
 HBUINT16      format;         /* Format number is set to 14. */
-HBUINT32              lengthZ;        /* Byte length of this subtable. */
+HBUINT32      length;         /* Byte length of this subtable. */
 SortedArrayOf<VariationSelectorRecord, HBUINT32>
 record;         /* Variation selector records; sorted
 * in increasing order of `varSelector'. */
 public:
 DEFINE_SIZE_ARRAY (10, record);
 struct cmap
 {
 static const hb_tag_t tableTag        = HB_OT_TAG_cmap;
+struct subset_plan {
+subset_plan(void)
+{
+format4_segments.init();
+format12_groups.init();
+}
+~subset_plan(void)
+{
+format4_segments.fini();
+format12_groups.fini();
+}
+inline size_t final_size() const
+{
+return 4 // header
++  8 * 3 // 3 EncodingRecord
++  CmapSubtableFormat4::get_sub_table_size (this->format4_segments)
++  CmapSubtableFormat12::get_sub_table_size (this->format12_groups);
+}
+// Format 4
+hb_vector_t<CmapSubtableFormat4::segment_plan> format4_segments;
+// Format 12
+hb_vector_t<CmapSubtableLongGroup> format12_groups;
+};
 inline bool sanitize (hb_sanitize_context_t *c) const
 {
 TRACE_SANITIZE (this);
 return_trace (c->check_struct (this) &&
 likely (version == 0) &&
 encodingRecord.sanitize (c, this));
 }
-inline bool populate_groups (hb_subset_plan_t *plan,
+inline bool _create_plan (const hb_subset_plan_t *plan,
-hb_prealloced_array_t<CmapSubtableLongGroup> *groups) const
+subset_plan *cmap_plan) const
 {
-CmapSubtableLongGroup *group = nullptr;
+if (unlikely( !CmapSubtableFormat4::create_sub_table_plan (plan, &cmap_plan->format4_segments)))
-for (unsigned int i = 0; i < plan->codepoints.len; i++) {
+return false;
-hb_codepoint_t cp = plan->codepoints[i];
+return CmapSubtableFormat12::create_sub_table_plan (plan, &cmap_plan->format12_groups);
-if (!group || cp - 1 != group->endCharCode)
+}
-{
-group = groups->push ();
+inline bool _subset (const hb_subset_plan_t *plan,
-group->startCharCode.set (cp);
+const subset_plan &cmap_subset_plan,
-group->endCharCode.set (cp);
-hb_codepoint_t new_gid;
-if (unlikely (!hb_subset_plan_new_gid_for_codepoint (plan, cp, &new_gid)))
-{
-DEBUG_MSG(SUBSET, nullptr, "Unable to find new gid for %04x", cp);
-return false;
-}
-group->glyphID.set (new_gid);
-} else
-{
-group->endCharCode.set (cp);
-}
-}
-DEBUG_MSG(SUBSET, nullptr, "cmap");
-for (unsigned int i = 0; i < groups->len; i++) {
-CmapSubtableLongGroup& group = (*groups)[i];
-DEBUG_MSG(SUBSET, nullptr, "  %d: U+%04X-U+%04X, gid %d-%d", i, (uint32_t) group.startCharCode, (uint32_t) group.endCharCode, (uint32_t) group.glyphID, (uint32_t) group.glyphID + ((uint32_t) group.endCharCode - (uint32_t) group.startCharCode));
-}
-return true;
-}
-inline bool _subset (hb_prealloced_array_t<CmapSubtableLongGroup> &groups,
 size_t dest_sz,
 void *dest) const
 {
 hb_serialize_context_t c (dest, dest_sz);
 return false;
 }
 cmap->version.set (0);
-if (unlikely (!cmap->encodingRecord.serialize (&c, /* numTables */ 1))) return false;
+if (unlikely (!cmap->encodingRecord.serialize (&c, /* numTables */ 3)))
+return false;
-EncodingRecord &rec = cmap->encodingRecord[0];
-rec.platformID.set (3); // Windows
+// TODO(grieger): Convert the below to a for loop
-rec.encodingID.set (10); // Unicode UCS-4
+// Format 4, Plat 0 Encoding Record
-/* capture offset to subtable */
+EncodingRecord &format4_plat0_rec = cmap->encodingRecord[0];
-CmapSubtable &subtable = rec.subtable.serialize (&c, cmap);
+format4_plat0_rec.platformID.set (0); // Unicode
+format4_plat0_rec.encodingID.set (3);
-subtable.u.format.set (12);
+// Format 4, Plat 3 Encoding Record
-CmapSubtableFormat12 &format12 = subtable.u.format12;
+EncodingRecord &format4_plat3_rec = cmap->encodingRecord[1];
-if (unlikely (!c.extend_min (format12))) return false;
+format4_plat3_rec.platformID.set (3); // Windows
+format4_plat3_rec.encodingID.set (1); // Unicode BMP
-format12.format.set (12);
-format12.reservedZ.set (0);
+// Format 12 Encoding Record
-format12.lengthZ.set (16 + 12 * groups.len);
+EncodingRecord &format12_rec = cmap->encodingRecord[2];
+format12_rec.platformID.set (3); // Windows
-if (unlikely (!format12.serialize (&c, groups))) return false;
+format12_rec.encodingID.set (10); // Unicode UCS-4
+// Write out format 4 sub table
+{
+CmapSubtable &subtable = format4_plat0_rec.subtable.serialize (&c, cmap);
+format4_plat3_rec.subtable.set (format4_plat0_rec.subtable);
+subtable.u.format.set (4);
+CmapSubtableFormat4 &format4 = subtable.u.format4;
+if (unlikely (!format4.serialize (&c, plan, cmap_subset_plan.format4_segments)))
+return false;
+}
+// Write out format 12 sub table.
+{
+CmapSubtable &subtable = format12_rec.subtable.serialize (&c, cmap);
+subtable.u.format.set (12);
+CmapSubtableFormat12 &format12 = subtable.u.format12;
+if (unlikely (!format12.serialize (&c, cmap_subset_plan.format12_groups)))
+return false;
+}
 c.end_serialize ();
 return true;
 }
 inline bool subset (hb_subset_plan_t *plan) const
 {
-hb_auto_array_t<CmapSubtableLongGroup> groups;
+subset_plan cmap_subset_plan;
-if (unlikely (!populate_groups (plan, &groups))) return false;
+if (unlikely (!_create_plan (plan, &cmap_subset_plan)))
+{
+DEBUG_MSG(SUBSET, nullptr, "Failed to generate a cmap subsetting plan.");
+return false;
+}
 // We now know how big our blob needs to be
-// TODO use APIs from the structs to get size?
+size_t dest_sz = cmap_subset_plan.final_size();
-size_t dest_sz = 4 // header
-+ 8 // 1 EncodingRecord
-+ 16 // Format 12 header
-+ 12 * groups.len; // SequentialMapGroup records
 void *dest = malloc (dest_sz);
 if (unlikely (!dest)) {
 DEBUG_MSG(SUBSET, nullptr, "Unable to alloc %lu for cmap subset output", (unsigned long) dest_sz);
 return false;
 }
-if (unlikely (!_subset (groups, dest_sz, dest)))
+if (unlikely (!_subset (plan, cmap_subset_plan, dest_sz, dest)))
 {
+DEBUG_MSG(SUBSET, nullptr, "Failed to perform subsetting of cmap.");
 free (dest);
 return false;
 }
 // all done, write the blob into dest
 hb_blob_t *cmap_prime = hb_blob_create ((const char *)dest,
 dest_sz,
 HB_MEMORY_MODE_READONLY,
 dest,
 free);
-bool result =  hb_subset_plan_add_table (plan, HB_OT_TAG_cmap, cmap_prime);
+bool result =  plan->add_table (HB_OT_TAG_cmap, cmap_prime);
 hb_blob_destroy (cmap_prime);
 return result;
 }
 struct accelerator_t
 {
 inline void init (hb_face_t *face)
 {
 this->blob = OT::Sanitizer<OT::cmap>().sanitize (face->reference_table (HB_OT_TAG_cmap));
-const OT::cmap *cmap = OT::Sanitizer<OT::cmap>::lock_instance (this->blob);
+const OT::cmap *cmap = this->blob->as<OT::cmap> ();
 const OT::CmapSubtable *subtable = nullptr;
 const OT::CmapSubtableFormat14 *subtable_uvs = nullptr;
 bool symbol = false;
 /* 32-bit subtables. */
 {
 subtable = cmap->find_subtable (3, 0);
 if (subtable) symbol = true;
 }
 /* Meh. */
-if (!subtable) subtable = &OT::Null(OT::CmapSubtable);
+if (!subtable) subtable = &Null(OT::CmapSubtable);
 /* UVS subtable. */
 if (!subtable_uvs)
 {
 const OT::CmapSubtable *st = cmap->find_subtable (0, 5);
 if (st && st->u.format == 14)
 subtable_uvs = &st->u.format14;
 }
 /* Meh. */
-if (!subtable_uvs) subtable_uvs = &OT::Null(OT::CmapSubtableFormat14);
+if (!subtable_uvs) subtable_uvs = &Null(OT::CmapSubtableFormat14);
 this->uvs_table = subtable_uvs;
 this->get_glyph_data = subtable;
 if (unlikely (symbol))
+{
 this->get_glyph_func = get_glyph_from_symbol<OT::CmapSubtable>;
-else
+this->get_all_codepoints_func = null_get_all_codepoints_func;
+} else {
 switch (subtable->u.format) {
 /* Accelerate format 4 and format 12. */
-default: this->get_glyph_func = get_glyph_from<OT::CmapSubtable>;               break;
+default:
-case 12: this->get_glyph_func = get_glyph_from<OT::CmapSubtableFormat12>;       break;
+this->get_glyph_func = get_glyph_from<OT::CmapSubtable>;
+this->get_all_codepoints_func = null_get_all_codepoints_func;
+break;
+case 12:
+this->get_glyph_func = get_glyph_from<OT::CmapSubtableFormat12>;
+this->get_all_codepoints_func = get_all_codepoints_from<OT::CmapSubtableFormat12>;
+break;
 case  4:
 {
 this->format4_accel.init (&subtable->u.format4);
 this->get_glyph_data = &this->format4_accel;
 this->get_glyph_func = this->format4_accel.get_glyph_func;
+this->get_all_codepoints_func = this->format4_accel.get_all_codepoints_func;
 }
 break;
 }
+}
 }
 inline void fini (void)
 {
 hb_blob_destroy (this->blob);
 case OT::GLYPH_VARIANT_FOUND:           return true;
 case OT::GLYPH_VARIANT_USE_DEFAULT:     break;
 }
 return get_nominal_glyph (unicode, glyph);
+}
+inline void get_all_codepoints (hb_set_t *out) const
+{
+this->get_all_codepoints_func (get_glyph_data, out);
 }
 protected:
 typedef bool (*hb_cmap_get_glyph_func_t) (const void *obj,
 hb_codepoint_t codepoint,
 hb_codepoint_t *glyph);
+typedef void (*hb_cmap_get_all_codepoints_func_t) (const void *obj,
+hb_set_t *out);
+static inline void null_get_all_codepoints_func (const void *obj, hb_set_t *out)
+{
+// NOOP
+}
 template <typename Type>
 static inline bool get_glyph_from (const void *obj,
 hb_codepoint_t codepoint,
 hb_codepoint_t *glyph)
 const Type *typed_obj = (const Type *) obj;
 return typed_obj->get_glyph (codepoint, glyph);
 }
 template <typename Type>
+static inline void get_all_codepoints_from (const void *obj,
+hb_set_t *out)
+{
+const Type *typed_obj = (const Type *) obj;
+typed_obj->get_all_codepoints (out);
+}
+template <typename Type>
 static inline bool get_glyph_from_symbol (const void *obj,
 hb_codepoint_t codepoint,
 hb_codepoint_t *glyph)
 {
 const Type *typed_obj = (const Type *) obj;
 if (codepoint <= 0x00FFu)
 {
 /* For symbol-encoded OpenType fonts, we duplicate the
 * U+F000..F0FF range at U+0000..U+00FF.  That's what
 * Windows seems to do, and that's hinted about at:
-* http://www.microsoft.com/typography/otspec/recom.htm
+* https://docs.microsoft.com/en-us/typography/opentype/spec/recom
 * under "Non-Standard (Symbol) Fonts". */
 return typed_obj->get_glyph (0xF000u + codepoint, glyph);
 }
 return false;
 }
 private:
 hb_cmap_get_glyph_func_t get_glyph_func;
 const void *get_glyph_data;
+hb_cmap_get_all_codepoints_func_t get_all_codepoints_func;
 OT::CmapSubtableFormat4::accelerator_t format4_accel;
 const OT::CmapSubtableFormat14 *uvs_table;
 hb_blob_t *blob;
 };

changeset 50826	f5b95be8b6e2
parent 50352	25db2c8f3cf8
child 54232	7c11a7cc7c1d