michael@0: /*
michael@0:  * Copyright © 2007,2008,2009  Red Hat, Inc.
michael@0:  * Copyright © 2010,2012  Google, Inc.
michael@0:  *
michael@0:  *  This is part of HarfBuzz, a text shaping library.
michael@0:  *
michael@0:  * Permission is hereby granted, without written agreement and without
michael@0:  * license or royalty fees, to use, copy, modify, and distribute this
michael@0:  * software and its documentation for any purpose, provided that the
michael@0:  * above copyright notice and the following two paragraphs appear in
michael@0:  * all copies of this software.
michael@0:  *
michael@0:  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
michael@0:  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
michael@0:  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
michael@0:  * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
michael@0:  * DAMAGE.
michael@0:  *
michael@0:  * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
michael@0:  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
michael@0:  * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
michael@0:  * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
michael@0:  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
michael@0:  *
michael@0:  * Red Hat Author(s): Behdad Esfahbod
michael@0:  * Google Author(s): Behdad Esfahbod
michael@0:  */
michael@0: 
michael@0: #ifndef HB_OT_LAYOUT_COMMON_PRIVATE_HH
michael@0: #define HB_OT_LAYOUT_COMMON_PRIVATE_HH
michael@0: 
michael@0: #include "hb-ot-layout-private.hh"
michael@0: #include "hb-open-type-private.hh"
michael@0: #include "hb-set-private.hh"
michael@0: 
michael@0: 
michael@0: namespace OT {
michael@0: 
michael@0: 
michael@0: #define NOT_COVERED		((unsigned int) -1)
michael@0: #define MAX_NESTING_LEVEL	8
michael@0: #define MAX_CONTEXT_LENGTH	64
michael@0: 
michael@0: 
michael@0: 
michael@0: /*
michael@0:  *
michael@0:  * OpenType Layout Common Table Formats
michael@0:  *
michael@0:  */
michael@0: 
michael@0: 
michael@0: /*
michael@0:  * Script, ScriptList, LangSys, Feature, FeatureList, Lookup, LookupList
michael@0:  */
michael@0: 
michael@0: template <typename Type>
michael@0: struct Record
michael@0: {
michael@0:   inline int cmp (hb_tag_t a) const {
michael@0:     return tag.cmp (a);
michael@0:   }
michael@0: 
michael@0:   struct sanitize_closure_t {
michael@0:     hb_tag_t tag;
michael@0:     void *list_base;
michael@0:   };
michael@0:   inline bool sanitize (hb_sanitize_context_t *c, void *base) {
michael@0:     TRACE_SANITIZE (this);
michael@0:     const sanitize_closure_t closure = {tag, base};
michael@0:     return TRACE_RETURN (c->check_struct (this) && offset.sanitize (c, base, &closure));
michael@0:   }
michael@0: 
michael@0:   Tag		tag;		/* 4-byte Tag identifier */
michael@0:   OffsetTo<Type>
michael@0: 		offset;		/* Offset from beginning of object holding
michael@0: 				 * the Record */
michael@0:   public:
michael@0:   DEFINE_SIZE_STATIC (6);
michael@0: };
michael@0: 
michael@0: template <typename Type>
michael@0: struct RecordArrayOf : SortedArrayOf<Record<Type> > {
michael@0:   inline const Tag& get_tag (unsigned int i) const
michael@0:   {
michael@0:     /* We cheat slightly and don't define separate Null objects
michael@0:      * for Record types.  Instead, we return the correct Null(Tag)
michael@0:      * here. */
michael@0:     if (unlikely (i >= this->len)) return Null(Tag);
michael@0:     return (*this)[i].tag;
michael@0:   }
michael@0:   inline unsigned int get_tags (unsigned int start_offset,
michael@0: 				unsigned int *record_count /* IN/OUT */,
michael@0: 				hb_tag_t     *record_tags /* OUT */) const
michael@0:   {
michael@0:     if (record_count) {
michael@0:       const Record<Type> *arr = this->sub_array (start_offset, record_count);
michael@0:       unsigned int count = *record_count;
michael@0:       for (unsigned int i = 0; i < count; i++)
michael@0: 	record_tags[i] = arr[i].tag;
michael@0:     }
michael@0:     return this->len;
michael@0:   }
michael@0:   inline bool find_index (hb_tag_t tag, unsigned int *index) const
michael@0:   {
michael@0:     int i = this->search (tag);
michael@0:     if (i != -1) {
michael@0:         if (index) *index = i;
michael@0:         return true;
michael@0:     } else {
michael@0:       if (index) *index = Index::NOT_FOUND_INDEX;
michael@0:       return false;
michael@0:     }
michael@0:   }
michael@0: };
michael@0: 
michael@0: template <typename Type>
michael@0: struct RecordListOf : RecordArrayOf<Type>
michael@0: {
michael@0:   inline const Type& operator [] (unsigned int i) const
michael@0:   { return this+RecordArrayOf<Type>::operator [](i).offset; }
michael@0: 
michael@0:   inline bool sanitize (hb_sanitize_context_t *c) {
michael@0:     TRACE_SANITIZE (this);
michael@0:     return TRACE_RETURN (RecordArrayOf<Type>::sanitize (c, this));
michael@0:   }
michael@0: };
michael@0: 
michael@0: 
michael@0: struct RangeRecord
michael@0: {
michael@0:   inline int cmp (hb_codepoint_t g) const {
michael@0:     return g < start ? -1 : g <= end ? 0 : +1 ;
michael@0:   }
michael@0: 
michael@0:   inline bool sanitize (hb_sanitize_context_t *c) {
michael@0:     TRACE_SANITIZE (this);
michael@0:     return TRACE_RETURN (c->check_struct (this));
michael@0:   }
michael@0: 
michael@0:   inline bool intersects (const hb_set_t *glyphs) const {
michael@0:     return glyphs->intersects (start, end);
michael@0:   }
michael@0: 
michael@0:   template <typename set_t>
michael@0:   inline void add_coverage (set_t *glyphs) const {
michael@0:     glyphs->add_range (start, end);
michael@0:   }
michael@0: 
michael@0:   GlyphID	start;		/* First GlyphID in the range */
michael@0:   GlyphID	end;		/* Last GlyphID in the range */
michael@0:   USHORT	value;		/* Value */
michael@0:   public:
michael@0:   DEFINE_SIZE_STATIC (6);
michael@0: };
michael@0: DEFINE_NULL_DATA (RangeRecord, "\000\001");
michael@0: 
michael@0: 
michael@0: struct IndexArray : ArrayOf<Index>
michael@0: {
michael@0:   inline unsigned int get_indexes (unsigned int start_offset,
michael@0: 				   unsigned int *_count /* IN/OUT */,
michael@0: 				   unsigned int *_indexes /* OUT */) const
michael@0:   {
michael@0:     if (_count) {
michael@0:       const USHORT *arr = this->sub_array (start_offset, _count);
michael@0:       unsigned int count = *_count;
michael@0:       for (unsigned int i = 0; i < count; i++)
michael@0: 	_indexes[i] = arr[i];
michael@0:     }
michael@0:     return this->len;
michael@0:   }
michael@0: };
michael@0: 
michael@0: 
michael@0: struct Script;
michael@0: struct LangSys;
michael@0: struct Feature;
michael@0: 
michael@0: 
michael@0: struct LangSys
michael@0: {
michael@0:   inline unsigned int get_feature_count (void) const
michael@0:   { return featureIndex.len; }
michael@0:   inline hb_tag_t get_feature_index (unsigned int i) const
michael@0:   { return featureIndex[i]; }
michael@0:   inline unsigned int get_feature_indexes (unsigned int start_offset,
michael@0: 					   unsigned int *feature_count /* IN/OUT */,
michael@0: 					   unsigned int *feature_indexes /* OUT */) const
michael@0:   { return featureIndex.get_indexes (start_offset, feature_count, feature_indexes); }
michael@0: 
michael@0:   inline bool has_required_feature (void) const { return reqFeatureIndex != 0xffff; }
michael@0:   inline unsigned int get_required_feature_index (void) const
michael@0:   {
michael@0:     if (reqFeatureIndex == 0xffff)
michael@0:       return Index::NOT_FOUND_INDEX;
michael@0:    return reqFeatureIndex;;
michael@0:   }
michael@0: 
michael@0:   inline bool sanitize (hb_sanitize_context_t *c,
michael@0: 			const Record<LangSys>::sanitize_closure_t * = NULL) {
michael@0:     TRACE_SANITIZE (this);
michael@0:     return TRACE_RETURN (c->check_struct (this) && featureIndex.sanitize (c));
michael@0:   }
michael@0: 
michael@0:   Offset	lookupOrder;	/* = Null (reserved for an offset to a
michael@0: 				 * reordering table) */
michael@0:   USHORT	reqFeatureIndex;/* Index of a feature required for this
michael@0: 				 * language system--if no required features
michael@0: 				 * = 0xFFFF */
michael@0:   IndexArray	featureIndex;	/* Array of indices into the FeatureList */
michael@0:   public:
michael@0:   DEFINE_SIZE_ARRAY (6, featureIndex);
michael@0: };
michael@0: DEFINE_NULL_DATA (LangSys, "\0\0\xFF\xFF");
michael@0: 
michael@0: 
michael@0: struct Script
michael@0: {
michael@0:   inline unsigned int get_lang_sys_count (void) const
michael@0:   { return langSys.len; }
michael@0:   inline const Tag& get_lang_sys_tag (unsigned int i) const
michael@0:   { return langSys.get_tag (i); }
michael@0:   inline unsigned int get_lang_sys_tags (unsigned int start_offset,
michael@0: 					 unsigned int *lang_sys_count /* IN/OUT */,
michael@0: 					 hb_tag_t     *lang_sys_tags /* OUT */) const
michael@0:   { return langSys.get_tags (start_offset, lang_sys_count, lang_sys_tags); }
michael@0:   inline const LangSys& get_lang_sys (unsigned int i) const
michael@0:   {
michael@0:     if (i == Index::NOT_FOUND_INDEX) return get_default_lang_sys ();
michael@0:     return this+langSys[i].offset;
michael@0:   }
michael@0:   inline bool find_lang_sys_index (hb_tag_t tag, unsigned int *index) const
michael@0:   { return langSys.find_index (tag, index); }
michael@0: 
michael@0:   inline bool has_default_lang_sys (void) const { return defaultLangSys != 0; }
michael@0:   inline const LangSys& get_default_lang_sys (void) const { return this+defaultLangSys; }
michael@0: 
michael@0:   inline bool sanitize (hb_sanitize_context_t *c,
michael@0: 			const Record<Script>::sanitize_closure_t * = NULL) {
michael@0:     TRACE_SANITIZE (this);
michael@0:     return TRACE_RETURN (defaultLangSys.sanitize (c, this) && langSys.sanitize (c, this));
michael@0:   }
michael@0: 
michael@0:   protected:
michael@0:   OffsetTo<LangSys>
michael@0: 		defaultLangSys;	/* Offset to DefaultLangSys table--from
michael@0: 				 * beginning of Script table--may be Null */
michael@0:   RecordArrayOf<LangSys>
michael@0: 		langSys;	/* Array of LangSysRecords--listed
michael@0: 				 * alphabetically by LangSysTag */
michael@0:   public:
michael@0:   DEFINE_SIZE_ARRAY (4, langSys);
michael@0: };
michael@0: 
michael@0: typedef RecordListOf<Script> ScriptList;
michael@0: 
michael@0: 
michael@0: /* http://www.microsoft.com/typography/otspec/features_pt.htm#size */
michael@0: struct FeatureParamsSize
michael@0: {
michael@0:   inline bool sanitize (hb_sanitize_context_t *c) {
michael@0:     TRACE_SANITIZE (this);
michael@0:     if (unlikely (!c->check_struct (this))) return TRACE_RETURN (false);
michael@0: 
michael@0:     /* This subtable has some "history", if you will.  Some earlier versions of
michael@0:      * Adobe tools calculated the offset of the FeatureParams sutable from the
michael@0:      * beginning of the FeatureList table!  Now, that is dealt with in the
michael@0:      * Feature implementation.  But we still need to be able to tell junk from
michael@0:      * real data.  Note: We don't check that the nameID actually exists.
michael@0:      *
michael@0:      * Read Roberts wrote on 9/15/06 on opentype-list@indx.co.uk :
michael@0:      *
michael@0:      * Yes, it is correct that a new version of the AFDKO (version 2.0) will be
michael@0:      * coming out soon, and that the makeotf program will build a font with a
michael@0:      * 'size' feature that is correct by the specification.
michael@0:      *
michael@0:      * The specification for this feature tag is in the "OpenType Layout Tag
michael@0:      * Registry". You can see a copy of this at:
michael@0:      * http://partners.adobe.com/public/developer/opentype/index_tag8.html#size
michael@0:      *
michael@0:      * Here is one set of rules to determine if the 'size' feature is built
michael@0:      * correctly, or as by the older versions of MakeOTF. You may be able to do
michael@0:      * better.
michael@0:      *
michael@0:      * Assume that the offset to the size feature is according to specification,
michael@0:      * and make the following value checks. If it fails, assume the the size
michael@0:      * feature is calculated as versions of MakeOTF before the AFDKO 2.0 built it.
michael@0:      * If this fails, reject the 'size' feature. The older makeOTF's calculated the
michael@0:      * offset from the beginning of the FeatureList table, rather than from the
michael@0:      * beginning of the 'size' Feature table.
michael@0:      *
michael@0:      * If "design size" == 0:
michael@0:      *     fails check
michael@0:      *
michael@0:      * Else if ("subfamily identifier" == 0 and
michael@0:      *     "range start" == 0 and
michael@0:      *     "range end" == 0 and
michael@0:      *     "range start" == 0 and
michael@0:      *     "menu name ID" == 0)
michael@0:      *     passes check: this is the format used when there is a design size
michael@0:      * specified, but there is no recommended size range.
michael@0:      *
michael@0:      * Else if ("design size" <  "range start" or
michael@0:      *     "design size" >   "range end" or
michael@0:      *     "range end" <= "range start" or
michael@0:      *     "menu name ID"  < 256 or
michael@0:      *     "menu name ID"  > 32767 or
michael@0:      *     menu name ID is not a name ID which is actually in the name table)
michael@0:      *     fails test
michael@0:      * Else
michael@0:      *     passes test.
michael@0:      */
michael@0: 
michael@0:     if (!designSize)
michael@0:       return TRACE_RETURN (false);
michael@0:     else if (subfamilyID == 0 &&
michael@0: 	     subfamilyNameID == 0 &&
michael@0: 	     rangeStart == 0 &&
michael@0: 	     rangeEnd == 0)
michael@0:       return TRACE_RETURN (true);
michael@0:     else if (designSize < rangeStart ||
michael@0: 	     designSize > rangeEnd ||
michael@0: 	     subfamilyNameID < 256 ||
michael@0: 	     subfamilyNameID > 32767)
michael@0:       return TRACE_RETURN (false);
michael@0:     else
michael@0:       return TRACE_RETURN (true);
michael@0:   }
michael@0: 
michael@0:   USHORT	designSize;	/* Represents the design size in 720/inch
michael@0: 				 * units (decipoints).  The design size entry
michael@0: 				 * must be non-zero.  When there is a design
michael@0: 				 * size but no recommended size range, the
michael@0: 				 * rest of the array will consist of zeros. */
michael@0:   USHORT	subfamilyID;	/* Has no independent meaning, but serves
michael@0: 				 * as an identifier that associates fonts
michael@0: 				 * in a subfamily. All fonts which share a
michael@0: 				 * Preferred or Font Family name and which
michael@0: 				 * differ only by size range shall have the
michael@0: 				 * same subfamily value, and no fonts which
michael@0: 				 * differ in weight or style shall have the
michael@0: 				 * same subfamily value. If this value is
michael@0: 				 * zero, the remaining fields in the array
michael@0: 				 * will be ignored. */
michael@0:   USHORT	subfamilyNameID;/* If the preceding value is non-zero, this
michael@0: 				 * value must be set in the range 256 - 32767
michael@0: 				 * (inclusive). It records the value of a
michael@0: 				 * field in the name table, which must
michael@0: 				 * contain English-language strings encoded
michael@0: 				 * in Windows Unicode and Macintosh Roman,
michael@0: 				 * and may contain additional strings
michael@0: 				 * localized to other scripts and languages.
michael@0: 				 * Each of these strings is the name an
michael@0: 				 * application should use, in combination
michael@0: 				 * with the family name, to represent the
michael@0: 				 * subfamily in a menu.  Applications will
michael@0: 				 * choose the appropriate version based on
michael@0: 				 * their selection criteria. */
michael@0:   USHORT	rangeStart;	/* Large end of the recommended usage range
michael@0: 				 * (inclusive), stored in 720/inch units
michael@0: 				 * (decipoints). */
michael@0:   USHORT	rangeEnd;	/* Small end of the recommended usage range
michael@0: 				   (exclusive), stored in 720/inch units
michael@0: 				 * (decipoints). */
michael@0:   public:
michael@0:   DEFINE_SIZE_STATIC (10);
michael@0: };
michael@0: 
michael@0: /* http://www.microsoft.com/typography/otspec/features_pt.htm#ssxx */
michael@0: struct FeatureParamsStylisticSet
michael@0: {
michael@0:   inline bool sanitize (hb_sanitize_context_t *c) {
michael@0:     TRACE_SANITIZE (this);
michael@0:     /* Right now minorVersion is at zero.  Which means, any table supports
michael@0:      * the uiNameID field. */
michael@0:     return TRACE_RETURN (c->check_struct (this));
michael@0:   }
michael@0: 
michael@0:   USHORT	version;	/* (set to 0): This corresponds to a “minor”
michael@0: 				 * version number. Additional data may be
michael@0: 				 * added to the end of this Feature Parameters
michael@0: 				 * table in the future. */
michael@0: 
michael@0:   USHORT	uiNameID;	/* The 'name' table name ID that specifies a
michael@0: 				 * string (or strings, for multiple languages)
michael@0: 				 * for a user-interface label for this
michael@0: 				 * feature.  The values of uiLabelNameId and
michael@0: 				 * sampleTextNameId are expected to be in the
michael@0: 				 * font-specific name ID range (256-32767),
michael@0: 				 * though that is not a requirement in this
michael@0: 				 * Feature Parameters specification. The
michael@0: 				 * user-interface label for the feature can
michael@0: 				 * be provided in multiple languages. An
michael@0: 				 * English string should be included as a
michael@0: 				 * fallback. The string should be kept to a
michael@0: 				 * minimal length to fit comfortably with
michael@0: 				 * different application interfaces. */
michael@0:   public:
michael@0:   DEFINE_SIZE_STATIC (4);
michael@0: };
michael@0: 
michael@0: /* http://www.microsoft.com/typography/otspec/features_ae.htm#cv01-cv99 */
michael@0: struct FeatureParamsCharacterVariants
michael@0: {
michael@0:   inline bool sanitize (hb_sanitize_context_t *c) {
michael@0:     TRACE_SANITIZE (this);
michael@0:     return TRACE_RETURN (c->check_struct (this) &&
michael@0: 			 characters.sanitize (c));
michael@0:   }
michael@0: 
michael@0:   USHORT	format;			/* Format number is set to 0. */
michael@0:   USHORT	featUILableNameID;	/* The ‘name’ table name ID that
michael@0: 					 * specifies a string (or strings,
michael@0: 					 * for multiple languages) for a
michael@0: 					 * user-interface label for this
michael@0: 					 * feature. (May be NULL.) */
michael@0:   USHORT	featUITooltipTextNameID;/* The ‘name’ table name ID that
michael@0: 					 * specifies a string (or strings,
michael@0: 					 * for multiple languages) that an
michael@0: 					 * application can use for tooltip
michael@0: 					 * text for this feature. (May be
michael@0: 					 * NULL.) */
michael@0:   USHORT	sampleTextNameID;	/* The ‘name’ table name ID that
michael@0: 					 * specifies sample text that
michael@0: 					 * illustrates the effect of this
michael@0: 					 * feature. (May be NULL.) */
michael@0:   USHORT	numNamedParameters;	/* Number of named parameters. (May
michael@0: 					 * be zero.) */
michael@0:   USHORT	firstParamUILabelNameID;/* The first ‘name’ table name ID
michael@0: 					 * used to specify strings for
michael@0: 					 * user-interface labels for the
michael@0: 					 * feature parameters. (Must be zero
michael@0: 					 * if numParameters is zero.) */
michael@0:   ArrayOf<UINT24>
michael@0: 		characters;		/* Array of the Unicode Scalar Value
michael@0: 					 * of the characters for which this
michael@0: 					 * feature provides glyph variants.
michael@0: 					 * (May be zero.) */
michael@0:   public:
michael@0:   DEFINE_SIZE_ARRAY (14, characters);
michael@0: };
michael@0: 
michael@0: struct FeatureParams
michael@0: {
michael@0:   inline bool sanitize (hb_sanitize_context_t *c, hb_tag_t tag) {
michael@0:     TRACE_SANITIZE (this);
michael@0:     if (tag == HB_TAG ('s','i','z','e'))
michael@0:       return TRACE_RETURN (u.size.sanitize (c));
michael@0:     if ((tag & 0xFFFF0000) == HB_TAG ('s','s','\0','\0')) /* ssXX */
michael@0:       return TRACE_RETURN (u.stylisticSet.sanitize (c));
michael@0:     if ((tag & 0xFFFF0000) == HB_TAG ('c','v','\0','\0')) /* cvXX */
michael@0:       return TRACE_RETURN (u.characterVariants.sanitize (c));
michael@0:     return TRACE_RETURN (true);
michael@0:   }
michael@0: 
michael@0:   inline const FeatureParamsSize& get_size_params (hb_tag_t tag) const
michael@0:   {
michael@0:     if (tag == HB_TAG ('s','i','z','e'))
michael@0:       return u.size;
michael@0:     return Null(FeatureParamsSize);
michael@0:   }
michael@0: 
michael@0:   private:
michael@0:   union {
michael@0:   FeatureParamsSize			size;
michael@0:   FeatureParamsStylisticSet		stylisticSet;
michael@0:   FeatureParamsCharacterVariants	characterVariants;
michael@0:   } u;
michael@0:   DEFINE_SIZE_STATIC (17);
michael@0: };
michael@0: 
michael@0: struct Feature
michael@0: {
michael@0:   inline unsigned int get_lookup_count (void) const
michael@0:   { return lookupIndex.len; }
michael@0:   inline hb_tag_t get_lookup_index (unsigned int i) const
michael@0:   { return lookupIndex[i]; }
michael@0:   inline unsigned int get_lookup_indexes (unsigned int start_index,
michael@0: 					  unsigned int *lookup_count /* IN/OUT */,
michael@0: 					  unsigned int *lookup_tags /* OUT */) const
michael@0:   { return lookupIndex.get_indexes (start_index, lookup_count, lookup_tags); }
michael@0: 
michael@0:   inline const FeatureParams &get_feature_params (void) const
michael@0:   { return this+featureParams; }
michael@0: 
michael@0:   inline bool sanitize (hb_sanitize_context_t *c,
michael@0: 			const Record<Feature>::sanitize_closure_t *closure) {
michael@0:     TRACE_SANITIZE (this);
michael@0:     if (unlikely (!(c->check_struct (this) && lookupIndex.sanitize (c))))
michael@0:       return TRACE_RETURN (false);
michael@0: 
michael@0:     /* Some earlier versions of Adobe tools calculated the offset of the
michael@0:      * FeatureParams subtable from the beginning of the FeatureList table!
michael@0:      *
michael@0:      * If sanitizing "failed" for the FeatureParams subtable, try it with the
michael@0:      * alternative location.  We would know sanitize "failed" if old value
michael@0:      * of the offset was non-zero, but it's zeroed now.
michael@0:      *
michael@0:      * Only do this for the 'size' feature, since at the time of the faulty
michael@0:      * Adobe tools, only the 'size' feature had FeatureParams defined.
michael@0:      */
michael@0: 
michael@0:     Offset orig_offset = featureParams;
michael@0:     if (unlikely (!featureParams.sanitize (c, this, closure ? closure->tag : HB_TAG_NONE)))
michael@0:       return TRACE_RETURN (false);
michael@0: 
michael@0:     if (likely (!orig_offset))
michael@0:       return TRACE_RETURN (true);
michael@0: 
michael@0:     if (featureParams == 0 && closure &&
michael@0: 	closure->tag == HB_TAG ('s','i','z','e') &&
michael@0: 	closure->list_base && closure->list_base < this)
michael@0:     {
michael@0:       unsigned int new_offset_int = (unsigned int) orig_offset -
michael@0: 				    ((char *) this - (char *) closure->list_base);
michael@0: 
michael@0:       Offset new_offset;
michael@0:       /* Check that it did not overflow. */
michael@0:       new_offset.set (new_offset_int);
michael@0:       if (new_offset == new_offset_int &&
michael@0: 	  featureParams.try_set (c, new_offset) &&
michael@0: 	  !featureParams.sanitize (c, this, closure ? closure->tag : HB_TAG_NONE))
michael@0: 	return TRACE_RETURN (false);
michael@0:     }
michael@0: 
michael@0:     return TRACE_RETURN (true);
michael@0:   }
michael@0: 
michael@0:   OffsetTo<FeatureParams>
michael@0: 		 featureParams;	/* Offset to Feature Parameters table (if one
michael@0: 				 * has been defined for the feature), relative
michael@0: 				 * to the beginning of the Feature Table; = Null
michael@0: 				 * if not required */
michael@0:   IndexArray	 lookupIndex;	/* Array of LookupList indices */
michael@0:   public:
michael@0:   DEFINE_SIZE_ARRAY (4, lookupIndex);
michael@0: };
michael@0: 
michael@0: typedef RecordListOf<Feature> FeatureList;
michael@0: 
michael@0: 
michael@0: struct LookupFlag : USHORT
michael@0: {
michael@0:   enum Flags {
michael@0:     RightToLeft		= 0x0001u,
michael@0:     IgnoreBaseGlyphs	= 0x0002u,
michael@0:     IgnoreLigatures	= 0x0004u,
michael@0:     IgnoreMarks		= 0x0008u,
michael@0:     IgnoreFlags		= 0x000Eu,
michael@0:     UseMarkFilteringSet	= 0x0010u,
michael@0:     Reserved		= 0x00E0u,
michael@0:     MarkAttachmentType	= 0xFF00u
michael@0:   };
michael@0:   public:
michael@0:   DEFINE_SIZE_STATIC (2);
michael@0: };
michael@0: 
michael@0: struct Lookup
michael@0: {
michael@0:   inline unsigned int get_subtable_count (void) const { return subTable.len; }
michael@0: 
michael@0:   inline unsigned int get_type (void) const { return lookupType; }
michael@0: 
michael@0:   /* lookup_props is a 32-bit integer where the lower 16-bit is LookupFlag and
michael@0:    * higher 16-bit is mark-filtering-set if the lookup uses one.
michael@0:    * Not to be confused with glyph_props which is very similar. */
michael@0:   inline uint32_t get_props (void) const
michael@0:   {
michael@0:     unsigned int flag = lookupFlag;
michael@0:     if (unlikely (flag & LookupFlag::UseMarkFilteringSet))
michael@0:     {
michael@0:       const USHORT &markFilteringSet = StructAfter<USHORT> (subTable);
michael@0:       flag += (markFilteringSet << 16);
michael@0:     }
michael@0:     return flag;
michael@0:   }
michael@0: 
michael@0:   inline bool serialize (hb_serialize_context_t *c,
michael@0: 			 unsigned int lookup_type,
michael@0: 			 uint32_t lookup_props,
michael@0: 			 unsigned int num_subtables)
michael@0:   {
michael@0:     TRACE_SERIALIZE (this);
michael@0:     if (unlikely (!c->extend_min (*this))) return TRACE_RETURN (false);
michael@0:     lookupType.set (lookup_type);
michael@0:     lookupFlag.set (lookup_props & 0xFFFF);
michael@0:     if (unlikely (!subTable.serialize (c, num_subtables))) return TRACE_RETURN (false);
michael@0:     if (lookupFlag & LookupFlag::UseMarkFilteringSet)
michael@0:     {
michael@0:       USHORT &markFilteringSet = StructAfter<USHORT> (subTable);
michael@0:       markFilteringSet.set (lookup_props >> 16);
michael@0:     }
michael@0:     return TRACE_RETURN (true);
michael@0:   }
michael@0: 
michael@0:   inline bool sanitize (hb_sanitize_context_t *c) {
michael@0:     TRACE_SANITIZE (this);
michael@0:     /* Real sanitize of the subtables is done by GSUB/GPOS/... */
michael@0:     if (!(c->check_struct (this) && subTable.sanitize (c))) return TRACE_RETURN (false);
michael@0:     if (lookupFlag & LookupFlag::UseMarkFilteringSet)
michael@0:     {
michael@0:       USHORT &markFilteringSet = StructAfter<USHORT> (subTable);
michael@0:       if (!markFilteringSet.sanitize (c)) return TRACE_RETURN (false);
michael@0:     }
michael@0:     return TRACE_RETURN (true);
michael@0:   }
michael@0: 
michael@0:   USHORT	lookupType;		/* Different enumerations for GSUB and GPOS */
michael@0:   USHORT	lookupFlag;		/* Lookup qualifiers */
michael@0:   ArrayOf<Offset>
michael@0: 		subTable;		/* Array of SubTables */
michael@0:   USHORT	markFilteringSetX[VAR];	/* Index (base 0) into GDEF mark glyph sets
michael@0: 					 * structure. This field is only present if bit
michael@0: 					 * UseMarkFilteringSet of lookup flags is set. */
michael@0:   public:
michael@0:   DEFINE_SIZE_ARRAY2 (6, subTable, markFilteringSetX);
michael@0: };
michael@0: 
michael@0: typedef OffsetListOf<Lookup> LookupList;
michael@0: 
michael@0: 
michael@0: /*
michael@0:  * Coverage Table
michael@0:  */
michael@0: 
michael@0: struct CoverageFormat1
michael@0: {
michael@0:   friend struct Coverage;
michael@0: 
michael@0:   private:
michael@0:   inline unsigned int get_coverage (hb_codepoint_t glyph_id) const
michael@0:   {
michael@0:     int i = glyphArray.search (glyph_id);
michael@0:     ASSERT_STATIC (((unsigned int) -1) == NOT_COVERED);
michael@0:     return i;
michael@0:   }
michael@0: 
michael@0:   inline bool serialize (hb_serialize_context_t *c,
michael@0: 			 Supplier<GlyphID> &glyphs,
michael@0: 			 unsigned int num_glyphs)
michael@0:   {
michael@0:     TRACE_SERIALIZE (this);
michael@0:     if (unlikely (!c->extend_min (*this))) return TRACE_RETURN (false);
michael@0:     glyphArray.len.set (num_glyphs);
michael@0:     if (unlikely (!c->extend (glyphArray))) return TRACE_RETURN (false);
michael@0:     for (unsigned int i = 0; i < num_glyphs; i++)
michael@0:       glyphArray[i] = glyphs[i];
michael@0:     glyphs.advance (num_glyphs);
michael@0:     return TRACE_RETURN (true);
michael@0:   }
michael@0: 
michael@0:   inline bool sanitize (hb_sanitize_context_t *c) {
michael@0:     TRACE_SANITIZE (this);
michael@0:     return TRACE_RETURN (glyphArray.sanitize (c));
michael@0:   }
michael@0: 
michael@0:   inline bool intersects_coverage (const hb_set_t *glyphs, unsigned int index) const {
michael@0:     return glyphs->has (glyphArray[index]);
michael@0:   }
michael@0: 
michael@0:   template <typename set_t>
michael@0:   inline void add_coverage (set_t *glyphs) const {
michael@0:     unsigned int count = glyphArray.len;
michael@0:     for (unsigned int i = 0; i < count; i++)
michael@0:       glyphs->add (glyphArray[i]);
michael@0:   }
michael@0: 
michael@0:   public:
michael@0:   /* Older compilers need this to be public. */
michael@0:   struct Iter {
michael@0:     inline void init (const struct CoverageFormat1 &c_) { c = &c_; i = 0; };
michael@0:     inline bool more (void) { return i < c->glyphArray.len; }
michael@0:     inline void next (void) { i++; }
michael@0:     inline uint16_t get_glyph (void) { return c->glyphArray[i]; }
michael@0:     inline uint16_t get_coverage (void) { return i; }
michael@0: 
michael@0:     private:
michael@0:     const struct CoverageFormat1 *c;
michael@0:     unsigned int i;
michael@0:   };
michael@0:   private:
michael@0: 
michael@0:   protected:
michael@0:   USHORT	coverageFormat;	/* Format identifier--format = 1 */
michael@0:   SortedArrayOf<GlyphID>
michael@0: 		glyphArray;	/* Array of GlyphIDs--in numerical order */
michael@0:   public:
michael@0:   DEFINE_SIZE_ARRAY (4, glyphArray);
michael@0: };
michael@0: 
michael@0: struct CoverageFormat2
michael@0: {
michael@0:   friend struct Coverage;
michael@0: 
michael@0:   private:
michael@0:   inline unsigned int get_coverage (hb_codepoint_t glyph_id) const
michael@0:   {
michael@0:     int i = rangeRecord.search (glyph_id);
michael@0:     if (i != -1) {
michael@0:       const RangeRecord &range = rangeRecord[i];
michael@0:       return (unsigned int) range.value + (glyph_id - range.start);
michael@0:     }
michael@0:     return NOT_COVERED;
michael@0:   }
michael@0: 
michael@0:   inline bool serialize (hb_serialize_context_t *c,
michael@0: 			 Supplier<GlyphID> &glyphs,
michael@0: 			 unsigned int num_glyphs)
michael@0:   {
michael@0:     TRACE_SERIALIZE (this);
michael@0:     if (unlikely (!c->extend_min (*this))) return TRACE_RETURN (false);
michael@0: 
michael@0:     if (unlikely (!num_glyphs)) return TRACE_RETURN (true);
michael@0: 
michael@0:     unsigned int num_ranges = 1;
michael@0:     for (unsigned int i = 1; i < num_glyphs; i++)
michael@0:       if (glyphs[i - 1] + 1 != glyphs[i])
michael@0:         num_ranges++;
michael@0:     rangeRecord.len.set (num_ranges);
michael@0:     if (unlikely (!c->extend (rangeRecord))) return TRACE_RETURN (false);
michael@0: 
michael@0:     unsigned int range = 0;
michael@0:     rangeRecord[range].start = glyphs[0];
michael@0:     rangeRecord[range].value.set (0);
michael@0:     for (unsigned int i = 1; i < num_glyphs; i++)
michael@0:       if (glyphs[i - 1] + 1 != glyphs[i]) {
michael@0: 	range++;
michael@0: 	rangeRecord[range].start = glyphs[i];
michael@0: 	rangeRecord[range].value.set (i);
michael@0:         rangeRecord[range].end = glyphs[i];
michael@0:       } else {
michael@0:         rangeRecord[range].end = glyphs[i];
michael@0:       }
michael@0:     glyphs.advance (num_glyphs);
michael@0:     return TRACE_RETURN (true);
michael@0:   }
michael@0: 
michael@0:   inline bool sanitize (hb_sanitize_context_t *c) {
michael@0:     TRACE_SANITIZE (this);
michael@0:     return TRACE_RETURN (rangeRecord.sanitize (c));
michael@0:   }
michael@0: 
michael@0:   inline bool intersects_coverage (const hb_set_t *glyphs, unsigned int index) const {
michael@0:     unsigned int i;
michael@0:     unsigned int count = rangeRecord.len;
michael@0:     for (i = 0; i < count; i++) {
michael@0:       const RangeRecord &range = rangeRecord[i];
michael@0:       if (range.value <= index &&
michael@0: 	  index < (unsigned int) range.value + (range.end - range.start) &&
michael@0: 	  range.intersects (glyphs))
michael@0:         return true;
michael@0:       else if (index < range.value)
michael@0:         return false;
michael@0:     }
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   template <typename set_t>
michael@0:   inline void add_coverage (set_t *glyphs) const {
michael@0:     unsigned int count = rangeRecord.len;
michael@0:     for (unsigned int i = 0; i < count; i++)
michael@0:       rangeRecord[i].add_coverage (glyphs);
michael@0:   }
michael@0: 
michael@0:   public:
michael@0:   /* Older compilers need this to be public. */
michael@0:   struct Iter {
michael@0:     inline void init (const CoverageFormat2 &c_) {
michael@0:       c = &c_;
michael@0:       coverage = 0;
michael@0:       i = 0;
michael@0:       j = c->rangeRecord.len ? c_.rangeRecord[0].start : 0;
michael@0:     }
michael@0:     inline bool more (void) { return i < c->rangeRecord.len; }
michael@0:     inline void next (void) {
michael@0:       coverage++;
michael@0:       if (j == c->rangeRecord[i].end) {
michael@0:         i++;
michael@0: 	if (more ())
michael@0: 	  j = c->rangeRecord[i].start;
michael@0: 	return;
michael@0:       }
michael@0:       j++;
michael@0:     }
michael@0:     inline uint16_t get_glyph (void) { return j; }
michael@0:     inline uint16_t get_coverage (void) { return coverage; }
michael@0: 
michael@0:     private:
michael@0:     const struct CoverageFormat2 *c;
michael@0:     unsigned int i, j, coverage;
michael@0:   };
michael@0:   private:
michael@0: 
michael@0:   protected:
michael@0:   USHORT	coverageFormat;	/* Format identifier--format = 2 */
michael@0:   SortedArrayOf<RangeRecord>
michael@0: 		rangeRecord;	/* Array of glyph ranges--ordered by
michael@0: 				 * Start GlyphID. rangeCount entries
michael@0: 				 * long */
michael@0:   public:
michael@0:   DEFINE_SIZE_ARRAY (4, rangeRecord);
michael@0: };
michael@0: 
michael@0: struct Coverage
michael@0: {
michael@0:   inline unsigned int get_coverage (hb_codepoint_t glyph_id) const
michael@0:   {
michael@0:     switch (u.format) {
michael@0:     case 1: return u.format1.get_coverage(glyph_id);
michael@0:     case 2: return u.format2.get_coverage(glyph_id);
michael@0:     default:return NOT_COVERED;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   inline bool serialize (hb_serialize_context_t *c,
michael@0: 			 Supplier<GlyphID> &glyphs,
michael@0: 			 unsigned int num_glyphs)
michael@0:   {
michael@0:     TRACE_SERIALIZE (this);
michael@0:     if (unlikely (!c->extend_min (*this))) return TRACE_RETURN (false);
michael@0:     unsigned int num_ranges = 1;
michael@0:     for (unsigned int i = 1; i < num_glyphs; i++)
michael@0:       if (glyphs[i - 1] + 1 != glyphs[i])
michael@0:         num_ranges++;
michael@0:     u.format.set (num_glyphs * 2 < num_ranges * 3 ? 1 : 2);
michael@0:     switch (u.format) {
michael@0:     case 1: return TRACE_RETURN (u.format1.serialize (c, glyphs, num_glyphs));
michael@0:     case 2: return TRACE_RETURN (u.format2.serialize (c, glyphs, num_glyphs));
michael@0:     default:return TRACE_RETURN (false);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   inline bool sanitize (hb_sanitize_context_t *c) {
michael@0:     TRACE_SANITIZE (this);
michael@0:     if (!u.format.sanitize (c)) return TRACE_RETURN (false);
michael@0:     switch (u.format) {
michael@0:     case 1: return TRACE_RETURN (u.format1.sanitize (c));
michael@0:     case 2: return TRACE_RETURN (u.format2.sanitize (c));
michael@0:     default:return TRACE_RETURN (true);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   inline bool intersects (const hb_set_t *glyphs) const {
michael@0:     /* TODO speed this up */
michael@0:     Coverage::Iter iter;
michael@0:     for (iter.init (*this); iter.more (); iter.next ()) {
michael@0:       if (glyphs->has (iter.get_glyph ()))
michael@0:         return true;
michael@0:     }
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   inline bool intersects_coverage (const hb_set_t *glyphs, unsigned int index) const {
michael@0:     switch (u.format) {
michael@0:     case 1: return u.format1.intersects_coverage (glyphs, index);
michael@0:     case 2: return u.format2.intersects_coverage (glyphs, index);
michael@0:     default:return false;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   template <typename set_t>
michael@0:   inline void add_coverage (set_t *glyphs) const {
michael@0:     switch (u.format) {
michael@0:     case 1: u.format1.add_coverage (glyphs); break;
michael@0:     case 2: u.format2.add_coverage (glyphs); break;
michael@0:     default:                                 break;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   struct Iter {
michael@0:     Iter (void) : format (0) {};
michael@0:     inline void init (const Coverage &c_) {
michael@0:       format = c_.u.format;
michael@0:       switch (format) {
michael@0:       case 1: u.format1.init (c_.u.format1); return;
michael@0:       case 2: u.format2.init (c_.u.format2); return;
michael@0:       default:                               return;
michael@0:       }
michael@0:     }
michael@0:     inline bool more (void) {
michael@0:       switch (format) {
michael@0:       case 1: return u.format1.more ();
michael@0:       case 2: return u.format2.more ();
michael@0:       default:return false;
michael@0:       }
michael@0:     }
michael@0:     inline void next (void) {
michael@0:       switch (format) {
michael@0:       case 1: u.format1.next (); break;
michael@0:       case 2: u.format2.next (); break;
michael@0:       default:                   break;
michael@0:       }
michael@0:     }
michael@0:     inline uint16_t get_glyph (void) {
michael@0:       switch (format) {
michael@0:       case 1: return u.format1.get_glyph ();
michael@0:       case 2: return u.format2.get_glyph ();
michael@0:       default:return 0;
michael@0:       }
michael@0:     }
michael@0:     inline uint16_t get_coverage (void) {
michael@0:       switch (format) {
michael@0:       case 1: return u.format1.get_coverage ();
michael@0:       case 2: return u.format2.get_coverage ();
michael@0:       default:return -1;
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     private:
michael@0:     unsigned int format;
michael@0:     union {
michael@0:     CoverageFormat1::Iter	format1;
michael@0:     CoverageFormat2::Iter	format2;
michael@0:     } u;
michael@0:   };
michael@0: 
michael@0:   protected:
michael@0:   union {
michael@0:   USHORT		format;		/* Format identifier */
michael@0:   CoverageFormat1	format1;
michael@0:   CoverageFormat2	format2;
michael@0:   } u;
michael@0:   public:
michael@0:   DEFINE_SIZE_UNION (2, format);
michael@0: };
michael@0: 
michael@0: 
michael@0: /*
michael@0:  * Class Definition Table
michael@0:  */
michael@0: 
michael@0: struct ClassDefFormat1
michael@0: {
michael@0:   friend struct ClassDef;
michael@0: 
michael@0:   private:
michael@0:   inline unsigned int get_class (hb_codepoint_t glyph_id) const
michael@0:   {
michael@0:     if (unlikely ((unsigned int) (glyph_id - startGlyph) < classValue.len))
michael@0:       return classValue[glyph_id - startGlyph];
michael@0:     return 0;
michael@0:   }
michael@0: 
michael@0:   inline bool sanitize (hb_sanitize_context_t *c) {
michael@0:     TRACE_SANITIZE (this);
michael@0:     return TRACE_RETURN (c->check_struct (this) && classValue.sanitize (c));
michael@0:   }
michael@0: 
michael@0:   template <typename set_t>
michael@0:   inline void add_class (set_t *glyphs, unsigned int klass) const {
michael@0:     unsigned int count = classValue.len;
michael@0:     for (unsigned int i = 0; i < count; i++)
michael@0:       if (classValue[i] == klass)
michael@0:         glyphs->add (startGlyph + i);
michael@0:   }
michael@0: 
michael@0:   inline bool intersects_class (const hb_set_t *glyphs, unsigned int klass) const {
michael@0:     unsigned int count = classValue.len;
michael@0:     if (klass == 0)
michael@0:     {
michael@0:       /* Match if there's any glyph that is not listed! */
michael@0:       hb_codepoint_t g = -1;
michael@0:       if (!hb_set_next (glyphs, &g))
michael@0:         return false;
michael@0:       if (g < startGlyph)
michael@0:         return true;
michael@0:       g = startGlyph + count - 1;
michael@0:       if (hb_set_next (glyphs, &g))
michael@0:         return true;
michael@0:       /* Fall through. */
michael@0:     }
michael@0:     for (unsigned int i = 0; i < count; i++)
michael@0:       if (classValue[i] == klass && glyphs->has (startGlyph + i))
michael@0:         return true;
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   protected:
michael@0:   USHORT	classFormat;		/* Format identifier--format = 1 */
michael@0:   GlyphID	startGlyph;		/* First GlyphID of the classValueArray */
michael@0:   ArrayOf<USHORT>
michael@0: 		classValue;		/* Array of Class Values--one per GlyphID */
michael@0:   public:
michael@0:   DEFINE_SIZE_ARRAY (6, classValue);
michael@0: };
michael@0: 
michael@0: struct ClassDefFormat2
michael@0: {
michael@0:   friend struct ClassDef;
michael@0: 
michael@0:   private:
michael@0:   inline unsigned int get_class (hb_codepoint_t glyph_id) const
michael@0:   {
michael@0:     int i = rangeRecord.search (glyph_id);
michael@0:     if (i != -1)
michael@0:       return rangeRecord[i].value;
michael@0:     return 0;
michael@0:   }
michael@0: 
michael@0:   inline bool sanitize (hb_sanitize_context_t *c) {
michael@0:     TRACE_SANITIZE (this);
michael@0:     return TRACE_RETURN (rangeRecord.sanitize (c));
michael@0:   }
michael@0: 
michael@0:   template <typename set_t>
michael@0:   inline void add_class (set_t *glyphs, unsigned int klass) const {
michael@0:     unsigned int count = rangeRecord.len;
michael@0:     for (unsigned int i = 0; i < count; i++)
michael@0:       if (rangeRecord[i].value == klass)
michael@0:         rangeRecord[i].add_coverage (glyphs);
michael@0:   }
michael@0: 
michael@0:   inline bool intersects_class (const hb_set_t *glyphs, unsigned int klass) const {
michael@0:     unsigned int count = rangeRecord.len;
michael@0:     if (klass == 0)
michael@0:     {
michael@0:       /* Match if there's any glyph that is not listed! */
michael@0:       hb_codepoint_t g = (hb_codepoint_t) -1;
michael@0:       for (unsigned int i = 0; i < count; i++)
michael@0:       {
michael@0: 	if (!hb_set_next (glyphs, &g))
michael@0: 	  break;
michael@0: 	if (g < rangeRecord[i].start)
michael@0: 	  return true;
michael@0: 	g = rangeRecord[i].end;
michael@0:       }
michael@0:       if (g != (hb_codepoint_t) -1 && hb_set_next (glyphs, &g))
michael@0:         return true;
michael@0:       /* Fall through. */
michael@0:     }
michael@0:     for (unsigned int i = 0; i < count; i++)
michael@0:       if (rangeRecord[i].value == klass && rangeRecord[i].intersects (glyphs))
michael@0:         return true;
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   protected:
michael@0:   USHORT	classFormat;	/* Format identifier--format = 2 */
michael@0:   SortedArrayOf<RangeRecord>
michael@0: 		rangeRecord;	/* Array of glyph ranges--ordered by
michael@0: 				 * Start GlyphID */
michael@0:   public:
michael@0:   DEFINE_SIZE_ARRAY (4, rangeRecord);
michael@0: };
michael@0: 
michael@0: struct ClassDef
michael@0: {
michael@0:   inline unsigned int get_class (hb_codepoint_t glyph_id) const
michael@0:   {
michael@0:     switch (u.format) {
michael@0:     case 1: return u.format1.get_class(glyph_id);
michael@0:     case 2: return u.format2.get_class(glyph_id);
michael@0:     default:return 0;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   inline bool sanitize (hb_sanitize_context_t *c) {
michael@0:     TRACE_SANITIZE (this);
michael@0:     if (!u.format.sanitize (c)) return TRACE_RETURN (false);
michael@0:     switch (u.format) {
michael@0:     case 1: return TRACE_RETURN (u.format1.sanitize (c));
michael@0:     case 2: return TRACE_RETURN (u.format2.sanitize (c));
michael@0:     default:return TRACE_RETURN (true);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   inline void add_class (hb_set_t *glyphs, unsigned int klass) const {
michael@0:     switch (u.format) {
michael@0:     case 1: u.format1.add_class (glyphs, klass); return;
michael@0:     case 2: u.format2.add_class (glyphs, klass); return;
michael@0:     default:return;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   inline bool intersects_class (const hb_set_t *glyphs, unsigned int klass) const {
michael@0:     switch (u.format) {
michael@0:     case 1: return u.format1.intersects_class (glyphs, klass);
michael@0:     case 2: return u.format2.intersects_class (glyphs, klass);
michael@0:     default:return false;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   protected:
michael@0:   union {
michael@0:   USHORT		format;		/* Format identifier */
michael@0:   ClassDefFormat1	format1;
michael@0:   ClassDefFormat2	format2;
michael@0:   } u;
michael@0:   public:
michael@0:   DEFINE_SIZE_UNION (2, format);
michael@0: };
michael@0: 
michael@0: 
michael@0: /*
michael@0:  * Device Tables
michael@0:  */
michael@0: 
michael@0: struct Device
michael@0: {
michael@0: 
michael@0:   inline hb_position_t get_x_delta (hb_font_t *font) const
michael@0:   { return get_delta (font->x_ppem, font->x_scale); }
michael@0: 
michael@0:   inline hb_position_t get_y_delta (hb_font_t *font) const
michael@0:   { return get_delta (font->y_ppem, font->y_scale); }
michael@0: 
michael@0:   inline int get_delta (unsigned int ppem, int scale) const
michael@0:   {
michael@0:     if (!ppem) return 0;
michael@0: 
michael@0:     int pixels = get_delta_pixels (ppem);
michael@0: 
michael@0:     if (!pixels) return 0;
michael@0: 
michael@0:     return (int) (pixels * (int64_t) scale / ppem);
michael@0:   }
michael@0: 
michael@0: 
michael@0:   inline int get_delta_pixels (unsigned int ppem_size) const
michael@0:   {
michael@0:     unsigned int f = deltaFormat;
michael@0:     if (unlikely (f < 1 || f > 3))
michael@0:       return 0;
michael@0: 
michael@0:     if (ppem_size < startSize || ppem_size > endSize)
michael@0:       return 0;
michael@0: 
michael@0:     unsigned int s = ppem_size - startSize;
michael@0: 
michael@0:     unsigned int byte = deltaValue[s >> (4 - f)];
michael@0:     unsigned int bits = (byte >> (16 - (((s & ((1 << (4 - f)) - 1)) + 1) << f)));
michael@0:     unsigned int mask = (0xFFFF >> (16 - (1 << f)));
michael@0: 
michael@0:     int delta = bits & mask;
michael@0: 
michael@0:     if ((unsigned int) delta >= ((mask + 1) >> 1))
michael@0:       delta -= mask + 1;
michael@0: 
michael@0:     return delta;
michael@0:   }
michael@0: 
michael@0:   inline unsigned int get_size (void) const
michael@0:   {
michael@0:     unsigned int f = deltaFormat;
michael@0:     if (unlikely (f < 1 || f > 3 || startSize > endSize)) return 3 * USHORT::static_size;
michael@0:     return USHORT::static_size * (4 + ((endSize - startSize) >> (4 - f)));
michael@0:   }
michael@0: 
michael@0:   inline bool sanitize (hb_sanitize_context_t *c) {
michael@0:     TRACE_SANITIZE (this);
michael@0:     return TRACE_RETURN (c->check_struct (this) && c->check_range (this, this->get_size ()));
michael@0:   }
michael@0: 
michael@0:   protected:
michael@0:   USHORT	startSize;		/* Smallest size to correct--in ppem */
michael@0:   USHORT	endSize;		/* Largest size to correct--in ppem */
michael@0:   USHORT	deltaFormat;		/* Format of DeltaValue array data: 1, 2, or 3
michael@0: 					 * 1	Signed 2-bit value, 8 values per uint16
michael@0: 					 * 2	Signed 4-bit value, 4 values per uint16
michael@0: 					 * 3	Signed 8-bit value, 2 values per uint16
michael@0: 					 */
michael@0:   USHORT	deltaValue[VAR];	/* Array of compressed data */
michael@0:   public:
michael@0:   DEFINE_SIZE_ARRAY (6, deltaValue);
michael@0: };
michael@0: 
michael@0: 
michael@0: } /* namespace OT */
michael@0: 
michael@0: 
michael@0: #endif /* HB_OT_LAYOUT_COMMON_PRIVATE_HH */