| /* |
| * Copyright © 2018 Adobe Inc. |
| * |
| * This is part of HarfBuzz, a text shaping library. |
| * |
| * Permission is hereby granted, without written agreement and without |
| * license or royalty fees, to use, copy, modify, and distribute this |
| * software and its documentation for any purpose, provided that the |
| * above copyright notice and the following two paragraphs appear in |
| * all copies of this software. |
| * |
| * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR |
| * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES |
| * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN |
| * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH |
| * DAMAGE. |
| * |
| * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, |
| * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND |
| * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS |
| * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO |
| * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. |
| * |
| * Adobe Author(s): Michiharu Ariza |
| */ |
| |
| #ifndef HB_SUBSET_CFF_COMMON_HH |
| #define HB_SUBSET_CFF_COMMON_HH |
| |
| #include "hb.hh" |
| |
| #include "hb-subset-plan.hh" |
| #include "hb-cff-interp-cs-common.hh" |
| |
| namespace CFF { |
| |
| /* Used for writing a temporary charstring */ |
| struct str_encoder_t |
| { |
| str_encoder_t (str_buff_t &buff_) |
| : buff (buff_), error (false) {} |
| |
| void reset () { buff.reset (); } |
| |
| void encode_byte (unsigned char b) |
| { |
| buff.push (b); |
| if (unlikely (buff.in_error ())) |
| set_error (); |
| } |
| |
| void encode_int (int v) |
| { |
| if ((-1131 <= v) && (v <= 1131)) |
| { |
| if ((-107 <= v) && (v <= 107)) |
| encode_byte (v + 139); |
| else if (v > 0) |
| { |
| v -= 108; |
| encode_byte ((v >> 8) + OpCode_TwoBytePosInt0); |
| encode_byte (v & 0xFF); |
| } |
| else |
| { |
| v = -v - 108; |
| encode_byte ((v >> 8) + OpCode_TwoByteNegInt0); |
| encode_byte (v & 0xFF); |
| } |
| } |
| else |
| { |
| if (unlikely (v < -32768)) |
| v = -32768; |
| else if (unlikely (v > 32767)) |
| v = 32767; |
| encode_byte (OpCode_shortint); |
| encode_byte ((v >> 8) & 0xFF); |
| encode_byte (v & 0xFF); |
| } |
| } |
| |
| void encode_num (const number_t& n) |
| { |
| if (n.in_int_range ()) |
| { |
| encode_int (n.to_int ()); |
| } |
| else |
| { |
| int32_t v = n.to_fixed (); |
| encode_byte (OpCode_fixedcs); |
| encode_byte ((v >> 24) & 0xFF); |
| encode_byte ((v >> 16) & 0xFF); |
| encode_byte ((v >> 8) & 0xFF); |
| encode_byte (v & 0xFF); |
| } |
| } |
| |
| void encode_op (op_code_t op) |
| { |
| if (Is_OpCode_ESC (op)) |
| { |
| encode_byte (OpCode_escape); |
| encode_byte (Unmake_OpCode_ESC (op)); |
| } |
| else |
| encode_byte (op); |
| } |
| |
| void copy_str (const hb_ubytes_t &str) |
| { |
| unsigned int offset = buff.length; |
| /* Manually resize buffer since faster. */ |
| if ((signed) (buff.length + str.length) <= buff.allocated) |
| buff.length += str.length; |
| else if (unlikely (!buff.resize (offset + str.length))) |
| { |
| set_error (); |
| return; |
| } |
| memcpy (buff.arrayZ + offset, &str[0], str.length); |
| } |
| |
| bool is_error () const { return error; } |
| |
| protected: |
| void set_error () { error = true; } |
| |
| str_buff_t &buff; |
| bool error; |
| }; |
| |
| struct cff_sub_table_info_t { |
| cff_sub_table_info_t () |
| : fd_array_link (0), |
| char_strings_link (0) |
| { |
| fd_select.init (); |
| } |
| |
| table_info_t fd_select; |
| objidx_t fd_array_link; |
| objidx_t char_strings_link; |
| }; |
| |
| template <typename OPSTR=op_str_t> |
| struct cff_top_dict_op_serializer_t : op_serializer_t |
| { |
| bool serialize (hb_serialize_context_t *c, |
| const OPSTR &opstr, |
| const cff_sub_table_info_t &info) const |
| { |
| TRACE_SERIALIZE (this); |
| |
| switch (opstr.op) |
| { |
| case OpCode_CharStrings: |
| return_trace (FontDict::serialize_link4_op(c, opstr.op, info.char_strings_link, whence_t::Absolute)); |
| |
| case OpCode_FDArray: |
| return_trace (FontDict::serialize_link4_op(c, opstr.op, info.fd_array_link, whence_t::Absolute)); |
| |
| case OpCode_FDSelect: |
| return_trace (FontDict::serialize_link4_op(c, opstr.op, info.fd_select.link, whence_t::Absolute)); |
| |
| default: |
| return_trace (copy_opstr (c, opstr)); |
| } |
| return_trace (true); |
| } |
| }; |
| |
| struct cff_font_dict_op_serializer_t : op_serializer_t |
| { |
| bool serialize (hb_serialize_context_t *c, |
| const op_str_t &opstr, |
| const table_info_t &privateDictInfo) const |
| { |
| TRACE_SERIALIZE (this); |
| |
| if (opstr.op == OpCode_Private) |
| { |
| /* serialize the private dict size & offset as 2-byte & 4-byte integers */ |
| return_trace (UnsizedByteStr::serialize_int2 (c, privateDictInfo.size) && |
| Dict::serialize_link4_op (c, opstr.op, privateDictInfo.link, whence_t::Absolute)); |
| } |
| else |
| { |
| HBUINT8 *d = c->allocate_size<HBUINT8> (opstr.str.length); |
| if (unlikely (!d)) return_trace (false); |
| memcpy (d, &opstr.str[0], opstr.str.length); |
| } |
| return_trace (true); |
| } |
| }; |
| |
| struct cff_private_dict_op_serializer_t : op_serializer_t |
| { |
| cff_private_dict_op_serializer_t (bool desubroutinize_, bool drop_hints_) |
| : desubroutinize (desubroutinize_), drop_hints (drop_hints_) {} |
| |
| bool serialize (hb_serialize_context_t *c, |
| const op_str_t &opstr, |
| objidx_t subrs_link) const |
| { |
| TRACE_SERIALIZE (this); |
| |
| if (drop_hints && dict_opset_t::is_hint_op (opstr.op)) |
| return true; |
| if (opstr.op == OpCode_Subrs) |
| { |
| if (desubroutinize || !subrs_link) |
| return_trace (true); |
| else |
| return_trace (FontDict::serialize_link2_op (c, opstr.op, subrs_link)); |
| } |
| else |
| return_trace (copy_opstr (c, opstr)); |
| } |
| |
| protected: |
| const bool desubroutinize; |
| const bool drop_hints; |
| }; |
| |
| struct flatten_param_t |
| { |
| str_buff_t &flatStr; |
| bool drop_hints; |
| }; |
| |
| template <typename ACC, typename ENV, typename OPSET, op_code_t endchar_op=OpCode_Invalid> |
| struct subr_flattener_t |
| { |
| subr_flattener_t (const ACC &acc_, |
| const hb_subset_plan_t *plan_) |
| : acc (acc_), plan (plan_) {} |
| |
| bool flatten (str_buff_vec_t &flat_charstrings) |
| { |
| if (!flat_charstrings.resize (plan->num_output_glyphs ())) |
| return false; |
| for (unsigned int i = 0; i < plan->num_output_glyphs (); i++) |
| flat_charstrings[i].init (); |
| for (unsigned int i = 0; i < plan->num_output_glyphs (); i++) |
| { |
| hb_codepoint_t glyph; |
| if (!plan->old_gid_for_new_gid (i, &glyph)) |
| { |
| /* add an endchar only charstring for a missing glyph if CFF1 */ |
| if (endchar_op != OpCode_Invalid) flat_charstrings[i].push (endchar_op); |
| continue; |
| } |
| const hb_ubytes_t str = (*acc.charStrings)[glyph]; |
| unsigned int fd = acc.fdSelect->get_fd (glyph); |
| if (unlikely (fd >= acc.fdCount)) |
| return false; |
| ENV env (str, acc, fd); |
| cs_interpreter_t<ENV, OPSET, flatten_param_t> interp (env); |
| flatten_param_t param = { |
| flat_charstrings[i], |
| (bool) (plan->flags & HB_SUBSET_FLAGS_NO_HINTING) |
| }; |
| if (unlikely (!interp.interpret (param))) |
| return false; |
| } |
| return true; |
| } |
| |
| const ACC &acc; |
| const hb_subset_plan_t *plan; |
| }; |
| |
| struct subr_closures_t |
| { |
| subr_closures_t (unsigned int fd_count) : valid (false), global_closure (), local_closures () |
| { |
| valid = true; |
| if (!local_closures.resize (fd_count)) |
| valid = false; |
| } |
| |
| void reset () |
| { |
| global_closure.clear(); |
| for (unsigned int i = 0; i < local_closures.length; i++) |
| local_closures[i].clear(); |
| } |
| |
| bool is_valid () const { return valid; } |
| bool valid; |
| hb_set_t global_closure; |
| hb_vector_t<hb_set_t> local_closures; |
| }; |
| |
| struct parsed_cs_op_t : op_str_t |
| { |
| void init (unsigned int subr_num_ = 0) |
| { |
| subr_num = subr_num_; |
| drop_flag = false; |
| keep_flag = false; |
| skip_flag = false; |
| } |
| |
| bool for_drop () const { return drop_flag; } |
| void set_drop () { if (!for_keep ()) drop_flag = true; } |
| |
| bool for_keep () const { return keep_flag; } |
| void set_keep () { keep_flag = true; } |
| |
| bool for_skip () const { return skip_flag; } |
| void set_skip () { skip_flag = true; } |
| |
| unsigned int subr_num; |
| |
| protected: |
| bool drop_flag; |
| bool keep_flag; |
| bool skip_flag; |
| }; |
| |
| struct parsed_cs_str_t : parsed_values_t<parsed_cs_op_t> |
| { |
| void init () |
| { |
| SUPER::init (); |
| parsed = false; |
| hint_dropped = false; |
| has_prefix_ = false; |
| } |
| |
| void add_op (op_code_t op, const byte_str_ref_t& str_ref) |
| { |
| if (!is_parsed ()) |
| SUPER::add_op (op, str_ref); |
| } |
| |
| void add_call_op (op_code_t op, const byte_str_ref_t& str_ref, unsigned int subr_num) |
| { |
| if (!is_parsed ()) |
| { |
| unsigned int parsed_len = get_count (); |
| if (likely (parsed_len > 0)) |
| values[parsed_len-1].set_skip (); |
| |
| parsed_cs_op_t val; |
| val.init (subr_num); |
| SUPER::add_op (op, str_ref, val); |
| } |
| } |
| |
| void set_prefix (const number_t &num, op_code_t op = OpCode_Invalid) |
| { |
| has_prefix_ = true; |
| prefix_op_ = op; |
| prefix_num_ = num; |
| } |
| |
| bool at_end (unsigned int pos) const |
| { |
| return ((pos + 1 >= values.length) /* CFF2 */ |
| || (values[pos + 1].op == OpCode_return)); |
| } |
| |
| bool is_parsed () const { return parsed; } |
| void set_parsed () { parsed = true; } |
| |
| bool is_hint_dropped () const { return hint_dropped; } |
| void set_hint_dropped () { hint_dropped = true; } |
| |
| bool is_vsindex_dropped () const { return vsindex_dropped; } |
| void set_vsindex_dropped () { vsindex_dropped = true; } |
| |
| bool has_prefix () const { return has_prefix_; } |
| op_code_t prefix_op () const { return prefix_op_; } |
| const number_t &prefix_num () const { return prefix_num_; } |
| |
| protected: |
| bool parsed; |
| bool hint_dropped; |
| bool vsindex_dropped; |
| bool has_prefix_; |
| op_code_t prefix_op_; |
| number_t prefix_num_; |
| |
| private: |
| typedef parsed_values_t<parsed_cs_op_t> SUPER; |
| }; |
| |
| struct parsed_cs_str_vec_t : hb_vector_t<parsed_cs_str_t> |
| { |
| private: |
| typedef hb_vector_t<parsed_cs_str_t> SUPER; |
| }; |
| |
| struct subr_subset_param_t |
| { |
| subr_subset_param_t (parsed_cs_str_t *parsed_charstring_, |
| parsed_cs_str_vec_t *parsed_global_subrs_, |
| parsed_cs_str_vec_t *parsed_local_subrs_, |
| hb_set_t *global_closure_, |
| hb_set_t *local_closure_, |
| bool drop_hints_) : |
| current_parsed_str (parsed_charstring_), |
| parsed_charstring (parsed_charstring_), |
| parsed_global_subrs (parsed_global_subrs_), |
| parsed_local_subrs (parsed_local_subrs_), |
| global_closure (global_closure_), |
| local_closure (local_closure_), |
| drop_hints (drop_hints_) {} |
| |
| parsed_cs_str_t *get_parsed_str_for_context (call_context_t &context) |
| { |
| switch (context.type) |
| { |
| case CSType_CharString: |
| return parsed_charstring; |
| |
| case CSType_LocalSubr: |
| if (likely (context.subr_num < parsed_local_subrs->length)) |
| return &(*parsed_local_subrs)[context.subr_num]; |
| break; |
| |
| case CSType_GlobalSubr: |
| if (likely (context.subr_num < parsed_global_subrs->length)) |
| return &(*parsed_global_subrs)[context.subr_num]; |
| break; |
| } |
| return nullptr; |
| } |
| |
| template <typename ENV> |
| void set_current_str (ENV &env, bool calling) |
| { |
| parsed_cs_str_t *parsed_str = get_parsed_str_for_context (env.context); |
| if (unlikely (!parsed_str)) |
| { |
| env.set_error (); |
| return; |
| } |
| /* If the called subroutine is parsed partially but not completely yet, |
| * it must be because we are calling it recursively. |
| * Handle it as an error. */ |
| if (unlikely (calling && !parsed_str->is_parsed () && (parsed_str->values.length > 0))) |
| env.set_error (); |
| else |
| current_parsed_str = parsed_str; |
| } |
| |
| parsed_cs_str_t *current_parsed_str; |
| |
| parsed_cs_str_t *parsed_charstring; |
| parsed_cs_str_vec_t *parsed_global_subrs; |
| parsed_cs_str_vec_t *parsed_local_subrs; |
| hb_set_t *global_closure; |
| hb_set_t *local_closure; |
| bool drop_hints; |
| }; |
| |
| struct subr_remap_t : hb_inc_bimap_t |
| { |
| void create (const hb_set_t *closure) |
| { |
| /* create a remapping of subroutine numbers from old to new. |
| * no optimization based on usage counts. fonttools doesn't appear doing that either. |
| */ |
| |
| resize (closure->get_population ()); |
| hb_codepoint_t old_num = HB_SET_VALUE_INVALID; |
| while (hb_set_next (closure, &old_num)) |
| add (old_num); |
| |
| if (get_population () < 1240) |
| bias = 107; |
| else if (get_population () < 33900) |
| bias = 1131; |
| else |
| bias = 32768; |
| } |
| |
| int biased_num (unsigned int old_num) const |
| { |
| hb_codepoint_t new_num = get (old_num); |
| return (int)new_num - bias; |
| } |
| |
| protected: |
| int bias; |
| }; |
| |
| struct subr_remaps_t |
| { |
| subr_remaps_t (unsigned int fdCount) |
| { |
| local_remaps.resize (fdCount); |
| } |
| |
| bool in_error() |
| { |
| return local_remaps.in_error (); |
| } |
| |
| void create (subr_closures_t& closures) |
| { |
| global_remap.create (&closures.global_closure); |
| for (unsigned int i = 0; i < local_remaps.length; i++) |
| local_remaps[i].create (&closures.local_closures[i]); |
| } |
| |
| subr_remap_t global_remap; |
| hb_vector_t<subr_remap_t> local_remaps; |
| }; |
| |
| template <typename SUBSETTER, typename SUBRS, typename ACC, typename ENV, typename OPSET, op_code_t endchar_op=OpCode_Invalid> |
| struct subr_subsetter_t |
| { |
| subr_subsetter_t (ACC &acc_, const hb_subset_plan_t *plan_) |
| : acc (acc_), plan (plan_), closures(acc_.fdCount), remaps(acc_.fdCount) |
| {} |
| |
| /* Subroutine subsetting with --no-desubroutinize runs in phases: |
| * |
| * 1. execute charstrings/subroutines to determine subroutine closures |
| * 2. parse out all operators and numbers |
| * 3. mark hint operators and operands for removal if --no-hinting |
| * 4. re-encode all charstrings and subroutines with new subroutine numbers |
| * |
| * Phases #1 and #2 are done at the same time in collect_subrs (). |
| * Phase #3 walks charstrings/subroutines forward then backward (hence parsing required), |
| * because we can't tell if a number belongs to a hint op until we see the first moveto. |
| * |
| * Assumption: a callsubr/callgsubr operator must immediately follow a (biased) subroutine number |
| * within the same charstring/subroutine, e.g., not split across a charstring and a subroutine. |
| */ |
| bool subset (void) |
| { |
| parsed_charstrings.resize (plan->num_output_glyphs ()); |
| parsed_global_subrs.resize (acc.globalSubrs->count); |
| |
| if (unlikely (remaps.in_error() |
| || parsed_charstrings.in_error () |
| || parsed_global_subrs.in_error ())) { |
| return false; |
| } |
| |
| if (unlikely (!parsed_local_subrs.resize (acc.fdCount))) return false; |
| |
| for (unsigned int i = 0; i < acc.fdCount; i++) |
| { |
| parsed_local_subrs[i].resize (acc.privateDicts[i].localSubrs->count); |
| if (unlikely (parsed_local_subrs[i].in_error ())) return false; |
| } |
| if (unlikely (!closures.valid)) |
| return false; |
| |
| /* phase 1 & 2 */ |
| for (unsigned int i = 0; i < plan->num_output_glyphs (); i++) |
| { |
| hb_codepoint_t glyph; |
| if (!plan->old_gid_for_new_gid (i, &glyph)) |
| continue; |
| const hb_ubytes_t str = (*acc.charStrings)[glyph]; |
| unsigned int fd = acc.fdSelect->get_fd (glyph); |
| if (unlikely (fd >= acc.fdCount)) |
| return false; |
| |
| ENV env (str, acc, fd); |
| cs_interpreter_t<ENV, OPSET, subr_subset_param_t> interp (env); |
| |
| parsed_charstrings[i].alloc (str.length); |
| subr_subset_param_t param (&parsed_charstrings[i], |
| &parsed_global_subrs, |
| &parsed_local_subrs[fd], |
| &closures.global_closure, |
| &closures.local_closures[fd], |
| plan->flags & HB_SUBSET_FLAGS_NO_HINTING); |
| |
| if (unlikely (!interp.interpret (param))) |
| return false; |
| |
| /* complete parsed string esp. copy CFF1 width or CFF2 vsindex to the parsed charstring for encoding */ |
| SUBSETTER::complete_parsed_str (interp.env, param, parsed_charstrings[i]); |
| } |
| |
| if (plan->flags & HB_SUBSET_FLAGS_NO_HINTING) |
| { |
| /* mark hint ops and arguments for drop */ |
| for (unsigned int i = 0; i < plan->num_output_glyphs (); i++) |
| { |
| hb_codepoint_t glyph; |
| if (!plan->old_gid_for_new_gid (i, &glyph)) |
| continue; |
| unsigned int fd = acc.fdSelect->get_fd (glyph); |
| if (unlikely (fd >= acc.fdCount)) |
| return false; |
| subr_subset_param_t param (&parsed_charstrings[i], |
| &parsed_global_subrs, |
| &parsed_local_subrs[fd], |
| &closures.global_closure, |
| &closures.local_closures[fd], |
| plan->flags & HB_SUBSET_FLAGS_NO_HINTING); |
| |
| drop_hints_param_t drop; |
| if (drop_hints_in_str (parsed_charstrings[i], param, drop)) |
| { |
| parsed_charstrings[i].set_hint_dropped (); |
| if (drop.vsindex_dropped) |
| parsed_charstrings[i].set_vsindex_dropped (); |
| } |
| } |
| |
| /* after dropping hints recreate closures of actually used subrs */ |
| closures.reset (); |
| for (unsigned int i = 0; i < plan->num_output_glyphs (); i++) |
| { |
| hb_codepoint_t glyph; |
| if (!plan->old_gid_for_new_gid (i, &glyph)) |
| continue; |
| unsigned int fd = acc.fdSelect->get_fd (glyph); |
| if (unlikely (fd >= acc.fdCount)) |
| return false; |
| subr_subset_param_t param (&parsed_charstrings[i], |
| &parsed_global_subrs, |
| &parsed_local_subrs[fd], |
| &closures.global_closure, |
| &closures.local_closures[fd], |
| plan->flags & HB_SUBSET_FLAGS_NO_HINTING); |
| collect_subr_refs_in_str (parsed_charstrings[i], param); |
| } |
| } |
| |
| remaps.create (closures); |
| |
| return true; |
| } |
| |
| bool encode_charstrings (str_buff_vec_t &buffArray) const |
| { |
| if (unlikely (!buffArray.resize (plan->num_output_glyphs ()))) |
| return false; |
| for (unsigned int i = 0; i < plan->num_output_glyphs (); i++) |
| { |
| hb_codepoint_t glyph; |
| if (!plan->old_gid_for_new_gid (i, &glyph)) |
| { |
| /* add an endchar only charstring for a missing glyph if CFF1 */ |
| if (endchar_op != OpCode_Invalid) buffArray[i].push (endchar_op); |
| continue; |
| } |
| unsigned int fd = acc.fdSelect->get_fd (glyph); |
| if (unlikely (fd >= acc.fdCount)) |
| return false; |
| if (unlikely (!encode_str (parsed_charstrings[i], fd, buffArray[i]))) |
| return false; |
| } |
| return true; |
| } |
| |
| bool encode_subrs (const parsed_cs_str_vec_t &subrs, const subr_remap_t& remap, unsigned int fd, str_buff_vec_t &buffArray) const |
| { |
| unsigned int count = remap.get_population (); |
| |
| if (unlikely (!buffArray.resize (count))) |
| return false; |
| for (unsigned int old_num = 0; old_num < subrs.length; old_num++) |
| { |
| hb_codepoint_t new_num = remap[old_num]; |
| if (new_num != CFF_UNDEF_CODE) |
| { |
| if (unlikely (!encode_str (subrs[old_num], fd, buffArray[new_num]))) |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| bool encode_globalsubrs (str_buff_vec_t &buffArray) |
| { |
| return encode_subrs (parsed_global_subrs, remaps.global_remap, 0, buffArray); |
| } |
| |
| bool encode_localsubrs (unsigned int fd, str_buff_vec_t &buffArray) const |
| { |
| return encode_subrs (parsed_local_subrs[fd], remaps.local_remaps[fd], fd, buffArray); |
| } |
| |
| protected: |
| struct drop_hints_param_t |
| { |
| drop_hints_param_t () |
| : seen_moveto (false), |
| ends_in_hint (false), |
| all_dropped (false), |
| vsindex_dropped (false) {} |
| |
| bool seen_moveto; |
| bool ends_in_hint; |
| bool all_dropped; |
| bool vsindex_dropped; |
| }; |
| |
| bool drop_hints_in_subr (parsed_cs_str_t &str, unsigned int pos, |
| parsed_cs_str_vec_t &subrs, unsigned int subr_num, |
| const subr_subset_param_t ¶m, drop_hints_param_t &drop) |
| { |
| drop.ends_in_hint = false; |
| bool has_hint = drop_hints_in_str (subrs[subr_num], param, drop); |
| |
| /* if this subr ends with a stem hint (i.e., not a number; potential argument for moveto), |
| * then this entire subroutine must be a hint. drop its call. */ |
| if (drop.ends_in_hint) |
| { |
| str.values[pos].set_drop (); |
| /* if this subr call is at the end of the parent subr, propagate the flag |
| * otherwise reset the flag */ |
| if (!str.at_end (pos)) |
| drop.ends_in_hint = false; |
| } |
| else if (drop.all_dropped) |
| { |
| str.values[pos].set_drop (); |
| } |
| |
| return has_hint; |
| } |
| |
| /* returns true if it sees a hint op before the first moveto */ |
| bool drop_hints_in_str (parsed_cs_str_t &str, const subr_subset_param_t ¶m, drop_hints_param_t &drop) |
| { |
| bool seen_hint = false; |
| |
| for (unsigned int pos = 0; pos < str.values.length; pos++) |
| { |
| bool has_hint = false; |
| switch (str.values[pos].op) |
| { |
| case OpCode_callsubr: |
| has_hint = drop_hints_in_subr (str, pos, |
| *param.parsed_local_subrs, str.values[pos].subr_num, |
| param, drop); |
| break; |
| |
| case OpCode_callgsubr: |
| has_hint = drop_hints_in_subr (str, pos, |
| *param.parsed_global_subrs, str.values[pos].subr_num, |
| param, drop); |
| break; |
| |
| case OpCode_rmoveto: |
| case OpCode_hmoveto: |
| case OpCode_vmoveto: |
| drop.seen_moveto = true; |
| break; |
| |
| case OpCode_hintmask: |
| case OpCode_cntrmask: |
| if (drop.seen_moveto) |
| { |
| str.values[pos].set_drop (); |
| break; |
| } |
| HB_FALLTHROUGH; |
| |
| case OpCode_hstemhm: |
| case OpCode_vstemhm: |
| case OpCode_hstem: |
| case OpCode_vstem: |
| has_hint = true; |
| str.values[pos].set_drop (); |
| if (str.at_end (pos)) |
| drop.ends_in_hint = true; |
| break; |
| |
| case OpCode_dotsection: |
| str.values[pos].set_drop (); |
| break; |
| |
| default: |
| /* NONE */ |
| break; |
| } |
| if (has_hint) |
| { |
| for (int i = pos - 1; i >= 0; i--) |
| { |
| parsed_cs_op_t &csop = str.values[(unsigned)i]; |
| if (csop.for_drop ()) |
| break; |
| csop.set_drop (); |
| if (csop.op == OpCode_vsindexcs) |
| drop.vsindex_dropped = true; |
| } |
| seen_hint |= has_hint; |
| } |
| } |
| |
| /* Raise all_dropped flag if all operators except return are dropped from a subr. |
| * It may happen even after seeing the first moveto if a subr contains |
| * only (usually one) hintmask operator, then calls to this subr can be dropped. |
| */ |
| drop.all_dropped = true; |
| for (unsigned int pos = 0; pos < str.values.length; pos++) |
| { |
| parsed_cs_op_t &csop = str.values[pos]; |
| if (csop.op == OpCode_return) |
| break; |
| if (!csop.for_drop ()) |
| { |
| drop.all_dropped = false; |
| break; |
| } |
| } |
| |
| return seen_hint; |
| } |
| |
| void collect_subr_refs_in_subr (parsed_cs_str_t &str, unsigned int pos, |
| unsigned int subr_num, parsed_cs_str_vec_t &subrs, |
| hb_set_t *closure, |
| const subr_subset_param_t ¶m) |
| { |
| closure->add (subr_num); |
| collect_subr_refs_in_str (subrs[subr_num], param); |
| } |
| |
| void collect_subr_refs_in_str (parsed_cs_str_t &str, const subr_subset_param_t ¶m) |
| { |
| for (unsigned int pos = 0; pos < str.values.length; pos++) |
| { |
| if (!str.values[pos].for_drop ()) |
| { |
| switch (str.values[pos].op) |
| { |
| case OpCode_callsubr: |
| collect_subr_refs_in_subr (str, pos, |
| str.values[pos].subr_num, *param.parsed_local_subrs, |
| param.local_closure, param); |
| break; |
| |
| case OpCode_callgsubr: |
| collect_subr_refs_in_subr (str, pos, |
| str.values[pos].subr_num, *param.parsed_global_subrs, |
| param.global_closure, param); |
| break; |
| |
| default: break; |
| } |
| } |
| } |
| } |
| |
| bool encode_str (const parsed_cs_str_t &str, const unsigned int fd, str_buff_t &buff) const |
| { |
| unsigned count = str.get_count (); |
| str_encoder_t encoder (buff); |
| encoder.reset (); |
| buff.alloc (count * 3); |
| /* if a prefix (CFF1 width or CFF2 vsindex) has been removed along with hints, |
| * re-insert it at the beginning of charstreing */ |
| if (str.has_prefix () && str.is_hint_dropped ()) |
| { |
| encoder.encode_num (str.prefix_num ()); |
| if (str.prefix_op () != OpCode_Invalid) |
| encoder.encode_op (str.prefix_op ()); |
| } |
| for (unsigned int i = 0; i < count; i++) |
| { |
| const parsed_cs_op_t &opstr = str.values[i]; |
| if (!opstr.for_drop () && !opstr.for_skip ()) |
| { |
| switch (opstr.op) |
| { |
| case OpCode_callsubr: |
| encoder.encode_int (remaps.local_remaps[fd].biased_num (opstr.subr_num)); |
| encoder.encode_op (OpCode_callsubr); |
| break; |
| |
| case OpCode_callgsubr: |
| encoder.encode_int (remaps.global_remap.biased_num (opstr.subr_num)); |
| encoder.encode_op (OpCode_callgsubr); |
| break; |
| |
| default: |
| encoder.copy_str (opstr.str); |
| break; |
| } |
| } |
| } |
| return !encoder.is_error (); |
| } |
| |
| protected: |
| const ACC &acc; |
| const hb_subset_plan_t *plan; |
| |
| subr_closures_t closures; |
| |
| parsed_cs_str_vec_t parsed_charstrings; |
| parsed_cs_str_vec_t parsed_global_subrs; |
| hb_vector_t<parsed_cs_str_vec_t> parsed_local_subrs; |
| |
| subr_remaps_t remaps; |
| |
| private: |
| typedef typename SUBRS::count_type subr_count_type; |
| }; |
| |
| } /* namespace CFF */ |
| |
| HB_INTERNAL bool |
| hb_plan_subset_cff_fdselect (const hb_subset_plan_t *plan, |
| unsigned int fdCount, |
| const CFF::FDSelect &src, /* IN */ |
| unsigned int &subset_fd_count /* OUT */, |
| unsigned int &subset_fdselect_size /* OUT */, |
| unsigned int &subset_fdselect_format /* OUT */, |
| hb_vector_t<CFF::code_pair_t> &fdselect_ranges /* OUT */, |
| hb_inc_bimap_t &fdmap /* OUT */); |
| |
| HB_INTERNAL bool |
| hb_serialize_cff_fdselect (hb_serialize_context_t *c, |
| unsigned int num_glyphs, |
| const CFF::FDSelect &src, |
| unsigned int fd_count, |
| unsigned int fdselect_format, |
| unsigned int size, |
| const hb_vector_t<CFF::code_pair_t> &fdselect_ranges); |
| |
| #endif /* HB_SUBSET_CFF_COMMON_HH */ |