• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 {
str_encoder_tCFF::str_encoder_t40   str_encoder_t (str_buff_t &buff_)
41     : buff (buff_), error (false) {}
42 
resetCFF::str_encoder_t43   void reset () { buff.resize (0); }
44 
encode_byteCFF::str_encoder_t45   void encode_byte (unsigned char b)
46   {
47     if (unlikely (buff.push (b) == &Crap(unsigned char)))
48       set_error ();
49   }
50 
encode_intCFF::str_encoder_t51   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 
encode_numCFF::str_encoder_t82   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 
encode_opCFF::str_encoder_t99   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 
copy_strCFF::str_encoder_t110   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 
is_errorCFF::str_encoder_t122   bool is_error () const { return error; }
123 
124   protected:
set_errorCFF::str_encoder_t125   void set_error () { error = true; }
126 
127   str_buff_t &buff;
128   bool    error;
129 };
130 
131 struct cff_sub_table_offsets_t {
cff_sub_table_offsets_tCFF::cff_sub_table_offsets_t132   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 
~cff_sub_table_offsets_tCFF::cff_sub_table_offsets_t142   ~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 {
serializeCFF::cff_top_dict_op_serializer_t156   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 
calculate_serialized_sizeCFF::cff_top_dict_op_serializer_t179   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 {
serializeCFF::cff_font_dict_op_serializer_t196   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 
calculate_serialized_sizeCFF::cff_font_dict_op_serializer_t225   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 {
cff_private_dict_op_serializer_tCFF::cff_private_dict_op_serializer_t236   cff_private_dict_op_serializer_t (bool desubroutinize_, bool drop_hints_)
237     : desubroutinize (desubroutinize_), drop_hints (drop_hints_) {}
238 
serializeCFF::cff_private_dict_op_serializer_t239   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 
calculate_serialized_sizeCFF::cff_private_dict_op_serializer_t258   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 {
subr_flattener_tCFF::subr_flattener_t288   subr_flattener_t (const ACC &acc_,
289 		    const hb_subset_plan_t *plan_)
290 		   : acc (acc_), plan (plan_) {}
291 
flattenCFF::subr_flattener_t292   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 {
subr_closures_tCFF::subr_closures_t326   subr_closures_t () : valid (false), global_closure (nullptr)
327   { local_closures.init (); }
328 
initCFF::subr_closures_t329   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 
finiCFF::subr_closures_t346   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 
resetCFF::subr_closures_t354   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 
is_validCFF::subr_closures_t361   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 {
initCFF::parsed_cs_op_t369   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 
finiCFF::parsed_cs_op_t378   void fini () { op_str_t::fini (); }
379 
for_dropCFF::parsed_cs_op_t380   bool for_drop () const { return drop_flag; }
set_dropCFF::parsed_cs_op_t381   void set_drop ()       { if (!for_keep ()) drop_flag = true; }
382 
for_keepCFF::parsed_cs_op_t383   bool for_keep () const { return keep_flag; }
set_keepCFF::parsed_cs_op_t384   void set_keep ()       { keep_flag = true; }
385 
for_skipCFF::parsed_cs_op_t386   bool for_skip () const { return skip_flag; }
set_skipCFF::parsed_cs_op_t387   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 {
initCFF::parsed_cs_str_t399   void init ()
400   {
401     SUPER::init ();
402     parsed = false;
403     hint_dropped = false;
404     has_prefix_ = false;
405   }
406 
add_opCFF::parsed_cs_str_t407   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 
add_call_opCFF::parsed_cs_str_t413   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 
set_prefixCFF::parsed_cs_str_t427   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 
at_endCFF::parsed_cs_str_t434   bool at_end (unsigned int pos) const
435   {
436     return ((pos + 1 >= values.length) /* CFF2 */
437 	|| (values[pos + 1].op == OpCode_return));
438   }
439 
is_parsedCFF::parsed_cs_str_t440   bool is_parsed () const { return parsed; }
set_parsedCFF::parsed_cs_str_t441   void set_parsed ()      { parsed = true; }
442 
is_hint_droppedCFF::parsed_cs_str_t443   bool is_hint_dropped () const { return hint_dropped; }
set_hint_droppedCFF::parsed_cs_str_t444   void set_hint_dropped ()      { hint_dropped = true; }
445 
is_vsindex_droppedCFF::parsed_cs_str_t446   bool is_vsindex_dropped () const { return vsindex_dropped; }
set_vsindex_droppedCFF::parsed_cs_str_t447   void set_vsindex_dropped ()      { vsindex_dropped = true; }
448 
has_prefixCFF::parsed_cs_str_t449   bool has_prefix () const          { return has_prefix_; }
prefix_opCFF::parsed_cs_str_t450   op_code_t prefix_op () const         { return prefix_op_; }
prefix_numCFF::parsed_cs_str_t451   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 {
initCFF::parsed_cs_str_vec_t467   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   }
finiCFF::parsed_cs_str_vec_t474   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 {
initCFF::subr_subset_param_t482   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 
get_parsed_str_for_contextCFF::subr_subset_param_t496   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>
set_current_strCFF::subr_subset_param_t517   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 {
createCFF::subr_remap_t546   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 
biased_numCFF::subr_remap_t564   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 {
subr_remaps_tCFF::subr_remaps_t576   subr_remaps_t ()
577   {
578     global_remap.init ();
579     local_remaps.init ();
580   }
581 
~subr_remaps_tCFF::subr_remaps_t582   ~subr_remaps_t () { fini (); }
583 
initCFF::subr_remaps_t584   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 
createCFF::subr_remaps_t591   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 
finiCFF::subr_remaps_t598   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 {
subr_subsetter_tCFF::subr_subsetter_t611   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 
~subr_subsetter_tCFF::subr_subsetter_t619   ~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    */
subsetCFF::subr_subsetter_t642   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 
encode_charstringsCFF::subr_subsetter_t734   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 
encode_subrsCFF::subr_subsetter_t756   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 
encode_globalsubrsCFF::subr_subsetter_t774   bool encode_globalsubrs (str_buff_vec_t &buffArray)
775   {
776     return encode_subrs (parsed_global_subrs, remaps.global_remap, 0, buffArray);
777   }
778 
encode_localsubrsCFF::subr_subsetter_t779   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   {
drop_hints_param_tCFF::subr_subsetter_t::drop_hints_param_t787     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 
drop_hints_in_subrCFF::subr_subsetter_t799   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 */
drop_hints_in_strCFF::subr_subsetter_t825   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 
collect_subr_refs_in_subrCFF::subr_subsetter_t914   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 
collect_subr_refs_in_strCFF::subr_subsetter_t923   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 
encode_strCFF::subr_subsetter_t949   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 */
1026