[aat] Implement Lookup table Untested, but compiles.
diff --git a/src/hb-aat-layout-common-private.hh b/src/hb-aat-layout-common-private.hh index e1abd07..88a9cd8 100644 --- a/src/hb-aat-layout-common-private.hh +++ b/src/hb-aat-layout-common-private.hh
@@ -41,7 +41,6 @@ struct BinSearchHeader { - friend struct BinSearchArray; inline bool sanitize (hb_sanitize_context_t *c) const { @@ -49,7 +48,6 @@ return_trace (c->check_struct (this)); } - protected: UINT16 unitSize; /* Size of a lookup unit for this search in bytes. */ UINT16 nUnits; /* Number of units of the preceding size to be searched. */ UINT16 searchRange; /* The value of unitSize times the largest power of 2 @@ -106,9 +104,23 @@ } template <typename T> - inline Type *bsearch (const T &key) const + inline const Type *bsearch (const T &key) const { - return ::bsearch (&key, bytes, header.nUnits, header.unitSize, Type::cmp); + unsigned int size = header.unitSize; + int min = 0, max = (int) header.nUnits - 1; + while (min <= max) + { + int mid = (min + max) / 2; + const Type *p = (const Type *) (((const char *) bytes) + (mid * size)); + int c = p->cmp (key); + if (c < 0) + max = mid - 1; + else if (c > 0) + min = mid + 1; + else + return p; + } + return NULL; } private: @@ -128,6 +140,294 @@ }; +/* TODO Move this to hb-open-type-private.hh and use it in ArrayOf, HeadlessArrayOf, + * and other places around the code base?? */ +template <typename Type> +struct UnsizedArrayOf +{ + inline const Type& operator [] (unsigned int i) const { return arrayZ[i]; } + inline Type& operator [] (unsigned int i) { return arrayZ[i]; } + + inline bool sanitize (hb_sanitize_context_t *c, unsigned int count) const + { + TRACE_SANITIZE (this); + + /* Note: for structs that do not reference other structs, + * we do not need to call their sanitize() as we already did + * a bound check on the aggregate array size. We just include + * a small unreachable expression to make sure the structs + * pointed to do have a simple sanitize(), ie. they do not + * reference other structs via offsets. + */ + (void) (false && count && arrayZ->sanitize (c)); + + return_trace (c->check_array (arrayZ, arrayZ[0].static_size, count)); + } + + protected: + Type arrayZ[VAR]; + public: + DEFINE_SIZE_ARRAY (0, arrayZ); +}; + + +/* + * Lookup Table + */ + +template <typename T> struct Lookup; + +template <typename T> +struct LookupFormat0 +{ + friend struct Lookup<T>; + + private: + inline const T& get_value (hb_codepoint_t glyph_id, unsigned int num_glyphs) const + { + if (unlikely (glyph_id >= num_glyphs)) return Null(T); + return arrayZ[glyph_id]; + } + + inline bool sanitize (hb_sanitize_context_t *c) const + { + TRACE_SANITIZE (this); + return_trace (arrayZ.sanitize (c, c->num_glyphs)); + } + + protected: + UINT16 format; /* Format identifier--format = 0 */ + UnsizedArrayOf<T> + arrayZ; /* Array of lookup values, indexed by glyph index. */ + public: + DEFINE_SIZE_ARRAY (2, arrayZ); +}; + + +template <typename T> +struct LookupSegmentSingle +{ + inline int cmp (hb_codepoint_t g) const { + return g < first ? -1 : g <= last ? 0 : +1 ; + } + + inline bool sanitize (hb_sanitize_context_t *c) const + { + TRACE_SANITIZE (this); + return_trace (c->check_struct (this) && value.sanitize (c)); + } + + GlyphID last; /* Last GlyphID in this segment */ + GlyphID first; /* First GlyphID in this segment */ + T value; /* The lookup value (only one) */ + public: + DEFINE_SIZE_STATIC (4 + sizeof (T)); +}; + +template <typename T> +struct LookupFormat2 +{ + friend struct Lookup<T>; + + private: + inline const T& get_value (hb_codepoint_t glyph_id) const + { + const LookupSegmentSingle<T> *v = segments.bsearch (glyph_id); + return v ? v->value : Null(T); + } + + inline bool sanitize (hb_sanitize_context_t *c) const + { + TRACE_SANITIZE (this); + return_trace (segments.sanitize (c)); + } + + protected: + UINT16 format; /* Format identifier--format = 2 */ + BinSearchArrayOf<LookupSegmentSingle<T> > + segments; /* The actual segments. These must already be sorted, + * according to the first word in each one (the last + * glyph in each segment). */ + public: + DEFINE_SIZE_ARRAY (8, segments); +}; + +template <typename T> +struct LookupSegmentArray +{ + inline const T& get_value (hb_codepoint_t glyph_id, const void *base) const + { + return first <= glyph_id && glyph_id <= last ? (base+valuesZ)[glyph_id - first] : Null(T); + } + + inline int cmp (hb_codepoint_t g) const { + return g < first ? -1 : g <= last ? 0 : +1 ; + } + + inline bool sanitize (hb_sanitize_context_t *c, const void *base) const + { + TRACE_SANITIZE (this); + return_trace (c->check_struct (this) && + first <= last && + valuesZ.sanitize (c, base, last - first + 1)); + } + + GlyphID last; /* Last GlyphID in this segment */ + GlyphID first; /* First GlyphID in this segment */ + OffsetTo<UnsizedArrayOf<T> > + valuesZ; /* A 16-bit offset from the start of + * the table to the data. */ + public: + DEFINE_SIZE_STATIC (6); +}; + +template <typename T> +struct LookupFormat4 +{ + friend struct Lookup<T>; + + private: + inline const T& get_value (hb_codepoint_t glyph_id) const + { + const LookupSegmentArray<T> *v = segments.bsearch (glyph_id); + return v ? v->get_value (glyph_id, this) : Null(T); + } + + inline bool sanitize (hb_sanitize_context_t *c) const + { + TRACE_SANITIZE (this); + return_trace (segments.sanitize (c, this)); + } + + protected: + UINT16 format; /* Format identifier--format = 2 */ + BinSearchArrayOf<LookupSegmentArray<T> > + segments; /* The actual segments. These must already be sorted, + * according to the first word in each one (the last + * glyph in each segment). */ + public: + DEFINE_SIZE_ARRAY (8, segments); +}; + +template <typename T> +struct LookupSingle +{ + inline int cmp (hb_codepoint_t g) const { return glyph.cmp (g); } + + inline bool sanitize (hb_sanitize_context_t *c) const + { + TRACE_SANITIZE (this); + return_trace (c->check_struct (this) && value.sanitize (c)); + } + + GlyphID glyph; /* Last GlyphID */ + T value; /* The lookup value (only one) */ + public: + DEFINE_SIZE_STATIC (4 + sizeof (T)); +}; + +template <typename T> +struct LookupFormat6 +{ + friend struct Lookup<T>; + + private: + inline const T& get_value (hb_codepoint_t glyph_id) const + { + const LookupSingle<T> *v = entries.bsearch (glyph_id); + return v ? v->value : Null(T); + } + + inline bool sanitize (hb_sanitize_context_t *c) const + { + TRACE_SANITIZE (this); + return_trace (entries.sanitize (c)); + } + + protected: + UINT16 format; /* Format identifier--format = 6 */ + BinSearchArrayOf<LookupSingle<T> > + entries; /* The actual entries, sorted by glyph index. */ + public: + DEFINE_SIZE_ARRAY (8, entries); +}; + +template <typename T> +struct LookupFormat8 +{ + friend struct Lookup<T>; + + private: + inline const T& get_value (hb_codepoint_t glyph_id) const + { + return firstGlyph <= glyph_id && glyph_id - firstGlyph < glyphCount ? valueArrayZ[glyph_id - firstGlyph] : Null(T); + } + + inline bool sanitize (hb_sanitize_context_t *c) const + { + TRACE_SANITIZE (this); + return_trace (c->check_struct (this) && valueArrayZ.sanitize (c, glyphCount)); + } + + protected: + UINT16 format; /* Format identifier--format = 6 */ + GlyphID firstGlyph; /* First glyph index included in the trimmed array. */ + UINT16 glyphCount; /* Total number of glyphs (equivalent to the last + * glyph minus the value of firstGlyph plus 1). */ + UnsizedArrayOf<T> + valueArrayZ; /* The lookup values (indexed by the glyph index + * minus the value of firstGlyph). */ + public: + DEFINE_SIZE_ARRAY (6, valueArrayZ); +}; + +template <typename T> +struct Lookup +{ + inline const T& get_value (hb_codepoint_t glyph_id, unsigned int num_glyphs) const + { + switch (u.format) { + case 0: return u.format0.get_value (glyph_id, num_glyphs); + case 2: return u.format2.get_value (glyph_id); + case 4: return u.format4.get_value (glyph_id); + case 6: return u.format6.get_value (glyph_id); + case 8: return u.format8.get_value (glyph_id); + default:return Null(T); + } + } + + inline bool sanitize (hb_sanitize_context_t *c) const + { + TRACE_SANITIZE (this); + if (!u.format.sanitize (c)) return_trace (false); + switch (u.format) { + case 0: return_trace (u.format0.sanitize (c)); + case 2: return_trace (u.format2.sanitize (c)); + case 4: return_trace (u.format4.sanitize (c)); + case 6: return_trace (u.format6.sanitize (c)); + case 8: return_trace (u.format8.sanitize (c)); + default:return_trace (true); + } + } + + protected: + union { + UINT16 format; /* Format identifier */ + LookupFormat0<T> format0; + LookupFormat2<T> format2; + LookupFormat4<T> format4; + LookupFormat6<T> format6; + LookupFormat8<T> format8; + } u; + public: + DEFINE_SIZE_UNION (2, format); +}; + +// Instantiate, to catch compile errors. +Lookup<GlyphID> g; +Lookup<Tag> t; + + } /* namespace AAT */
diff --git a/src/hb-aat-layout-morx-table.hh b/src/hb-aat-layout-morx-table.hh index a8a8de4..2cd7743 100644 --- a/src/hb-aat-layout-morx-table.hh +++ b/src/hb-aat-layout-morx-table.hh
@@ -74,13 +74,16 @@ struct NoncontextualSubtable { - /* TODO */ inline bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); - /* TODO */ - return_trace (false); + return_trace (substitute.sanitize (c)); } + + protected: + Lookup<GlyphID> substitute; + public: + DEFINE_SIZE_MIN (2); }; struct InsertionSubtable
diff --git a/src/hb-aat-layout.cc b/src/hb-aat-layout.cc index 73ceafe..bd647d5 100644 --- a/src/hb-aat-layout.cc +++ b/src/hb-aat-layout.cc
@@ -41,3 +41,17 @@ hb_ot_layout_t * layout = hb_ot_layout_from_face (face); return *(layout->morx.get ()); } + +void +_hb_aat_layout_create (hb_face_t *face) +{ + OT::Sanitizer<AAT::morx> sanitizer; + sanitizer.set_num_glyphs (face->get_num_glyphs ()); + hb_blob_t *morx_blob = sanitizer.sanitize (face->reference_table (HB_AAT_TAG_MORX)); + OT::Sanitizer<AAT::morx>::lock_instance (morx_blob); + + if (0) + { + OT::Sanitizer<AAT::Lookup<OT::GlyphID> >::lock_instance (morx_blob)->get_value (1, face->get_num_glyphs ()); + } +}
diff --git a/src/hb-face.cc b/src/hb-face.cc index 26fddbe..d8af8c1 100644 --- a/src/hb-face.cc +++ b/src/hb-face.cc
@@ -164,7 +164,7 @@ if (unlikely (!blob)) blob = hb_blob_get_empty (); - hb_face_for_data_closure_t *closure = _hb_face_for_data_closure_create (OT::Sanitizer<OT::OpenTypeFontFile>::sanitize (hb_blob_reference (blob)), index); + hb_face_for_data_closure_t *closure = _hb_face_for_data_closure_create (OT::Sanitizer<OT::OpenTypeFontFile>().sanitize (hb_blob_reference (blob)), index); if (unlikely (!closure)) return hb_face_get_empty (); @@ -424,7 +424,7 @@ void hb_face_t::load_upem (void) const { - hb_blob_t *head_blob = OT::Sanitizer<OT::head>::sanitize (reference_table (HB_OT_TAG_head)); + hb_blob_t *head_blob = OT::Sanitizer<OT::head>().sanitize (reference_table (HB_OT_TAG_head)); const OT::head *head_table = OT::Sanitizer<OT::head>::lock_instance (head_blob); upem = head_table->get_upem (); hb_blob_destroy (head_blob); @@ -468,7 +468,7 @@ void hb_face_t::load_num_glyphs (void) const { - hb_blob_t *maxp_blob = OT::Sanitizer<OT::maxp>::sanitize (reference_table (HB_OT_TAG_maxp)); + hb_blob_t *maxp_blob = OT::Sanitizer<OT::maxp>().sanitize (reference_table (HB_OT_TAG_maxp)); const OT::maxp *maxp_table = OT::Sanitizer<OT::maxp>::lock_instance (maxp_blob); num_glyphs = maxp_table->get_num_glyphs (); hb_blob_destroy (maxp_blob);
diff --git a/src/hb-open-type-private.hh b/src/hb-open-type-private.hh index 2f4e1b9..b68568c 100644 --- a/src/hb-open-type-private.hh +++ b/src/hb-open-type-private.hh
@@ -187,7 +187,8 @@ debug_depth (0), start (nullptr), end (nullptr), writable (false), edit_count (0), - blob (nullptr) {} + blob (nullptr), + num_glyphs (0) {} inline const char *get_name (void) { return "SANITIZE"; } template <typename T, typename F> @@ -298,6 +299,7 @@ bool writable; unsigned int edit_count; hb_blob_t *blob; + unsigned int num_glyphs; }; @@ -306,8 +308,9 @@ template <typename Type> struct Sanitizer { - static hb_blob_t *sanitize (hb_blob_t *blob) { - hb_sanitize_context_t c[1]; + inline Sanitizer (void) {} + + inline hb_blob_t *sanitize (hb_blob_t *blob) { bool sane; /* TODO is_sane() stuff */ @@ -370,6 +373,11 @@ const char *base = hb_blob_get_data (blob, nullptr); return unlikely (!base) ? &Null(Type) : CastP<Type> (base); } + + inline void set_num_glyphs (unsigned int num_glyphs) { c->num_glyphs = num_glyphs; } + + private: + hb_sanitize_context_t c[1]; }; @@ -1154,7 +1162,7 @@ T *p = (T *) hb_atomic_ptr_get (&instance); if (unlikely (!p)) { - hb_blob_t *blob_ = OT::Sanitizer<T>::sanitize (face->reference_table (T::tableTag)); + hb_blob_t *blob_ = OT::Sanitizer<T>().sanitize (face->reference_table (T::tableTag)); p = const_cast<T *>(OT::Sanitizer<T>::lock_instance (blob_)); if (!hb_atomic_ptr_cmpexch (const_cast<T **>(&instance), nullptr, p)) {
diff --git a/src/hb-ot-cbdt-table.hh b/src/hb-ot-cbdt-table.hh index 415625e..dad34e2 100644 --- a/src/hb-ot-cbdt-table.hh +++ b/src/hb-ot-cbdt-table.hh
@@ -379,8 +379,8 @@ { upem = face->get_upem(); - cblc_blob = Sanitizer<CBLC>::sanitize (face->reference_table (HB_OT_TAG_CBLC)); - cbdt_blob = Sanitizer<CBDT>::sanitize (face->reference_table (HB_OT_TAG_CBDT)); + cblc_blob = Sanitizer<CBLC>().sanitize (face->reference_table (HB_OT_TAG_CBLC)); + cbdt_blob = Sanitizer<CBDT>().sanitize (face->reference_table (HB_OT_TAG_CBDT)); cbdt_len = hb_blob_get_length (cbdt_blob); if (hb_blob_get_length (cblc_blob) == 0) {
diff --git a/src/hb-ot-cmap-table.hh b/src/hb-ot-cmap-table.hh index 883d7b3..c61801c 100644 --- a/src/hb-ot-cmap-table.hh +++ b/src/hb-ot-cmap-table.hh
@@ -508,7 +508,7 @@ { inline void init (hb_face_t *face) { - this->blob = OT::Sanitizer<OT::cmap>::sanitize (face->reference_table (HB_OT_TAG_cmap)); + 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::CmapSubtable *subtable = nullptr; const OT::CmapSubtableFormat14 *subtable_uvs = nullptr;
diff --git a/src/hb-ot-glyf-table.hh b/src/hb-ot-glyf-table.hh index 88d3850..c5a54e3 100644 --- a/src/hb-ot-glyf-table.hh +++ b/src/hb-ot-glyf-table.hh
@@ -96,7 +96,7 @@ { inline void init (hb_face_t *face) { - hb_blob_t *head_blob = Sanitizer<head>::sanitize (face->reference_table (HB_OT_TAG_head)); + hb_blob_t *head_blob = Sanitizer<head>().sanitize (face->reference_table (HB_OT_TAG_head)); const head *head_table = Sanitizer<head>::lock_instance (head_blob); if ((unsigned int) head_table->indexToLocFormat > 1 || head_table->glyphDataFormat != 0) { @@ -107,9 +107,9 @@ short_offset = 0 == head_table->indexToLocFormat; hb_blob_destroy (head_blob); - loca_blob = Sanitizer<loca>::sanitize (face->reference_table (HB_OT_TAG_loca)); + loca_blob = Sanitizer<loca>().sanitize (face->reference_table (HB_OT_TAG_loca)); loca_table = Sanitizer<loca>::lock_instance (loca_blob); - glyf_blob = Sanitizer<glyf>::sanitize (face->reference_table (HB_OT_TAG_glyf)); + glyf_blob = Sanitizer<glyf>().sanitize (face->reference_table (HB_OT_TAG_glyf)); glyf_table = Sanitizer<glyf>::lock_instance (glyf_blob); num_glyphs = MAX (1u, hb_blob_get_length (loca_blob) / (short_offset ? 2 : 4)) - 1;
diff --git a/src/hb-ot-hmtx-table.hh b/src/hb-ot-hmtx-table.hh index 29770f7..934acde 100644 --- a/src/hb-ot-hmtx-table.hh +++ b/src/hb-ot-hmtx-table.hh
@@ -74,7 +74,7 @@ bool got_font_extents = false; if (T::os2Tag) { - hb_blob_t *os2_blob = Sanitizer<os2>::sanitize (face->reference_table (T::os2Tag)); + hb_blob_t *os2_blob = Sanitizer<os2>().sanitize (face->reference_table (T::os2Tag)); const os2 *os2_table = Sanitizer<os2>::lock_instance (os2_blob); #define USE_TYPO_METRICS (1u<<7) if (0 != (os2_table->fsSelection & USE_TYPO_METRICS)) @@ -87,7 +87,7 @@ hb_blob_destroy (os2_blob); } - hb_blob_t *_hea_blob = Sanitizer<_hea>::sanitize (face->reference_table (T::headerTag)); + hb_blob_t *_hea_blob = Sanitizer<_hea>().sanitize (face->reference_table (T::headerTag)); const _hea *_hea_table = Sanitizer<_hea>::lock_instance (_hea_blob); num_advances = _hea_table->numberOfLongMetrics; if (!got_font_extents) @@ -101,7 +101,7 @@ has_font_extents = got_font_extents; - blob = Sanitizer<hmtxvmtx>::sanitize (face->reference_table (T::tableTag)); + blob = Sanitizer<hmtxvmtx>().sanitize (face->reference_table (T::tableTag)); /* Cap num_metrics() and num_advances() based on table length. */ unsigned int len = hb_blob_get_length (blob); @@ -119,7 +119,7 @@ } table = Sanitizer<hmtxvmtx>::lock_instance (blob); - var_blob = Sanitizer<HVARVVAR>::sanitize (face->reference_table (T::variationsTag)); + var_blob = Sanitizer<HVARVVAR>().sanitize (face->reference_table (T::variationsTag)); var_table = Sanitizer<HVARVVAR>::lock_instance (var_blob); }
diff --git a/src/hb-ot-kern-table.hh b/src/hb-ot-kern-table.hh index e07faca..c9aaf03 100644 --- a/src/hb-ot-kern-table.hh +++ b/src/hb-ot-kern-table.hh
@@ -360,7 +360,7 @@ { inline void init (hb_face_t *face) { - blob = Sanitizer<kern>::sanitize (face->reference_table (HB_OT_TAG_kern)); + blob = Sanitizer<kern>().sanitize (face->reference_table (HB_OT_TAG_kern)); table = Sanitizer<kern>::lock_instance (blob); table_length = hb_blob_get_length (blob); }
diff --git a/src/hb-ot-layout.cc b/src/hb-ot-layout.cc index d473739..14b6435 100644 --- a/src/hb-ot-layout.cc +++ b/src/hb-ot-layout.cc
@@ -50,13 +50,13 @@ if (unlikely (!layout)) return nullptr; - layout->gdef_blob = OT::Sanitizer<OT::GDEF>::sanitize (face->reference_table (HB_OT_TAG_GDEF)); + layout->gdef_blob = OT::Sanitizer<OT::GDEF>().sanitize (face->reference_table (HB_OT_TAG_GDEF)); layout->gdef = OT::Sanitizer<OT::GDEF>::lock_instance (layout->gdef_blob); - layout->gsub_blob = OT::Sanitizer<OT::GSUB>::sanitize (face->reference_table (HB_OT_TAG_GSUB)); + layout->gsub_blob = OT::Sanitizer<OT::GSUB>().sanitize (face->reference_table (HB_OT_TAG_GSUB)); layout->gsub = OT::Sanitizer<OT::GSUB>::lock_instance (layout->gsub_blob); - layout->gpos_blob = OT::Sanitizer<OT::GPOS>::sanitize (face->reference_table (HB_OT_TAG_GPOS)); + layout->gpos_blob = OT::Sanitizer<OT::GPOS>().sanitize (face->reference_table (HB_OT_TAG_GPOS)); layout->gpos = OT::Sanitizer<OT::GPOS>::lock_instance (layout->gpos_blob); layout->math.init (face);
diff --git a/src/hb-ot-post-table.hh b/src/hb-ot-post-table.hh index 7f1c2c4..523ba2a 100644 --- a/src/hb-ot-post-table.hh +++ b/src/hb-ot-post-table.hh
@@ -86,7 +86,7 @@ { inline void init (hb_face_t *face) { - blob = Sanitizer<post>::sanitize (face->reference_table (HB_OT_TAG_post)); + blob = Sanitizer<post>().sanitize (face->reference_table (HB_OT_TAG_post)); const post *table = Sanitizer<post>::lock_instance (blob); unsigned int table_length = hb_blob_get_length (blob);
diff --git a/src/hb-uniscribe.cc b/src/hb-uniscribe.cc index 0b0bad5..5e05baa 100644 --- a/src/hb-uniscribe.cc +++ b/src/hb-uniscribe.cc
@@ -351,7 +351,7 @@ * full, PS. All of them point to the same name data with our unique name. */ - blob = OT::Sanitizer<OT::OpenTypeFontFile>::sanitize (blob); + blob = OT::Sanitizer<OT::OpenTypeFontFile>().sanitize (blob); unsigned int length, new_length, name_str_len; const char *orig_sfnt_data = hb_blob_get_data (blob, &length);