src/hb-ot-cff1-table.hh

   1 /*
   2  * Copyright © 2018 Adobe Inc.
   3  *
   4  *  This is part of HarfBuzz, a text shaping library.
   5  *
   6  * Permission is hereby granted, without written agreement and without
   7  * license or royalty fees, to use, copy, modify, and distribute this
   8  * software and its documentation for any purpose, provided that the
   9  * above copyright notice and the following two paragraphs appear in
  10  * all copies of this software.
  11  *
  12  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
  13  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
  14  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
  15  * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
  16  * DAMAGE.
  17  *
  18  * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
  19  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  20  * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  21  * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
  22  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  23  *
  24  * Adobe Author(s): Michiharu Ariza
  25  */
  26
  27 #ifndef HB_OT_CFF1_TABLE_HH
  28 #define HB_OT_CFF1_TABLE_HH
  29
  30 #include "hb-ot-head-table.hh"
  31 #include "hb-ot-cff-common.hh"
  32 #include "hb-subset-cff1.hh"
  33
  34 namespace CFF {
  35
  36 /*
  37  * CFF -- Compact Font Format (CFF)
  38  * http://www.adobe.com/content/dam/acom/en/devnet/font/pdfs/5176.CFF.pdf
  39  */
  40 #define HB_OT_TAG_cff1 HB_TAG('C','F','F',' ')
  41
  42 #define CFF_UNDEF_SID   CFF_UNDEF_CODE
  43
  44 enum EncodingID { StandardEncoding = 0, ExpertEncoding = 1 };
  45 enum CharsetID { ISOAdobeCharset = 0, ExpertCharset = 1, ExpertSubsetCharset = 2 };
  46
  47 typedef CFFIndex<HBUINT16>  CFF1Index;
  48 template <typename Type> struct CFF1IndexOf : CFFIndexOf<HBUINT16, Type> {};
  49
  50 typedef CFFIndex<HBUINT16> CFF1Index;
  51 typedef CFF1Index          CFF1CharStrings;
  52 typedef FDArray<HBUINT16>  CFF1FDArray;
  53 typedef Subrs<HBUINT16>    CFF1Subrs;
  54
  55 struct CFF1FDSelect : FDSelect {};
  56
  57 /* Encoding */
  58 struct Encoding0 {
  59   bool sanitize (hb_sanitize_context_t *c) const
  60   {
  61     TRACE_SANITIZE (this);
  62     return_trace (c->check_struct (this) && codes[nCodes - 1].sanitize (c));
  63   }
  64
  65   hb_codepoint_t get_code (hb_codepoint_t glyph) const
  66   {
  67     assert (glyph > 0);
  68     glyph--;
  69     if (glyph < nCodes)
  70     {
  71       return (hb_codepoint_t)codes[glyph];
  72     }
  73     else
  74       return CFF_UNDEF_CODE;
  75   }
  76
  77   unsigned int get_size () const
  78   { return HBUINT8::static_size * (nCodes + 1); }
  79
  80   HBUINT8     nCodes;
  81   HBUINT8     codes[VAR];
  82
  83   DEFINE_SIZE_ARRAY(1, codes);
  84 };
  85
  86 struct Encoding1_Range {
  87   bool sanitize (hb_sanitize_context_t *c) const
  88   {
  89     TRACE_SANITIZE (this);
  90     return_trace (c->check_struct (this));
  91   }
  92
  93   HBUINT8   first;
  94   HBUINT8   nLeft;
  95
  96   DEFINE_SIZE_STATIC (2);
  97 };
  98
  99 struct Encoding1 {
 100   unsigned int get_size () const
 101   { return HBUINT8::static_size + Encoding1_Range::static_size * nRanges; }
 102
 103   bool sanitize (hb_sanitize_context_t *c) const
 104   {
 105     TRACE_SANITIZE (this);
 106     return_trace (c->check_struct (this) && ((nRanges == 0) || (ranges[nRanges - 1]).sanitize (c)));
 107   }
 108
 109   hb_codepoint_t get_code (hb_codepoint_t glyph) const
 110   {
 111     assert (glyph > 0);
 112     glyph--;
 113     for (unsigned int i = 0; i < nRanges; i++)
 114     {
 115       if (glyph <= ranges[i].nLeft)
 116       {
 117         return (hb_codepoint_t)ranges[i].first + glyph;
 118       }
 119       glyph -= (ranges[i].nLeft + 1);
 120     }
 121     return CFF_UNDEF_CODE;
 122   }
 123
 124   HBUINT8          nRanges;
 125   Encoding1_Range   ranges[VAR];
 126
 127   DEFINE_SIZE_ARRAY (1, ranges);
 128 };
 129
 130 struct SuppEncoding {
 131   bool sanitize (hb_sanitize_context_t *c) const
 132   {
 133     TRACE_SANITIZE (this);
 134     return_trace (c->check_struct (this));
 135   }
 136
 137   HBUINT8   code;
 138   HBUINT16  glyph;
 139
 140   DEFINE_SIZE_STATIC (3);
 141 };
 142
 143 struct CFF1SuppEncData {
 144   bool sanitize (hb_sanitize_context_t *c) const
 145   {
 146     TRACE_SANITIZE (this);
 147     return_trace (c->check_struct (this) && ((nSups == 0) || (supps[nSups - 1]).sanitize (c)));
 148   }
 149
 150   void get_codes (hb_codepoint_t sid, hb_vector_t<hb_codepoint_t> &codes) const
 151   {
 152     for (unsigned int i = 0; i < nSups; i++)
 153       if (sid == supps[i].glyph)
 154         codes.push (supps[i].code);
 155   }
 156
 157   unsigned int get_size () const
 158   { return HBUINT8::static_size + SuppEncoding::static_size * nSups; }
 159
 160   HBUINT8        nSups;
 161   SuppEncoding   supps[VAR];
 162
 163   DEFINE_SIZE_ARRAY (1, supps);
 164 };
 165
 166 struct Encoding {
 167   bool sanitize (hb_sanitize_context_t *c) const
 168   {
 169     TRACE_SANITIZE (this);
 170
 171     if (unlikely (!c->check_struct (this)))
 172       return_trace (false);
 173     unsigned int fmt = format & 0x7F;
 174     if (unlikely (fmt > 1))
 175       return_trace (false);
 176     if (unlikely (!((fmt == 0)? u.format0.sanitize (c): u.format1.sanitize (c))))
 177       return_trace (false);
 178     return_trace (((format & 0x80) == 0) || suppEncData ().sanitize (c));
 179   }
 180
 181   /* serialize a fullset Encoding */
 182   bool serialize (hb_serialize_context_t *c, const Encoding &src)
 183   {
 184     TRACE_SERIALIZE (this);
 185     unsigned int size = src.get_size ();
 186     Encoding *dest = c->allocate_size<Encoding> (size);
 187     if (unlikely (dest == nullptr)) return_trace (false);
 188     memcpy (dest, &src, size);
 189     return_trace (true);
 190   }
 191
 192   /* serialize a subset Encoding */
 193   bool serialize (hb_serialize_context_t *c,
 194                   uint8_t format,
 195                   unsigned int enc_count,
 196                   const hb_vector_t<code_pair_t>& code_ranges,
 197                   const hb_vector_t<code_pair_t>& supp_codes)
 198   {
 199     TRACE_SERIALIZE (this);
 200     Encoding *dest = c->extend_min (*this);
 201     if (unlikely (dest == nullptr)) return_trace (false);
 202     dest->format.set (format | ((supp_codes.length > 0)? 0x80: 0));
 203     if (format == 0)
 204     {
 205       Encoding0 *fmt0 = c->allocate_size<Encoding0> (Encoding0::min_size + HBUINT8::static_size * enc_count);
 206     if (unlikely (fmt0 == nullptr)) return_trace (false);
 207       fmt0->nCodes.set (enc_count);
 208       unsigned int glyph = 0;
 209       for (unsigned int i = 0; i < code_ranges.length; i++)
 210       {
 211         hb_codepoint_t code = code_ranges[i].code;
 212         for (int left = (int)code_ranges[i].glyph; left >= 0; left--)
 213           fmt0->codes[glyph++].set (code++);
 214         if (unlikely (!((glyph <= 0x100) && (code <= 0x100))))
 215           return_trace (false);
 216       }
 217     }
 218     else
 219     {
 220       Encoding1 *fmt1 = c->allocate_size<Encoding1> (Encoding1::min_size + Encoding1_Range::static_size * code_ranges.length);
 221       if (unlikely (fmt1 == nullptr)) return_trace (false);
 222       fmt1->nRanges.set (code_ranges.length);
 223       for (unsigned int i = 0; i < code_ranges.length; i++)
 224       {
 225         if (unlikely (!((code_ranges[i].code <= 0xFF) && (code_ranges[i].glyph <= 0xFF))))
 226           return_trace (false);
 227         fmt1->ranges[i].first.set (code_ranges[i].code);
 228         fmt1->ranges[i].nLeft.set (code_ranges[i].glyph);
 229       }
 230     }
 231     if (supp_codes.length > 0)
 232     {
 233       CFF1SuppEncData *suppData = c->allocate_size<CFF1SuppEncData> (CFF1SuppEncData::min_size + SuppEncoding::static_size * supp_codes.length);
 234       if (unlikely (suppData == nullptr)) return_trace (false);
 235       suppData->nSups.set (supp_codes.length);
 236       for (unsigned int i = 0; i < supp_codes.length; i++)
 237       {
 238         suppData->supps[i].code.set (supp_codes[i].code);
 239         suppData->supps[i].glyph.set (supp_codes[i].glyph); /* actually SID */
 240       }
 241     }
 242     return_trace (true);
 243   }
 244
 245   /* parallel to above: calculate the size of a subset Encoding */
 246   static unsigned int calculate_serialized_size (uint8_t format,
 247                                                  unsigned int enc_count,
 248                                                  unsigned int supp_count)
 249   {
 250     unsigned int  size = min_size;
 251     if (format == 0)
 252       size += Encoding0::min_size + HBUINT8::static_size * enc_count;
 253     else
 254       size += Encoding1::min_size + Encoding1_Range::static_size * enc_count;
 255     if (supp_count > 0)
 256       size += CFF1SuppEncData::min_size + SuppEncoding::static_size * supp_count;
 257     return size;
 258   }
 259
 260   unsigned int get_size () const
 261   {
 262     unsigned int size = min_size;
 263     if (table_format () == 0)
 264       size += u.format0.get_size ();
 265     else
 266       size += u.format1.get_size ();
 267     if (has_supplement ())
 268       size += suppEncData ().get_size ();
 269     return size;
 270   }
 271
 272   hb_codepoint_t get_code (hb_codepoint_t glyph) const
 273   {
 274     if (table_format () == 0)
 275       return u.format0.get_code (glyph);
 276     else
 277       return u.format1.get_code (glyph);
 278   }
 279
 280   uint8_t table_format () const { return (format & 0x7F); }
 281   bool  has_supplement () const { return (format & 0x80) != 0; }
 282
 283   void get_supplement_codes (hb_codepoint_t sid, hb_vector_t<hb_codepoint_t> &codes) const
 284   {
 285     codes.resize (0);
 286     if (has_supplement ())
 287       suppEncData().get_codes (sid, codes);
 288   }
 289
 290   protected:
 291   const CFF1SuppEncData &suppEncData () const
 292   {
 293     if ((format & 0x7F) == 0)
 294       return StructAfter<CFF1SuppEncData> (u.format0.codes[u.format0.nCodes-1]);
 295     else
 296       return StructAfter<CFF1SuppEncData> (u.format1.ranges[u.format1.nRanges-1]);
 297   }
 298
 299   public:
 300   HBUINT8       format;
 301
 302   union {
 303     Encoding0   format0;
 304     Encoding1   format1;
 305   } u;
 306   /* CFF1SuppEncData  suppEncData; */
 307
 308   DEFINE_SIZE_MIN (1);
 309 };
 310
 311 /* Charset */
 312 struct Charset0 {
 313   bool sanitize (hb_sanitize_context_t *c, unsigned int num_glyphs) const
 314   {
 315     TRACE_SANITIZE (this);
 316     return_trace (c->check_struct (this) && sids[num_glyphs - 1].sanitize (c));
 317   }
 318
 319   hb_codepoint_t get_sid (hb_codepoint_t glyph) const
 320   {
 321     if (glyph == 0)
 322       return 0;
 323     else
 324       return sids[glyph - 1];
 325   }
 326
 327   hb_codepoint_t get_glyph (hb_codepoint_t sid, unsigned int num_glyphs) const
 328   {
 329     if (sid == 0)
 330       return 0;
 331
 332     for (unsigned int glyph = 1; glyph < num_glyphs; glyph++)
 333     {
 334       if (sids[glyph-1] == sid)
 335         return glyph;
 336     }
 337     return 0;
 338   }
 339
 340   unsigned int get_size (unsigned int num_glyphs) const
 341   {
 342     assert (num_glyphs > 0);
 343     return HBUINT16::static_size * (num_glyphs - 1);
 344   }
 345
 346   HBUINT16  sids[VAR];
 347
 348   DEFINE_SIZE_ARRAY(0, sids);
 349 };
 350
 351 template <typename TYPE>
 352 struct Charset_Range {
 353   bool sanitize (hb_sanitize_context_t *c) const
 354   {
 355     TRACE_SANITIZE (this);
 356     return_trace (c->check_struct (this));
 357   }
 358
 359   HBUINT16  first;
 360   TYPE      nLeft;
 361
 362   DEFINE_SIZE_STATIC (HBUINT16::static_size + TYPE::static_size);
 363 };
 364
 365 template <typename TYPE>
 366 struct Charset1_2 {
 367   bool sanitize (hb_sanitize_context_t *c, unsigned int num_glyphs) const
 368   {
 369     TRACE_SANITIZE (this);
 370     if (unlikely (!c->check_struct (this)))
 371       return_trace (false);
 372     num_glyphs--;
 373     for (unsigned int i = 0; num_glyphs > 0; i++)
 374     {
 375       if (unlikely (!ranges[i].sanitize (c) || (num_glyphs < ranges[i].nLeft + 1)))
 376         return_trace (false);
 377       num_glyphs -= (ranges[i].nLeft + 1);
 378     }
 379     return_trace (true);
 380   }
 381
 382   hb_codepoint_t get_sid (hb_codepoint_t glyph) const
 383   {
 384     if (glyph == 0) return 0;
 385     glyph--;
 386     for (unsigned int i = 0;; i++)
 387     {
 388       if (glyph <= ranges[i].nLeft)
 389         return (hb_codepoint_t)ranges[i].first + glyph;
 390       glyph -= (ranges[i].nLeft + 1);
 391     }
 392
 393     return 0;
 394   }
 395
 396   hb_codepoint_t get_glyph (hb_codepoint_t sid, unsigned int num_glyphs) const
 397   {
 398     if (sid == 0) return 0;
 399     hb_codepoint_t  glyph = 1;
 400     for (unsigned int i = 0;; i++)
 401     {
 402       if (glyph >= num_glyphs)
 403         return 0;
 404       if ((ranges[i].first <= sid) && (sid <= ranges[i].first + ranges[i].nLeft))
 405         return glyph + (sid - ranges[i].first);
 406       glyph += (ranges[i].nLeft + 1);
 407     }
 408
 409     return 0;
 410   }
 411
 412   unsigned int get_size (unsigned int num_glyphs) const
 413   {
 414     unsigned int size = HBUINT8::static_size;
 415     int glyph = (int)num_glyphs;
 416
 417     assert (glyph > 0);
 418     glyph--;
 419     for (unsigned int i = 0; glyph > 0; i++)
 420     {
 421       glyph -= (ranges[i].nLeft + 1);
 422       size += Charset_Range<TYPE>::static_size;
 423     }
 424
 425     return size;
 426   }
 427
 428   Charset_Range<TYPE>   ranges[VAR];
 429
 430   DEFINE_SIZE_ARRAY (0, ranges);
 431 };
 432
 433 typedef Charset1_2<HBUINT8>     Charset1;
 434 typedef Charset1_2<HBUINT16>    Charset2;
 435 typedef Charset_Range<HBUINT8>  Charset1_Range;
 436 typedef Charset_Range<HBUINT16> Charset2_Range;
 437
 438 struct Charset {
 439   bool sanitize (hb_sanitize_context_t *c) const
 440   {
 441     TRACE_SANITIZE (this);
 442
 443     if (unlikely (!c->check_struct (this)))
 444       return_trace (false);
 445     if (format == 0)
 446       return_trace (u.format0.sanitize (c, c->get_num_glyphs ()));
 447     else if (format == 1)
 448       return_trace (u.format1.sanitize (c, c->get_num_glyphs ()));
 449     else if (likely (format == 2))
 450       return_trace (u.format2.sanitize (c, c->get_num_glyphs ()));
 451     else
 452       return_trace (false);
 453   }
 454
 455   /* serialize a fullset Charset */
 456   bool serialize (hb_serialize_context_t *c, const Charset &src, unsigned int num_glyphs)
 457   {
 458     TRACE_SERIALIZE (this);
 459     unsigned int size = src.get_size (num_glyphs);
 460     Charset *dest = c->allocate_size<Charset> (size);
 461     if (unlikely (dest == nullptr)) return_trace (false);
 462     memcpy (dest, &src, size);
 463     return_trace (true);
 464   }
 465
 466   /* serialize a subset Charset */
 467   bool serialize (hb_serialize_context_t *c,
 468                   uint8_t format,
 469                   unsigned int num_glyphs,
 470                   const hb_vector_t<code_pair_t>& sid_ranges)
 471   {
 472     TRACE_SERIALIZE (this);
 473     Charset *dest = c->extend_min (*this);
 474     if (unlikely (dest == nullptr)) return_trace (false);
 475     dest->format.set (format);
 476     if (format == 0)
 477     {
 478       Charset0 *fmt0 = c->allocate_size<Charset0> (Charset0::min_size + HBUINT16::static_size * (num_glyphs - 1));
 479     if (unlikely (fmt0 == nullptr)) return_trace (false);
 480       unsigned int glyph = 0;
 481       for (unsigned int i = 0; i < sid_ranges.length; i++)
 482       {
 483         hb_codepoint_t sid = sid_ranges[i].code;
 484         for (int left = (int)sid_ranges[i].glyph; left >= 0; left--)
 485           fmt0->sids[glyph++].set (sid++);
 486       }
 487     }
 488     else if (format == 1)
 489     {
 490       Charset1 *fmt1 = c->allocate_size<Charset1> (Charset1::min_size + Charset1_Range::static_size * sid_ranges.length);
 491       if (unlikely (fmt1 == nullptr)) return_trace (false);
 492       for (unsigned int i = 0; i < sid_ranges.length; i++)
 493       {
 494         if (unlikely (!(sid_ranges[i].glyph <= 0xFF)))
 495           return_trace (false);
 496         fmt1->ranges[i].first.set (sid_ranges[i].code);
 497         fmt1->ranges[i].nLeft.set (sid_ranges[i].glyph);
 498       }
 499     }
 500     else /* format 2 */
 501     {
 502       Charset2 *fmt2 = c->allocate_size<Charset2> (Charset2::min_size + Charset2_Range::static_size * sid_ranges.length);
 503       if (unlikely (fmt2 == nullptr)) return_trace (false);
 504       for (unsigned int i = 0; i < sid_ranges.length; i++)
 505       {
 506         if (unlikely (!(sid_ranges[i].glyph <= 0xFFFF)))
 507           return_trace (false);
 508         fmt2->ranges[i].first.set (sid_ranges[i].code);
 509         fmt2->ranges[i].nLeft.set (sid_ranges[i].glyph);
 510       }
 511     }
 512     return_trace (true);
 513   }
 514
 515   /* parallel to above: calculate the size of a subset Charset */
 516   static unsigned int calculate_serialized_size (
 517                         uint8_t format,
 518                         unsigned int count)
 519   {
 520     unsigned int  size = min_size;
 521     if (format == 0)
 522       size += Charset0::min_size + HBUINT16::static_size * (count - 1);
 523     else if (format == 1)
 524       size += Charset1::min_size + Charset1_Range::static_size * count;
 525     else
 526       size += Charset2::min_size + Charset2_Range::static_size * count;
 527
 528     return size;
 529   }
 530
 531   unsigned int get_size (unsigned int num_glyphs) const
 532   {
 533     unsigned int size = min_size;
 534     if (format == 0)
 535       size += u.format0.get_size (num_glyphs);
 536     else if (format == 1)
 537       size += u.format1.get_size (num_glyphs);
 538     else
 539       size += u.format2.get_size (num_glyphs);
 540     return size;
 541   }
 542
 543   hb_codepoint_t get_sid (hb_codepoint_t glyph) const
 544   {
 545     if (format == 0)
 546       return u.format0.get_sid (glyph);
 547     else if (format == 1)
 548       return u.format1.get_sid (glyph);
 549     else
 550       return u.format2.get_sid (glyph);
 551   }
 552
 553   hb_codepoint_t get_glyph (hb_codepoint_t sid, unsigned int num_glyphs) const
 554   {
 555     if (format == 0)
 556       return u.format0.get_glyph (sid, num_glyphs);
 557     else if (format == 1)
 558       return u.format1.get_glyph (sid, num_glyphs);
 559     else
 560       return u.format2.get_glyph (sid, num_glyphs);
 561   }
 562
 563   HBUINT8       format;
 564   union {
 565     Charset0    format0;
 566     Charset1    format1;
 567     Charset2    format2;
 568   } u;
 569
 570   DEFINE_SIZE_MIN (1);
 571 };
 572
 573 struct CFF1StringIndex : CFF1Index
 574 {
 575   bool serialize (hb_serialize_context_t *c, const CFF1StringIndex &strings,
 576                   unsigned int offSize_, const remap_t &sidmap)
 577   {
 578     TRACE_SERIALIZE (this);
 579     if (unlikely ((strings.count == 0) || (sidmap.get_count () == 0)))
 580     {
 581       if (!unlikely (c->extend_min (this->count)))
 582         return_trace (false);
 583       count.set (0);
 584       return_trace (true);
 585     }
 586
 587     byte_str_array_t bytesArray;
 588     bytesArray.init ();
 589     if (!bytesArray.resize (sidmap.get_count ()))
 590       return_trace (false);
 591     for (unsigned int i = 0; i < strings.count; i++)
 592     {
 593       hb_codepoint_t  j = sidmap[i];
 594       if (j != CFF_UNDEF_CODE)
 595         bytesArray[j] = strings[i];
 596     }
 597
 598     bool result = CFF1Index::serialize (c, offSize_, bytesArray);
 599     bytesArray.fini ();
 600     return_trace (result);
 601   }
 602
 603   /* in parallel to above */
 604   unsigned int calculate_serialized_size (unsigned int &offSize /*OUT*/, const remap_t &sidmap) const
 605   {
 606     offSize = 0;
 607     if ((count == 0) || (sidmap.get_count () == 0))
 608       return count.static_size;
 609
 610     unsigned int dataSize = 0;
 611     for (unsigned int i = 0; i < count; i++)
 612       if (sidmap[i] != CFF_UNDEF_CODE)
 613         dataSize += length_at (i);
 614
 615     offSize = calcOffSize(dataSize);
 616     return CFF1Index::calculate_serialized_size (offSize, sidmap.get_count (), dataSize);
 617   }
 618 };
 619
 620 struct cff1_top_dict_interp_env_t : num_interp_env_t
 621 {
 622   cff1_top_dict_interp_env_t ()
 623     : num_interp_env_t(), prev_offset(0), last_offset(0) {}
 624
 625   unsigned int prev_offset;
 626   unsigned int last_offset;
 627 };
 628
 629 struct name_dict_values_t
 630 {
 631   enum name_dict_val_index_t
 632   {
 633       version,
 634       notice,
 635       copyright,
 636       fullName,
 637       familyName,
 638       weight,
 639       postscript,
 640       fontName,
 641       baseFontName,
 642       registry,
 643       ordering,
 644
 645       ValCount
 646   };
 647
 648   void init ()
 649   {
 650     for (unsigned int i = 0; i < ValCount; i++)
 651       values[i] = CFF_UNDEF_SID;
 652   }
 653
 654   unsigned int& operator[] (unsigned int i)
 655   { assert (i < ValCount); return values[i]; }
 656
 657   unsigned int operator[] (unsigned int i) const
 658   { assert (i < ValCount); return values[i]; }
 659
 660   static enum name_dict_val_index_t name_op_to_index (op_code_t op)
 661   {
 662     switch (op) {
 663       default: // can't happen - just make some compiler happy
 664       case OpCode_version:
 665         return version;
 666       case OpCode_Notice:
 667         return notice;
 668       case OpCode_Copyright:
 669         return copyright;
 670       case OpCode_FullName:
 671         return fullName;
 672       case OpCode_FamilyName:
 673         return familyName;
 674       case OpCode_Weight:
 675         return weight;
 676       case OpCode_PostScript:
 677         return postscript;
 678       case OpCode_FontName:
 679         return fontName;
 680       case OpCode_BaseFontName:
 681         return baseFontName;
 682     }
 683   }
 684
 685   unsigned int  values[ValCount];
 686 };
 687
 688 struct cff1_top_dict_val_t : op_str_t
 689 {
 690   unsigned int  last_arg_offset;
 691 };
 692
 693 struct cff1_top_dict_values_t : top_dict_values_t<cff1_top_dict_val_t>
 694 {
 695   void init ()
 696   {
 697     top_dict_values_t<cff1_top_dict_val_t>::init ();
 698
 699     nameSIDs.init ();
 700     ros_supplement = 0;
 701     cidCount = 8720;
 702     EncodingOffset = 0;
 703     CharsetOffset = 0;
 704     FDSelectOffset = 0;
 705     privateDictInfo.init ();
 706   }
 707   void fini () { top_dict_values_t<cff1_top_dict_val_t>::fini (); }
 708
 709   bool is_CID () const
 710   { return nameSIDs[name_dict_values_t::registry] != CFF_UNDEF_SID; }
 711
 712   name_dict_values_t  nameSIDs;
 713   unsigned int    ros_supplement_offset;
 714   unsigned int    ros_supplement;
 715   unsigned int    cidCount;
 716
 717   unsigned int    EncodingOffset;
 718   unsigned int    CharsetOffset;
 719   unsigned int    FDSelectOffset;
 720   table_info_t       privateDictInfo;
 721 };
 722
 723 struct cff1_top_dict_opset_t : top_dict_opset_t<cff1_top_dict_val_t>
 724 {
 725   static void process_op (op_code_t op, cff1_top_dict_interp_env_t& env, cff1_top_dict_values_t& dictval)
 726   {
 727     cff1_top_dict_val_t  val;
 728     val.last_arg_offset = (env.last_offset-1) - dictval.opStart;  /* offset to the last argument */
 729
 730     switch (op) {
 731       case OpCode_version:
 732       case OpCode_Notice:
 733       case OpCode_Copyright:
 734       case OpCode_FullName:
 735       case OpCode_FamilyName:
 736       case OpCode_Weight:
 737       case OpCode_PostScript:
 738       case OpCode_BaseFontName:
 739         dictval.nameSIDs[name_dict_values_t::name_op_to_index (op)] = env.argStack.pop_uint ();
 740         env.clear_args ();
 741         break;
 742       case OpCode_isFixedPitch:
 743       case OpCode_ItalicAngle:
 744       case OpCode_UnderlinePosition:
 745       case OpCode_UnderlineThickness:
 746       case OpCode_PaintType:
 747       case OpCode_CharstringType:
 748       case OpCode_UniqueID:
 749       case OpCode_StrokeWidth:
 750       case OpCode_SyntheticBase:
 751       case OpCode_CIDFontVersion:
 752       case OpCode_CIDFontRevision:
 753       case OpCode_CIDFontType:
 754       case OpCode_UIDBase:
 755       case OpCode_FontBBox:
 756       case OpCode_XUID:
 757       case OpCode_BaseFontBlend:
 758         env.clear_args ();
 759         break;
 760
 761       case OpCode_CIDCount:
 762         dictval.cidCount = env.argStack.pop_uint ();
 763         env.clear_args ();
 764         break;
 765
 766       case OpCode_ROS:
 767         dictval.ros_supplement = env.argStack.pop_uint ();
 768         dictval.nameSIDs[name_dict_values_t::ordering] = env.argStack.pop_uint ();
 769         dictval.nameSIDs[name_dict_values_t::registry] = env.argStack.pop_uint ();
 770         env.clear_args ();
 771         break;
 772
 773       case OpCode_Encoding:
 774         dictval.EncodingOffset = env.argStack.pop_uint ();
 775         env.clear_args ();
 776         if (unlikely (dictval.EncodingOffset == 0)) return;
 777         break;
 778
 779       case OpCode_charset:
 780         dictval.CharsetOffset = env.argStack.pop_uint ();
 781         env.clear_args ();
 782         if (unlikely (dictval.CharsetOffset == 0)) return;
 783         break;
 784
 785       case OpCode_FDSelect:
 786         dictval.FDSelectOffset = env.argStack.pop_uint ();
 787         env.clear_args ();
 788         break;
 789
 790       case OpCode_Private:
 791         dictval.privateDictInfo.offset = env.argStack.pop_uint ();
 792         dictval.privateDictInfo.size = env.argStack.pop_uint ();
 793         env.clear_args ();
 794         break;
 795
 796       default:
 797         env.last_offset = env.str_ref.offset;
 798         top_dict_opset_t<cff1_top_dict_val_t>::process_op (op, env, dictval);
 799         /* Record this operand below if stack is empty, otherwise done */
 800         if (!env.argStack.is_empty ()) return;
 801         break;
 802     }
 803
 804     if (unlikely (env.in_error ())) return;
 805
 806     dictval.add_op (op, env.str_ref, val);
 807   }
 808 };
 809
 810 struct cff1_font_dict_values_t : dict_values_t<op_str_t>
 811 {
 812   void init ()
 813   {
 814     dict_values_t<op_str_t>::init ();
 815     privateDictInfo.init ();
 816     fontName = CFF_UNDEF_SID;
 817   }
 818   void fini () { dict_values_t<op_str_t>::fini (); }
 819
 820   table_info_t       privateDictInfo;
 821   unsigned int    fontName;
 822 };
 823
 824 struct cff1_font_dict_opset_t : dict_opset_t
 825 {
 826   static void process_op (op_code_t op, num_interp_env_t& env, cff1_font_dict_values_t& dictval)
 827   {
 828     switch (op) {
 829       case OpCode_FontName:
 830         dictval.fontName = env.argStack.pop_uint ();
 831         env.clear_args ();
 832         break;
 833       case OpCode_FontMatrix:
 834       case OpCode_PaintType:
 835         env.clear_args ();
 836         break;
 837       case OpCode_Private:
 838         dictval.privateDictInfo.offset = env.argStack.pop_uint ();
 839         dictval.privateDictInfo.size = env.argStack.pop_uint ();
 840         env.clear_args ();
 841         break;
 842
 843       default:
 844         dict_opset_t::process_op (op, env);
 845         if (!env.argStack.is_empty ()) return;
 846         break;
 847     }
 848
 849     if (unlikely (env.in_error ())) return;
 850
 851     dictval.add_op (op, env.str_ref);
 852   }
 853 };
 854
 855 template <typename VAL>
 856 struct cff1_private_dict_values_base_t : dict_values_t<VAL>
 857 {
 858   void init ()
 859   {
 860     dict_values_t<VAL>::init ();
 861     subrsOffset = 0;
 862     localSubrs = &Null(CFF1Subrs);
 863   }
 864   void fini () { dict_values_t<VAL>::fini (); }
 865
 866   unsigned int calculate_serialized_size () const
 867   {
 868     unsigned int size = 0;
 869     for (unsigned int i = 0; i < dict_values_t<VAL>::get_count; i++)
 870       if (dict_values_t<VAL>::get_value (i).op == OpCode_Subrs)
 871         size += OpCode_Size (OpCode_shortint) + 2 + OpCode_Size (OpCode_Subrs);
 872       else
 873         size += dict_values_t<VAL>::get_value (i).str.length;
 874     return size;
 875   }
 876
 877   unsigned int      subrsOffset;
 878   const CFF1Subrs    *localSubrs;
 879 };
 880
 881 typedef cff1_private_dict_values_base_t<op_str_t> cff1_private_dict_values_subset_t;
 882 typedef cff1_private_dict_values_base_t<num_dict_val_t> cff1_private_dict_values_t;
 883
 884 struct cff1_private_dict_opset_t : dict_opset_t
 885 {
 886   static void process_op (op_code_t op, num_interp_env_t& env, cff1_private_dict_values_t& dictval)
 887   {
 888     num_dict_val_t val;
 889     val.init ();
 890
 891     switch (op) {
 892       case OpCode_BlueValues:
 893       case OpCode_OtherBlues:
 894       case OpCode_FamilyBlues:
 895       case OpCode_FamilyOtherBlues:
 896       case OpCode_StemSnapH:
 897       case OpCode_StemSnapV:
 898         env.clear_args ();
 899         break;
 900       case OpCode_StdHW:
 901       case OpCode_StdVW:
 902       case OpCode_BlueScale:
 903       case OpCode_BlueShift:
 904       case OpCode_BlueFuzz:
 905       case OpCode_ForceBold:
 906       case OpCode_LanguageGroup:
 907       case OpCode_ExpansionFactor:
 908       case OpCode_initialRandomSeed:
 909       case OpCode_defaultWidthX:
 910       case OpCode_nominalWidthX:
 911         val.single_val = env.argStack.pop_num ();
 912         env.clear_args ();
 913         break;
 914       case OpCode_Subrs:
 915         dictval.subrsOffset = env.argStack.pop_uint ();
 916         env.clear_args ();
 917         break;
 918
 919       default:
 920         dict_opset_t::process_op (op, env);
 921         if (!env.argStack.is_empty ()) return;
 922         break;
 923     }
 924
 925     if (unlikely (env.in_error ())) return;
 926
 927     dictval.add_op (op, env.str_ref, val);
 928   }
 929 };
 930
 931 struct cff1_private_dict_opset_subset : dict_opset_t
 932 {
 933   static void process_op (op_code_t op, num_interp_env_t& env, cff1_private_dict_values_subset_t& dictval)
 934   {
 935     switch (op) {
 936       case OpCode_BlueValues:
 937       case OpCode_OtherBlues:
 938       case OpCode_FamilyBlues:
 939       case OpCode_FamilyOtherBlues:
 940       case OpCode_StemSnapH:
 941       case OpCode_StemSnapV:
 942       case OpCode_StdHW:
 943       case OpCode_StdVW:
 944       case OpCode_BlueScale:
 945       case OpCode_BlueShift:
 946       case OpCode_BlueFuzz:
 947       case OpCode_ForceBold:
 948       case OpCode_LanguageGroup:
 949       case OpCode_ExpansionFactor:
 950       case OpCode_initialRandomSeed:
 951       case OpCode_defaultWidthX:
 952       case OpCode_nominalWidthX:
 953         env.clear_args ();
 954         break;
 955
 956       case OpCode_Subrs:
 957         dictval.subrsOffset = env.argStack.pop_uint ();
 958         env.clear_args ();
 959         break;
 960
 961       default:
 962         dict_opset_t::process_op (op, env);
 963         if (!env.argStack.is_empty ()) return;
 964         break;
 965     }
 966
 967     if (unlikely (env.in_error ())) return;
 968
 969     dictval.add_op (op, env.str_ref);
 970   }
 971 };
 972
 973 typedef dict_interpreter_t<cff1_top_dict_opset_t, cff1_top_dict_values_t, cff1_top_dict_interp_env_t> cff1_top_dict_interpreter_t;
 974 typedef dict_interpreter_t<cff1_font_dict_opset_t, cff1_font_dict_values_t> cff1_font_dict_interpreter_t;
 975
 976 typedef CFF1Index CFF1NameIndex;
 977 typedef CFF1IndexOf<TopDict> CFF1TopDictIndex;
 978
 979 } /* namespace CFF */
 980
 981 namespace OT {
 982
 983 using namespace CFF;
 984
 985 struct cff1
 986 {
 987   static constexpr hb_tag_t tableTag = HB_OT_TAG_cff1;
 988
 989   bool sanitize (hb_sanitize_context_t *c) const
 990   {
 991     TRACE_SANITIZE (this);
 992     return_trace (c->check_struct (this) &&
 993                   likely (version.major == 1));
 994   }
 995
 996   template <typename PRIVOPSET, typename PRIVDICTVAL>
 997   struct accelerator_templ_t
 998   {
 999     void init (hb_face_t *face)
1000     {
1001       topDict.init ();
1002       fontDicts.init ();
1003       privateDicts.init ();
1004
1005       this->blob = sc.reference_table<cff1> (face);
1006
1007       /* setup for run-time santization */
1008       sc.init (this->blob);
1009       sc.start_processing ();
1010
1011       const OT::cff1 *cff = this->blob->template as<OT::cff1> ();
1012
1013       if (cff == &Null(OT::cff1))
1014       { fini (); return; }
1015
1016       nameIndex = &cff->nameIndex (cff);
1017       if ((nameIndex == &Null (CFF1NameIndex)) || !nameIndex->sanitize (&sc))
1018       { fini (); return; }
1019
1020       topDictIndex = &StructAtOffset<CFF1TopDictIndex> (nameIndex, nameIndex->get_size ());
1021       if ((topDictIndex == &Null (CFF1TopDictIndex)) || !topDictIndex->sanitize (&sc) || (topDictIndex->count == 0))
1022       { fini (); return; }
1023
1024       { /* parse top dict */
1025         const byte_str_t topDictStr = (*topDictIndex)[0];
1026         if (unlikely (!topDictStr.sanitize (&sc))) { fini (); return; }
1027         cff1_top_dict_interpreter_t top_interp;
1028         top_interp.env.init (topDictStr);
1029         topDict.init ();
1030         if (unlikely (!top_interp.interpret (topDict))) { fini (); return; }
1031       }
1032
1033       if (is_predef_charset ())
1034         charset = &Null(Charset);
1035       else
1036       {
1037         charset = &StructAtOffsetOrNull<Charset> (cff, topDict.CharsetOffset);
1038         if (unlikely ((charset == &Null (Charset)) || !charset->sanitize (&sc))) { fini (); return; }
1039       }
1040
1041       fdCount = 1;
1042       if (is_CID ())
1043       {
1044         fdArray = &StructAtOffsetOrNull<CFF1FDArray> (cff, topDict.FDArrayOffset);
1045         fdSelect = &StructAtOffsetOrNull<CFF1FDSelect> (cff, topDict.FDSelectOffset);
1046         if (unlikely ((fdArray == &Null(CFF1FDArray)) || !fdArray->sanitize (&sc) ||
1047             (fdSelect == &Null(CFF1FDSelect)) || !fdSelect->sanitize (&sc, fdArray->count)))
1048         { fini (); return; }
1049
1050         fdCount = fdArray->count;
1051       }
1052       else
1053       {
1054         fdArray = &Null(CFF1FDArray);
1055         fdSelect = &Null(CFF1FDSelect);
1056       }
1057
1058       stringIndex = &StructAtOffset<CFF1StringIndex> (topDictIndex, topDictIndex->get_size ());
1059       if ((stringIndex == &Null (CFF1StringIndex)) || !stringIndex->sanitize (&sc))
1060       { fini (); return; }
1061
1062       globalSubrs = &StructAtOffset<CFF1Subrs> (stringIndex, stringIndex->get_size ());
1063       if ((globalSubrs != &Null (CFF1Subrs)) && !globalSubrs->sanitize (&sc))
1064       { fini (); return; }
1065
1066       charStrings = &StructAtOffsetOrNull<CFF1CharStrings> (cff, topDict.charStringsOffset);
1067
1068       if ((charStrings == &Null(CFF1CharStrings)) || unlikely (!charStrings->sanitize (&sc)))
1069       { fini (); return; }
1070
1071       num_glyphs = charStrings->count;
1072       if (num_glyphs != sc.get_num_glyphs ())
1073       { fini (); return; }
1074
1075       privateDicts.resize (fdCount);
1076       for (unsigned int i = 0; i < fdCount; i++)
1077         privateDicts[i].init ();
1078
1079       // parse CID font dicts and gather private dicts
1080       if (is_CID ())
1081       {
1082         for (unsigned int i = 0; i < fdCount; i++)
1083         {
1084           byte_str_t fontDictStr = (*fdArray)[i];
1085           if (unlikely (!fontDictStr.sanitize (&sc))) { fini (); return; }
1086           cff1_font_dict_values_t  *font;
1087           cff1_font_dict_interpreter_t font_interp;
1088           font_interp.env.init (fontDictStr);
1089           font = fontDicts.push ();
1090           if (unlikely (font == &Crap(cff1_font_dict_values_t))) { fini (); return; }
1091           font->init ();
1092           if (unlikely (!font_interp.interpret (*font))) { fini (); return; }
1093           PRIVDICTVAL  *priv = &privateDicts[i];
1094           const byte_str_t privDictStr (StructAtOffset<UnsizedByteStr> (cff, font->privateDictInfo.offset), font->privateDictInfo.size);
1095           if (unlikely (!privDictStr.sanitize (&sc))) { fini (); return; }
1096           dict_interpreter_t<PRIVOPSET, PRIVDICTVAL> priv_interp;
1097           priv_interp.env.init (privDictStr);
1098           priv->init ();
1099           if (unlikely (!priv_interp.interpret (*priv))) { fini (); return; }
1100
1101           priv->localSubrs = &StructAtOffsetOrNull<CFF1Subrs> (&privDictStr, priv->subrsOffset);
1102           if (priv->localSubrs != &Null(CFF1Subrs) &&
1103               unlikely (!priv->localSubrs->sanitize (&sc)))
1104           { fini (); return; }
1105         }
1106       }
1107       else  /* non-CID */
1108       {
1109         cff1_top_dict_values_t  *font = &topDict;
1110         PRIVDICTVAL  *priv = &privateDicts[0];
1111
1112         const byte_str_t privDictStr (StructAtOffset<UnsizedByteStr> (cff, font->privateDictInfo.offset), font->privateDictInfo.size);
1113         if (unlikely (!privDictStr.sanitize (&sc))) { fini (); return; }
1114         dict_interpreter_t<PRIVOPSET, PRIVDICTVAL> priv_interp;
1115         priv_interp.env.init (privDictStr);
1116         priv->init ();
1117         if (unlikely (!priv_interp.interpret (*priv))) { fini (); return; }
1118
1119         priv->localSubrs = &StructAtOffsetOrNull<CFF1Subrs> (&privDictStr, priv->subrsOffset);
1120         if (priv->localSubrs != &Null(CFF1Subrs) &&
1121             unlikely (!priv->localSubrs->sanitize (&sc)))
1122         { fini (); return; }
1123       }
1124     }
1125
1126     void fini ()
1127     {
1128       sc.end_processing ();
1129       topDict.fini ();
1130       fontDicts.fini_deep ();
1131       privateDicts.fini_deep ();
1132       hb_blob_destroy (blob);
1133       blob = nullptr;
1134     }
1135
1136     bool is_valid () const { return blob != nullptr; }
1137     bool is_CID () const { return topDict.is_CID (); }
1138
1139     bool is_predef_charset () const { return topDict.CharsetOffset <= ExpertSubsetCharset; }
1140
1141     unsigned int std_code_to_glyph (hb_codepoint_t code) const
1142     {
1143       hb_codepoint_t sid = lookup_standard_encoding_for_sid (code);
1144       if (unlikely (sid == CFF_UNDEF_SID))
1145         return 0;
1146
1147       if (charset != &Null(Charset))
1148         return charset->get_glyph (sid, num_glyphs);
1149       else if ((topDict.CharsetOffset == ISOAdobeCharset)
1150               && (code <= 228 /*zcaron*/)) return sid;
1151       return 0;
1152     }
1153
1154     protected:
1155     hb_blob_t          *blob;
1156     hb_sanitize_context_t   sc;
1157
1158     public:
1159     const Charset          *charset;
1160     const CFF1NameIndex     *nameIndex;
1161     const CFF1TopDictIndex  *topDictIndex;
1162     const CFF1StringIndex   *stringIndex;
1163     const CFF1Subrs      *globalSubrs;
1164     const CFF1CharStrings   *charStrings;
1165     const CFF1FDArray       *fdArray;
1166     const CFF1FDSelect      *fdSelect;
1167     unsigned int            fdCount;
1168
1169     cff1_top_dict_values_t       topDict;
1170     hb_vector_t<cff1_font_dict_values_t>   fontDicts;
1171     hb_vector_t<PRIVDICTVAL>      privateDicts;
1172
1173     unsigned int            num_glyphs;
1174   };
1175
1176   struct accelerator_t : accelerator_templ_t<cff1_private_dict_opset_t, cff1_private_dict_values_t>
1177   {
1178     HB_INTERNAL bool get_extents (hb_codepoint_t glyph, hb_glyph_extents_t *extents) const;
1179     HB_INTERNAL bool get_seac_components (hb_codepoint_t glyph, hb_codepoint_t *base, hb_codepoint_t *accent) const;
1180   };
1181
1182   struct accelerator_subset_t : accelerator_templ_t<cff1_private_dict_opset_subset, cff1_private_dict_values_subset_t>
1183   {
1184     void init (hb_face_t *face)
1185     {
1186       SUPER::init (face);
1187       if (blob == nullptr) return;
1188
1189       const OT::cff1 *cff = this->blob->as<OT::cff1> ();
1190       encoding = &Null(Encoding);
1191       if (is_CID ())
1192       {
1193         if (unlikely (charset == &Null(Charset))) { fini (); return; }
1194       }
1195       else
1196       {
1197         if (!is_predef_encoding ())
1198         {
1199           encoding = &StructAtOffsetOrNull<Encoding> (cff, topDict.EncodingOffset);
1200           if (unlikely ((encoding == &Null (Encoding)) || !encoding->sanitize (&sc))) { fini (); return; }
1201         }
1202       }
1203     }
1204
1205     bool is_predef_encoding () const { return topDict.EncodingOffset <= ExpertEncoding; }
1206
1207     hb_codepoint_t  glyph_to_code (hb_codepoint_t glyph) const
1208     {
1209       if (encoding != &Null(Encoding))
1210         return encoding->get_code (glyph);
1211       else
1212       {
1213         hb_codepoint_t  sid = glyph_to_sid (glyph);
1214         if (sid == 0) return 0;
1215         hb_codepoint_t  code = 0;
1216         switch (topDict.EncodingOffset)
1217         {
1218           case  StandardEncoding:
1219             code = lookup_standard_encoding_for_code (sid);
1220             break;
1221           case  ExpertEncoding:
1222             code = lookup_expert_encoding_for_code (sid);
1223             break;
1224           default:
1225             break;
1226         }
1227         return code;
1228       }
1229     }
1230
1231     hb_codepoint_t glyph_to_sid (hb_codepoint_t glyph) const
1232     {
1233       if (charset != &Null(Charset))
1234         return charset->get_sid (glyph);
1235       else
1236       {
1237         hb_codepoint_t sid = 0;
1238         switch (topDict.CharsetOffset)
1239         {
1240           case  ISOAdobeCharset:
1241             if (glyph <= 228 /*zcaron*/) sid = glyph;
1242             break;
1243           case  ExpertCharset:
1244             sid = lookup_expert_charset_for_sid (glyph);
1245             break;
1246           case  ExpertSubsetCharset:
1247               sid = lookup_expert_subset_charset_for_sid (glyph);
1248             break;
1249           default:
1250             break;
1251         }
1252         return sid;
1253       }
1254     }
1255
1256     const Encoding        *encoding;
1257
1258     private:
1259     typedef accelerator_templ_t<cff1_private_dict_opset_subset, cff1_private_dict_values_subset_t> SUPER;
1260   };
1261
1262   bool subset (hb_subset_plan_t *plan) const
1263   {
1264     hb_blob_t *cff_prime = nullptr;
1265
1266     bool success = true;
1267     if (hb_subset_cff1 (plan, &cff_prime)) {
1268       success = success && plan->add_table (HB_OT_TAG_cff1, cff_prime);
1269       hb_blob_t *head_blob = hb_sanitize_context_t().reference_table<head> (plan->source);
1270       success = success && head_blob && plan->add_table (HB_OT_TAG_head, head_blob);
1271       hb_blob_destroy (head_blob);
1272     } else {
1273       success = false;
1274     }
1275     hb_blob_destroy (cff_prime);
1276
1277     return success;
1278   }
1279
1280   protected:
1281   HB_INTERNAL static hb_codepoint_t lookup_standard_encoding_for_code (hb_codepoint_t sid);
1282   HB_INTERNAL static hb_codepoint_t lookup_expert_encoding_for_code (hb_codepoint_t sid);
1283   HB_INTERNAL static hb_codepoint_t lookup_expert_charset_for_sid (hb_codepoint_t glyph);
1284   HB_INTERNAL static hb_codepoint_t lookup_expert_subset_charset_for_sid (hb_codepoint_t glyph);
1285   HB_INTERNAL static hb_codepoint_t lookup_standard_encoding_for_sid (hb_codepoint_t code);
1286
1287   public:
1288   FixedVersion<HBUINT8> version;          /* Version of CFF table. set to 0x0100u */
1289   OffsetTo<CFF1NameIndex, HBUINT8> nameIndex; /* headerSize = Offset to Name INDEX. */
1290   HBUINT8              offSize;   /* offset size (unused?) */
1291
1292   public:
1293   DEFINE_SIZE_STATIC (4);
1294 };
1295
1296 struct cff1_accelerator_t : cff1::accelerator_t {};
1297 } /* namespace OT */
1298
1299 #endif /* HB_OT_CFF1_TABLE_HH */