/* * Copyright © 2007,2008,2009 Red Hat, Inc. * Copyright © 2010,2012 Google, Inc. * * This is part of HarfBuzz, a text shaping library. * * Permission is hereby granted, without written agreement and without * license or royalty fees, to use, copy, modify, and distribute this * software and its documentation for any purpose, provided that the * above copyright notice and the following two paragraphs appear in * all copies of this software. * * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH * DAMAGE. * * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. * * Red Hat Author(s): Behdad Esfahbod * Google Author(s): Behdad Esfahbod */ #ifndef HB_OT_LAYOUT_COMMON_HH #define HB_OT_LAYOUT_COMMON_HH #include "hb.hh" #include "hb-ot-layout.hh" #include "hb-open-type.hh" #include "hb-set.hh" #include "hb-bimap.hh" #include "OT/Layout/Common/Coverage.hh" #include "OT/Layout/types.hh" // TODO(garretrieger): cleanup these after migration. using OT::Layout::Common::Coverage; using OT::Layout::Common::RangeRecord; using OT::Layout::SmallTypes; using OT::Layout::MediumTypes; #ifndef HB_MAX_NESTING_LEVEL #define HB_MAX_NESTING_LEVEL 64 #endif #ifndef HB_MAX_CONTEXT_LENGTH #define HB_MAX_CONTEXT_LENGTH 64 #endif #ifndef HB_CLOSURE_MAX_STAGES /* * The maximum number of times a lookup can be applied during shaping. * Used to limit the number of iterations of the closure algorithm. * This must be larger than the number of times add_gsub_pause() is * called in a collect_features call of any shaper. */ #define HB_CLOSURE_MAX_STAGES 12 #endif #ifndef HB_MAX_SCRIPTS #define HB_MAX_SCRIPTS 500 #endif #ifndef HB_MAX_LANGSYS #define HB_MAX_LANGSYS 2000 #endif #ifndef HB_MAX_LANGSYS_FEATURE_COUNT #define HB_MAX_LANGSYS_FEATURE_COUNT 50000 #endif #ifndef HB_MAX_FEATURE_INDICES #define HB_MAX_FEATURE_INDICES 1500 #endif #ifndef HB_MAX_LOOKUP_VISIT_COUNT #define HB_MAX_LOOKUP_VISIT_COUNT 35000 #endif namespace OT { template static inline bool ClassDef_serialize (hb_serialize_context_t *c, Iterator it); static bool ClassDef_remap_and_serialize ( hb_serialize_context_t *c, const hb_set_t &klasses, bool use_class_zero, hb_sorted_vector_t> &glyph_and_klass, /* IN/OUT */ hb_map_t *klass_map /*IN/OUT*/); struct hb_collect_feature_substitutes_with_var_context_t { const hb_map_t *axes_index_tag_map; const hb_hashmap_t *axes_location; hb_hashmap_t> *record_cond_idx_map; hb_hashmap_t *feature_substitutes_map; // not stored in subset_plan hb_set_t *feature_indices; bool apply; unsigned cur_record_idx; hb_hashmap_t, unsigned> *conditionset_map; }; struct hb_prune_langsys_context_t { hb_prune_langsys_context_t (const void *table_, hb_hashmap_t> *script_langsys_map_, const hb_map_t *duplicate_feature_map_, hb_set_t *new_collected_feature_indexes_) :table (table_), script_langsys_map (script_langsys_map_), duplicate_feature_map (duplicate_feature_map_), new_feature_indexes (new_collected_feature_indexes_), script_count (0),langsys_feature_count (0) {} bool visitScript () { return script_count++ < HB_MAX_SCRIPTS; } bool visitLangsys (unsigned feature_count) { langsys_feature_count += feature_count; return langsys_feature_count < HB_MAX_LANGSYS_FEATURE_COUNT; } public: const void *table; hb_hashmap_t> *script_langsys_map; const hb_map_t *duplicate_feature_map; hb_set_t *new_feature_indexes; private: unsigned script_count; unsigned langsys_feature_count; }; struct hb_subset_layout_context_t : hb_dispatch_context_t { const char *get_name () { return "SUBSET_LAYOUT"; } static return_t default_return_value () { return hb_empty_t (); } bool visitScript () { return script_count++ < HB_MAX_SCRIPTS; } bool visitLangSys () { return langsys_count++ < HB_MAX_LANGSYS; } bool visitFeatureIndex (int count) { feature_index_count += count; return feature_index_count < HB_MAX_FEATURE_INDICES; } bool visitLookupIndex() { lookup_index_count++; return lookup_index_count < HB_MAX_LOOKUP_VISIT_COUNT; } hb_subset_context_t *subset_context; const hb_tag_t table_tag; const hb_map_t *lookup_index_map; const hb_hashmap_t> *script_langsys_map; const hb_map_t *feature_index_map; const hb_hashmap_t *feature_substitutes_map; hb_hashmap_t> *feature_record_cond_idx_map; unsigned cur_script_index; unsigned cur_feature_var_record_idx; hb_subset_layout_context_t (hb_subset_context_t *c_, hb_tag_t tag_) : subset_context (c_), table_tag (tag_), cur_script_index (0xFFFFu), cur_feature_var_record_idx (0u), script_count (0), langsys_count (0), feature_index_count (0), lookup_index_count (0) { if (tag_ == HB_OT_TAG_GSUB) { lookup_index_map = c_->plan->gsub_lookups; script_langsys_map = c_->plan->gsub_langsys; feature_index_map = c_->plan->gsub_features; feature_substitutes_map = c_->plan->gsub_feature_substitutes_map; feature_record_cond_idx_map = c_->plan->user_axes_location->is_empty () ? nullptr : c_->plan->gsub_feature_record_cond_idx_map; } else { lookup_index_map = c_->plan->gpos_lookups; script_langsys_map = c_->plan->gpos_langsys; feature_index_map = c_->plan->gpos_features; feature_substitutes_map = c_->plan->gpos_feature_substitutes_map; feature_record_cond_idx_map = c_->plan->user_axes_location->is_empty () ? nullptr : c_->plan->gpos_feature_record_cond_idx_map; } } private: unsigned script_count; unsigned langsys_count; unsigned feature_index_count; unsigned lookup_index_count; }; struct VariationStore; struct hb_collect_variation_indices_context_t : hb_dispatch_context_t { template return_t dispatch (const T &obj) { obj.collect_variation_indices (this); return hb_empty_t (); } static return_t default_return_value () { return hb_empty_t (); } hb_set_t *layout_variation_indices; hb_hashmap_t> *varidx_delta_map; hb_font_t *font; const VariationStore *var_store; const hb_set_t *glyph_set; const hb_map_t *gpos_lookups; float *store_cache; hb_collect_variation_indices_context_t (hb_set_t *layout_variation_indices_, hb_hashmap_t> *varidx_delta_map_, hb_font_t *font_, const VariationStore *var_store_, const hb_set_t *glyph_set_, const hb_map_t *gpos_lookups_, float *store_cache_) : layout_variation_indices (layout_variation_indices_), varidx_delta_map (varidx_delta_map_), font (font_), var_store (var_store_), glyph_set (glyph_set_), gpos_lookups (gpos_lookups_), store_cache (store_cache_) {} }; template struct subset_offset_array_t { subset_offset_array_t (hb_subset_context_t *subset_context_, OutputArray& out_, const void *base_) : subset_context (subset_context_), out (out_), base (base_) {} template bool operator () (T&& offset) { auto snap = subset_context->serializer->snapshot (); auto *o = out.serialize_append (subset_context->serializer); if (unlikely (!o)) return false; bool ret = o->serialize_subset (subset_context, offset, base); if (!ret) { out.pop (); subset_context->serializer->revert (snap); } return ret; } private: hb_subset_context_t *subset_context; OutputArray &out; const void *base; }; template struct subset_offset_array_arg_t { subset_offset_array_arg_t (hb_subset_context_t *subset_context_, OutputArray& out_, const void *base_, Arg &&arg_) : subset_context (subset_context_), out (out_), base (base_), arg (arg_) {} template bool operator () (T&& offset) { auto snap = subset_context->serializer->snapshot (); auto *o = out.serialize_append (subset_context->serializer); if (unlikely (!o)) return false; bool ret = o->serialize_subset (subset_context, offset, base, arg); if (!ret) { out.pop (); subset_context->serializer->revert (snap); } return ret; } private: hb_subset_context_t *subset_context; OutputArray &out; const void *base; Arg &&arg; }; /* * Helper to subset an array of offsets. Subsets the thing pointed to by each offset * and discards the offset in the array if the subset operation results in an empty * thing. */ struct { template subset_offset_array_t operator () (hb_subset_context_t *subset_context, OutputArray& out, const void *base) const { return subset_offset_array_t (subset_context, out, base); } /* Variant with one extra argument passed to serialize_subset */ template subset_offset_array_arg_t operator () (hb_subset_context_t *subset_context, OutputArray& out, const void *base, Arg &&arg) const { return subset_offset_array_arg_t (subset_context, out, base, arg); } } HB_FUNCOBJ (subset_offset_array); template struct subset_record_array_t { subset_record_array_t (hb_subset_layout_context_t *c_, OutputArray* out_, const void *base_) : subset_layout_context (c_), out (out_), base (base_) {} template void operator () (T&& record) { auto snap = subset_layout_context->subset_context->serializer->snapshot (); bool ret = record.subset (subset_layout_context, base); if (!ret) subset_layout_context->subset_context->serializer->revert (snap); else out->len++; } private: hb_subset_layout_context_t *subset_layout_context; OutputArray *out; const void *base; }; template struct subset_record_array_arg_t { subset_record_array_arg_t (hb_subset_layout_context_t *c_, OutputArray* out_, const void *base_, Arg &&arg_) : subset_layout_context (c_), out (out_), base (base_), arg (arg_) {} template void operator () (T&& record) { auto snap = subset_layout_context->subset_context->serializer->snapshot (); bool ret = record.subset (subset_layout_context, base, arg); if (!ret) subset_layout_context->subset_context->serializer->revert (snap); else out->len++; } private: hb_subset_layout_context_t *subset_layout_context; OutputArray *out; const void *base; Arg &&arg; }; /* * Helper to subset a RecordList/record array. Subsets each Record in the array and * discards the record if the subset operation returns false. */ struct { template subset_record_array_t operator () (hb_subset_layout_context_t *c, OutputArray* out, const void *base) const { return subset_record_array_t (c, out, base); } /* Variant with one extra argument passed to subset */ template subset_record_array_arg_t operator () (hb_subset_layout_context_t *c, OutputArray* out, const void *base, Arg &&arg) const { return subset_record_array_arg_t (c, out, base, arg); } } HB_FUNCOBJ (subset_record_array); template struct serialize_math_record_array_t { serialize_math_record_array_t (hb_serialize_context_t *serialize_context_, OutputArray& out_, const void *base_) : serialize_context (serialize_context_), out (out_), base (base_) {} template bool operator () (T&& record) { if (!serialize_context->copy (record, base)) return false; out.len++; return true; } private: hb_serialize_context_t *serialize_context; OutputArray &out; const void *base; }; /* * Helper to serialize an array of MATH records. */ struct { template serialize_math_record_array_t operator () (hb_serialize_context_t *serialize_context, OutputArray& out, const void *base) const { return serialize_math_record_array_t (serialize_context, out, base); } } HB_FUNCOBJ (serialize_math_record_array); /* * * OpenType Layout Common Table Formats * */ /* * Script, ScriptList, LangSys, Feature, FeatureList, Lookup, LookupList */ struct IndexArray : Array16Of { bool intersects (const hb_map_t *indexes) const { return hb_any (*this, indexes); } template void serialize (hb_serialize_context_t *c, hb_subset_layout_context_t *l, Iterator it) { if (!it) return; if (unlikely (!c->extend_min ((*this)))) return; for (const auto _ : it) { if (!l->visitLookupIndex()) break; Index i; i = _; c->copy (i); this->len++; } } unsigned int get_indexes (unsigned int start_offset, unsigned int *_count /* IN/OUT */, unsigned int *_indexes /* OUT */) const { if (_count) { + this->sub_array (start_offset, _count) | hb_sink (hb_array (_indexes, *_count)) ; } return this->len; } void add_indexes_to (hb_set_t* output /* OUT */) const { output->add_array (as_array ()); } }; /* https://docs.microsoft.com/en-us/typography/opentype/spec/features_pt#size */ struct FeatureParamsSize { bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); if (unlikely (!c->check_struct (this))) return_trace (false); /* This subtable has some "history", if you will. Some earlier versions of * Adobe tools calculated the offset of the FeatureParams subtable from the * beginning of the FeatureList table! Now, that is dealt with in the * Feature implementation. But we still need to be able to tell junk from * real data. Note: We don't check that the nameID actually exists. * * Read Roberts wrote on 9/15/06 on opentype-list@indx.co.uk : * * Yes, it is correct that a new version of the AFDKO (version 2.0) will be * coming out soon, and that the makeotf program will build a font with a * 'size' feature that is correct by the specification. * * The specification for this feature tag is in the "OpenType Layout Tag * Registry". You can see a copy of this at: * https://docs.microsoft.com/en-us/typography/opentype/spec/features_pt#tag-size * * Here is one set of rules to determine if the 'size' feature is built * correctly, or as by the older versions of MakeOTF. You may be able to do * better. * * Assume that the offset to the size feature is according to specification, * and make the following value checks. If it fails, assume the size * feature is calculated as versions of MakeOTF before the AFDKO 2.0 built it. * If this fails, reject the 'size' feature. The older makeOTF's calculated the * offset from the beginning of the FeatureList table, rather than from the * beginning of the 'size' Feature table. * * If "design size" == 0: * fails check * * Else if ("subfamily identifier" == 0 and * "range start" == 0 and * "range end" == 0 and * "range start" == 0 and * "menu name ID" == 0) * passes check: this is the format used when there is a design size * specified, but there is no recommended size range. * * Else if ("design size" < "range start" or * "design size" > "range end" or * "range end" <= "range start" or * "menu name ID" < 256 or * "menu name ID" > 32767 or * menu name ID is not a name ID which is actually in the name table) * fails test * Else * passes test. */ if (!designSize) return_trace (false); else if (subfamilyID == 0 && subfamilyNameID == 0 && rangeStart == 0 && rangeEnd == 0) return_trace (true); else if (designSize < rangeStart || designSize > rangeEnd || subfamilyNameID < 256 || subfamilyNameID > 32767) return_trace (false); else return_trace (true); } bool subset (hb_subset_context_t *c) const { TRACE_SUBSET (this); return_trace ((bool) c->serializer->embed (*this)); } HBUINT16 designSize; /* Represents the design size in 720/inch * units (decipoints). The design size entry * must be non-zero. When there is a design * size but no recommended size range, the * rest of the array will consist of zeros. */ HBUINT16 subfamilyID; /* Has no independent meaning, but serves * as an identifier that associates fonts * in a subfamily. All fonts which share a * Preferred or Font Family name and which * differ only by size range shall have the * same subfamily value, and no fonts which * differ in weight or style shall have the * same subfamily value. If this value is * zero, the remaining fields in the array * will be ignored. */ NameID subfamilyNameID;/* If the preceding value is non-zero, this * value must be set in the range 256 - 32767 * (inclusive). It records the value of a * field in the name table, which must * contain English-language strings encoded * in Windows Unicode and Macintosh Roman, * and may contain additional strings * localized to other scripts and languages. * Each of these strings is the name an * application should use, in combination * with the family name, to represent the * subfamily in a menu. Applications will * choose the appropriate version based on * their selection criteria. */ HBUINT16 rangeStart; /* Large end of the recommended usage range * (inclusive), stored in 720/inch units * (decipoints). */ HBUINT16 rangeEnd; /* Small end of the recommended usage range (exclusive), stored in 720/inch units * (decipoints). */ public: DEFINE_SIZE_STATIC (10); }; /* https://docs.microsoft.com/en-us/typography/opentype/spec/features_pt#ssxx */ struct FeatureParamsStylisticSet { bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); /* Right now minorVersion is at zero. Which means, any table supports * the uiNameID field. */ return_trace (c->check_struct (this)); } bool subset (hb_subset_context_t *c) const { TRACE_SUBSET (this); return_trace ((bool) c->serializer->embed (*this)); } HBUINT16 version; /* (set to 0): This corresponds to a “minor” * version number. Additional data may be * added to the end of this Feature Parameters * table in the future. */ NameID uiNameID; /* The 'name' table name ID that specifies a * string (or strings, for multiple languages) * for a user-interface label for this * feature. The values of uiLabelNameId and * sampleTextNameId are expected to be in the * font-specific name ID range (256-32767), * though that is not a requirement in this * Feature Parameters specification. The * user-interface label for the feature can * be provided in multiple languages. An * English string should be included as a * fallback. The string should be kept to a * minimal length to fit comfortably with * different application interfaces. */ public: DEFINE_SIZE_STATIC (4); }; /* https://docs.microsoft.com/en-us/typography/opentype/spec/features_ae#cv01-cv99 */ struct FeatureParamsCharacterVariants { unsigned get_characters (unsigned start_offset, unsigned *char_count, hb_codepoint_t *chars) const { if (char_count) { + characters.sub_array (start_offset, char_count) | hb_sink (hb_array (chars, *char_count)) ; } return characters.len; } unsigned get_size () const { return min_size + characters.len * HBUINT24::static_size; } bool subset (hb_subset_context_t *c) const { TRACE_SUBSET (this); return_trace ((bool) c->serializer->embed (*this)); } bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (c->check_struct (this) && characters.sanitize (c)); } HBUINT16 format; /* Format number is set to 0. */ NameID featUILableNameID; /* The ‘name’ table name ID that * specifies a string (or strings, * for multiple languages) for a * user-interface label for this * feature. (May be NULL.) */ NameID featUITooltipTextNameID;/* The ‘name’ table name ID that * specifies a string (or strings, * for multiple languages) that an * application can use for tooltip * text for this feature. (May be * nullptr.) */ NameID sampleTextNameID; /* The ‘name’ table name ID that * specifies sample text that * illustrates the effect of this * feature. (May be NULL.) */ HBUINT16 numNamedParameters; /* Number of named parameters. (May * be zero.) */ NameID firstParamUILabelNameID;/* The first ‘name’ table name ID * used to specify strings for * user-interface labels for the * feature parameters. (Must be zero * if numParameters is zero.) */ Array16Of characters; /* Array of the Unicode Scalar Value * of the characters for which this * feature provides glyph variants. * (May be zero.) */ public: DEFINE_SIZE_ARRAY (14, characters); }; struct FeatureParams { bool sanitize (hb_sanitize_context_t *c, hb_tag_t tag) const { #ifdef HB_NO_LAYOUT_FEATURE_PARAMS return true; #endif TRACE_SANITIZE (this); if (tag == HB_TAG ('s','i','z','e')) return_trace (u.size.sanitize (c)); if ((tag & 0xFFFF0000u) == HB_TAG ('s','s','\0','\0')) /* ssXX */ return_trace (u.stylisticSet.sanitize (c)); if ((tag & 0xFFFF0000u) == HB_TAG ('c','v','\0','\0')) /* cvXX */ return_trace (u.characterVariants.sanitize (c)); return_trace (true); } bool subset (hb_subset_context_t *c, const Tag* tag) const { TRACE_SUBSET (this); if (!tag) return_trace (false); if (*tag == HB_TAG ('s','i','z','e')) return_trace (u.size.subset (c)); if ((*tag & 0xFFFF0000u) == HB_TAG ('s','s','\0','\0')) /* ssXX */ return_trace (u.stylisticSet.subset (c)); if ((*tag & 0xFFFF0000u) == HB_TAG ('c','v','\0','\0')) /* cvXX */ return_trace (u.characterVariants.subset (c)); return_trace (false); } #ifndef HB_NO_LAYOUT_FEATURE_PARAMS const FeatureParamsSize& get_size_params (hb_tag_t tag) const { if (tag == HB_TAG ('s','i','z','e')) return u.size; return Null (FeatureParamsSize); } const FeatureParamsStylisticSet& get_stylistic_set_params (hb_tag_t tag) const { if ((tag & 0xFFFF0000u) == HB_TAG ('s','s','\0','\0')) /* ssXX */ return u.stylisticSet; return Null (FeatureParamsStylisticSet); } const FeatureParamsCharacterVariants& get_character_variants_params (hb_tag_t tag) const { if ((tag & 0xFFFF0000u) == HB_TAG ('c','v','\0','\0')) /* cvXX */ return u.characterVariants; return Null (FeatureParamsCharacterVariants); } #endif private: union { FeatureParamsSize size; FeatureParamsStylisticSet stylisticSet; FeatureParamsCharacterVariants characterVariants; } u; public: DEFINE_SIZE_MIN (0); }; struct Record_sanitize_closure_t { hb_tag_t tag; const void *list_base; }; struct Feature { unsigned int get_lookup_count () const { return lookupIndex.len; } hb_tag_t get_lookup_index (unsigned int i) const { return lookupIndex[i]; } unsigned int get_lookup_indexes (unsigned int start_index, unsigned int *lookup_count /* IN/OUT */, unsigned int *lookup_tags /* OUT */) const { return lookupIndex.get_indexes (start_index, lookup_count, lookup_tags); } void add_lookup_indexes_to (hb_set_t *lookup_indexes) const { lookupIndex.add_indexes_to (lookup_indexes); } const FeatureParams &get_feature_params () const { return this+featureParams; } bool intersects_lookup_indexes (const hb_map_t *lookup_indexes) const { return lookupIndex.intersects (lookup_indexes); } bool subset (hb_subset_context_t *c, hb_subset_layout_context_t *l, const Tag *tag = nullptr) const { TRACE_SUBSET (this); auto *out = c->serializer->start_embed (*this); if (unlikely (!out || !c->serializer->extend_min (out))) return_trace (false); out->featureParams.serialize_subset (c, featureParams, this, tag); auto it = + hb_iter (lookupIndex) | hb_filter (l->lookup_index_map) | hb_map (l->lookup_index_map) ; out->lookupIndex.serialize (c->serializer, l, it); // The decision to keep or drop this feature is already made before we get here // so always retain it. return_trace (true); } bool sanitize (hb_sanitize_context_t *c, const Record_sanitize_closure_t *closure = nullptr) const { TRACE_SANITIZE (this); if (unlikely (!(c->check_struct (this) && lookupIndex.sanitize (c)))) return_trace (false); /* Some earlier versions of Adobe tools calculated the offset of the * FeatureParams subtable from the beginning of the FeatureList table! * * If sanitizing "failed" for the FeatureParams subtable, try it with the * alternative location. We would know sanitize "failed" if old value * of the offset was non-zero, but it's zeroed now. * * Only do this for the 'size' feature, since at the time of the faulty * Adobe tools, only the 'size' feature had FeatureParams defined. */ if (likely (featureParams.is_null ())) return_trace (true); unsigned int orig_offset = featureParams; if (unlikely (!featureParams.sanitize (c, this, closure ? closure->tag : HB_TAG_NONE))) return_trace (false); if (featureParams == 0 && closure && closure->tag == HB_TAG ('s','i','z','e') && closure->list_base && closure->list_base < this) { unsigned int new_offset_int = orig_offset - (((char *) this) - ((char *) closure->list_base)); Offset16To new_offset; /* Check that it would not overflow. */ new_offset = new_offset_int; if (new_offset == new_offset_int && c->try_set (&featureParams, new_offset_int) && !featureParams.sanitize (c, this, closure ? closure->tag : HB_TAG_NONE)) return_trace (false); } return_trace (true); } Offset16To featureParams; /* Offset to Feature Parameters table (if one * has been defined for the feature), relative * to the beginning of the Feature Table; = Null * if not required */ IndexArray lookupIndex; /* Array of LookupList indices */ public: DEFINE_SIZE_ARRAY_SIZED (4, lookupIndex); }; template struct Record { int cmp (hb_tag_t a) const { return tag.cmp (a); } bool subset (hb_subset_layout_context_t *c, const void *base, const void *f_sub = nullptr) const { TRACE_SUBSET (this); auto *out = c->subset_context->serializer->embed (this); if (unlikely (!out)) return_trace (false); if (!f_sub) return_trace (out->offset.serialize_subset (c->subset_context, offset, base, c, &tag)); const Feature& f = *reinterpret_cast (f_sub); auto *s = c->subset_context->serializer; s->push (); out->offset = 0; bool ret = f.subset (c->subset_context, c, &tag); if (ret) s->add_link (out->offset, s->pop_pack ()); else s->pop_discard (); return_trace (ret); } bool sanitize (hb_sanitize_context_t *c, const void *base) const { TRACE_SANITIZE (this); const Record_sanitize_closure_t closure = {tag, base}; return_trace (c->check_struct (this) && offset.sanitize (c, base, &closure)); } Tag tag; /* 4-byte Tag identifier */ Offset16To offset; /* Offset from beginning of object holding * the Record */ public: DEFINE_SIZE_STATIC (6); }; template struct RecordArrayOf : SortedArray16Of> { const Offset16To& get_offset (unsigned int i) const { return (*this)[i].offset; } Offset16To& get_offset (unsigned int i) { return (*this)[i].offset; } const Tag& get_tag (unsigned int i) const { return (*this)[i].tag; } unsigned int get_tags (unsigned int start_offset, unsigned int *record_count /* IN/OUT */, hb_tag_t *record_tags /* OUT */) const { if (record_count) { + this->sub_array (start_offset, record_count) | hb_map (&Record::tag) | hb_sink (hb_array (record_tags, *record_count)) ; } return this->len; } bool find_index (hb_tag_t tag, unsigned int *index) const { return this->bfind (tag, index, HB_NOT_FOUND_STORE, Index::NOT_FOUND_INDEX); } }; template struct RecordListOf : RecordArrayOf { const Type& operator [] (unsigned int i) const { return this+this->get_offset (i); } bool subset (hb_subset_context_t *c, hb_subset_layout_context_t *l) const { TRACE_SUBSET (this); auto *out = c->serializer->start_embed (*this); if (unlikely (!c->serializer->extend_min (out))) return_trace (false); + this->iter () | hb_apply (subset_record_array (l, out, this)) ; return_trace (true); } bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (RecordArrayOf::sanitize (c, this)); } }; struct RecordListOfFeature : RecordListOf { bool subset (hb_subset_context_t *c, hb_subset_layout_context_t *l) const { TRACE_SUBSET (this); auto *out = c->serializer->start_embed (*this); if (unlikely (!out || !c->serializer->extend_min (out))) return_trace (false); unsigned count = this->len; + hb_zip (*this, hb_range (count)) | hb_filter (l->feature_index_map, hb_second) | hb_apply ([l, out, this] (const hb_pair_t&, unsigned>& _) { const Feature *f_sub = nullptr; const Feature **f = nullptr; if (l->feature_substitutes_map->has (_.second, &f)) f_sub = *f; subset_record_array (l, out, this, f_sub) (_.first); }) ; return_trace (true); } }; typedef RecordListOf FeatureList; struct LangSys { unsigned int get_feature_count () const { return featureIndex.len; } hb_tag_t get_feature_index (unsigned int i) const { return featureIndex[i]; } unsigned int get_feature_indexes (unsigned int start_offset, unsigned int *feature_count /* IN/OUT */, unsigned int *feature_indexes /* OUT */) const { return featureIndex.get_indexes (start_offset, feature_count, feature_indexes); } void add_feature_indexes_to (hb_set_t *feature_indexes) const { featureIndex.add_indexes_to (feature_indexes); } bool has_required_feature () const { return reqFeatureIndex != 0xFFFFu; } unsigned int get_required_feature_index () const { if (reqFeatureIndex == 0xFFFFu) return Index::NOT_FOUND_INDEX; return reqFeatureIndex; } LangSys* copy (hb_serialize_context_t *c) const { TRACE_SERIALIZE (this); return_trace (c->embed (*this)); } bool compare (const LangSys& o, const hb_map_t *feature_index_map) const { if (reqFeatureIndex != o.reqFeatureIndex) return false; auto iter = + hb_iter (featureIndex) | hb_filter (feature_index_map) | hb_map (feature_index_map) ; auto o_iter = + hb_iter (o.featureIndex) | hb_filter (feature_index_map) | hb_map (feature_index_map) ; for (; iter && o_iter; iter++, o_iter++) { unsigned a = *iter; unsigned b = *o_iter; if (a != b) return false; } if (iter || o_iter) return false; return true; } void collect_features (hb_prune_langsys_context_t *c) const { if (!has_required_feature () && !get_feature_count ()) return; if (has_required_feature () && c->duplicate_feature_map->has (reqFeatureIndex)) c->new_feature_indexes->add (get_required_feature_index ()); + hb_iter (featureIndex) | hb_filter (c->duplicate_feature_map) | hb_sink (c->new_feature_indexes) ; } bool subset (hb_subset_context_t *c, hb_subset_layout_context_t *l, const Tag *tag = nullptr) const { TRACE_SUBSET (this); auto *out = c->serializer->start_embed (*this); if (unlikely (!out || !c->serializer->extend_min (out))) return_trace (false); const unsigned *v; out->reqFeatureIndex = l->feature_index_map->has (reqFeatureIndex, &v) ? *v : 0xFFFFu; if (!l->visitFeatureIndex (featureIndex.len)) return_trace (false); auto it = + hb_iter (featureIndex) | hb_filter (l->feature_index_map) | hb_map (l->feature_index_map) ; bool ret = bool (it); out->featureIndex.serialize (c->serializer, l, it); return_trace (ret); } bool sanitize (hb_sanitize_context_t *c, const Record_sanitize_closure_t * = nullptr) const { TRACE_SANITIZE (this); return_trace (c->check_struct (this) && featureIndex.sanitize (c)); } Offset16 lookupOrderZ; /* = Null (reserved for an offset to a * reordering table) */ HBUINT16 reqFeatureIndex;/* Index of a feature required for this * language system--if no required features * = 0xFFFFu */ IndexArray featureIndex; /* Array of indices into the FeatureList */ public: DEFINE_SIZE_ARRAY_SIZED (6, featureIndex); }; DECLARE_NULL_NAMESPACE_BYTES (OT, LangSys); struct Script { unsigned int get_lang_sys_count () const { return langSys.len; } const Tag& get_lang_sys_tag (unsigned int i) const { return langSys.get_tag (i); } unsigned int get_lang_sys_tags (unsigned int start_offset, unsigned int *lang_sys_count /* IN/OUT */, hb_tag_t *lang_sys_tags /* OUT */) const { return langSys.get_tags (start_offset, lang_sys_count, lang_sys_tags); } const LangSys& get_lang_sys (unsigned int i) const { if (i == Index::NOT_FOUND_INDEX) return get_default_lang_sys (); return this+langSys[i].offset; } bool find_lang_sys_index (hb_tag_t tag, unsigned int *index) const { return langSys.find_index (tag, index); } bool has_default_lang_sys () const { return defaultLangSys != 0; } const LangSys& get_default_lang_sys () const { return this+defaultLangSys; } void prune_langsys (hb_prune_langsys_context_t *c, unsigned script_index) const { if (!has_default_lang_sys () && !get_lang_sys_count ()) return; if (!c->visitScript ()) return; if (!c->script_langsys_map->has (script_index)) { if (unlikely (!c->script_langsys_map->set (script_index, hb::unique_ptr {hb_set_create ()}))) return; } unsigned langsys_count = get_lang_sys_count (); if (has_default_lang_sys ()) { //only collect features from non-redundant langsys const LangSys& d = get_default_lang_sys (); if (c->visitLangsys (d.get_feature_count ())) { d.collect_features (c); } for (auto _ : + hb_zip (langSys, hb_range (langsys_count))) { const LangSys& l = this+_.first.offset; if (!c->visitLangsys (l.get_feature_count ())) continue; if (l.compare (d, c->duplicate_feature_map)) continue; l.collect_features (c); c->script_langsys_map->get (script_index)->add (_.second); } } else { for (auto _ : + hb_zip (langSys, hb_range (langsys_count))) { const LangSys& l = this+_.first.offset; if (!c->visitLangsys (l.get_feature_count ())) continue; l.collect_features (c); c->script_langsys_map->get (script_index)->add (_.second); } } } bool subset (hb_subset_context_t *c, hb_subset_layout_context_t *l, const Tag *tag) const { TRACE_SUBSET (this); if (!l->visitScript ()) return_trace (false); if (tag && !c->plan->layout_scripts->has (*tag)) return false; auto *out = c->serializer->start_embed (*this); if (unlikely (!out || !c->serializer->extend_min (out))) return_trace (false); bool defaultLang = false; if (has_default_lang_sys ()) { c->serializer->push (); const LangSys& ls = this+defaultLangSys; bool ret = ls.subset (c, l); if (!ret && tag && *tag != HB_TAG ('D', 'F', 'L', 'T')) { c->serializer->pop_discard (); out->defaultLangSys = 0; } else { c->serializer->add_link (out->defaultLangSys, c->serializer->pop_pack ()); defaultLang = true; } } const hb_set_t *active_langsys = l->script_langsys_map->get (l->cur_script_index); if (active_langsys) { unsigned count = langSys.len; + hb_zip (langSys, hb_range (count)) | hb_filter (active_langsys, hb_second) | hb_map (hb_first) | hb_filter ([=] (const Record& record) {return l->visitLangSys (); }) | hb_apply (subset_record_array (l, &(out->langSys), this)) ; } return_trace (bool (out->langSys.len) || defaultLang || l->table_tag == HB_OT_TAG_GSUB); } bool sanitize (hb_sanitize_context_t *c, const Record_sanitize_closure_t * = nullptr) const { TRACE_SANITIZE (this); return_trace (defaultLangSys.sanitize (c, this) && langSys.sanitize (c, this)); } protected: Offset16To defaultLangSys; /* Offset to DefaultLangSys table--from * beginning of Script table--may be Null */ RecordArrayOf langSys; /* Array of LangSysRecords--listed * alphabetically by LangSysTag */ public: DEFINE_SIZE_ARRAY_SIZED (4, langSys); }; struct RecordListOfScript : RecordListOf