src/hb-subset-cff-common.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_SUBSET_CFF_COMMON_HH
  28 #define HB_SUBSET_CFF_COMMON_HH
  29
  30 #include "hb.hh"
  31
  32 #include "hb-subset-plan.hh"
  33 #include "hb-cff-interp-cs-common.hh"
  34
  35 namespace CFF {
  36
  37 /* Used for writing a temporary charstring */
  38 struct str_encoder_t
  39 {
  40   str_encoder_t (str_buff_t &buff_)
  41     : buff (buff_), error (false) {}
  42
  43   void reset () { buff.resize (0); }
  44
  45   void encode_byte (unsigned char b)
  46   {
  47     if (unlikely (buff.push (b) == &Crap(unsigned char)))
  48       set_error ();
  49   }
  50
  51   void encode_int (int v)
  52   {
  53     if ((-1131 <= v) && (v <= 1131))
  54     {
  55       if ((-107 <= v) && (v <= 107))
  56         encode_byte (v + 139);
  57       else if (v > 0)
  58       {
  59         v -= 108;
  60         encode_byte ((v >> 8) + OpCode_TwoBytePosInt0);
  61         encode_byte (v & 0xFF);
  62       }
  63       else
  64       {
  65         v = -v - 108;
  66         encode_byte ((v >> 8) + OpCode_TwoByteNegInt0);
  67         encode_byte (v & 0xFF);
  68       }
  69     }
  70     else
  71     {
  72       if (unlikely (v < -32768))
  73         v = -32768;
  74       else if (unlikely (v > 32767))
  75         v = 32767;
  76       encode_byte (OpCode_shortint);
  77       encode_byte ((v >> 8) & 0xFF);
  78       encode_byte (v & 0xFF);
  79     }
  80   }
  81
  82   void encode_num (const number_t& n)
  83   {
  84     if (n.in_int_range ())
  85     {
  86       encode_int (n.to_int ());
  87     }
  88     else
  89     {
  90       int32_t v = n.to_fixed ();
  91       encode_byte (OpCode_fixedcs);
  92       encode_byte ((v >> 24) & 0xFF);
  93       encode_byte ((v >> 16) & 0xFF);
  94       encode_byte ((v >> 8) & 0xFF);
  95       encode_byte (v & 0xFF);
  96     }
  97   }
  98
  99   void encode_op (op_code_t op)
 100   {
 101     if (Is_OpCode_ESC (op))
 102     {
 103       encode_byte (OpCode_escape);
 104       encode_byte (Unmake_OpCode_ESC (op));
 105     }
 106     else
 107       encode_byte (op);
 108   }
 109
 110   void copy_str (const byte_str_t &str)
 111   {
 112     unsigned int  offset = buff.length;
 113     buff.resize (offset + str.length);
 114     if (unlikely (buff.length < offset + str.length))
 115     {
 116       set_error ();
 117       return;
 118     }
 119     memcpy (&buff[offset], &str[0], str.length);
 120   }
 121
 122   bool is_error () const { return error; }
 123
 124   protected:
 125   void set_error () { error = true; }
 126
 127   str_buff_t &buff;
 128   bool    error;
 129 };
 130
 131 struct cff_sub_table_offsets_t {
 132   cff_sub_table_offsets_t () : privateDictsOffset (0)
 133   {
 134     topDictInfo.init ();
 135     FDSelectInfo.init ();
 136     FDArrayInfo.init ();
 137     charStringsInfo.init ();
 138     globalSubrsInfo.init ();
 139     localSubrsInfos.init ();
 140   }
 141
 142   ~cff_sub_table_offsets_t () { localSubrsInfos.fini (); }
 143
 144   table_info_t     topDictInfo;
 145   table_info_t     FDSelectInfo;
 146   table_info_t     FDArrayInfo;
 147   table_info_t     charStringsInfo;
 148   unsigned int  privateDictsOffset;
 149   table_info_t     globalSubrsInfo;
 150   hb_vector_t<table_info_t>  localSubrsInfos;
 151 };
 152
 153 template <typename OPSTR=op_str_t>
 154 struct cff_top_dict_op_serializer_t : op_serializer_t
 155 {
 156   bool serialize (hb_serialize_context_t *c,
 157                   const OPSTR &opstr,
 158                   const cff_sub_table_offsets_t &offsets) const
 159   {
 160     TRACE_SERIALIZE (this);
 161
 162     switch (opstr.op)
 163     {
 164       case OpCode_CharStrings:
 165         return_trace (FontDict::serialize_offset4_op(c, opstr.op, offsets.charStringsInfo.offset));
 166
 167       case OpCode_FDArray:
 168         return_trace (FontDict::serialize_offset4_op(c, opstr.op, offsets.FDArrayInfo.offset));
 169
 170       case OpCode_FDSelect:
 171         return_trace (FontDict::serialize_offset4_op(c, opstr.op, offsets.FDSelectInfo.offset));
 172
 173       default:
 174         return_trace (copy_opstr (c, opstr));
 175     }
 176     return_trace (true);
 177   }
 178
 179   unsigned int calculate_serialized_size (const OPSTR &opstr) const
 180   {
 181     switch (opstr.op)
 182     {
 183       case OpCode_CharStrings:
 184       case OpCode_FDArray:
 185       case OpCode_FDSelect:
 186         return OpCode_Size (OpCode_longintdict) + 4 + OpCode_Size (opstr.op);
 187
 188       default:
 189         return opstr.str.length;
 190     }
 191   }
 192 };
 193
 194 struct cff_font_dict_op_serializer_t : op_serializer_t
 195 {
 196   bool serialize (hb_serialize_context_t *c,
 197                   const op_str_t &opstr,
 198                   const table_info_t &privateDictInfo) const
 199   {
 200     TRACE_SERIALIZE (this);
 201
 202     if (opstr.op == OpCode_Private)
 203     {
 204       /* serialize the private dict size & offset as 2-byte & 4-byte integers */
 205       if (unlikely (!UnsizedByteStr::serialize_int2 (c, privateDictInfo.size) ||
 206                     !UnsizedByteStr::serialize_int4 (c, privateDictInfo.offset)))
 207         return_trace (false);
 208
 209       /* serialize the opcode */
 210       HBUINT8 *p = c->allocate_size<HBUINT8> (1);
 211       if (unlikely (p == nullptr)) return_trace (false);
 212       *p = OpCode_Private;
 213
 214       return_trace (true);
 215     }
 216     else
 217     {
 218       HBUINT8 *d = c->allocate_size<HBUINT8> (opstr.str.length);
 219       if (unlikely (d == nullptr)) return_trace (false);
 220       memcpy (d, &opstr.str[0], opstr.str.length);
 221     }
 222     return_trace (true);
 223   }
 224
 225   unsigned int calculate_serialized_size (const op_str_t &opstr) const
 226   {
 227     if (opstr.op == OpCode_Private)
 228       return OpCode_Size (OpCode_longintdict) + 4 + OpCode_Size (OpCode_shortint) + 2 + OpCode_Size (OpCode_Private);
 229     else
 230       return opstr.str.length;
 231   }
 232 };
 233
 234 struct cff_private_dict_op_serializer_t : op_serializer_t
 235 {
 236   cff_private_dict_op_serializer_t (bool desubroutinize_, bool drop_hints_)
 237     : desubroutinize (desubroutinize_), drop_hints (drop_hints_) {}
 238
 239   bool serialize (hb_serialize_context_t *c,
 240                   const op_str_t &opstr,
 241                   const unsigned int subrsOffset) const
 242   {
 243     TRACE_SERIALIZE (this);
 244
 245     if (drop_hints && dict_opset_t::is_hint_op (opstr.op))
 246       return true;
 247     if (opstr.op == OpCode_Subrs)
 248     {
 249       if (desubroutinize || (subrsOffset == 0))
 250         return_trace (true);
 251       else
 252         return_trace (FontDict::serialize_offset2_op (c, opstr.op, subrsOffset));
 253     }
 254     else
 255       return_trace (copy_opstr (c, opstr));
 256   }
 257
 258   unsigned int calculate_serialized_size (const op_str_t &opstr,
 259                                           bool has_localsubr=true) const
 260   {
 261     if (drop_hints && dict_opset_t::is_hint_op (opstr.op))
 262       return 0;
 263     if (opstr.op == OpCode_Subrs)
 264     {
 265       if (desubroutinize || !has_localsubr)
 266         return 0;
 267       else
 268         return OpCode_Size (OpCode_shortint) + 2 + OpCode_Size (opstr.op);
 269     }
 270     else
 271       return opstr.str.length;
 272   }
 273
 274   protected:
 275   const bool  desubroutinize;
 276   const bool  drop_hints;
 277 };
 278
 279 struct flatten_param_t
 280 {
 281   str_buff_t     &flatStr;
 282   bool  drop_hints;
 283 };
 284
 285 template <typename ACC, typename ENV, typename OPSET, op_code_t endchar_op=OpCode_Invalid>
 286 struct subr_flattener_t
 287 {
 288   subr_flattener_t (const ACC &acc_,
 289                     const hb_subset_plan_t *plan_)
 290                    : acc (acc_), plan (plan_) {}
 291
 292   bool flatten (str_buff_vec_t &flat_charstrings)
 293   {
 294     if (!flat_charstrings.resize (plan->num_output_glyphs ()))
 295       return false;
 296     for (unsigned int i = 0; i < plan->num_output_glyphs (); i++)
 297       flat_charstrings[i].init ();
 298     for (unsigned int i = 0; i < plan->num_output_glyphs (); i++)
 299     {
 300       hb_codepoint_t  glyph;
 301       if (!plan->old_gid_for_new_gid (i, &glyph))
 302       {
 303         /* add an endchar only charstring for a missing glyph if CFF1 */
 304         if (endchar_op != OpCode_Invalid) flat_charstrings[i].push (endchar_op);
 305         continue;
 306       }
 307       const byte_str_t str = (*acc.charStrings)[glyph];
 308       unsigned int fd = acc.fdSelect->get_fd (glyph);
 309       if (unlikely (fd >= acc.fdCount))
 310         return false;
 311       cs_interpreter_t<ENV, OPSET, flatten_param_t> interp;
 312       interp.env.init (str, acc, fd);
 313       flatten_param_t  param = { flat_charstrings[i], plan->drop_hints };
 314       if (unlikely (!interp.interpret (param)))
 315         return false;
 316     }
 317     return true;
 318   }
 319
 320   const ACC &acc;
 321   const hb_subset_plan_t *plan;
 322 };
 323
 324 struct subr_closures_t
 325 {
 326   subr_closures_t () : valid (false), global_closure (nullptr)
 327   { local_closures.init (); }
 328
 329   void init (unsigned int fd_count)
 330   {
 331     valid = true;
 332     global_closure = hb_set_create ();
 333     if (global_closure == hb_set_get_empty ())
 334       valid = false;
 335     if (!local_closures.resize (fd_count))
 336       valid = false;
 337
 338     for (unsigned int i = 0; i < local_closures.length; i++)
 339     {
 340       local_closures[i] = hb_set_create ();
 341       if (local_closures[i] == hb_set_get_empty ())
 342         valid = false;
 343     }
 344   }
 345
 346   void fini ()
 347   {
 348     hb_set_destroy (global_closure);
 349     for (unsigned int i = 0; i < local_closures.length; i++)
 350       hb_set_destroy (local_closures[i]);
 351     local_closures.fini ();
 352   }
 353
 354   void reset ()
 355   {
 356     hb_set_clear (global_closure);
 357     for (unsigned int i = 0; i < local_closures.length; i++)
 358       hb_set_clear (local_closures[i]);
 359   }
 360
 361   bool is_valid () const { return valid; }
 362   bool  valid;
 363   hb_set_t  *global_closure;
 364   hb_vector_t<hb_set_t *> local_closures;
 365 };
 366
 367 struct parsed_cs_op_t : op_str_t
 368 {
 369   void init (unsigned int subr_num_ = 0)
 370   {
 371     op_str_t::init ();
 372     subr_num = subr_num_;
 373     drop_flag = false;
 374     keep_flag = false;
 375     skip_flag = false;
 376   }
 377
 378   void fini () { op_str_t::fini (); }
 379
 380   bool for_drop () const { return drop_flag; }
 381   void set_drop ()       { if (!for_keep ()) drop_flag = true; }
 382
 383   bool for_keep () const { return keep_flag; }
 384   void set_keep ()       { keep_flag = true; }
 385
 386   bool for_skip () const { return skip_flag; }
 387   void set_skip ()       { skip_flag = true; }
 388
 389   unsigned int  subr_num;
 390
 391   protected:
 392   bool    drop_flag : 1;
 393   bool    keep_flag : 1;
 394   bool    skip_flag : 1;
 395 };
 396
 397 struct parsed_cs_str_t : parsed_values_t<parsed_cs_op_t>
 398 {
 399   void init ()
 400   {
 401     SUPER::init ();
 402     parsed = false;
 403     hint_dropped = false;
 404     has_prefix_ = false;
 405   }
 406
 407   void add_op (op_code_t op, const byte_str_ref_t& str_ref)
 408   {
 409     if (!is_parsed ())
 410       SUPER::add_op (op, str_ref);
 411   }
 412
 413   void add_call_op (op_code_t op, const byte_str_ref_t& str_ref, unsigned int subr_num)
 414   {
 415     if (!is_parsed ())
 416     {
 417       unsigned int parsed_len = get_count ();
 418       if (likely (parsed_len > 0))
 419         values[parsed_len-1].set_skip ();
 420
 421       parsed_cs_op_t val;
 422       val.init (subr_num);
 423       SUPER::add_op (op, str_ref, val);
 424     }
 425   }
 426
 427   void set_prefix (const number_t &num, op_code_t op = OpCode_Invalid)
 428   {
 429     has_prefix_ = true;
 430     prefix_op_ = op;
 431     prefix_num_ = num;
 432   }
 433
 434   bool at_end (unsigned int pos) const
 435   {
 436     return ((pos + 1 >= values.length) /* CFF2 */
 437         || (values[pos + 1].op == OpCode_return));
 438   }
 439
 440   bool is_parsed () const { return parsed; }
 441   void set_parsed ()      { parsed = true; }
 442
 443   bool is_hint_dropped () const { return hint_dropped; }
 444   void set_hint_dropped ()      { hint_dropped = true; }
 445
 446   bool is_vsindex_dropped () const { return vsindex_dropped; }
 447   void set_vsindex_dropped ()      { vsindex_dropped = true; }
 448
 449   bool has_prefix () const          { return has_prefix_; }
 450   op_code_t prefix_op () const         { return prefix_op_; }
 451   const number_t &prefix_num () const { return prefix_num_; }
 452
 453   protected:
 454   bool    parsed;
 455   bool    hint_dropped;
 456   bool    vsindex_dropped;
 457   bool    has_prefix_;
 458   op_code_t     prefix_op_;
 459   number_t      prefix_num_;
 460
 461   private:
 462   typedef parsed_values_t<parsed_cs_op_t> SUPER;
 463 };
 464
 465 struct parsed_cs_str_vec_t : hb_vector_t<parsed_cs_str_t>
 466 {
 467   void init (unsigned int len_ = 0)
 468   {
 469     SUPER::init ();
 470     resize (len_);
 471     for (unsigned int i = 0; i < length; i++)
 472       (*this)[i].init ();
 473   }
 474   void fini () { SUPER::fini_deep (); }
 475
 476   private:
 477   typedef hb_vector_t<parsed_cs_str_t> SUPER;
 478 };
 479
 480 struct subr_subset_param_t
 481 {
 482   void init (parsed_cs_str_t *parsed_charstring_,
 483              parsed_cs_str_vec_t *parsed_global_subrs_, parsed_cs_str_vec_t *parsed_local_subrs_,
 484              hb_set_t *global_closure_, hb_set_t *local_closure_,
 485              bool drop_hints_)
 486   {
 487     parsed_charstring = parsed_charstring_;
 488     current_parsed_str = parsed_charstring;
 489     parsed_global_subrs = parsed_global_subrs_;
 490     parsed_local_subrs = parsed_local_subrs_;
 491     global_closure = global_closure_;
 492     local_closure = local_closure_;
 493     drop_hints = drop_hints_;
 494   }
 495
 496   parsed_cs_str_t *get_parsed_str_for_context (call_context_t &context)
 497   {
 498     switch (context.type)
 499     {
 500       case CSType_CharString:
 501         return parsed_charstring;
 502
 503       case CSType_LocalSubr:
 504         if (likely (context.subr_num < parsed_local_subrs->length))
 505           return &(*parsed_local_subrs)[context.subr_num];
 506         break;
 507
 508       case CSType_GlobalSubr:
 509         if (likely (context.subr_num < parsed_global_subrs->length))
 510           return &(*parsed_global_subrs)[context.subr_num];
 511         break;
 512     }
 513     return nullptr;
 514   }
 515
 516   template <typename ENV>
 517   void set_current_str (ENV &env, bool calling)
 518   {
 519     parsed_cs_str_t  *parsed_str = get_parsed_str_for_context (env.context);
 520     if (likely (parsed_str != nullptr))
 521     {
 522       /* If the called subroutine is parsed partially but not completely yet,
 523        * it must be because we are calling it recursively.
 524        * Handle it as an error. */
 525       if (unlikely (calling && !parsed_str->is_parsed () && (parsed_str->values.length > 0)))
 526         env.set_error ();
 527       else
 528         current_parsed_str = parsed_str;
 529     }
 530     else
 531       env.set_error ();
 532   }
 533
 534   parsed_cs_str_t       *current_parsed_str;
 535
 536   parsed_cs_str_t       *parsed_charstring;
 537   parsed_cs_str_vec_t   *parsed_global_subrs;
 538   parsed_cs_str_vec_t   *parsed_local_subrs;
 539   hb_set_t      *global_closure;
 540   hb_set_t      *local_closure;
 541   bool    drop_hints;
 542 };
 543
 544 struct subr_remap_t : hb_inc_bimap_t
 545 {
 546   void create (hb_set_t *closure)
 547   {
 548     /* create a remapping of subroutine numbers from old to new.
 549      * no optimization based on usage counts. fonttools doesn't appear doing that either.
 550      */
 551
 552     hb_codepoint_t old_num = HB_SET_VALUE_INVALID;
 553     while (hb_set_next (closure, &old_num))
 554       add (old_num);
 555
 556     if (get_population () < 1240)
 557       bias = 107;
 558     else if (get_population () < 33900)
 559       bias = 1131;
 560     else
 561       bias = 32768;
 562   }
 563
 564   int biased_num (unsigned int old_num) const
 565   {
 566     hb_codepoint_t new_num = get (old_num);
 567     return (int)new_num - bias;
 568   }
 569
 570   protected:
 571   int bias;
 572 };
 573
 574 struct subr_remaps_t
 575 {
 576   subr_remaps_t ()
 577   {
 578     global_remap.init ();
 579     local_remaps.init ();
 580   }
 581
 582   ~subr_remaps_t () { fini (); }
 583
 584   void init (unsigned int fdCount)
 585   {
 586     local_remaps.resize (fdCount);
 587     for (unsigned int i = 0; i < fdCount; i++)
 588       local_remaps[i].init ();
 589   }
 590
 591   void create (subr_closures_t& closures)
 592   {
 593     global_remap.create (closures.global_closure);
 594     for (unsigned int i = 0; i < local_remaps.length; i++)
 595       local_remaps[i].create (closures.local_closures[i]);
 596   }
 597
 598   void fini ()
 599   {
 600     global_remap.fini ();
 601     local_remaps.fini_deep ();
 602   }
 603
 604   subr_remap_t         global_remap;
 605   hb_vector_t<subr_remap_t>  local_remaps;
 606 };
 607
 608 template <typename SUBSETTER, typename SUBRS, typename ACC, typename ENV, typename OPSET, op_code_t endchar_op=OpCode_Invalid>
 609 struct subr_subsetter_t
 610 {
 611   subr_subsetter_t (ACC &acc_, const hb_subset_plan_t *plan_)
 612     : acc (acc_), plan (plan_)
 613   {
 614     parsed_charstrings.init ();
 615     parsed_global_subrs.init ();
 616     parsed_local_subrs.init ();
 617   }
 618
 619   ~subr_subsetter_t ()
 620   {
 621     closures.fini ();
 622     remaps.fini ();
 623     parsed_charstrings.fini_deep ();
 624     parsed_global_subrs.fini_deep ();
 625     parsed_local_subrs.fini_deep ();
 626   }
 627
 628   /* Subroutine subsetting with --no-desubroutinize runs in phases:
 629    *
 630    * 1. execute charstrings/subroutines to determine subroutine closures
 631    * 2. parse out all operators and numbers
 632    * 3. mark hint operators and operands for removal if --no-hinting
 633    * 4. re-encode all charstrings and subroutines with new subroutine numbers
 634    *
 635    * Phases #1 and #2 are done at the same time in collect_subrs ().
 636    * Phase #3 walks charstrings/subroutines forward then backward (hence parsing required),
 637    * because we can't tell if a number belongs to a hint op until we see the first moveto.
 638    *
 639    * Assumption: a callsubr/callgsubr operator must immediately follow a (biased) subroutine number
 640    * within the same charstring/subroutine, e.g., not split across a charstring and a subroutine.
 641    */
 642   bool subset (void)
 643   {
 644     closures.init (acc.fdCount);
 645     remaps.init (acc.fdCount);
 646
 647     parsed_charstrings.init (plan->num_output_glyphs ());
 648     parsed_global_subrs.init (acc.globalSubrs->count);
 649     parsed_local_subrs.resize (acc.fdCount);
 650     for (unsigned int i = 0; i < acc.fdCount; i++)
 651     {
 652       parsed_local_subrs[i].init (acc.privateDicts[i].localSubrs->count);
 653     }
 654     if (unlikely (!closures.valid))
 655       return false;
 656
 657     /* phase 1 & 2 */
 658     for (unsigned int i = 0; i < plan->num_output_glyphs (); i++)
 659     {
 660       hb_codepoint_t  glyph;
 661       if (!plan->old_gid_for_new_gid (i, &glyph))
 662         continue;
 663       const byte_str_t str = (*acc.charStrings)[glyph];
 664       unsigned int fd = acc.fdSelect->get_fd (glyph);
 665       if (unlikely (fd >= acc.fdCount))
 666         return false;
 667
 668       cs_interpreter_t<ENV, OPSET, subr_subset_param_t> interp;
 669       interp.env.init (str, acc, fd);
 670
 671       subr_subset_param_t  param;
 672       param.init (&parsed_charstrings[i],
 673                   &parsed_global_subrs,  &parsed_local_subrs[fd],
 674                   closures.global_closure, closures.local_closures[fd],
 675                   plan->drop_hints);
 676
 677       if (unlikely (!interp.interpret (param)))
 678         return false;
 679
 680       /* finalize parsed string esp. copy CFF1 width or CFF2 vsindex to the parsed charstring for encoding */
 681       SUBSETTER::finalize_parsed_str (interp.env, param, parsed_charstrings[i]);
 682     }
 683
 684     if (plan->drop_hints)
 685     {
 686       /* mark hint ops and arguments for drop */
 687       for (unsigned int i = 0; i < plan->num_output_glyphs (); i++)
 688       {
 689         hb_codepoint_t  glyph;
 690         if (!plan->old_gid_for_new_gid (i, &glyph))
 691           continue;
 692         unsigned int fd = acc.fdSelect->get_fd (glyph);
 693         if (unlikely (fd >= acc.fdCount))
 694           return false;
 695         subr_subset_param_t  param;
 696         param.init (&parsed_charstrings[i],
 697                     &parsed_global_subrs,  &parsed_local_subrs[fd],
 698                     closures.global_closure, closures.local_closures[fd],
 699                     plan->drop_hints);
 700
 701         drop_hints_param_t  drop;
 702         if (drop_hints_in_str (parsed_charstrings[i], param, drop))
 703         {
 704           parsed_charstrings[i].set_hint_dropped ();
 705           if (drop.vsindex_dropped)
 706             parsed_charstrings[i].set_vsindex_dropped ();
 707         }
 708       }
 709
 710       /* after dropping hints recreate closures of actually used subrs */
 711       closures.reset ();
 712       for (unsigned int i = 0; i < plan->num_output_glyphs (); i++)
 713       {
 714         hb_codepoint_t  glyph;
 715         if (!plan->old_gid_for_new_gid (i, &glyph))
 716           continue;
 717         unsigned int fd = acc.fdSelect->get_fd (glyph);
 718         if (unlikely (fd >= acc.fdCount))
 719           return false;
 720         subr_subset_param_t  param;
 721         param.init (&parsed_charstrings[i],
 722                     &parsed_global_subrs,  &parsed_local_subrs[fd],
 723                     closures.global_closure, closures.local_closures[fd],
 724                     plan->drop_hints);
 725         collect_subr_refs_in_str (parsed_charstrings[i], param);
 726       }
 727     }
 728
 729     remaps.create (closures);
 730
 731     return true;
 732   }
 733
 734   bool encode_charstrings (str_buff_vec_t &buffArray) const
 735   {
 736     if (unlikely (!buffArray.resize (plan->num_output_glyphs ())))
 737       return false;
 738     for (unsigned int i = 0; i < plan->num_output_glyphs (); i++)
 739     {
 740       hb_codepoint_t  glyph;
 741       if (!plan->old_gid_for_new_gid (i, &glyph))
 742       {
 743         /* add an endchar only charstring for a missing glyph if CFF1 */
 744         if (endchar_op != OpCode_Invalid) buffArray[i].push (endchar_op);
 745         continue;
 746       }
 747       unsigned int  fd = acc.fdSelect->get_fd (glyph);
 748       if (unlikely (fd >= acc.fdCount))
 749         return false;
 750       if (unlikely (!encode_str (parsed_charstrings[i], fd, buffArray[i])))
 751         return false;
 752     }
 753     return true;
 754   }
 755
 756   bool encode_subrs (const parsed_cs_str_vec_t &subrs, const subr_remap_t& remap, unsigned int fd, str_buff_vec_t &buffArray) const
 757   {
 758     unsigned int  count = remap.get_population ();
 759
 760     if (unlikely (!buffArray.resize (count)))
 761       return false;
 762     for (unsigned int old_num = 0; old_num < subrs.length; old_num++)
 763     {
 764       hb_codepoint_t new_num = remap[old_num];
 765       if (new_num != CFF_UNDEF_CODE)
 766       {
 767         if (unlikely (!encode_str (subrs[old_num], fd, buffArray[new_num])))
 768           return false;
 769       }
 770     }
 771     return true;
 772   }
 773
 774   bool encode_globalsubrs (str_buff_vec_t &buffArray)
 775   {
 776     return encode_subrs (parsed_global_subrs, remaps.global_remap, 0, buffArray);
 777   }
 778
 779   bool encode_localsubrs (unsigned int fd, str_buff_vec_t &buffArray) const
 780   {
 781     return encode_subrs (parsed_local_subrs[fd], remaps.local_remaps[fd], fd, buffArray);
 782   }
 783
 784   protected:
 785   struct drop_hints_param_t
 786   {
 787     drop_hints_param_t ()
 788       : seen_moveto (false),
 789         ends_in_hint (false),
 790         all_dropped (false),
 791         vsindex_dropped (false) {}
 792
 793     bool  seen_moveto;
 794     bool  ends_in_hint;
 795     bool  all_dropped;
 796     bool  vsindex_dropped;
 797   };
 798
 799   bool drop_hints_in_subr (parsed_cs_str_t &str, unsigned int pos,
 800                            parsed_cs_str_vec_t &subrs, unsigned int subr_num,
 801                            const subr_subset_param_t &param, drop_hints_param_t &drop)
 802   {
 803     drop.ends_in_hint = false;
 804     bool has_hint = drop_hints_in_str (subrs[subr_num], param, drop);
 805
 806     /* if this subr ends with a stem hint (i.e., not a number; potential argument for moveto),
 807      * then this entire subroutine must be a hint. drop its call. */
 808     if (drop.ends_in_hint)
 809     {
 810       str.values[pos].set_drop ();
 811       /* if this subr call is at the end of the parent subr, propagate the flag
 812        * otherwise reset the flag */
 813       if (!str.at_end (pos))
 814         drop.ends_in_hint = false;
 815     }
 816     else if (drop.all_dropped)
 817     {
 818       str.values[pos].set_drop ();
 819     }
 820
 821     return has_hint;
 822   }
 823
 824   /* returns true if it sees a hint op before the first moveto */
 825   bool drop_hints_in_str (parsed_cs_str_t &str, const subr_subset_param_t &param, drop_hints_param_t &drop)
 826   {
 827     bool  seen_hint = false;
 828
 829     for (unsigned int pos = 0; pos < str.values.length; pos++)
 830     {
 831       bool  has_hint = false;
 832       switch (str.values[pos].op)
 833       {
 834         case OpCode_callsubr:
 835           has_hint = drop_hints_in_subr (str, pos,
 836                                         *param.parsed_local_subrs, str.values[pos].subr_num,
 837                                         param, drop);
 838           break;
 839
 840         case OpCode_callgsubr:
 841           has_hint = drop_hints_in_subr (str, pos,
 842                                         *param.parsed_global_subrs, str.values[pos].subr_num,
 843                                         param, drop);
 844           break;
 845
 846         case OpCode_rmoveto:
 847         case OpCode_hmoveto:
 848         case OpCode_vmoveto:
 849           drop.seen_moveto = true;
 850           break;
 851
 852         case OpCode_hintmask:
 853         case OpCode_cntrmask:
 854           if (drop.seen_moveto)
 855           {
 856             str.values[pos].set_drop ();
 857             break;
 858           }
 859           HB_FALLTHROUGH;
 860
 861         case OpCode_hstemhm:
 862         case OpCode_vstemhm:
 863         case OpCode_hstem:
 864         case OpCode_vstem:
 865           has_hint = true;
 866           str.values[pos].set_drop ();
 867           if (str.at_end (pos))
 868             drop.ends_in_hint = true;
 869           break;
 870
 871         case OpCode_dotsection:
 872           str.values[pos].set_drop ();
 873           break;
 874
 875         default:
 876           /* NONE */
 877           break;
 878       }
 879       if (has_hint)
 880       {
 881         for (int i = pos - 1; i >= 0; i--)
 882         {
 883           parsed_cs_op_t  &csop = str.values[(unsigned)i];
 884           if (csop.for_drop ())
 885             break;
 886           csop.set_drop ();
 887           if (csop.op == OpCode_vsindexcs)
 888             drop.vsindex_dropped = true;
 889         }
 890         seen_hint |= has_hint;
 891       }
 892     }
 893
 894     /* Raise all_dropped flag if all operators except return are dropped from a subr.
 895      * It may happen even after seeing the first moveto if a subr contains
 896      * only (usually one) hintmask operator, then calls to this subr can be dropped.
 897      */
 898     drop.all_dropped = true;
 899     for (unsigned int pos = 0; pos < str.values.length; pos++)
 900     {
 901       parsed_cs_op_t  &csop = str.values[pos];
 902       if (csop.op == OpCode_return)
 903         break;
 904       if (!csop.for_drop ())
 905       {
 906         drop.all_dropped = false;
 907         break;
 908       }
 909     }
 910
 911     return seen_hint;
 912   }
 913
 914   void collect_subr_refs_in_subr (parsed_cs_str_t &str, unsigned int pos,
 915                                   unsigned int subr_num, parsed_cs_str_vec_t &subrs,
 916                                   hb_set_t *closure,
 917                                   const subr_subset_param_t &param)
 918   {
 919     closure->add (subr_num);
 920     collect_subr_refs_in_str (subrs[subr_num], param);
 921   }
 922
 923   void collect_subr_refs_in_str (parsed_cs_str_t &str, const subr_subset_param_t &param)
 924   {
 925     for (unsigned int pos = 0; pos < str.values.length; pos++)
 926     {
 927       if (!str.values[pos].for_drop ())
 928       {
 929         switch (str.values[pos].op)
 930         {
 931           case OpCode_callsubr:
 932             collect_subr_refs_in_subr (str, pos,
 933                                        str.values[pos].subr_num, *param.parsed_local_subrs,
 934                                        param.local_closure, param);
 935             break;
 936
 937           case OpCode_callgsubr:
 938             collect_subr_refs_in_subr (str, pos,
 939                                        str.values[pos].subr_num, *param.parsed_global_subrs,
 940                                        param.global_closure, param);
 941             break;
 942
 943           default: break;
 944         }
 945       }
 946     }
 947   }
 948
 949   bool encode_str (const parsed_cs_str_t &str, const unsigned int fd, str_buff_t &buff) const
 950   {
 951     buff.init ();
 952     str_encoder_t  encoder (buff);
 953     encoder.reset ();
 954     /* if a prefix (CFF1 width or CFF2 vsindex) has been removed along with hints,
 955      * re-insert it at the beginning of charstreing */
 956     if (str.has_prefix () && str.is_hint_dropped ())
 957     {
 958       encoder.encode_num (str.prefix_num ());
 959       if (str.prefix_op () != OpCode_Invalid)
 960         encoder.encode_op (str.prefix_op ());
 961     }
 962     for (unsigned int i = 0; i < str.get_count(); i++)
 963     {
 964       const parsed_cs_op_t  &opstr = str.values[i];
 965       if (!opstr.for_drop () && !opstr.for_skip ())
 966       {
 967         switch (opstr.op)
 968         {
 969           case OpCode_callsubr:
 970             encoder.encode_int (remaps.local_remaps[fd].biased_num (opstr.subr_num));
 971             encoder.encode_op (OpCode_callsubr);
 972             break;
 973
 974           case OpCode_callgsubr:
 975             encoder.encode_int (remaps.global_remap.biased_num (opstr.subr_num));
 976             encoder.encode_op (OpCode_callgsubr);
 977             break;
 978
 979           default:
 980             encoder.copy_str (opstr.str);
 981             break;
 982         }
 983       }
 984     }
 985     return !encoder.is_error ();
 986   }
 987
 988   protected:
 989   const ACC                     &acc;
 990   const hb_subset_plan_t        *plan;
 991
 992   subr_closures_t               closures;
 993
 994   parsed_cs_str_vec_t           parsed_charstrings;
 995   parsed_cs_str_vec_t           parsed_global_subrs;
 996   hb_vector_t<parsed_cs_str_vec_t>  parsed_local_subrs;
 997
 998   subr_remaps_t                 remaps;
 999
1000   private:
1001   typedef typename SUBRS::count_type subr_count_type;
1002 };
1003
1004 } /* namespace CFF */
1005
1006 HB_INTERNAL bool
1007 hb_plan_subset_cff_fdselect (const hb_subset_plan_t *plan,
1008                             unsigned int fdCount,
1009                             const CFF::FDSelect &src, /* IN */
1010                             unsigned int &subset_fd_count /* OUT */,
1011                             unsigned int &subset_fdselect_size /* OUT */,
1012                             unsigned int &subset_fdselect_format /* OUT */,
1013                             hb_vector_t<CFF::code_pair_t> &fdselect_ranges /* OUT */,
1014                             hb_inc_bimap_t &fdmap /* OUT */);
1015
1016 HB_INTERNAL bool
1017 hb_serialize_cff_fdselect (hb_serialize_context_t *c,
1018                           unsigned int num_glyphs,
1019                           const CFF::FDSelect &src,
1020                           unsigned int fd_count,
1021                           unsigned int fdselect_format,
1022                           unsigned int size,
1023                           const hb_vector_t<CFF::code_pair_t> &fdselect_ranges);
1024
1025 #endif /* HB_SUBSET_CFF_COMMON_HH */