src/hb-ot-layout-common-private.hh

   1 /*
   2  * Copyright © 2007,2008,2009  Red Hat, Inc.
   3  * Copyright © 2010,2012  Google, Inc.
   4  *
   5  *  This is part of HarfBuzz, a text shaping library.
   6  *
   7  * Permission is hereby granted, without written agreement and without
   8  * license or royalty fees, to use, copy, modify, and distribute this
   9  * software and its documentation for any purpose, provided that the
  10  * above copyright notice and the following two paragraphs appear in
  11  * all copies of this software.
  12  *
  13  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
  14  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
  15  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
  16  * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
  17  * DAMAGE.
  18  *
  19  * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
  20  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  21  * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  22  * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
  23  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  24  *
  25  * Red Hat Author(s): Behdad Esfahbod
  26  * Google Author(s): Behdad Esfahbod
  27  */
  28
  29 #ifndef HB_OT_LAYOUT_COMMON_PRIVATE_HH
  30 #define HB_OT_LAYOUT_COMMON_PRIVATE_HH
  31
  32 #include "hb-ot-layout-private.hh"
  33 #include "hb-open-type-private.hh"
  34 #include "hb-set-private.hh"
  35
  36
  37 namespace OT {
  38
  39
  40 #define NOT_COVERED             ((unsigned int) -1)
  41 #define MAX_NESTING_LEVEL       8
  42
  43
  44
  45 /*
  46  *
  47  * OpenType Layout Common Table Formats
  48  *
  49  */
  50
  51
  52 /*
  53  * Script, ScriptList, LangSys, Feature, FeatureList, Lookup, LookupList
  54  */
  55
  56 template <typename Type>
  57 struct Record
  58 {
  59   inline int cmp (hb_tag_t a) const {
  60     return tag.cmp (a);
  61   }
  62
  63   struct sanitize_closure_t {
  64     hb_tag_t tag;
  65     void *list_base;
  66   };
  67   inline bool sanitize (hb_sanitize_context_t *c, void *base) {
  68     TRACE_SANITIZE (this);
  69     const sanitize_closure_t closure = {tag, base};
  70     return TRACE_RETURN (c->check_struct (this) && offset.sanitize (c, base, &closure));
  71   }
  72
  73   Tag           tag;            /* 4-byte Tag identifier */
  74   OffsetTo<Type>
  75                 offset;         /* Offset from beginning of object holding
  76                                  * the Record */
  77   public:
  78   DEFINE_SIZE_STATIC (6);
  79 };
  80
  81 template <typename Type>
  82 struct RecordArrayOf : SortedArrayOf<Record<Type> > {
  83   inline const Tag& get_tag (unsigned int i) const
  84   {
  85     /* We cheat slightly and don't define separate Null objects
  86      * for Record types.  Instead, we return the correct Null(Tag)
  87      * here. */
  88     if (unlikely (i >= this->len)) return Null(Tag);
  89     return (*this)[i].tag;
  90   }
  91   inline unsigned int get_tags (unsigned int start_offset,
  92                                 unsigned int *record_count /* IN/OUT */,
  93                                 hb_tag_t     *record_tags /* OUT */) const
  94   {
  95     if (record_count) {
  96       const Record<Type> *arr = this->sub_array (start_offset, record_count);
  97       unsigned int count = *record_count;
  98       for (unsigned int i = 0; i < count; i++)
  99         record_tags[i] = arr[i].tag;
 100     }
 101     return this->len;
 102   }
 103   inline bool find_index (hb_tag_t tag, unsigned int *index) const
 104   {
 105     int i = this->search (tag);
 106     if (i != -1) {
 107         if (index) *index = i;
 108         return true;
 109     } else {
 110       if (index) *index = Index::NOT_FOUND_INDEX;
 111       return false;
 112     }
 113   }
 114 };
 115
 116 template <typename Type>
 117 struct RecordListOf : RecordArrayOf<Type>
 118 {
 119   inline const Type& operator [] (unsigned int i) const
 120   { return this+RecordArrayOf<Type>::operator [](i).offset; }
 121
 122   inline bool sanitize (hb_sanitize_context_t *c) {
 123     TRACE_SANITIZE (this);
 124     return TRACE_RETURN (RecordArrayOf<Type>::sanitize (c, this));
 125   }
 126 };
 127
 128
 129 struct RangeRecord
 130 {
 131   inline int cmp (hb_codepoint_t g) const {
 132     hb_codepoint_t a = start, b = end;
 133     return g < a ? -1 : g <= b ? 0 : +1 ;
 134   }
 135
 136   inline bool sanitize (hb_sanitize_context_t *c) {
 137     TRACE_SANITIZE (this);
 138     return TRACE_RETURN (c->check_struct (this));
 139   }
 140
 141   inline bool intersects (const hb_set_t *glyphs) const {
 142     return glyphs->intersects (start, end);
 143   }
 144
 145   template <typename set_t>
 146   inline void add_coverage (set_t *glyphs) const {
 147     glyphs->add_range (start, end);
 148   }
 149
 150   GlyphID       start;          /* First GlyphID in the range */
 151   GlyphID       end;            /* Last GlyphID in the range */
 152   USHORT        value;          /* Value */
 153   public:
 154   DEFINE_SIZE_STATIC (6);
 155 };
 156 DEFINE_NULL_DATA (RangeRecord, "\000\001");
 157
 158
 159 struct IndexArray : ArrayOf<Index>
 160 {
 161   inline unsigned int get_indexes (unsigned int start_offset,
 162                                    unsigned int *_count /* IN/OUT */,
 163                                    unsigned int *_indexes /* OUT */) const
 164   {
 165     if (_count) {
 166       const USHORT *arr = this->sub_array (start_offset, _count);
 167       unsigned int count = *_count;
 168       for (unsigned int i = 0; i < count; i++)
 169         _indexes[i] = arr[i];
 170     }
 171     return this->len;
 172   }
 173 };
 174
 175
 176 struct Script;
 177 struct LangSys;
 178 struct Feature;
 179
 180
 181 struct LangSys
 182 {
 183   inline unsigned int get_feature_count (void) const
 184   { return featureIndex.len; }
 185   inline hb_tag_t get_feature_index (unsigned int i) const
 186   { return featureIndex[i]; }
 187   inline unsigned int get_feature_indexes (unsigned int start_offset,
 188                                            unsigned int *feature_count /* IN/OUT */,
 189                                            unsigned int *feature_indexes /* OUT */) const
 190   { return featureIndex.get_indexes (start_offset, feature_count, feature_indexes); }
 191
 192   inline bool has_required_feature (void) const { return reqFeatureIndex != 0xffff; }
 193   inline unsigned int get_required_feature_index (void) const
 194   {
 195     if (reqFeatureIndex == 0xffff)
 196       return Index::NOT_FOUND_INDEX;
 197    return reqFeatureIndex;;
 198   }
 199
 200   inline bool sanitize (hb_sanitize_context_t *c,
 201                         const Record<LangSys>::sanitize_closure_t * = NULL) {
 202     TRACE_SANITIZE (this);
 203     return TRACE_RETURN (c->check_struct (this) && featureIndex.sanitize (c));
 204   }
 205
 206   Offset        lookupOrder;    /* = Null (reserved for an offset to a
 207                                  * reordering table) */
 208   USHORT        reqFeatureIndex;/* Index of a feature required for this
 209                                  * language system--if no required features
 210                                  * = 0xFFFF */
 211   IndexArray    featureIndex;   /* Array of indices into the FeatureList */
 212   public:
 213   DEFINE_SIZE_ARRAY (6, featureIndex);
 214 };
 215 DEFINE_NULL_DATA (LangSys, "\0\0\xFF\xFF");
 216
 217
 218 struct Script
 219 {
 220   inline unsigned int get_lang_sys_count (void) const
 221   { return langSys.len; }
 222   inline const Tag& get_lang_sys_tag (unsigned int i) const
 223   { return langSys.get_tag (i); }
 224   inline unsigned int get_lang_sys_tags (unsigned int start_offset,
 225                                          unsigned int *lang_sys_count /* IN/OUT */,
 226                                          hb_tag_t     *lang_sys_tags /* OUT */) const
 227   { return langSys.get_tags (start_offset, lang_sys_count, lang_sys_tags); }
 228   inline const LangSys& get_lang_sys (unsigned int i) const
 229   {
 230     if (i == Index::NOT_FOUND_INDEX) return get_default_lang_sys ();
 231     return this+langSys[i].offset;
 232   }
 233   inline bool find_lang_sys_index (hb_tag_t tag, unsigned int *index) const
 234   { return langSys.find_index (tag, index); }
 235
 236   inline bool has_default_lang_sys (void) const { return defaultLangSys != 0; }
 237   inline const LangSys& get_default_lang_sys (void) const { return this+defaultLangSys; }
 238
 239   inline bool sanitize (hb_sanitize_context_t *c,
 240                         const Record<Script>::sanitize_closure_t * = NULL) {
 241     TRACE_SANITIZE (this);
 242     return TRACE_RETURN (defaultLangSys.sanitize (c, this) && langSys.sanitize (c, this));
 243   }
 244
 245   protected:
 246   OffsetTo<LangSys>
 247                 defaultLangSys; /* Offset to DefaultLangSys table--from
 248                                  * beginning of Script table--may be Null */
 249   RecordArrayOf<LangSys>
 250                 langSys;        /* Array of LangSysRecords--listed
 251                                  * alphabetically by LangSysTag */
 252   public:
 253   DEFINE_SIZE_ARRAY (4, langSys);
 254 };
 255
 256 typedef RecordListOf<Script> ScriptList;
 257
 258
 259 /* http://www.microsoft.com/typography/otspec/features_pt.htm#size */
 260 struct FeatureParamsSize
 261 {
 262   inline bool sanitize (hb_sanitize_context_t *c) {
 263     TRACE_SANITIZE (this);
 264     if (unlikely (!c->check_struct (this))) return TRACE_RETURN (false);
 265
 266     /* This subtable has some "history", if you will.  Some earlier versions of
 267      * Adobe tools calculated the offset of the FeatureParams sutable from the
 268      * beginning of the FeatureList table!  Now, that is dealt with in the
 269      * Feature implementation.  But we still need to be able to tell junk from
 270      * real data.  Note: We don't check that the nameID actually exists.
 271      *
 272      * Read Roberts wrote on 9/15/06 on opentype-list@indx.co.uk :
 273      *
 274      * Yes, it is correct that a new version of the AFDKO (version 2.0) will be
 275      * coming out soon, and that the makeotf program will build a font with a
 276      * 'size' feature that is correct by the specification.
 277      *
 278      * The specification for this feature tag is in the "OpenType Layout Tag
 279      * Registry". You can see a copy of this at:
 280      * http://partners.adobe.com/public/developer/opentype/index_tag8.html#size
 281      *
 282      * Here is one set of rules to determine if the 'size' feature is built
 283      * correctly, or as by the older versions of MakeOTF. You may be able to do
 284      * better.
 285      *
 286      * Assume that the offset to the size feature is according to specification,
 287      * and make the following value checks. If it fails, assume the the size
 288      * feature is calculated as versions of MakeOTF before the AFDKO 2.0 built it.
 289      * If this fails, reject the 'size' feature. The older makeOTF's calculated the
 290      * offset from the beginning of the FeatureList table, rather than from the
 291      * beginning of the 'size' Feature table.
 292      *
 293      * If "design size" == 0:
 294      *     fails check
 295      *
 296      * Else if ("subfamily identifier" == 0 and
 297      *     "range start" == 0 and
 298      *     "range end" == 0 and
 299      *     "range start" == 0 and
 300      *     "menu name ID" == 0)
 301      *     passes check: this is the format used when there is a design size
 302      * specified, but there is no recommended size range.
 303      *
 304      * Else if ("design size" <  "range start" or
 305      *     "design size" >   "range end" or
 306      *     "range end" <= "range start" or
 307      *     "menu name ID"  < 256 or
 308      *     "menu name ID"  > 32767 or
 309      *     menu name ID is not a name ID which is actually in the name table)
 310      *     fails test
 311      * Else
 312      *     passes test.
 313      */
 314
 315     if (!designSize)
 316       return TRACE_RETURN (false);
 317     else if (subfamilyID == 0 &&
 318              subfamilyNameID == 0 &&
 319              rangeStart == 0 &&
 320              rangeEnd == 0)
 321       return TRACE_RETURN (true);
 322     else if (designSize < rangeStart ||
 323              designSize > rangeEnd ||
 324              subfamilyNameID < 256 ||
 325              subfamilyNameID > 32767)
 326       return TRACE_RETURN (false);
 327     else
 328       return TRACE_RETURN (true);
 329   }
 330
 331   USHORT        designSize;     /* Represents the design size in 720/inch
 332                                  * units (decipoints).  The design size entry
 333                                  * must be non-zero.  When there is a design
 334                                  * size but no recommended size range, the
 335                                  * rest of the array will consist of zeros. */
 336   USHORT        subfamilyID;    /* Has no independent meaning, but serves
 337                                  * as an identifier that associates fonts
 338                                  * in a subfamily. All fonts which share a
 339                                  * Preferred or Font Family name and which
 340                                  * differ only by size range shall have the
 341                                  * same subfamily value, and no fonts which
 342                                  * differ in weight or style shall have the
 343                                  * same subfamily value. If this value is
 344                                  * zero, the remaining fields in the array
 345                                  * will be ignored. */
 346   USHORT        subfamilyNameID;/* If the preceding value is non-zero, this
 347                                  * value must be set in the range 256 - 32767
 348                                  * (inclusive). It records the value of a
 349                                  * field in the name table, which must
 350                                  * contain English-language strings encoded
 351                                  * in Windows Unicode and Macintosh Roman,
 352                                  * and may contain additional strings
 353                                  * localized to other scripts and languages.
 354                                  * Each of these strings is the name an
 355                                  * application should use, in combination
 356                                  * with the family name, to represent the
 357                                  * subfamily in a menu.  Applications will
 358                                  * choose the appropriate version based on
 359                                  * their selection criteria. */
 360   USHORT        rangeStart;     /* Large end of the recommended usage range
 361                                  * (inclusive), stored in 720/inch units
 362                                  * (decipoints). */
 363   USHORT        rangeEnd;       /* Small end of the recommended usage range
 364                                    (exclusive), stored in 720/inch units
 365                                  * (decipoints). */
 366   public:
 367   DEFINE_SIZE_STATIC (10);
 368 };
 369
 370 /* http://www.microsoft.com/typography/otspec/features_pt.htm#ssxx */
 371 struct FeatureParamsStylisticSet
 372 {
 373   inline bool sanitize (hb_sanitize_context_t *c) {
 374     TRACE_SANITIZE (this);
 375     /* Right now minorVersion is at zero.  Which means, any table supports
 376      * the uiNameID field. */
 377     return TRACE_RETURN (c->check_struct (this));
 378   }
 379
 380   USHORT        minorVersion;   /* (set to 0): This corresponds to a “minor”
 381                                  * version number. Additional data may be
 382                                  * added to the end of this Feature Parameters
 383                                  * table in the future. */
 384
 385   USHORT        uiNameID;       /* The 'name' table name ID that specifies a
 386                                  * string (or strings, for multiple languages)
 387                                  * for a user-interface label for this
 388                                  * feature.  The values of uiLabelNameId and
 389                                  * sampleTextNameId are expected to be in the
 390                                  * font-specific name ID range (256-32767),
 391                                  * though that is not a requirement in this
 392                                  * Feature Parameters specification. The
 393                                  * user-interface label for the feature can
 394                                  * be provided in multiple languages. An
 395                                  * English string should be included as a
 396                                  * fallback. The string should be kept to a
 397                                  * minimal length to fit comfortably with
 398                                  * different application interfaces. */
 399   public:
 400   DEFINE_SIZE_STATIC (4);
 401 };
 402
 403 struct FeatureParamsCharacterVariants
 404 {
 405   inline bool sanitize (hb_sanitize_context_t *c) {
 406     TRACE_SANITIZE (this);
 407     return TRACE_RETURN (c->check_struct (this) &&
 408                          characters.sanitize (c));
 409   }
 410
 411   USHORT        format;                 /* Format number is set to 0. */
 412   USHORT        featUILableNameID;      /* The ‘name’ table name ID that
 413                                          * specifies a string (or strings,
 414                                          * for multiple languages) for a
 415                                          * user-interface label for this
 416                                          * feature. (May be NULL.) */
 417   USHORT        featUITooltipTextNameID;/* The ‘name’ table name ID that
 418                                          * specifies a string (or strings,
 419                                          * for multiple languages) that an
 420                                          * application can use for tooltip
 421                                          * text for this feature. (May be
 422                                          * NULL.) */
 423   USHORT        sampleTextNameID;       /* The ‘name’ table name ID that
 424                                          * specifies sample text that
 425                                          * illustrates the effect of this
 426                                          * feature. (May be NULL.) */
 427   USHORT        numNamedParameters;     /* Number of named parameters. (May
 428                                          * be zero.) */
 429   USHORT        firstParamUILabelNameID;/* The first ‘name’ table name ID
 430                                          * used to specify strings for
 431                                          * user-interface labels for the
 432                                          * feature parameters. (Must be zero
 433                                          * if numParameters is zero.) */
 434   ArrayOf<UINT24>
 435                 characters;             /* Array of the Unicode Scalar Value
 436                                          * of the characters for which this
 437                                          * feature provides glyph variants.
 438                                          * (May be zero.) */
 439   public:
 440   DEFINE_SIZE_ARRAY (14, characters);
 441 };
 442
 443 struct FeatureParams
 444 {
 445   inline bool sanitize (hb_sanitize_context_t *c, hb_tag_t tag) {
 446     TRACE_SANITIZE (this);
 447     if (tag == HB_TAG ('s','i','z','e'))
 448       return TRACE_RETURN (u.size.sanitize (c));
 449     if ((tag & 0xFFFF0000) == HB_TAG ('s','s','\0','\0')) /* ssXX */
 450       return TRACE_RETURN (u.stylisticSet.sanitize (c));
 451     if ((tag & 0xFFFF0000) == HB_TAG ('c','v','\0','\0')) /* cvXX */
 452       return TRACE_RETURN (u.characterVariants.sanitize (c));
 453     return TRACE_RETURN (true);
 454   }
 455
 456   inline const FeatureParamsSize& get_size_params (hb_tag_t tag) const
 457   {
 458     if (tag == HB_TAG ('s','i','z','e'))
 459       return u.size;
 460     return Null(FeatureParamsSize);
 461   }
 462
 463   private:
 464   union {
 465   FeatureParamsSize                     size;
 466   FeatureParamsStylisticSet             stylisticSet;
 467   FeatureParamsCharacterVariants        characterVariants;
 468   } u;
 469   DEFINE_SIZE_STATIC (17);
 470 };
 471
 472 struct Feature
 473 {
 474   inline unsigned int get_lookup_count (void) const
 475   { return lookupIndex.len; }
 476   inline hb_tag_t get_lookup_index (unsigned int i) const
 477   { return lookupIndex[i]; }
 478   inline unsigned int get_lookup_indexes (unsigned int start_index,
 479                                           unsigned int *lookup_count /* IN/OUT */,
 480                                           unsigned int *lookup_tags /* OUT */) const
 481   { return lookupIndex.get_indexes (start_index, lookup_count, lookup_tags); }
 482
 483   inline const FeatureParams &get_feature_params (void) const
 484   { return this+featureParams; }
 485
 486   inline bool sanitize (hb_sanitize_context_t *c,
 487                         const Record<Feature>::sanitize_closure_t *closure) {
 488     TRACE_SANITIZE (this);
 489     if (unlikely (!(c->check_struct (this) && lookupIndex.sanitize (c))))
 490       return TRACE_RETURN (false);
 491
 492     /* Some earlier versions of Adobe tools calculated the offset of the
 493      * FeatureParams subtable from the beginning of the FeatureList table!
 494      *
 495      * If sanitizing "failed" for the FeatureParams subtable, try it with the
 496      * alternative location.  We would know sanitize "failed" if old value
 497      * of the offset was non-zero, but it's zeroed now.
 498      *
 499      * Only do this for the 'size' feature, since at the time of the faulty
 500      * Adobe tools, only the 'size' feature had FeatureParams defined.
 501      */
 502
 503     Offset orig_offset = featureParams;
 504     if (unlikely (!featureParams.sanitize (c, this, closure ? closure->tag : HB_TAG_NONE)))
 505       return TRACE_RETURN (false);
 506
 507     if (likely (!orig_offset))
 508       return TRACE_RETURN (true);
 509
 510     if (featureParams == 0 && closure &&
 511         closure->tag == HB_TAG ('s','i','z','e') &&
 512         closure->list_base && closure->list_base < this)
 513     {
 514       unsigned int new_offset_int = (unsigned int) orig_offset -
 515                                     ((char *) this - (char *) closure->list_base);
 516
 517       Offset new_offset;
 518       /* Check that it did not overflow. */
 519       new_offset.set (new_offset_int);
 520       if (new_offset == new_offset_int &&
 521           featureParams.try_set (c, new_offset) &&
 522           !featureParams.sanitize (c, this, closure ? closure->tag : HB_TAG_NONE))
 523         return TRACE_RETURN (false);
 524     }
 525
 526     return TRACE_RETURN (true);
 527   }
 528
 529   OffsetTo<FeatureParams>
 530                  featureParams; /* Offset to Feature Parameters table (if one
 531                                  * has been defined for the feature), relative
 532                                  * to the beginning of the Feature Table; = Null
 533                                  * if not required */
 534   IndexArray     lookupIndex;   /* Array of LookupList indices */
 535   public:
 536   DEFINE_SIZE_ARRAY (4, lookupIndex);
 537 };
 538
 539 typedef RecordListOf<Feature> FeatureList;
 540
 541
 542 struct LookupFlag : USHORT
 543 {
 544   enum Flags {
 545     RightToLeft         = 0x0001u,
 546     IgnoreBaseGlyphs    = 0x0002u,
 547     IgnoreLigatures     = 0x0004u,
 548     IgnoreMarks         = 0x0008u,
 549     IgnoreFlags         = 0x000Eu,
 550     UseMarkFilteringSet = 0x0010u,
 551     Reserved            = 0x00E0u,
 552     MarkAttachmentType  = 0xFF00u
 553   };
 554   public:
 555   DEFINE_SIZE_STATIC (2);
 556 };
 557
 558 struct Lookup
 559 {
 560   inline unsigned int get_subtable_count (void) const { return subTable.len; }
 561
 562   inline unsigned int get_type (void) const { return lookupType; }
 563
 564   /* lookup_props is a 32-bit integer where the lower 16-bit is LookupFlag and
 565    * higher 16-bit is mark-filtering-set if the lookup uses one.
 566    * Not to be confused with glyph_props which is very similar. */
 567   inline uint32_t get_props (void) const
 568   {
 569     unsigned int flag = lookupFlag;
 570     if (unlikely (flag & LookupFlag::UseMarkFilteringSet))
 571     {
 572       const USHORT &markFilteringSet = StructAfter<USHORT> (subTable);
 573       flag += (markFilteringSet << 16);
 574     }
 575     return flag;
 576   }
 577
 578   inline bool serialize (hb_serialize_context_t *c,
 579                          unsigned int lookup_type,
 580                          uint32_t lookup_props,
 581                          unsigned int num_subtables)
 582   {
 583     TRACE_SERIALIZE (this);
 584     if (unlikely (!c->extend_min (*this))) return TRACE_RETURN (false);
 585     lookupType.set (lookup_type);
 586     lookupFlag.set (lookup_props & 0xFFFF);
 587     if (unlikely (!subTable.serialize (c, num_subtables))) return TRACE_RETURN (false);
 588     if (lookupFlag & LookupFlag::UseMarkFilteringSet)
 589     {
 590       USHORT &markFilteringSet = StructAfter<USHORT> (subTable);
 591       markFilteringSet.set (lookup_props >> 16);
 592     }
 593     return TRACE_RETURN (true);
 594   }
 595
 596   inline bool sanitize (hb_sanitize_context_t *c) {
 597     TRACE_SANITIZE (this);
 598     /* Real sanitize of the subtables is done by GSUB/GPOS/... */
 599     if (!(c->check_struct (this) && subTable.sanitize (c))) return TRACE_RETURN (false);
 600     if (lookupFlag & LookupFlag::UseMarkFilteringSet)
 601     {
 602       USHORT &markFilteringSet = StructAfter<USHORT> (subTable);
 603       if (!markFilteringSet.sanitize (c)) return TRACE_RETURN (false);
 604     }
 605     return TRACE_RETURN (true);
 606   }
 607
 608   USHORT        lookupType;             /* Different enumerations for GSUB and GPOS */
 609   USHORT        lookupFlag;             /* Lookup qualifiers */
 610   ArrayOf<Offset>
 611                 subTable;               /* Array of SubTables */
 612   USHORT        markFilteringSetX[VAR]; /* Index (base 0) into GDEF mark glyph sets
 613                                          * structure. This field is only present if bit
 614                                          * UseMarkFilteringSet of lookup flags is set. */
 615   public:
 616   DEFINE_SIZE_ARRAY2 (6, subTable, markFilteringSetX);
 617 };
 618
 619 typedef OffsetListOf<Lookup> LookupList;
 620
 621
 622 /*
 623  * Coverage Table
 624  */
 625
 626 struct CoverageFormat1
 627 {
 628   friend struct Coverage;
 629
 630   private:
 631   inline unsigned int get_coverage (hb_codepoint_t glyph_id) const
 632   {
 633     int i = glyphArray.search (glyph_id);
 634     ASSERT_STATIC (((unsigned int) -1) == NOT_COVERED);
 635     return i;
 636   }
 637
 638   inline bool serialize (hb_serialize_context_t *c,
 639                          Supplier<GlyphID> &glyphs,
 640                          unsigned int num_glyphs)
 641   {
 642     TRACE_SERIALIZE (this);
 643     if (unlikely (!c->extend_min (*this))) return TRACE_RETURN (false);
 644     glyphArray.len.set (num_glyphs);
 645     if (unlikely (!c->extend (glyphArray))) return TRACE_RETURN (false);
 646     for (unsigned int i = 0; i < num_glyphs; i++)
 647       glyphArray[i] = glyphs[i];
 648     glyphs.advance (num_glyphs);
 649     return TRACE_RETURN (true);
 650   }
 651
 652   inline bool sanitize (hb_sanitize_context_t *c) {
 653     TRACE_SANITIZE (this);
 654     return TRACE_RETURN (glyphArray.sanitize (c));
 655   }
 656
 657   inline bool intersects_coverage (const hb_set_t *glyphs, unsigned int index) const {
 658     return glyphs->has (glyphArray[index]);
 659   }
 660
 661   template <typename set_t>
 662   inline void add_coverage (set_t *glyphs) const {
 663     unsigned int count = glyphArray.len;
 664     for (unsigned int i = 0; i < count; i++)
 665       glyphs->add (glyphArray[i]);
 666   }
 667
 668   public:
 669   /* Older compilers need this to be public. */
 670   struct Iter {
 671     inline void init (const struct CoverageFormat1 &c_) { c = &c_; i = 0; };
 672     inline bool more (void) { return i < c->glyphArray.len; }
 673     inline void next (void) { i++; }
 674     inline uint16_t get_glyph (void) { return c->glyphArray[i]; }
 675     inline uint16_t get_coverage (void) { return i; }
 676
 677     private:
 678     const struct CoverageFormat1 *c;
 679     unsigned int i;
 680   };
 681   private:
 682
 683   protected:
 684   USHORT        coverageFormat; /* Format identifier--format = 1 */
 685   SortedArrayOf<GlyphID>
 686                 glyphArray;     /* Array of GlyphIDs--in numerical order */
 687   public:
 688   DEFINE_SIZE_ARRAY (4, glyphArray);
 689 };
 690
 691 struct CoverageFormat2
 692 {
 693   friend struct Coverage;
 694
 695   private:
 696   inline unsigned int get_coverage (hb_codepoint_t glyph_id) const
 697   {
 698     int i = rangeRecord.search (glyph_id);
 699     if (i != -1) {
 700       const RangeRecord &range = rangeRecord[i];
 701       return (unsigned int) range.value + (glyph_id - range.start);
 702     }
 703     return NOT_COVERED;
 704   }
 705
 706   inline bool serialize (hb_serialize_context_t *c,
 707                          Supplier<GlyphID> &glyphs,
 708                          unsigned int num_glyphs)
 709   {
 710     TRACE_SERIALIZE (this);
 711     if (unlikely (!c->extend_min (*this))) return TRACE_RETURN (false);
 712
 713     if (unlikely (!num_glyphs)) return TRACE_RETURN (true);
 714
 715     unsigned int num_ranges = 1;
 716     for (unsigned int i = 1; i < num_glyphs; i++)
 717       if (glyphs[i - 1] + 1 != glyphs[i])
 718         num_ranges++;
 719     rangeRecord.len.set (num_ranges);
 720     if (unlikely (!c->extend (rangeRecord))) return TRACE_RETURN (false);
 721
 722     unsigned int range = 0;
 723     rangeRecord[range].start = glyphs[0];
 724     rangeRecord[range].value.set (0);
 725     for (unsigned int i = 1; i < num_glyphs; i++)
 726       if (glyphs[i - 1] + 1 != glyphs[i]) {
 727         range++;
 728         rangeRecord[range].start = glyphs[i];
 729         rangeRecord[range].value.set (i);
 730         rangeRecord[range].end = glyphs[i];
 731       } else {
 732         rangeRecord[range].end = glyphs[i];
 733       }
 734     glyphs.advance (num_glyphs);
 735     return TRACE_RETURN (true);
 736   }
 737
 738   inline bool sanitize (hb_sanitize_context_t *c) {
 739     TRACE_SANITIZE (this);
 740     return TRACE_RETURN (rangeRecord.sanitize (c));
 741   }
 742
 743   inline bool intersects_coverage (const hb_set_t *glyphs, unsigned int index) const {
 744     unsigned int i;
 745     unsigned int count = rangeRecord.len;
 746     for (i = 0; i < count; i++) {
 747       const RangeRecord &range = rangeRecord[i];
 748       if (range.value <= index &&
 749           index < (unsigned int) range.value + (range.end - range.start) &&
 750           range.intersects (glyphs))
 751         return true;
 752       else if (index < range.value)
 753         return false;
 754     }
 755     return false;
 756   }
 757
 758   template <typename set_t>
 759   inline void add_coverage (set_t *glyphs) const {
 760     unsigned int count = rangeRecord.len;
 761     for (unsigned int i = 0; i < count; i++)
 762       rangeRecord[i].add_coverage (glyphs);
 763   }
 764
 765   public:
 766   /* Older compilers need this to be public. */
 767   struct Iter {
 768     inline void init (const CoverageFormat2 &c_) {
 769       c = &c_;
 770       coverage = 0;
 771       i = 0;
 772       j = c->rangeRecord.len ? c_.rangeRecord[0].start : 0;
 773     }
 774     inline bool more (void) { return i < c->rangeRecord.len; }
 775     inline void next (void) {
 776       coverage++;
 777       if (j == c->rangeRecord[i].end) {
 778         i++;
 779         if (more ())
 780           j = c->rangeRecord[i].start;
 781         return;
 782       }
 783       j++;
 784     }
 785     inline uint16_t get_glyph (void) { return j; }
 786     inline uint16_t get_coverage (void) { return coverage; }
 787
 788     private:
 789     const struct CoverageFormat2 *c;
 790     unsigned int i, j, coverage;
 791   };
 792   private:
 793
 794   protected:
 795   USHORT        coverageFormat; /* Format identifier--format = 2 */
 796   SortedArrayOf<RangeRecord>
 797                 rangeRecord;    /* Array of glyph ranges--ordered by
 798                                  * Start GlyphID. rangeCount entries
 799                                  * long */
 800   public:
 801   DEFINE_SIZE_ARRAY (4, rangeRecord);
 802 };
 803
 804 struct Coverage
 805 {
 806   inline unsigned int get_coverage (hb_codepoint_t glyph_id) const
 807   {
 808     switch (u.format) {
 809     case 1: return u.format1.get_coverage(glyph_id);
 810     case 2: return u.format2.get_coverage(glyph_id);
 811     default:return NOT_COVERED;
 812     }
 813   }
 814
 815   inline bool serialize (hb_serialize_context_t *c,
 816                          Supplier<GlyphID> &glyphs,
 817                          unsigned int num_glyphs)
 818   {
 819     TRACE_SERIALIZE (this);
 820     if (unlikely (!c->extend_min (*this))) return TRACE_RETURN (false);
 821     unsigned int num_ranges = 1;
 822     for (unsigned int i = 1; i < num_glyphs; i++)
 823       if (glyphs[i - 1] + 1 != glyphs[i])
 824         num_ranges++;
 825     u.format.set (num_glyphs * 2 < num_ranges * 3 ? 1 : 2);
 826     switch (u.format) {
 827     case 1: return TRACE_RETURN (u.format1.serialize (c, glyphs, num_glyphs));
 828     case 2: return TRACE_RETURN (u.format2.serialize (c, glyphs, num_glyphs));
 829     default:return TRACE_RETURN (false);
 830     }
 831   }
 832
 833   inline bool sanitize (hb_sanitize_context_t *c) {
 834     TRACE_SANITIZE (this);
 835     if (!u.format.sanitize (c)) return TRACE_RETURN (false);
 836     switch (u.format) {
 837     case 1: return TRACE_RETURN (u.format1.sanitize (c));
 838     case 2: return TRACE_RETURN (u.format2.sanitize (c));
 839     default:return TRACE_RETURN (true);
 840     }
 841   }
 842
 843   inline bool intersects (const hb_set_t *glyphs) const {
 844     /* TODO speed this up */
 845     Coverage::Iter iter;
 846     for (iter.init (*this); iter.more (); iter.next ()) {
 847       if (glyphs->has (iter.get_glyph ()))
 848         return true;
 849     }
 850     return false;
 851   }
 852
 853   inline bool intersects_coverage (const hb_set_t *glyphs, unsigned int index) const {
 854     switch (u.format) {
 855     case 1: return u.format1.intersects_coverage (glyphs, index);
 856     case 2: return u.format2.intersects_coverage (glyphs, index);
 857     default:return false;
 858     }
 859   }
 860
 861   template <typename set_t>
 862   inline void add_coverage (set_t *glyphs) const {
 863     switch (u.format) {
 864     case 1: u.format1.add_coverage (glyphs); break;
 865     case 2: u.format2.add_coverage (glyphs); break;
 866     default:                                 break;
 867     }
 868   }
 869
 870   struct Iter {
 871     Iter (void) : format (0) {};
 872     inline void init (const Coverage &c_) {
 873       format = c_.u.format;
 874       switch (format) {
 875       case 1: return u.format1.init (c_.u.format1);
 876       case 2: return u.format2.init (c_.u.format2);
 877       default:return;
 878       }
 879     }
 880     inline bool more (void) {
 881       switch (format) {
 882       case 1: return u.format1.more ();
 883       case 2: return u.format2.more ();
 884       default:return true;
 885       }
 886     }
 887     inline void next (void) {
 888       switch (format) {
 889       case 1: u.format1.next (); break;
 890       case 2: u.format2.next (); break;
 891       default:                   break;
 892       }
 893     }
 894     inline uint16_t get_glyph (void) {
 895       switch (format) {
 896       case 1: return u.format1.get_glyph ();
 897       case 2: return u.format2.get_glyph ();
 898       default:return true;
 899       }
 900     }
 901     inline uint16_t get_coverage (void) {
 902       switch (format) {
 903       case 1: return u.format1.get_coverage ();
 904       case 2: return u.format2.get_coverage ();
 905       default:return true;
 906       }
 907     }
 908
 909     private:
 910     unsigned int format;
 911     union {
 912     CoverageFormat1::Iter       format1;
 913     CoverageFormat2::Iter       format2;
 914     } u;
 915   };
 916
 917   protected:
 918   union {
 919   USHORT                format;         /* Format identifier */
 920   CoverageFormat1       format1;
 921   CoverageFormat2       format2;
 922   } u;
 923   public:
 924   DEFINE_SIZE_UNION (2, format);
 925 };
 926
 927
 928 /*
 929  * Class Definition Table
 930  */
 931
 932 struct ClassDefFormat1
 933 {
 934   friend struct ClassDef;
 935
 936   private:
 937   inline unsigned int get_class (hb_codepoint_t glyph_id) const
 938   {
 939     if (unlikely ((unsigned int) (glyph_id - startGlyph) < classValue.len))
 940       return classValue[glyph_id - startGlyph];
 941     return 0;
 942   }
 943
 944   inline bool sanitize (hb_sanitize_context_t *c) {
 945     TRACE_SANITIZE (this);
 946     return TRACE_RETURN (c->check_struct (this) && classValue.sanitize (c));
 947   }
 948
 949   template <typename set_t>
 950   inline void add_class (set_t *glyphs, unsigned int klass) const {
 951     unsigned int count = classValue.len;
 952     for (unsigned int i = 0; i < count; i++)
 953       if (classValue[i] == klass)
 954         glyphs->add (startGlyph + i);
 955   }
 956
 957   inline bool intersects_class (const hb_set_t *glyphs, unsigned int klass) const {
 958     unsigned int count = classValue.len;
 959     for (unsigned int i = 0; i < count; i++)
 960       if (classValue[i] == klass && glyphs->has (startGlyph + i))
 961         return true;
 962     return false;
 963   }
 964
 965   protected:
 966   USHORT        classFormat;            /* Format identifier--format = 1 */
 967   GlyphID       startGlyph;             /* First GlyphID of the classValueArray */
 968   ArrayOf<USHORT>
 969                 classValue;             /* Array of Class Values--one per GlyphID */
 970   public:
 971   DEFINE_SIZE_ARRAY (6, classValue);
 972 };
 973
 974 struct ClassDefFormat2
 975 {
 976   friend struct ClassDef;
 977
 978   private:
 979   inline unsigned int get_class (hb_codepoint_t glyph_id) const
 980   {
 981     int i = rangeRecord.search (glyph_id);
 982     if (i != -1)
 983       return rangeRecord[i].value;
 984     return 0;
 985   }
 986
 987   inline bool sanitize (hb_sanitize_context_t *c) {
 988     TRACE_SANITIZE (this);
 989     return TRACE_RETURN (rangeRecord.sanitize (c));
 990   }
 991
 992   template <typename set_t>
 993   inline void add_class (set_t *glyphs, unsigned int klass) const {
 994     unsigned int count = rangeRecord.len;
 995     for (unsigned int i = 0; i < count; i++)
 996       if (rangeRecord[i].value == klass)
 997         rangeRecord[i].add_coverage (glyphs);
 998   }
 999
1000   inline bool intersects_class (const hb_set_t *glyphs, unsigned int klass) const {
1001     unsigned int count = rangeRecord.len;
1002     for (unsigned int i = 0; i < count; i++)
1003       if (rangeRecord[i].value == klass && rangeRecord[i].intersects (glyphs))
1004         return true;
1005     return false;
1006   }
1007
1008   protected:
1009   USHORT        classFormat;    /* Format identifier--format = 2 */
1010   SortedArrayOf<RangeRecord>
1011                 rangeRecord;    /* Array of glyph ranges--ordered by
1012                                  * Start GlyphID */
1013   public:
1014   DEFINE_SIZE_ARRAY (4, rangeRecord);
1015 };
1016
1017 struct ClassDef
1018 {
1019   inline unsigned int get_class (hb_codepoint_t glyph_id) const
1020   {
1021     switch (u.format) {
1022     case 1: return u.format1.get_class(glyph_id);
1023     case 2: return u.format2.get_class(glyph_id);
1024     default:return 0;
1025     }
1026   }
1027
1028   inline bool sanitize (hb_sanitize_context_t *c) {
1029     TRACE_SANITIZE (this);
1030     if (!u.format.sanitize (c)) return TRACE_RETURN (false);
1031     switch (u.format) {
1032     case 1: return TRACE_RETURN (u.format1.sanitize (c));
1033     case 2: return TRACE_RETURN (u.format2.sanitize (c));
1034     default:return TRACE_RETURN (true);
1035     }
1036   }
1037
1038   inline void add_class (hb_set_t *glyphs, unsigned int klass) const {
1039     switch (u.format) {
1040     case 1: u.format1.add_class (glyphs, klass); return;
1041     case 2: u.format2.add_class (glyphs, klass); return;
1042     default:return;
1043     }
1044   }
1045
1046   inline bool intersects_class (const hb_set_t *glyphs, unsigned int klass) const {
1047     switch (u.format) {
1048     case 1: return u.format1.intersects_class (glyphs, klass);
1049     case 2: return u.format2.intersects_class (glyphs, klass);
1050     default:return false;
1051     }
1052   }
1053
1054   protected:
1055   union {
1056   USHORT                format;         /* Format identifier */
1057   ClassDefFormat1       format1;
1058   ClassDefFormat2       format2;
1059   } u;
1060   public:
1061   DEFINE_SIZE_UNION (2, format);
1062 };
1063
1064
1065 /*
1066  * Device Tables
1067  */
1068
1069 struct Device
1070 {
1071
1072   inline hb_position_t get_x_delta (hb_font_t *font) const
1073   { return get_delta (font->x_ppem, font->x_scale); }
1074
1075   inline hb_position_t get_y_delta (hb_font_t *font) const
1076   { return get_delta (font->y_ppem, font->y_scale); }
1077
1078   inline int get_delta (unsigned int ppem, int scale) const
1079   {
1080     if (!ppem) return 0;
1081
1082     int pixels = get_delta_pixels (ppem);
1083
1084     if (!pixels) return 0;
1085
1086     return pixels * (int64_t) scale / ppem;
1087   }
1088
1089
1090   inline int get_delta_pixels (unsigned int ppem_size) const
1091   {
1092     unsigned int f = deltaFormat;
1093     if (unlikely (f < 1 || f > 3))
1094       return 0;
1095
1096     if (ppem_size < startSize || ppem_size > endSize)
1097       return 0;
1098
1099     unsigned int s = ppem_size - startSize;
1100
1101     unsigned int byte = deltaValue[s >> (4 - f)];
1102     unsigned int bits = (byte >> (16 - (((s & ((1 << (4 - f)) - 1)) + 1) << f)));
1103     unsigned int mask = (0xFFFF >> (16 - (1 << f)));
1104
1105     int delta = bits & mask;
1106
1107     if ((unsigned int) delta >= ((mask + 1) >> 1))
1108       delta -= mask + 1;
1109
1110     return delta;
1111   }
1112
1113   inline unsigned int get_size (void) const
1114   {
1115     unsigned int f = deltaFormat;
1116     if (unlikely (f < 1 || f > 3 || startSize > endSize)) return 3 * USHORT::static_size;
1117     return USHORT::static_size * (4 + ((endSize - startSize) >> (4 - f)));
1118   }
1119
1120   inline bool sanitize (hb_sanitize_context_t *c) {
1121     TRACE_SANITIZE (this);
1122     return TRACE_RETURN (c->check_struct (this) && c->check_range (this, this->get_size ()));
1123   }
1124
1125   protected:
1126   USHORT        startSize;              /* Smallest size to correct--in ppem */
1127   USHORT        endSize;                /* Largest size to correct--in ppem */
1128   USHORT        deltaFormat;            /* Format of DeltaValue array data: 1, 2, or 3
1129                                          * 1    Signed 2-bit value, 8 values per uint16
1130                                          * 2    Signed 4-bit value, 4 values per uint16
1131                                          * 3    Signed 8-bit value, 2 values per uint16
1132                                          */
1133   USHORT        deltaValue[VAR];        /* Array of compressed data */
1134   public:
1135   DEFINE_SIZE_ARRAY (6, deltaValue);
1136 };
1137
1138
1139 } /* namespace OT */
1140
1141
1142 #endif /* HB_OT_LAYOUT_COMMON_PRIVATE_HH */