From 21163c30e9d18759414f7fe2518628241599f039 Mon Sep 17 00:00:00 2001 From: Michiharu Ariza Date: Fri, 21 Dec 2018 16:06:35 -0800 Subject: [PATCH] fixed tabs, added inline --- src/hb-cff-interp-common.hh | 167 +++++++++++++------------ src/hb-cff-interp-cs-common.hh | 161 ++++++++++++------------ src/hb-cff-interp-dict-common.hh | 34 ++--- src/hb-cff1-interp-cs.hh | 18 +-- src/hb-cff2-interp-cs.hh | 52 ++++---- src/hb-ot-cff-common.hh | 172 +++++++++++++------------- src/hb-ot-cff1-table.cc | 40 +++--- src/hb-ot-cff1-table.hh | 205 +++++++++++++++---------------- src/hb-ot-cff2-table.cc | 16 +-- src/hb-ot-cff2-table.hh | 76 ++++++------ src/hb-subset-cff-common.hh | 96 +++++++-------- src/hb-subset-cff1.cc | 149 +++++++++++----------- src/hb-subset-cff2.cc | 68 +++++----- src/hb-subset-cff2.hh | 2 +- 14 files changed, 628 insertions(+), 628 deletions(-) diff --git a/src/hb-cff-interp-common.hh b/src/hb-cff-interp-common.hh index 80857aec1..69830a161 100644 --- a/src/hb-cff-interp-common.hh +++ b/src/hb-cff-interp-common.hh @@ -217,37 +217,37 @@ inline unsigned int OpCode_Size (op_code_t op) { return Is_OpCode_ESC (op) ? 2: struct number_t { - void init () { set_real (0.0); } - void fini () {} + inline void init () { set_real (0.0); } + inline void fini () {} - void set_int (int v) { value = (double) v; } - int to_int () const { return (int) value; } + inline void set_int (int v) { value = (double) v; } + inline int to_int () const { return (int) value; } - void set_fixed (int32_t v) { value = v / 65536.0; } - int32_t to_fixed () const { return (int32_t) (value * 65536.0); } + inline void set_fixed (int32_t v) { value = v / 65536.0; } + inline int32_t to_fixed () const { return (int32_t) (value * 65536.0); } - void set_real (double v) { value = v; } - double to_real () const { return value; } + inline void set_real (double v) { value = v; } + inline double to_real () const { return value; } - int ceil () const { return (int) ::ceil (value); } - int floor () const { return (int) ::floor (value); } + inline int ceil () const { return (int) ::ceil (value); } + inline int floor () const { return (int) ::floor (value); } - bool in_int_range () const + inline bool in_int_range () const { return ((double) (int16_t) to_int () == value); } - bool operator > (const number_t &n) const + inline bool operator > (const number_t &n) const { return value > n.to_real (); } - bool operator < (const number_t &n) const + inline bool operator < (const number_t &n) const { return n > *this; } - bool operator >= (const number_t &n) const + inline bool operator >= (const number_t &n) const { return !(*this < n); } - bool operator <= (const number_t &n) const + inline bool operator <= (const number_t &n) const { return !(*this > n); } - const number_t &operator += (const number_t &n) + inline const number_t &operator += (const number_t &n) { set_real (to_real () + n.to_real ()); @@ -263,7 +263,7 @@ struct UnsizedByteStr : UnsizedArrayOf { // encode 2-byte int (Dict/CharString) or 4-byte int (Dict) template - static bool serialize_int (hb_serialize_context_t *c, op_code_t intOp, int value) + static inline bool serialize_int (hb_serialize_context_t *c, op_code_t intOp, int value) { TRACE_SERIALIZE (this); @@ -281,10 +281,10 @@ struct UnsizedByteStr : UnsizedArrayOf return_trace (true); } - static bool serialize_int4 (hb_serialize_context_t *c, int value) + static inline bool serialize_int4 (hb_serialize_context_t *c, int value) { return serialize_int (c, OpCode_longintdict, value); } - static bool serialize_int2 (hb_serialize_context_t *c, int value) + static inline bool serialize_int2 (hb_serialize_context_t *c, int value) { return serialize_int (c, OpCode_shortint, value); } /* Defining null_size allows a Null object may be created. Should be safe because: @@ -300,49 +300,48 @@ struct UnsizedByteStr : UnsizedArrayOf /* Holder of a section of byte string within a CFFIndex entry */ struct byte_str_t : hb_ubytes_t { - byte_str_t () + inline byte_str_t () : hb_ubytes_t () {} - byte_str_t (const UnsizedByteStr& s, unsigned int l) + inline byte_str_t (const UnsizedByteStr& s, unsigned int l) : hb_ubytes_t ((const unsigned char*)&s, l) {} - byte_str_t (const unsigned char *s, unsigned int l) + inline byte_str_t (const unsigned char *s, unsigned int l) : hb_ubytes_t (s, l) {} - byte_str_t (const hb_ubytes_t &ub) /* conversion from hb_ubytes_t */ + inline byte_str_t (const hb_ubytes_t &ub) /* conversion from hb_ubytes_t */ : hb_ubytes_t (ub) {} /* sub-string */ - byte_str_t sub_str (unsigned int offset, unsigned int len_) const + inline byte_str_t sub_str (unsigned int offset, unsigned int len_) const { return byte_str_t (hb_ubytes_t::sub_array (offset, len_)); } - bool check_limit (unsigned int offset, unsigned int count) const + inline bool check_limit (unsigned int offset, unsigned int count) const { return (offset + count <= len); } }; /* A byte string associated with the current offset and an error condition */ struct byte_str_ref_t { - byte_str_ref_t () - { init (); } + inline byte_str_ref_t () { init (); } - void init () + inline void init () { str = byte_str_t (); offset = 0; error = false; } - void fini () {} + inline void fini () {} - byte_str_ref_t (const byte_str_t &str_, unsigned int offset_ = 0) + inline byte_str_ref_t (const byte_str_t &str_, unsigned int offset_ = 0) : str (str_), offset (offset_), error (false) {} - void reset (const byte_str_t &str_, unsigned int offset_ = 0) + inline void reset (const byte_str_t &str_, unsigned int offset_ = 0) { str = str_; offset = offset_; error = false; } - const unsigned char& operator [] (int i) { + inline const unsigned char& operator [] (int i) { if (unlikely ((unsigned int)(offset + i) >= str.len)) { set_error (); @@ -353,16 +352,16 @@ struct byte_str_ref_t } /* Conversion to byte_str_t */ - operator byte_str_t () const { return str.sub_str (offset, str.len - offset); } + inline operator byte_str_t () const { return str.sub_str (offset, str.len - offset); } - byte_str_t sub_str (unsigned int offset_, unsigned int len_) const + inline byte_str_t sub_str (unsigned int offset_, unsigned int len_) const { return str.sub_str (offset_, len_); } - bool avail (unsigned int count=1) const + inline bool avail (unsigned int count=1) const { return (!in_error () && str.check_limit (offset, count)); } - void inc (unsigned int count=1) + inline void inc (unsigned int count=1) { if (likely (!in_error () && (offset <= str.len) && (offset + count <= str.len))) { @@ -375,8 +374,8 @@ struct byte_str_ref_t } } - void set_error () { error = true; } - bool in_error () const { return error; } + inline void set_error () { error = true; } + inline bool in_error () const { return error; } byte_str_t str; unsigned int offset; /* beginning of the sub-string within str */ @@ -391,7 +390,7 @@ typedef hb_vector_t byte_str_array_t; template struct stack_t { - void init () + inline void init () { error = false; count = 0; @@ -401,18 +400,18 @@ struct stack_t elements[i].init (); } - void fini () + inline void fini () { elements.fini_deep (); } - ELEM& operator [] (unsigned int i) + inline ELEM& operator [] (unsigned int i) { if (unlikely (i >= count)) set_error (); return elements[i]; } - void push (const ELEM &v) + inline void push (const ELEM &v) { if (likely (count < elements.len)) elements[count++] = v; @@ -420,7 +419,7 @@ struct stack_t set_error (); } - ELEM &push () + inline ELEM &push () { if (likely (count < elements.len)) return elements[count++]; @@ -431,7 +430,7 @@ struct stack_t } } - ELEM& pop () + inline ELEM& pop () { if (likely (count > 0)) return elements[--count]; @@ -442,7 +441,7 @@ struct stack_t } } - void pop (unsigned int n) + inline void pop (unsigned int n) { if (likely (count >= n)) count -= n; @@ -450,7 +449,7 @@ struct stack_t set_error (); } - const ELEM& peek () + inline const ELEM& peek () { if (likely (count > 0)) return elements[count-1]; @@ -461,7 +460,7 @@ struct stack_t } } - void unpop () + inline void unpop () { if (likely (count < elements.len)) count++; @@ -469,13 +468,13 @@ struct stack_t set_error (); } - void clear () { count = 0; } + inline void clear () { count = 0; } - bool in_error () const { return (error || elements.in_error ()); } - void set_error () { error = true; } + inline bool in_error () const { return (error || elements.in_error ()); } + inline void set_error () { error = true; } - unsigned int get_count () const { return count; } - bool is_empty () const { return count == 0; } + inline unsigned int get_count () const { return count; } + inline bool is_empty () const { return count == 0; } static const unsigned int kSizeLimit = LIMIT; @@ -489,29 +488,29 @@ struct stack_t template struct arg_stack_t : stack_t { - void push_int (int v) + inline void push_int (int v) { ARG &n = S::push (); n.set_int (v); } - void push_fixed (int32_t v) + inline void push_fixed (int32_t v) { ARG &n = S::push (); n.set_fixed (v); } - void push_real (double v) + inline void push_real (double v) { ARG &n = S::push (); n.set_real (v); } - ARG& pop_num () { return this->pop (); } + inline ARG& pop_num () { return this->pop (); } - int pop_int () { return this->pop ().to_int (); } + inline int pop_int () { return this->pop ().to_int (); } - unsigned int pop_uint () + inline unsigned int pop_uint () { int i = pop_int (); if (unlikely (i < 0)) @@ -522,13 +521,13 @@ struct arg_stack_t : stack_t return (unsigned)i; } - void push_longint_from_substr (byte_str_ref_t& str_ref) + inline void push_longint_from_substr (byte_str_ref_t& str_ref) { push_int ((str_ref[0] << 24) | (str_ref[1] << 16) | (str_ref[2] << 8) | (str_ref[3])); str_ref.inc (4); } - bool push_fixed_from_substr (byte_str_ref_t& str_ref) + inline bool push_fixed_from_substr (byte_str_ref_t& str_ref) { if (unlikely (!str_ref.avail (4))) return false; @@ -537,7 +536,7 @@ struct arg_stack_t : stack_t return true; } - hb_array_t get_subarray (unsigned int start) const + inline hb_array_t get_subarray (unsigned int start) const { return S::elements.sub_array (start); } @@ -549,8 +548,8 @@ struct arg_stack_t : stack_t /* an operator prefixed by its operands in a byte string */ struct op_str_t { - void init () {} - void fini () {} + inline void init () {} + inline void fini () {} op_code_t op; byte_str_t str; @@ -560,7 +559,7 @@ struct op_str_t struct op_serializer_t { protected: - bool copy_opstr (hb_serialize_context_t *c, const op_str_t& opstr) const + inline bool copy_opstr (hb_serialize_context_t *c, const op_str_t& opstr) const { TRACE_SERIALIZE (this); @@ -574,14 +573,14 @@ struct op_serializer_t template struct parsed_values_t { - void init () + inline void init () { opStart = 0; values.init (); } - void fini () { values.fini_deep (); } + inline void fini () { values.fini_deep (); } - void add_op (op_code_t op, const byte_str_ref_t& str_ref = byte_str_ref_t ()) + inline void add_op (op_code_t op, const byte_str_ref_t& str_ref = byte_str_ref_t ()) { VAL *val = values.push (); val->op = op; @@ -589,7 +588,7 @@ struct parsed_values_t opStart = str_ref.offset; } - void add_op (op_code_t op, const byte_str_ref_t& str_ref, const VAL &v) + inline void add_op (op_code_t op, const byte_str_ref_t& str_ref, const VAL &v) { VAL *val = values.push (v); val->op = op; @@ -597,16 +596,16 @@ struct parsed_values_t opStart = str_ref.offset; } - bool has_op (op_code_t op) const + inline bool has_op (op_code_t op) const { for (unsigned int i = 0; i < get_count (); i++) if (get_value (i).op == op) return true; return false; } - unsigned get_count () const { return values.len; } - const VAL &get_value (unsigned int i) const { return values[i]; } - const VAL &operator [] (unsigned int i) const { return get_value (i); } + inline unsigned get_count () const { return values.len; } + inline const VAL &get_value (unsigned int i) const { return values[i]; } + inline const VAL &operator [] (unsigned int i) const { return get_value (i); } unsigned int opStart; hb_vector_t values; @@ -615,20 +614,20 @@ struct parsed_values_t template struct interp_env_t { - void init (const byte_str_t &str_) + inline void init (const byte_str_t &str_) { str_ref.reset (str_); argStack.init (); error = false; } - void fini () { argStack.fini (); } + inline void fini () { argStack.fini (); } - bool in_error () const + inline bool in_error () const { return error || str_ref.in_error () || argStack.in_error (); } - void set_error () { error = true; } + inline void set_error () { error = true; } - op_code_t fetch_op () + inline op_code_t fetch_op () { op_code_t op = OpCode_Invalid; if (unlikely (!str_ref.avail ())) @@ -644,22 +643,22 @@ struct interp_env_t return op; } - const ARG& eval_arg (unsigned int i) + inline const ARG& eval_arg (unsigned int i) { return argStack[i]; } - ARG& pop_arg () + inline ARG& pop_arg () { return argStack.pop (); } - void pop_n_args (unsigned int n) + inline void pop_n_args (unsigned int n) { argStack.pop (n); } - void clear_args () + inline void clear_args () { pop_n_args (argStack.get_count ()); } @@ -675,7 +674,7 @@ typedef interp_env_t<> num_interp_env_t; template struct opset_t { - static void process_op (op_code_t op, interp_env_t& env) + static inline void process_op (op_code_t op, interp_env_t& env) { switch (op) { case OpCode_shortint: @@ -713,9 +712,9 @@ struct opset_t template struct interpreter_t { - ~interpreter_t() { fini (); } + inline ~interpreter_t() { fini (); } - void fini () { env.fini (); } + inline void fini () { env.fini (); } ENV env; }; diff --git a/src/hb-cff-interp-cs-common.hh b/src/hb-cff-interp-cs-common.hh index 241c1ba96..40b571cfa 100644 --- a/src/hb-cff-interp-cs-common.hh +++ b/src/hb-cff-interp-cs-common.hh @@ -41,7 +41,7 @@ enum cs_type_t { struct call_context_t { - void init (const byte_str_ref_t substr_=byte_str_ref_t (), cs_type_t type_=CSType_CharString, unsigned int subr_num_=0) + inline void init (const byte_str_ref_t substr_=byte_str_ref_t (), cs_type_t type_=CSType_CharString, unsigned int subr_num_=0) { str_ref = substr_; type = type_; @@ -62,7 +62,7 @@ struct call_stack_t : stack_t {}; template struct biased_subrs_t { - void init (const SUBRS &subrs_) + inline void init (const SUBRS &subrs_) { subrs = &subrs_; unsigned int nSubrs = get_count (); @@ -74,12 +74,12 @@ struct biased_subrs_t bias = 32768; } - void fini () {} + inline void fini () {} - unsigned int get_count () const { return (subrs == nullptr)? 0: subrs->count; } - unsigned int get_bias () const { return bias; } + inline unsigned int get_count () const { return (subrs == nullptr)? 0: subrs->count; } + inline unsigned int get_bias () const { return bias; } - byte_str_t operator [] (unsigned int index) const + inline byte_str_t operator [] (unsigned int index) const { if (unlikely ((subrs == nullptr) || index >= subrs->count)) return Null(byte_str_t); @@ -94,22 +94,22 @@ struct biased_subrs_t struct point_t { - void init () + inline void init () { x.init (); y.init (); } - void set_int (int _x, int _y) + inline void set_int (int _x, int _y) { x.set_int (_x); y.set_int (_y); } - void move_x (const number_t &dx) { x += dx; } - void move_y (const number_t &dy) { y += dy; } - void move (const number_t &dx, const number_t &dy) { move_x (dx); move_y (dy); } - void move (const point_t &d) { move_x (d.x); move_y (d.y); } + inline void move_x (const number_t &dx) { x += dx; } + inline void move_y (const number_t &dy) { y += dy; } + inline void move (const number_t &dx, const number_t &dy) { move_x (dx); move_y (dy); } + inline void move (const point_t &d) { move_x (d.x); move_y (d.y); } number_t x; number_t y; @@ -118,7 +118,7 @@ struct point_t template struct cs_interp_env_t : interp_env_t { - void init (const byte_str_t &str, const SUBRS &globalSubrs_, const SUBRS &localSubrs_) + inline void init (const byte_str_t &str, const SUBRS &globalSubrs_, const SUBRS &localSubrs_) { interp_env_t::init (str); @@ -132,7 +132,7 @@ struct cs_interp_env_t : interp_env_t globalSubrs.init (globalSubrs_); localSubrs.init (localSubrs_); } - void fini () + inline void fini () { interp_env_t::fini (); @@ -141,12 +141,12 @@ struct cs_interp_env_t : interp_env_t localSubrs.fini (); } - bool in_error () const + inline bool in_error () const { return callStack.in_error () || SUPER::in_error (); } - bool popSubrNum (const biased_subrs_t& biasedSubrs, unsigned int &subr_num) + inline bool popSubrNum (const biased_subrs_t& biasedSubrs, unsigned int &subr_num) { int n = SUPER::argStack.pop_int (); n += biasedSubrs.get_bias (); @@ -157,7 +157,7 @@ struct cs_interp_env_t : interp_env_t return true; } - void callSubr (const biased_subrs_t& biasedSubrs, cs_type_t type) + inline void callSubr (const biased_subrs_t& biasedSubrs, cs_type_t type) { unsigned int subr_num; @@ -174,7 +174,7 @@ struct cs_interp_env_t : interp_env_t SUPER::str_ref = context.str_ref; } - void returnFromSubr () + inline void returnFromSubr () { if (unlikely (SUPER::str_ref.in_error ())) SUPER::set_error (); @@ -182,7 +182,7 @@ struct cs_interp_env_t : interp_env_t SUPER::str_ref = context.str_ref; } - void determine_hintmask_size () + inline void determine_hintmask_size () { if (!seen_hintmask) { @@ -192,14 +192,14 @@ struct cs_interp_env_t : interp_env_t } } - void set_endchar (bool endchar_flag_) { endchar_flag = endchar_flag_; } - bool is_endchar () const { return endchar_flag; } + inline void set_endchar (bool endchar_flag_) { endchar_flag = endchar_flag_; } + inline bool is_endchar () const { return endchar_flag; } - const number_t &get_x () const { return pt.x; } - const number_t &get_y () const { return pt.y; } - const point_t &get_pt () const { return pt; } + inline const number_t &get_x () const { return pt.x; } + inline const number_t &get_y () const { return pt.y; } + inline const point_t &get_pt () const { return pt; } - void moveto (const point_t &pt_ ) { pt = pt_; } + inline void moveto (const point_t &pt_ ) { pt = pt_; } public: call_context_t context; @@ -210,7 +210,7 @@ struct cs_interp_env_t : interp_env_t unsigned int hstem_count; unsigned int vstem_count; unsigned int hintmask_size; - call_stack_t callStack; + call_stack_t callStack; biased_subrs_t globalSubrs; biased_subrs_t localSubrs; @@ -223,32 +223,32 @@ struct cs_interp_env_t : interp_env_t template struct path_procs_null_t { - static void rmoveto (ENV &env, PARAM& param) {} - static void hmoveto (ENV &env, PARAM& param) {} - static void vmoveto (ENV &env, PARAM& param) {} - static void rlineto (ENV &env, PARAM& param) {} - static void hlineto (ENV &env, PARAM& param) {} - static void vlineto (ENV &env, PARAM& param) {} - static void rrcurveto (ENV &env, PARAM& param) {} - static void rcurveline (ENV &env, PARAM& param) {} - static void rlinecurve (ENV &env, PARAM& param) {} - static void vvcurveto (ENV &env, PARAM& param) {} - static void hhcurveto (ENV &env, PARAM& param) {} - static void vhcurveto (ENV &env, PARAM& param) {} - static void hvcurveto (ENV &env, PARAM& param) {} - static void moveto (ENV &env, PARAM& param, const point_t &pt) {} - static void line (ENV &env, PARAM& param, const point_t &pt1) {} - static void curve (ENV &env, PARAM& param, const point_t &pt1, const point_t &pt2, const point_t &pt3) {} - static void hflex (ENV &env, PARAM& param) {} - static void flex (ENV &env, PARAM& param) {} - static void hflex1 (ENV &env, PARAM& param) {} - static void flex1 (ENV &env, PARAM& param) {} + static inline void rmoveto (ENV &env, PARAM& param) {} + static inline void hmoveto (ENV &env, PARAM& param) {} + static inline void vmoveto (ENV &env, PARAM& param) {} + static inline void rlineto (ENV &env, PARAM& param) {} + static inline void hlineto (ENV &env, PARAM& param) {} + static inline void vlineto (ENV &env, PARAM& param) {} + static inline void rrcurveto (ENV &env, PARAM& param) {} + static inline void rcurveline (ENV &env, PARAM& param) {} + static inline void rlinecurve (ENV &env, PARAM& param) {} + static inline void vvcurveto (ENV &env, PARAM& param) {} + static inline void hhcurveto (ENV &env, PARAM& param) {} + static inline void vhcurveto (ENV &env, PARAM& param) {} + static inline void hvcurveto (ENV &env, PARAM& param) {} + static inline void moveto (ENV &env, PARAM& param, const point_t &pt) {} + static inline void line (ENV &env, PARAM& param, const point_t &pt1) {} + static inline void curve (ENV &env, PARAM& param, const point_t &pt1, const point_t &pt2, const point_t &pt3) {} + static inline void hflex (ENV &env, PARAM& param) {} + static inline void flex (ENV &env, PARAM& param) {} + static inline void hflex1 (ENV &env, PARAM& param) {} + static inline void flex1 (ENV &env, PARAM& param) {} }; template > struct cs_opset_t : opset_t { - static void process_op (op_code_t op, ENV &env, PARAM& param) + static inline void process_op (op_code_t op, ENV &env, PARAM& param) { switch (op) { @@ -370,19 +370,19 @@ struct cs_opset_t : opset_t } } - static void process_hstem (op_code_t op, ENV &env, PARAM& param) + static inline void process_hstem (op_code_t op, ENV &env, PARAM& param) { env.hstem_count += env.argStack.get_count () / 2; OPSET::flush_args_and_op (op, env, param); } - static void process_vstem (op_code_t op, ENV &env, PARAM& param) + static inline void process_vstem (op_code_t op, ENV &env, PARAM& param) { env.vstem_count += env.argStack.get_count () / 2; OPSET::flush_args_and_op (op, env, param); } - static void process_hintmask (op_code_t op, ENV &env, PARAM& param) + static inline void process_hintmask (op_code_t op, ENV &env, PARAM& param) { env.determine_hintmask_size (); if (likely (env.str_ref.avail (env.hintmask_size))) @@ -392,15 +392,15 @@ struct cs_opset_t : opset_t } } - static void process_post_flex (op_code_t op, ENV &env, PARAM& param) + static inline void process_post_flex (op_code_t op, ENV &env, PARAM& param) { OPSET::flush_args_and_op (op, env, param); } - static void check_width (op_code_t op, ENV &env, PARAM& param) + static inline void check_width (op_code_t op, ENV &env, PARAM& param) {} - static void process_post_move (op_code_t op, ENV &env, PARAM& param) + static inline void process_post_move (op_code_t op, ENV &env, PARAM& param) { if (!env.seen_moveto) { @@ -410,27 +410,27 @@ struct cs_opset_t : opset_t OPSET::flush_args_and_op (op, env, param); } - static void process_post_path (op_code_t op, ENV &env, PARAM& param) + static inline void process_post_path (op_code_t op, ENV &env, PARAM& param) { OPSET::flush_args_and_op (op, env, param); } - static void flush_args_and_op (op_code_t op, ENV &env, PARAM& param) + static inline void flush_args_and_op (op_code_t op, ENV &env, PARAM& param) { OPSET::flush_args (env, param); OPSET::flush_op (op, env, param); } - static void flush_args (ENV &env, PARAM& param) + static inline void flush_args (ENV &env, PARAM& param) { env.pop_n_args (env.argStack.get_count ()); } - static void flush_op (op_code_t op, ENV &env, PARAM& param) + static inline void flush_op (op_code_t op, ENV &env, PARAM& param) { } - static void flush_hintmask (op_code_t op, ENV &env, PARAM& param) + static inline void flush_hintmask (op_code_t op, ENV &env, PARAM& param) { OPSET::flush_args_and_op (op, env, param); } @@ -460,7 +460,7 @@ struct cs_opset_t : opset_t template struct path_procs_t { - static void rmoveto (ENV &env, PARAM& param) + static inline void rmoveto (ENV &env, PARAM& param) { point_t pt1 = env.get_pt (); const number_t &dy = env.pop_arg (); @@ -469,21 +469,21 @@ struct path_procs_t PATH::moveto (env, param, pt1); } - static void hmoveto (ENV &env, PARAM& param) + static inline void hmoveto (ENV &env, PARAM& param) { point_t pt1 = env.get_pt (); pt1.move_x (env.pop_arg ()); PATH::moveto (env, param, pt1); } - static void vmoveto (ENV &env, PARAM& param) + static inline void vmoveto (ENV &env, PARAM& param) { point_t pt1 = env.get_pt (); pt1.move_y (env.pop_arg ()); PATH::moveto (env, param, pt1); } - static void rlineto (ENV &env, PARAM& param) + static inline void rlineto (ENV &env, PARAM& param) { for (unsigned int i = 0; i + 2 <= env.argStack.get_count (); i += 2) { @@ -493,7 +493,7 @@ struct path_procs_t } } - static void hlineto (ENV &env, PARAM& param) + static inline void hlineto (ENV &env, PARAM& param) { point_t pt1; unsigned int i = 0; @@ -513,7 +513,7 @@ struct path_procs_t } } - static void vlineto (ENV &env, PARAM& param) + static inline void vlineto (ENV &env, PARAM& param) { point_t pt1; unsigned int i = 0; @@ -533,7 +533,7 @@ struct path_procs_t } } - static void rrcurveto (ENV &env, PARAM& param) + static inline void rrcurveto (ENV &env, PARAM& param) { for (unsigned int i = 0; i + 6 <= env.argStack.get_count (); i += 6) { @@ -547,7 +547,7 @@ struct path_procs_t } } - static void rcurveline (ENV &env, PARAM& param) + static inline void rcurveline (ENV &env, PARAM& param) { unsigned int i = 0; for (; i + 6 <= env.argStack.get_count (); i += 6) @@ -568,7 +568,7 @@ struct path_procs_t } } - static void rlinecurve (ENV &env, PARAM& param) + static inline void rlinecurve (ENV &env, PARAM& param) { unsigned int i = 0; unsigned int line_limit = (env.argStack.get_count () % 6); @@ -590,7 +590,7 @@ struct path_procs_t } } - static void vvcurveto (ENV &env, PARAM& param) + static inline void vvcurveto (ENV &env, PARAM& param) { unsigned int i = 0; point_t pt1 = env.get_pt (); @@ -608,7 +608,7 @@ struct path_procs_t } } - static void hhcurveto (ENV &env, PARAM& param) + static inline void hhcurveto (ENV &env, PARAM& param) { unsigned int i = 0; point_t pt1 = env.get_pt (); @@ -626,7 +626,7 @@ struct path_procs_t } } - static void vhcurveto (ENV &env, PARAM& param) + static inline void vhcurveto (ENV &env, PARAM& param) { point_t pt1, pt2, pt3; unsigned int i = 0; @@ -687,7 +687,7 @@ struct path_procs_t } } - static void hvcurveto (ENV &env, PARAM& param) + static inline void hvcurveto (ENV &env, PARAM& param) { point_t pt1, pt2, pt3; unsigned int i = 0; @@ -749,16 +749,16 @@ struct path_procs_t } /* default actions to be overridden */ - static void moveto (ENV &env, PARAM& param, const point_t &pt) + static inline void moveto (ENV &env, PARAM& param, const point_t &pt) { env.moveto (pt); } - static void line (ENV &env, PARAM& param, const point_t &pt1) + static inline void line (ENV &env, PARAM& param, const point_t &pt1) { PATH::moveto (env, param, pt1); } - static void curve (ENV &env, PARAM& param, const point_t &pt1, const point_t &pt2, const point_t &pt3) + static inline void curve (ENV &env, PARAM& param, const point_t &pt1, const point_t &pt2, const point_t &pt3) { PATH::moveto (env, param, pt3); } - static void hflex (ENV &env, PARAM& param) + static inline void hflex (ENV &env, PARAM& param) { if (likely (env.argStack.get_count () == 7)) { @@ -782,7 +782,7 @@ struct path_procs_t env.set_error (); } - static void flex (ENV &env, PARAM& param) + static inline void flex (ENV &env, PARAM& param) { if (likely (env.argStack.get_count () == 13)) { @@ -805,7 +805,7 @@ struct path_procs_t env.set_error (); } - static void hflex1 (ENV &env, PARAM& param) + static inline void hflex1 (ENV &env, PARAM& param) { if (likely (env.argStack.get_count () == 9)) { @@ -829,7 +829,7 @@ struct path_procs_t env.set_error (); } - static void flex1 (ENV &env, PARAM& param) + static inline void flex1 (ENV &env, PARAM& param) { if (likely (env.argStack.get_count () == 11)) { @@ -868,7 +868,7 @@ struct path_procs_t } protected: - static void curve2 (ENV &env, PARAM& param, + static inline void curve2 (ENV &env, PARAM& param, const point_t &pt1, const point_t &pt2, const point_t &pt3, const point_t &pt4, const point_t &pt5, const point_t &pt6) { @@ -880,7 +880,7 @@ struct path_procs_t template struct cs_interpreter_t : interpreter_t { - bool interpret (PARAM& param) + inline bool interpret (PARAM& param) { SUPER::env.set_endchar (false); @@ -902,3 +902,4 @@ struct cs_interpreter_t : interpreter_t } /* namespace CFF */ #endif /* HB_CFF_INTERP_CS_COMMON_HH */ + diff --git a/src/hb-cff-interp-dict-common.hh b/src/hb-cff-interp-dict-common.hh index 9224bf556..794ab99e1 100644 --- a/src/hb-cff-interp-dict-common.hh +++ b/src/hb-cff-interp-dict-common.hh @@ -37,8 +37,8 @@ using namespace OT; /* an opstr and the parsed out dict value(s) */ struct dict_val_t : op_str_t { - void init () { single_val.set_int (0); } - void fini () {} + inline void init () { single_val.set_int (0); } + inline void fini () {} number_t single_val; }; @@ -50,15 +50,15 @@ template struct dict_values_t : parsed_values_t {}; template struct top_dict_values_t : dict_values_t { - void init () + inline void init () { dict_values_t::init (); charStringsOffset = 0; FDArrayOffset = 0; } - void fini () { dict_values_t::fini (); } + inline void fini () { dict_values_t::fini (); } - unsigned int calculate_serialized_op_size (const OPSTR& opstr) const + inline unsigned int calculate_serialized_op_size (const OPSTR& opstr) const { switch (opstr.op) { @@ -77,7 +77,7 @@ struct top_dict_values_t : dict_values_t struct dict_opset_t : opset_t { - static void process_op (op_code_t op, interp_env_t& env) + static inline void process_op (op_code_t op, interp_env_t& env) { switch (op) { case OpCode_longintdict: /* 5-byte integer */ @@ -96,19 +96,19 @@ struct dict_opset_t : opset_t static double parse_bcd (byte_str_ref_t& str_ref) { - bool neg = false; - double int_part = 0; - uint64_t frac_part = 0; - uint32_t frac_count = 0; - bool exp_neg = false; - uint32_t exp_part = 0; - bool exp_overflow = false; + bool neg = false; + double int_part = 0; + uint64_t frac_part = 0; + uint32_t frac_count = 0; + bool exp_neg = false; + uint32_t exp_part = 0; + bool exp_overflow = false; enum Part { INT_PART=0, FRAC_PART, EXP_PART } part = INT_PART; enum Nibble { DECIMAL=10, EXP_POS, EXP_NEG, RESERVED, NEG, END }; const uint64_t MAX_FRACT = 0xFFFFFFFFFFFFFull; /* 1^52-1 */ const uint32_t MAX_EXP = 0x7FFu; /* 1^11-1 */ - double value = 0.0; + double value = 0.0; unsigned char byte = 0; for (uint32_t i = 0;; i++) { @@ -220,7 +220,7 @@ struct dict_opset_t : opset_t return value; } - static bool is_hint_op (op_code_t op) + static inline bool is_hint_op (op_code_t op) { switch (op) { @@ -248,7 +248,7 @@ struct dict_opset_t : opset_t template struct top_dict_opset_t : dict_opset_t { - static void process_op (op_code_t op, interp_env_t& env, top_dict_values_t & dictval) + static inline void process_op (op_code_t op, interp_env_t& env, top_dict_values_t & dictval) { switch (op) { case OpCode_CharStrings: @@ -272,7 +272,7 @@ struct top_dict_opset_t : dict_opset_t template struct dict_interpreter_t : interpreter_t { - bool interpret (PARAM& param) + inline bool interpret (PARAM& param) { param.init (); while (SUPER::env.str_ref.avail ()) diff --git a/src/hb-cff1-interp-cs.hh b/src/hb-cff1-interp-cs.hh index c7209ed80..e7b1c95c4 100644 --- a/src/hb-cff1-interp-cs.hh +++ b/src/hb-cff1-interp-cs.hh @@ -38,7 +38,7 @@ typedef biased_subrs_t cff1_biased_subrs_t; struct cff1_cs_interp_env_t : cs_interp_env_t { template - void init (const byte_str_t &str, ACC &acc, unsigned int fd) + inline void init (const byte_str_t &str, ACC &acc, unsigned int fd) { SUPER::init (str, *acc.globalSubrs, *acc.privateDicts[fd].localSubrs); processed_width = false; @@ -47,9 +47,9 @@ struct cff1_cs_interp_env_t : cs_interp_env_t in_seac = false; } - void fini () { SUPER::fini (); } + inline void fini () { SUPER::fini (); } - void set_width (bool has_width_) + inline void set_width (bool has_width_) { if (likely (!processed_width && (SUPER::argStack.get_count () > 0))) { @@ -63,13 +63,13 @@ struct cff1_cs_interp_env_t : cs_interp_env_t processed_width = true; } - void clear_args () + inline void clear_args () { arg_start = 0; SUPER::clear_args (); } - void set_in_seac (bool _in_seac) { in_seac = _in_seac; } + inline void set_in_seac (bool _in_seac) { in_seac = _in_seac; } bool processed_width; bool has_width; @@ -87,7 +87,7 @@ struct cff1_cs_opset_t : cs_opset_t blends_) { numValues = numValues_; @@ -61,8 +61,8 @@ struct blend_arg_t : number_t deltas[i] = blends_[i]; } - bool blending () const { return deltas.len > 0; } - void reset_blends () + inline bool blending () const { return deltas.len > 0; } + inline void reset_blends () { numValues = valueIndex = 0; deltas.resize (0); @@ -79,7 +79,7 @@ typedef biased_subrs_t cff2_biased_subrs_t; struct cff2_cs_interp_env_t : cs_interp_env_t { template - void init (const byte_str_t &str, ACC &acc, unsigned int fd, + inline void init (const byte_str_t &str, ACC &acc, unsigned int fd, const int *coords_=nullptr, unsigned int num_coords_=0) { SUPER::init (str, *acc.globalSubrs, *acc.privateDicts[fd].localSubrs); @@ -90,17 +90,17 @@ struct cff2_cs_interp_env_t : cs_interp_env_t seen_blend = false; seen_vsindex_ = false; scalars.init (); - do_blend = (coords != nullptr) && num_coords && (varStore != &Null(CFF2VariationStore)); + do_blend = (coords != nullptr) && num_coords && (varStore != &Null(cff2_variation_store_t)); set_ivs (acc.privateDicts[fd].ivs); } - void fini () + inline void fini () { scalars.fini (); SUPER::fini (); } - op_code_t fetch_op () + inline op_code_t fetch_op () { if (this->str_ref.avail ()) return SUPER::fetch_op (); @@ -112,21 +112,21 @@ struct cff2_cs_interp_env_t : cs_interp_env_t return OpCode_return; } - const blend_arg_t& eval_arg (unsigned int i) + inline const blend_arg_t& eval_arg (unsigned int i) { blend_arg_t &arg = argStack[i]; blend_arg (arg); return arg; } - const blend_arg_t& pop_arg () + inline const blend_arg_t& pop_arg () { blend_arg_t &arg = argStack.pop (); blend_arg (arg); return arg; } - void process_blend () + inline void process_blend () { if (!seen_blend) { @@ -142,7 +142,7 @@ struct cff2_cs_interp_env_t : cs_interp_env_t } } - void process_vsindex () + inline void process_vsindex () { unsigned int index = argStack.pop_uint (); if (unlikely (seen_vsindex () || seen_blend)) @@ -156,14 +156,14 @@ struct cff2_cs_interp_env_t : cs_interp_env_t seen_vsindex_ = true; } - unsigned int get_region_count () const { return region_count; } - void set_region_count (unsigned int region_count_) { region_count = region_count_; } - unsigned int get_ivs () const { return ivs; } - void set_ivs (unsigned int ivs_) { ivs = ivs_; } - bool seen_vsindex () const { return seen_vsindex_; } + inline unsigned int get_region_count () const { return region_count; } + inline void set_region_count (unsigned int region_count_) { region_count = region_count_; } + inline unsigned int get_ivs () const { return ivs; } + inline void set_ivs (unsigned int ivs_) { ivs = ivs_; } + inline bool seen_vsindex () const { return seen_vsindex_; } protected: - void blend_arg (blend_arg_t &arg) + inline void blend_arg (blend_arg_t &arg) { if (do_blend && arg.blending ()) { @@ -183,7 +183,7 @@ struct cff2_cs_interp_env_t : cs_interp_env_t protected: const int *coords; unsigned int num_coords; - const CFF2VariationStore *varStore; + const cff2_variation_store_t *varStore; unsigned int region_count; unsigned int ivs; hb_vector_t scalars; @@ -196,7 +196,7 @@ struct cff2_cs_interp_env_t : cs_interp_env_t template > struct cff2_cs_opset_t : cs_opset_t { - static void process_op (op_code_t op, cff2_cs_interp_env_t &env, PARAM& param) + static inline void process_op (op_code_t op, cff2_cs_interp_env_t &env, PARAM& param) { switch (op) { case OpCode_callsubr: @@ -228,7 +228,7 @@ struct cff2_cs_opset_t : cs_opset_t str_buff_t; struct str_buff_vec_t : hb_vector_t { - void fini () { SUPER::fini_deep (); } + inline void fini () { SUPER::fini_deep (); } - unsigned int total_size () const + inline unsigned int total_size () const { unsigned int size = 0; for (unsigned int i = 0; i < len; i++) @@ -82,7 +82,7 @@ struct str_buff_vec_t : hb_vector_t template struct CFFIndex { - bool sanitize (hb_sanitize_context_t *c) const + inline bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (likely ((count.sanitize (c) && count == 0) || /* empty INDEX */ @@ -91,13 +91,13 @@ struct CFFIndex c->check_array ((const HBUINT8*)data_base (), 1, max_offset () - 1)))); } - static unsigned int calculate_offset_array_size (unsigned int offSize, unsigned int count) + static inline unsigned int calculate_offset_array_size (unsigned int offSize, unsigned int count) { return offSize * (count + 1); } - unsigned int offset_array_size () const + inline unsigned int offset_array_size () const { return calculate_offset_array_size (offSize, count); } - static unsigned int calculate_serialized_size (unsigned int offSize, unsigned int count, unsigned int dataSize) + static inline unsigned int calculate_serialized_size (unsigned int offSize, unsigned int count, unsigned int dataSize) { if (count == 0) return COUNT::static_size; @@ -105,7 +105,7 @@ struct CFFIndex return min_size + calculate_offset_array_size (offSize, count) + dataSize; } - bool serialize (hb_serialize_context_t *c, const CFFIndex &src) + inline bool serialize (hb_serialize_context_t *c, const CFFIndex &src) { TRACE_SERIALIZE (this); unsigned int size = src.get_size (); @@ -115,9 +115,9 @@ struct CFFIndex return_trace (true); } - bool serialize (hb_serialize_context_t *c, - unsigned int offSize_, - const byte_str_array_t &byteArray) + inline bool serialize (hb_serialize_context_t *c, + unsigned int offSize_, + const byte_str_array_t &byteArray) { TRACE_SERIALIZE (this); if (byteArray.len == 0) @@ -158,9 +158,9 @@ struct CFFIndex return_trace (true); } - bool serialize (hb_serialize_context_t *c, - unsigned int offSize_, - const str_buff_vec_t &buffArray) + inline bool serialize (hb_serialize_context_t *c, + unsigned int offSize_, + const str_buff_vec_t &buffArray) { byte_str_array_t byteArray; byteArray.init (); @@ -174,7 +174,7 @@ struct CFFIndex return result; } - void set_offset_at (unsigned int index, unsigned int offset) + inline void set_offset_at (unsigned int index, unsigned int offset) { HBUINT8 *p = offsets + offSize * index + offSize; unsigned int size = offSize; @@ -186,7 +186,7 @@ struct CFFIndex } } - unsigned int offset_at (unsigned int index) const + inline unsigned int offset_at (unsigned int index) const { assert (index <= count); const HBUINT8 *p = offsets + offSize * index; @@ -197,7 +197,7 @@ struct CFFIndex return offset; } - unsigned int length_at (unsigned int index) const + inline unsigned int length_at (unsigned int index) const { if (likely ((offset_at (index + 1) >= offset_at (index)) && (offset_at (index + 1) <= offset_at (count)))) @@ -206,12 +206,12 @@ struct CFFIndex return 0; } - const unsigned char *data_base () const + inline const unsigned char *data_base () const { return (const unsigned char *)this + min_size + offset_array_size (); } unsigned int data_size () const { return HBINT8::static_size; } - byte_str_t operator [] (unsigned int index) const + inline byte_str_t operator [] (unsigned int index) const { if (likely (index < count)) return byte_str_t (data_base () + offset_at (index) - 1, length_at (index)); @@ -219,7 +219,7 @@ struct CFFIndex return Null(byte_str_t); } - unsigned int get_size () const + inline unsigned int get_size () const { if (this != &Null(CFFIndex)) { @@ -233,7 +233,7 @@ struct CFFIndex } protected: - unsigned int max_offset () const + inline unsigned int max_offset () const { unsigned int max = 0; for (unsigned int i = 0; i < count + 1u; i++) @@ -256,7 +256,7 @@ struct CFFIndex template struct CFFIndexOf : CFFIndex { - const byte_str_t operator [] (unsigned int index) const + inline const byte_str_t operator [] (unsigned int index) const { if (likely (index < CFFIndex::count)) return byte_str_t (CFFIndex::data_base () + CFFIndex::offset_at (index) - 1, CFFIndex::length_at (index)); @@ -264,13 +264,13 @@ struct CFFIndexOf : CFFIndex } template - bool serialize (hb_serialize_context_t *c, - unsigned int offSize_, - const DATA *dataArray, - unsigned int dataArrayLen, - const hb_vector_t &dataSizeArray, - const PARAM1 ¶m1, - const PARAM2 ¶m2) + inline bool serialize (hb_serialize_context_t *c, + unsigned int offSize_, + const DATA *dataArray, + unsigned int dataArrayLen, + const hb_vector_t &dataSizeArray, + const PARAM1 ¶m1, + const PARAM2 ¶m2) { TRACE_SERIALIZE (this); /* serialize CFFIndex header */ @@ -303,11 +303,11 @@ struct CFFIndexOf : CFFIndex /* in parallel to above */ template - static unsigned int calculate_serialized_size (unsigned int &offSize_ /* OUT */, - const DATA *dataArray, - unsigned int dataArrayLen, - hb_vector_t &dataSizeArray, /* OUT */ - const PARAM ¶m) + static inline unsigned int calculate_serialized_size (unsigned int &offSize_ /* OUT */, + const DATA *dataArray, + unsigned int dataArrayLen, + hb_vector_t &dataSizeArray, /* OUT */ + const PARAM ¶m) { /* determine offset size */ unsigned int totalDataSize = 0; @@ -327,10 +327,10 @@ struct CFFIndexOf : CFFIndex struct Dict : UnsizedByteStr { template - bool serialize (hb_serialize_context_t *c, - const DICTVAL &dictval, - OP_SERIALIZER& opszr, - PARAM& param) + inline bool serialize (hb_serialize_context_t *c, + const DICTVAL &dictval, + OP_SERIALIZER& opszr, + PARAM& param) { TRACE_SERIALIZE (this); for (unsigned int i = 0; i < dictval.get_count (); i++) @@ -343,9 +343,9 @@ struct Dict : UnsizedByteStr /* in parallel to above */ template - static unsigned int calculate_serialized_size (const DICTVAL &dictval, - OP_SERIALIZER& opszr, - PARAM& param) + static inline unsigned int calculate_serialized_size (const DICTVAL &dictval, + OP_SERIALIZER& opszr, + PARAM& param) { unsigned int size = 0; for (unsigned int i = 0; i < dictval.get_count (); i++) @@ -354,8 +354,8 @@ struct Dict : UnsizedByteStr } template - static unsigned int calculate_serialized_size (const DICTVAL &dictval, - OP_SERIALIZER& opszr) + static inline unsigned int calculate_serialized_size (const DICTVAL &dictval, + OP_SERIALIZER& opszr) { unsigned int size = 0; for (unsigned int i = 0; i < dictval.get_count (); i++) @@ -364,7 +364,7 @@ struct Dict : UnsizedByteStr } template - static bool serialize_int_op (hb_serialize_context_t *c, op_code_t op, int value, op_code_t intOp) + static inline bool serialize_int_op (hb_serialize_context_t *c, op_code_t op, int value, op_code_t intOp) { // XXX: not sure why but LLVM fails to compile the following 'unlikely' macro invocation if (/*unlikely*/ (!serialize_int (c, intOp, value))) @@ -384,18 +384,18 @@ struct Dict : UnsizedByteStr return_trace (true); } - static bool serialize_uint4_op (hb_serialize_context_t *c, op_code_t op, int value) + static inline bool serialize_uint4_op (hb_serialize_context_t *c, op_code_t op, int value) { return serialize_int_op (c, op, value, OpCode_longintdict); } - static bool serialize_uint2_op (hb_serialize_context_t *c, op_code_t op, int value) + static inline bool serialize_uint2_op (hb_serialize_context_t *c, op_code_t op, int value) { return serialize_int_op (c, op, value, OpCode_shortint); } - static bool serialize_offset4_op (hb_serialize_context_t *c, op_code_t op, int value) + static inline bool serialize_offset4_op (hb_serialize_context_t *c, op_code_t op, int value) { return serialize_uint4_op (c, op, value); } - static bool serialize_offset2_op (hb_serialize_context_t *c, op_code_t op, int value) + static inline bool serialize_offset2_op (hb_serialize_context_t *c, op_code_t op, int value) { return serialize_uint2_op (c, op, value); } @@ -407,7 +407,7 @@ struct PrivateDict : Dict {}; struct table_info_t { - void init () { offSize = offset = size = 0; } + inline void init () { offSize = offset = size = 0; } unsigned int offset; unsigned int size; @@ -418,11 +418,11 @@ struct table_info_t * set to CFF_UNDEF_CODE if excluded from subset */ struct remap_t : hb_vector_t { - void init () { SUPER::init (); } + inline void init () { SUPER::init (); } - void fini () { SUPER::fini (); } + inline void fini () { SUPER::fini (); } - bool reset (unsigned int size) + inline bool reset (unsigned int size) { if (unlikely (!SUPER::resize (size))) return false; @@ -432,7 +432,7 @@ struct remap_t : hb_vector_t return true; } - bool identity (unsigned int size) + inline bool identity (unsigned int size) { if (unlikely (!SUPER::resize (size))) return false; @@ -443,20 +443,20 @@ struct remap_t : hb_vector_t return true; } - bool excludes (hb_codepoint_t id) const + inline bool excludes (hb_codepoint_t id) const { return (id < len) && ((*this)[id] == CFF_UNDEF_CODE); } - bool includes (hb_codepoint_t id) const + inline bool includes (hb_codepoint_t id) const { return !excludes (id); } - unsigned int add (unsigned int i) + inline unsigned int add (unsigned int i) { if ((*this)[i] == CFF_UNDEF_CODE) (*this)[i] = count++; return (*this)[i]; } - hb_codepoint_t get_count () const { return count; } + inline hb_codepoint_t get_count () const { return count; } protected: hb_codepoint_t count; @@ -470,10 +470,10 @@ struct FDArray : CFFIndexOf { /* used by CFF1 */ template - bool serialize (hb_serialize_context_t *c, - unsigned int offSize_, - const hb_vector_t &fontDicts, - OP_SERIALIZER& opszr) + inline bool serialize (hb_serialize_context_t *c, + unsigned int offSize_, + const hb_vector_t &fontDicts, + OP_SERIALIZER& opszr) { TRACE_SERIALIZE (this); if (unlikely (!c->extend_min (*this))) return_trace (false); @@ -504,13 +504,13 @@ struct FDArray : CFFIndexOf /* used by CFF2 */ template - bool serialize (hb_serialize_context_t *c, - unsigned int offSize_, - const hb_vector_t &fontDicts, - unsigned int fdCount, - const remap_t &fdmap, - OP_SERIALIZER& opszr, - const hb_vector_t &privateInfos) + inline bool serialize (hb_serialize_context_t *c, + unsigned int offSize_, + const hb_vector_t &fontDicts, + unsigned int fdCount, + const remap_t &fdmap, + OP_SERIALIZER& opszr, + const hb_vector_t &privateInfos) { TRACE_SERIALIZE (this); if (unlikely (!c->extend_min (*this))) return_trace (false); @@ -543,11 +543,11 @@ struct FDArray : CFFIndexOf /* in parallel to above */ template - static unsigned int calculate_serialized_size (unsigned int &offSize_ /* OUT */, - const hb_vector_t &fontDicts, - unsigned int fdCount, - const remap_t &fdmap, - OP_SERIALIZER& opszr) + static inline unsigned int calculate_serialized_size (unsigned int &offSize_ /* OUT */, + const hb_vector_t &fontDicts, + unsigned int fdCount, + const remap_t &fdmap, + OP_SERIALIZER& opszr) { unsigned int dictsSize = 0; for (unsigned int i = 0; i < fontDicts.len; i++) @@ -561,7 +561,7 @@ struct FDArray : CFFIndexOf /* FDSelect */ struct FDSelect0 { - bool sanitize (hb_sanitize_context_t *c, unsigned int fdcount) const + inline bool sanitize (hb_sanitize_context_t *c, unsigned int fdcount) const { TRACE_SANITIZE (this); if (unlikely (!(c->check_struct (this)))) @@ -573,12 +573,12 @@ struct FDSelect0 { return_trace (true); } - hb_codepoint_t get_fd (hb_codepoint_t glyph) const + inline hb_codepoint_t get_fd (hb_codepoint_t glyph) const { return (hb_codepoint_t)fds[glyph]; } - unsigned int get_size (unsigned int num_glyphs) const + inline unsigned int get_size (unsigned int num_glyphs) const { return HBUINT8::static_size * num_glyphs; } HBUINT8 fds[VAR]; @@ -588,7 +588,7 @@ struct FDSelect0 { template struct FDSelect3_4_Range { - bool sanitize (hb_sanitize_context_t *c, unsigned int fdcount) const + inline bool sanitize (hb_sanitize_context_t *c, unsigned int fdcount) const { TRACE_SANITIZE (this); return_trace (likely (c->check_struct (this) && (first < c->get_num_glyphs ()) && (fd < fdcount))); @@ -602,10 +602,10 @@ struct FDSelect3_4_Range { template struct FDSelect3_4 { - unsigned int get_size () const + inline unsigned int get_size () const { return GID_TYPE::static_size * 2 + FDSelect3_4_Range::static_size * nRanges; } - bool sanitize (hb_sanitize_context_t *c, unsigned int fdcount) const + inline bool sanitize (hb_sanitize_context_t *c, unsigned int fdcount) const { TRACE_SANITIZE (this); if (unlikely (!(c->check_struct (this) && (nRanges > 0) && (ranges[0].first == 0)))) @@ -624,7 +624,7 @@ struct FDSelect3_4 { return_trace (true); } - hb_codepoint_t get_fd (hb_codepoint_t glyph) const + inline hb_codepoint_t get_fd (hb_codepoint_t glyph) const { unsigned int i; for (i = 1; i < nRanges; i++) @@ -634,8 +634,8 @@ struct FDSelect3_4 { return (hb_codepoint_t)ranges[i - 1].fd; } - GID_TYPE &sentinel () { return StructAfter (ranges[nRanges - 1]); } - const GID_TYPE &sentinel () const { return StructAfter (ranges[nRanges - 1]); } + inline GID_TYPE &sentinel () { return StructAfter (ranges[nRanges - 1]); } + inline const GID_TYPE &sentinel () const { return StructAfter (ranges[nRanges - 1]); } GID_TYPE nRanges; FDSelect3_4_Range ranges[VAR]; @@ -648,7 +648,7 @@ typedef FDSelect3_4 FDSelect3; typedef FDSelect3_4_Range FDSelect3_Range; struct FDSelect { - bool sanitize (hb_sanitize_context_t *c, unsigned int fdcount) const + inline bool sanitize (hb_sanitize_context_t *c, unsigned int fdcount) const { TRACE_SANITIZE (this); @@ -658,7 +658,7 @@ struct FDSelect { u.format3.sanitize (c, fdcount))); } - bool serialize (hb_serialize_context_t *c, const FDSelect &src, unsigned int num_glyphs) + inline bool serialize (hb_serialize_context_t *c, const FDSelect &src, unsigned int num_glyphs) { TRACE_SERIALIZE (this); unsigned int size = src.get_size (num_glyphs); @@ -668,10 +668,10 @@ struct FDSelect { return_trace (true); } - unsigned int calculate_serialized_size (unsigned int num_glyphs) const + inline unsigned int calculate_serialized_size (unsigned int num_glyphs) const { return get_size (num_glyphs); } - unsigned int get_size (unsigned int num_glyphs) const + inline unsigned int get_size (unsigned int num_glyphs) const { unsigned int size = format.static_size; if (format == 0) @@ -681,7 +681,7 @@ struct FDSelect { return size; } - hb_codepoint_t get_fd (hb_codepoint_t glyph) const + inline hb_codepoint_t get_fd (hb_codepoint_t glyph) const { if (this == &Null(FDSelect)) return 0; diff --git a/src/hb-ot-cff1-table.cc b/src/hb-ot-cff1-table.cc index 8773c05a2..fc0d2606b 100644 --- a/src/hb-ot-cff1-table.cc +++ b/src/hb-ot-cff1-table.cc @@ -163,13 +163,13 @@ hb_codepoint_t OT::cff1::lookup_standard_encoding_for_sid (hb_codepoint_t code) struct bounds_t { - void init () + inline void init () { min.set_int (0x7FFFFFFF, 0x7FFFFFFF); max.set_int (-0x80000000, -0x80000000); } - void update (const point_t &pt) + inline void update (const point_t &pt) { if (pt.x < min.x) min.x = pt.x; if (pt.x > max.x) max.x = pt.x; @@ -177,7 +177,7 @@ struct bounds_t if (pt.y > max.y) max.y = pt.y; } - void merge (const bounds_t &b) + inline void merge (const bounds_t &b) { if (empty ()) *this = b; @@ -190,7 +190,7 @@ struct bounds_t } } - void offset (const point_t &delta) + inline void offset (const point_t &delta) { if (!empty ()) { @@ -199,7 +199,7 @@ struct bounds_t } } - bool empty () const + inline bool empty () const { return (min.x >= max.x) || (min.y >= max.y); } point_t min; @@ -208,32 +208,32 @@ struct bounds_t struct extents_param_t { - void init (const OT::cff1::accelerator_t *_cff) + inline void init (const OT::cff1::accelerator_t *_cff) { path_open = false; cff = _cff; bounds.init (); } - void start_path () { path_open = true; } - void end_path () { path_open = false; } - bool is_path_open () const { return path_open; } + inline void start_path () { path_open = true; } + inline void end_path () { path_open = false; } + inline bool is_path_open () const { return path_open; } - bool path_open; - bounds_t bounds; + bool path_open; + bounds_t bounds; const OT::cff1::accelerator_t *cff; }; struct cff1_path_procs_extents_t : path_procs_t { - static void moveto (cff1_cs_interp_env_t &env, extents_param_t& param, const point_t &pt) + static inline void moveto (cff1_cs_interp_env_t &env, extents_param_t& param, const point_t &pt) { param.end_path (); env.moveto (pt); } - static void line (cff1_cs_interp_env_t &env, extents_param_t& param, const point_t &pt1) + static inline void line (cff1_cs_interp_env_t &env, extents_param_t& param, const point_t &pt1) { if (!param.is_path_open ()) { @@ -244,7 +244,7 @@ struct cff1_path_procs_extents_t : path_procs_t { - static void process_seac (cff1_cs_interp_env_t &env, extents_param_t& param) + static inline void process_seac (cff1_cs_interp_env_t &env, extents_param_t& param) { unsigned int n = env.argStack.get_count (); point_t delta; @@ -286,7 +286,7 @@ struct cff1_cs_opset_extents_t : cff1_cs_opset_tis_valid () || (glyph >= cff->num_glyphs))) return false; @@ -336,14 +336,14 @@ bool OT::cff1::accelerator_t::get_extents (hb_codepoint_t glyph, hb_glyph_extent struct get_seac_param_t { - void init (const OT::cff1::accelerator_t *_cff) + inline void init (const OT::cff1::accelerator_t *_cff) { cff = _cff; base = 0; accent = 0; } - bool has_seac () const { return base && accent; } + inline bool has_seac () const { return base && accent; } const OT::cff1::accelerator_t *cff; hb_codepoint_t base; @@ -352,7 +352,7 @@ struct get_seac_param_t struct cff1_cs_opset_seac_t : cff1_cs_opset_t { - static void process_seac (cff1_cs_interp_env_t &env, get_seac_param_t& param) + static inline void process_seac (cff1_cs_interp_env_t &env, get_seac_param_t& param) { unsigned int n = env.argStack.get_count (); hb_codepoint_t base_char = (hb_codepoint_t)env.argStack[n-2].to_int (); diff --git a/src/hb-ot-cff1-table.hh b/src/hb-ot-cff1-table.hh index 3594a94c2..f44752b02 100644 --- a/src/hb-ot-cff1-table.hh +++ b/src/hb-ot-cff1-table.hh @@ -56,13 +56,13 @@ struct CFF1FDSelect : FDSelect {}; /* Encoding */ struct Encoding0 { - bool sanitize (hb_sanitize_context_t *c) const + inline bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (c->check_struct (this) && codes[nCodes - 1].sanitize (c)); } - hb_codepoint_t get_code (hb_codepoint_t glyph) const + inline hb_codepoint_t get_code (hb_codepoint_t glyph) const { assert (glyph > 0); glyph--; @@ -74,7 +74,7 @@ struct Encoding0 { return CFF_UNDEF_CODE; } - unsigned int get_size () const + inline unsigned int get_size () const { return HBUINT8::static_size * (nCodes + 1); } HBUINT8 nCodes; @@ -84,7 +84,7 @@ struct Encoding0 { }; struct Encoding1_Range { - bool sanitize (hb_sanitize_context_t *c) const + inline bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (c->check_struct (this)); @@ -97,16 +97,16 @@ struct Encoding1_Range { }; struct Encoding1 { - unsigned int get_size () const + inline unsigned int get_size () const { return HBUINT8::static_size + Encoding1_Range::static_size * nRanges; } - bool sanitize (hb_sanitize_context_t *c) const + inline bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (c->check_struct (this) && ((nRanges == 0) || (ranges[nRanges - 1]).sanitize (c))); } - hb_codepoint_t get_code (hb_codepoint_t glyph) const + inline hb_codepoint_t get_code (hb_codepoint_t glyph) const { assert (glyph > 0); glyph--; @@ -128,7 +128,7 @@ struct Encoding1 { }; struct SuppEncoding { - bool sanitize (hb_sanitize_context_t *c) const + inline bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (c->check_struct (this)); @@ -141,20 +141,20 @@ struct SuppEncoding { }; struct CFF1SuppEncData { - bool sanitize (hb_sanitize_context_t *c) const + inline bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (c->check_struct (this) && ((nSups == 0) || (supps[nSups - 1]).sanitize (c))); } - void get_codes (hb_codepoint_t sid, hb_vector_t &codes) const + inline void get_codes (hb_codepoint_t sid, hb_vector_t &codes) const { for (unsigned int i = 0; i < nSups; i++) if (sid == supps[i].glyph) codes.push (supps[i].code); } - unsigned int get_size () const + inline unsigned int get_size () const { return HBUINT8::static_size + SuppEncoding::static_size * nSups; } HBUINT8 nSups; @@ -164,7 +164,7 @@ struct CFF1SuppEncData { }; struct Encoding { - bool sanitize (hb_sanitize_context_t *c) const + inline bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); @@ -179,7 +179,7 @@ struct Encoding { } /* serialize a fullset Encoding */ - bool serialize (hb_serialize_context_t *c, const Encoding &src) + inline bool serialize (hb_serialize_context_t *c, const Encoding &src) { TRACE_SERIALIZE (this); unsigned int size = src.get_size (); @@ -190,11 +190,11 @@ struct Encoding { } /* serialize a subset Encoding */ - bool serialize (hb_serialize_context_t *c, - uint8_t format, - unsigned int enc_count, - const hb_vector_t& code_ranges, - const hb_vector_t& supp_codes) + inline bool serialize (hb_serialize_context_t *c, + uint8_t format, + unsigned int enc_count, + const hb_vector_t& code_ranges, + const hb_vector_t& supp_codes) { TRACE_SERIALIZE (this); Encoding *dest = c->extend_min (*this); @@ -243,9 +243,9 @@ struct Encoding { } /* parallel to above: calculate the size of a subset Encoding */ - static unsigned int calculate_serialized_size (uint8_t format, - unsigned int enc_count, - unsigned int supp_count) + static inline unsigned int calculate_serialized_size (uint8_t format, + unsigned int enc_count, + unsigned int supp_count) { unsigned int size = min_size; if (format == 0) @@ -257,7 +257,7 @@ struct Encoding { return size; } - unsigned int get_size () const + inline unsigned int get_size () const { unsigned int size = min_size; if (table_format () == 0) @@ -269,7 +269,7 @@ struct Encoding { return size; } - hb_codepoint_t get_code (hb_codepoint_t glyph) const + inline hb_codepoint_t get_code (hb_codepoint_t glyph) const { if (table_format () == 0) return u.format0.get_code (glyph); @@ -277,10 +277,10 @@ struct Encoding { return u.format1.get_code (glyph); } - uint8_t table_format () const { return (format & 0x7F); } - bool has_supplement () const { return (format & 0x80) != 0; } + inline uint8_t table_format () const { return (format & 0x7F); } + inline bool has_supplement () const { return (format & 0x80) != 0; } - void get_supplement_codes (hb_codepoint_t sid, hb_vector_t &codes) const + inline void get_supplement_codes (hb_codepoint_t sid, hb_vector_t &codes) const { codes.resize (0); if (has_supplement ()) @@ -288,7 +288,7 @@ struct Encoding { } protected: - const CFF1SuppEncData &suppEncData () const + inline const CFF1SuppEncData &suppEncData () const { if ((format & 0x7F) == 0) return StructAfter (u.format0.codes[u.format0.nCodes-1]); @@ -310,13 +310,13 @@ struct Encoding { /* Charset */ struct Charset0 { - bool sanitize (hb_sanitize_context_t *c, unsigned int num_glyphs) const + inline bool sanitize (hb_sanitize_context_t *c, unsigned int num_glyphs) const { TRACE_SANITIZE (this); return_trace (c->check_struct (this) && sids[num_glyphs - 1].sanitize (c)); } - hb_codepoint_t get_sid (hb_codepoint_t glyph) const + inline hb_codepoint_t get_sid (hb_codepoint_t glyph) const { if (glyph == 0) return 0; @@ -324,7 +324,7 @@ struct Charset0 { return sids[glyph - 1]; } - hb_codepoint_t get_glyph (hb_codepoint_t sid, unsigned int num_glyphs) const + inline hb_codepoint_t get_glyph (hb_codepoint_t sid, unsigned int num_glyphs) const { if (sid == 0) return 0; @@ -337,7 +337,7 @@ struct Charset0 { return 0; } - unsigned int get_size (unsigned int num_glyphs) const + inline unsigned int get_size (unsigned int num_glyphs) const { assert (num_glyphs > 0); return HBUINT16::static_size * (num_glyphs - 1); @@ -350,7 +350,7 @@ struct Charset0 { template struct Charset_Range { - bool sanitize (hb_sanitize_context_t *c) const + inline bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (c->check_struct (this)); @@ -364,7 +364,7 @@ struct Charset_Range { template struct Charset1_2 { - bool sanitize (hb_sanitize_context_t *c, unsigned int num_glyphs) const + inline bool sanitize (hb_sanitize_context_t *c, unsigned int num_glyphs) const { TRACE_SANITIZE (this); if (unlikely (!c->check_struct (this))) @@ -379,7 +379,7 @@ struct Charset1_2 { return_trace (true); } - hb_codepoint_t get_sid (hb_codepoint_t glyph) const + inline hb_codepoint_t get_sid (hb_codepoint_t glyph) const { if (glyph == 0) return 0; glyph--; @@ -393,7 +393,7 @@ struct Charset1_2 { return 0; } - hb_codepoint_t get_glyph (hb_codepoint_t sid, unsigned int num_glyphs) const + inline hb_codepoint_t get_glyph (hb_codepoint_t sid, unsigned int num_glyphs) const { if (sid == 0) return 0; hb_codepoint_t glyph = 1; @@ -409,7 +409,7 @@ struct Charset1_2 { return 0; } - unsigned int get_size (unsigned int num_glyphs) const + inline unsigned int get_size (unsigned int num_glyphs) const { unsigned int size = HBUINT8::static_size; int glyph = (int)num_glyphs; @@ -436,7 +436,7 @@ typedef Charset_Range Charset1_Range; typedef Charset_Range Charset2_Range; struct Charset { - bool sanitize (hb_sanitize_context_t *c) const + inline bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); @@ -453,7 +453,7 @@ struct Charset { } /* serialize a fullset Charset */ - bool serialize (hb_serialize_context_t *c, const Charset &src, unsigned int num_glyphs) + inline bool serialize (hb_serialize_context_t *c, const Charset &src, unsigned int num_glyphs) { TRACE_SERIALIZE (this); unsigned int size = src.get_size (num_glyphs); @@ -464,7 +464,7 @@ struct Charset { } /* serialize a subset Charset */ - bool serialize (hb_serialize_context_t *c, + inline bool serialize (hb_serialize_context_t *c, uint8_t format, unsigned int num_glyphs, const hb_vector_t& sid_ranges) @@ -513,9 +513,8 @@ struct Charset { } /* parallel to above: calculate the size of a subset Charset */ - static unsigned int calculate_serialized_size ( - uint8_t format, - unsigned int count) + static inline unsigned int calculate_serialized_size (uint8_t format, + unsigned int count) { unsigned int size = min_size; if (format == 0) @@ -528,7 +527,7 @@ struct Charset { return size; } - unsigned int get_size (unsigned int num_glyphs) const + inline unsigned int get_size (unsigned int num_glyphs) const { unsigned int size = min_size; if (format == 0) @@ -540,7 +539,7 @@ struct Charset { return size; } - hb_codepoint_t get_sid (hb_codepoint_t glyph) const + inline hb_codepoint_t get_sid (hb_codepoint_t glyph) const { if (format == 0) return u.format0.get_sid (glyph); @@ -550,7 +549,7 @@ struct Charset { return u.format2.get_sid (glyph); } - hb_codepoint_t get_glyph (hb_codepoint_t sid, unsigned int num_glyphs) const + inline hb_codepoint_t get_glyph (hb_codepoint_t sid, unsigned int num_glyphs) const { if (format == 0) return u.format0.get_glyph (sid, num_glyphs); @@ -572,8 +571,8 @@ struct Charset { struct CFF1StringIndex : CFF1Index { - bool serialize (hb_serialize_context_t *c, const CFF1StringIndex &strings, - unsigned int offSize_, const remap_t &sidmap) + inline bool serialize (hb_serialize_context_t *c, const CFF1StringIndex &strings, + unsigned int offSize_, const remap_t &sidmap) { TRACE_SERIALIZE (this); if (unlikely ((strings.count == 0) || (sidmap.get_count () == 0))) @@ -601,7 +600,7 @@ struct CFF1StringIndex : CFF1Index } /* in parallel to above */ - unsigned int calculate_serialized_size (unsigned int &offSize /*OUT*/, const remap_t &sidmap) const + inline unsigned int calculate_serialized_size (unsigned int &offSize /*OUT*/, const remap_t &sidmap) const { offSize = 0; if ((count == 0) || (sidmap.get_count () == 0)) @@ -619,7 +618,7 @@ struct CFF1StringIndex : CFF1Index struct cff1_top_dict_interp_env_t : num_interp_env_t { - cff1_top_dict_interp_env_t () + inline cff1_top_dict_interp_env_t () : num_interp_env_t(), prev_offset(0), last_offset(0) {} unsigned int prev_offset; @@ -645,19 +644,19 @@ struct name_dict_values_t ValCount }; - void init () + inline void init () { for (unsigned int i = 0; i < ValCount; i++) values[i] = CFF_UNDEF_SID; } - unsigned int& operator[] (unsigned int i) + inline unsigned int& operator[] (unsigned int i) { assert (i < ValCount); return values[i]; } - unsigned int operator[] (unsigned int i) const + inline unsigned int operator[] (unsigned int i) const { assert (i < ValCount); return values[i]; } - static enum name_dict_val_index_t name_op_to_index (op_code_t op) + static inline enum name_dict_val_index_t name_op_to_index (op_code_t op) { switch (op) { default: // can't happen - just make some compiler happy @@ -692,7 +691,7 @@ struct cff1_top_dict_val_t : op_str_t struct cff1_top_dict_values_t : top_dict_values_t { - void init () + inline void init () { top_dict_values_t::init (); @@ -704,25 +703,25 @@ struct cff1_top_dict_values_t : top_dict_values_t FDSelectOffset = 0; privateDictInfo.init (); } - void fini () { top_dict_values_t::fini (); } + inline void fini () { top_dict_values_t::fini (); } - bool is_CID () const + inline bool is_CID () const { return nameSIDs[name_dict_values_t::registry] != CFF_UNDEF_SID; } - name_dict_values_t nameSIDs; - unsigned int ros_supplement_offset; - unsigned int ros_supplement; - unsigned int cidCount; + name_dict_values_t nameSIDs; + unsigned int ros_supplement_offset; + unsigned int ros_supplement; + unsigned int cidCount; - unsigned int EncodingOffset; - unsigned int CharsetOffset; - unsigned int FDSelectOffset; - table_info_t privateDictInfo; + unsigned int EncodingOffset; + unsigned int CharsetOffset; + unsigned int FDSelectOffset; + table_info_t privateDictInfo; }; struct cff1_top_dict_opset_t : top_dict_opset_t { - static void process_op (op_code_t op, cff1_top_dict_interp_env_t& env, cff1_top_dict_values_t& dictval) + static inline void process_op (op_code_t op, cff1_top_dict_interp_env_t& env, cff1_top_dict_values_t& dictval) { cff1_top_dict_val_t val; val.last_arg_offset = (env.last_offset-1) - dictval.opStart; /* offset to the last argument */ @@ -809,21 +808,21 @@ struct cff1_top_dict_opset_t : top_dict_opset_t struct cff1_font_dict_values_t : dict_values_t { - void init () + inline void init () { dict_values_t::init (); privateDictInfo.init (); fontName = CFF_UNDEF_SID; } - void fini () { dict_values_t::fini (); } + inline void fini () { dict_values_t::fini (); } - table_info_t privateDictInfo; - unsigned int fontName; + table_info_t privateDictInfo; + unsigned int fontName; }; struct cff1_font_dict_opset_t : dict_opset_t { - static void process_op (op_code_t op, num_interp_env_t& env, cff1_font_dict_values_t& dictval) + static inline void process_op (op_code_t op, num_interp_env_t& env, cff1_font_dict_values_t& dictval) { switch (op) { case OpCode_FontName: @@ -855,15 +854,15 @@ struct cff1_font_dict_opset_t : dict_opset_t template struct cff1_private_dict_values_base_t : dict_values_t { - void init () + inline void init () { dict_values_t::init (); subrsOffset = 0; localSubrs = &Null(CFF1Subrs); } - void fini () { dict_values_t::fini (); } + inline void fini () { dict_values_t::fini (); } - unsigned int calculate_serialized_size () const + inline unsigned int calculate_serialized_size () const { unsigned int size = 0; for (unsigned int i = 0; i < dict_values_t::get_count; i++) @@ -874,8 +873,8 @@ struct cff1_private_dict_values_base_t : dict_values_t return size; } - unsigned int subrsOffset; - const CFF1Subrs *localSubrs; + unsigned int subrsOffset; + const CFF1Subrs *localSubrs; }; typedef cff1_private_dict_values_base_t cff1_private_dict_values_subset_t; @@ -883,7 +882,7 @@ typedef cff1_private_dict_values_base_t cff1_private_dict_values struct cff1_private_dict_opset_t : dict_opset_t { - static void process_op (op_code_t op, num_interp_env_t& env, cff1_private_dict_values_t& dictval) + static inline void process_op (op_code_t op, num_interp_env_t& env, cff1_private_dict_values_t& dictval) { num_dict_val_t val; val.init (); @@ -930,7 +929,7 @@ struct cff1_private_dict_opset_t : dict_opset_t struct cff1_private_dict_opset_subset : dict_opset_t { - static void process_op (op_code_t op, num_interp_env_t& env, cff1_private_dict_values_subset_t& dictval) + static inline void process_op (op_code_t op, num_interp_env_t& env, cff1_private_dict_values_subset_t& dictval) { switch (op) { case OpCode_BlueValues: @@ -986,7 +985,7 @@ struct cff1 { static const hb_tag_t tableTag = HB_OT_TAG_cff1; - bool sanitize (hb_sanitize_context_t *c) const + inline bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (c->check_struct (this) && @@ -996,7 +995,7 @@ struct cff1 template struct accelerator_templ_t { - void init (hb_face_t *face) + inline void init (hb_face_t *face) { topDict.init (); fontDicts.init (); @@ -1123,7 +1122,7 @@ struct cff1 } } - void fini () + inline void fini () { sc.end_processing (); topDict.fini (); @@ -1133,12 +1132,12 @@ struct cff1 blob = nullptr; } - bool is_valid () const { return blob != nullptr; } - bool is_CID () const { return topDict.is_CID (); } + inline bool is_valid () const { return blob != nullptr; } + inline bool is_CID () const { return topDict.is_CID (); } - bool is_predef_charset () const { return topDict.CharsetOffset <= ExpertSubsetCharset; } + inline bool is_predef_charset () const { return topDict.CharsetOffset <= ExpertSubsetCharset; } - unsigned int std_code_to_glyph (hb_codepoint_t code) const + inline unsigned int std_code_to_glyph (hb_codepoint_t code) const { hb_codepoint_t sid = lookup_standard_encoding_for_sid (code); if (unlikely (sid == CFF_UNDEF_SID)) @@ -1152,23 +1151,23 @@ struct cff1 } protected: - hb_blob_t *blob; - hb_sanitize_context_t sc; + hb_blob_t *blob; + hb_sanitize_context_t sc; public: - const Charset *charset; - const CFF1NameIndex *nameIndex; - const CFF1TopDictIndex *topDictIndex; - const CFF1StringIndex *stringIndex; - const CFF1Subrs *globalSubrs; - const CFF1CharStrings *charStrings; - const CFF1FDArray *fdArray; - const CFF1FDSelect *fdSelect; - unsigned int fdCount; + const Charset *charset; + const CFF1NameIndex *nameIndex; + const CFF1TopDictIndex *topDictIndex; + const CFF1StringIndex *stringIndex; + const CFF1Subrs *globalSubrs; + const CFF1CharStrings *charStrings; + const CFF1FDArray *fdArray; + const CFF1FDSelect *fdSelect; + unsigned int fdCount; - cff1_top_dict_values_t topDict; - hb_vector_t fontDicts; - hb_vector_t privateDicts; + cff1_top_dict_values_t topDict; + hb_vector_t fontDicts; + hb_vector_t privateDicts; unsigned int num_glyphs; }; @@ -1181,7 +1180,7 @@ struct cff1 struct accelerator_subset_t : accelerator_templ_t { - void init (hb_face_t *face) + inline void init (hb_face_t *face) { SUPER::init (face); if (blob == nullptr) return; @@ -1202,9 +1201,9 @@ struct cff1 } } - bool is_predef_encoding () const { return topDict.EncodingOffset <= ExpertEncoding; } + inline bool is_predef_encoding () const { return topDict.EncodingOffset <= ExpertEncoding; } - hb_codepoint_t glyph_to_code (hb_codepoint_t glyph) const + inline hb_codepoint_t glyph_to_code (hb_codepoint_t glyph) const { if (encoding != &Null(Encoding)) return encoding->get_code (glyph); @@ -1228,7 +1227,7 @@ struct cff1 } } - hb_codepoint_t glyph_to_sid (hb_codepoint_t glyph) const + inline hb_codepoint_t glyph_to_sid (hb_codepoint_t glyph) const { if (charset != &Null(Charset)) return charset->get_sid (glyph); @@ -1259,7 +1258,7 @@ struct cff1 typedef accelerator_templ_t SUPER; }; - bool subset (hb_subset_plan_t *plan) const + inline bool subset (hb_subset_plan_t *plan) const { hb_blob_t *cff_prime = nullptr; diff --git a/src/hb-ot-cff2-table.cc b/src/hb-ot-cff2-table.cc index 7daa53656..5aad7b4a2 100644 --- a/src/hb-ot-cff2-table.cc +++ b/src/hb-ot-cff2-table.cc @@ -31,7 +31,7 @@ using namespace CFF; struct extents_param_t { - void init () + inline void init () { path_open = false; min_x.set_int (0x7FFFFFFF); @@ -40,11 +40,11 @@ struct extents_param_t max_y.set_int (-0x80000000); } - void start_path () { path_open = true; } - void end_path () { path_open = false; } - bool is_path_open () const { return path_open; } + inline void start_path () { path_open = true; } + inline void end_path () { path_open = false; } + inline bool is_path_open () const { return path_open; } - void update_bounds (const point_t &pt) + inline void update_bounds (const point_t &pt) { if (pt.x < min_x) min_x = pt.x; if (pt.x > max_x) max_x = pt.x; @@ -61,13 +61,13 @@ struct extents_param_t struct cff2_path_procs_extents_t : path_procs_t { - static void moveto (cff2_cs_interp_env_t &env, extents_param_t& param, const point_t &pt) + static inline void moveto (cff2_cs_interp_env_t &env, extents_param_t& param, const point_t &pt) { param.end_path (); env.moveto (pt); } - static void line (cff2_cs_interp_env_t &env, extents_param_t& param, const point_t &pt1) + static inline void line (cff2_cs_interp_env_t &env, extents_param_t& param, const point_t &pt1) { if (!param.is_path_open ()) { @@ -78,7 +78,7 @@ struct cff2_path_procs_extents_t : path_procs_t FDSelect4_Range; struct CFF2FDSelect { - bool sanitize (hb_sanitize_context_t *c, unsigned int fdcount) const + inline bool sanitize (hb_sanitize_context_t *c, unsigned int fdcount) const { TRACE_SANITIZE (this); @@ -63,7 +63,7 @@ struct CFF2FDSelect u.format4.sanitize (c, fdcount)))); } - bool serialize (hb_serialize_context_t *c, const CFF2FDSelect &src, unsigned int num_glyphs) + inline bool serialize (hb_serialize_context_t *c, const CFF2FDSelect &src, unsigned int num_glyphs) { TRACE_SERIALIZE (this); unsigned int size = src.get_size (num_glyphs); @@ -73,10 +73,10 @@ struct CFF2FDSelect return_trace (true); } - unsigned int calculate_serialized_size (unsigned int num_glyphs) const + inline unsigned int calculate_serialized_size (unsigned int num_glyphs) const { return get_size (num_glyphs); } - unsigned int get_size (unsigned int num_glyphs) const + inline unsigned int get_size (unsigned int num_glyphs) const { unsigned int size = format.static_size; if (format == 0) @@ -88,7 +88,7 @@ struct CFF2FDSelect return size; } - hb_codepoint_t get_fd (hb_codepoint_t glyph) const + inline hb_codepoint_t get_fd (hb_codepoint_t glyph) const { if (this == &Null(CFF2FDSelect)) return 0; @@ -110,43 +110,43 @@ struct CFF2FDSelect DEFINE_SIZE_MIN (2); }; -struct CFF2VariationStore +struct cff2_variation_store_t { - bool sanitize (hb_sanitize_context_t *c) const + inline bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (likely (c->check_struct (this)) && c->check_range (&varStore, size) && varStore.sanitize (c)); } - bool serialize (hb_serialize_context_t *c, const CFF2VariationStore *varStore) + inline bool serialize (hb_serialize_context_t *c, const cff2_variation_store_t *varStore) { TRACE_SERIALIZE (this); unsigned int size_ = varStore->get_size (); - CFF2VariationStore *dest = c->allocate_size (size_); + cff2_variation_store_t *dest = c->allocate_size (size_); if (unlikely (dest == nullptr)) return_trace (false); memcpy (dest, varStore, size_); return_trace (true); } - unsigned int get_size () const { return HBUINT16::static_size + size; } + inline unsigned int get_size () const { return HBUINT16::static_size + size; } - HBUINT16 size; - VariationStore varStore; + HBUINT16 size; + VariationStore varStore; DEFINE_SIZE_MIN (2 + VariationStore::min_size); }; struct cff2_top_dict_values_t : top_dict_values_t<> { - void init () + inline void init () { top_dict_values_t<>::init (); vstoreOffset = 0; FDSelectOffset = 0; } - void fini () { top_dict_values_t<>::fini (); } + inline void fini () { top_dict_values_t<>::fini (); } - unsigned int calculate_serialized_size () const + inline unsigned int calculate_serialized_size () const { unsigned int size = 0; for (unsigned int i = 0; i < get_count (); i++) @@ -172,7 +172,7 @@ struct cff2_top_dict_values_t : top_dict_values_t<> struct cff2_top_dict_opset_t : top_dict_opset_t<> { - static void process_op (op_code_t op, num_interp_env_t& env, cff2_top_dict_values_t& dictval) + static inline void process_op (op_code_t op, num_interp_env_t& env, cff2_top_dict_values_t& dictval) { switch (op) { case OpCode_FontMatrix: @@ -221,7 +221,7 @@ struct cff2_font_dict_values_t : dict_values_t struct cff2_font_dict_opset_t : dict_opset_t { - static void process_op (op_code_t op, num_interp_env_t& env, cff2_font_dict_values_t& dictval) + static inline void process_op (op_code_t op, num_interp_env_t& env, cff2_font_dict_values_t& dictval) { switch (op) { case OpCode_Private: @@ -304,7 +304,7 @@ struct cff2_priv_dict_interp_env_t : num_interp_env_t struct cff2_private_dict_opset_t : dict_opset_t { - static void process_op (op_code_t op, cff2_priv_dict_interp_env_t& env, cff2_private_dict_values_t& dictval) + static inline void process_op (op_code_t op, cff2_priv_dict_interp_env_t& env, cff2_private_dict_values_t& dictval) { num_dict_val_t val; val.init (); @@ -354,7 +354,7 @@ struct cff2_private_dict_opset_t : dict_opset_t struct cff2_private_dict_opset_subset_t : dict_opset_t { - static void process_op (op_code_t op, cff2_priv_dict_interp_env_t& env, cff2_private_dict_values_subset_t& dictval) + static inline void process_op (op_code_t op, cff2_priv_dict_interp_env_t& env, cff2_private_dict_values_subset_t& dictval) { switch (op) { case OpCode_BlueValues: @@ -410,7 +410,7 @@ struct cff2 { static const hb_tag_t tableTag = HB_OT_TAG_cff2; - bool sanitize (hb_sanitize_context_t *c) const + inline bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (c->check_struct (this) && @@ -420,7 +420,7 @@ struct cff2 template struct accelerator_templ_t { - void init (hb_face_t *face) + inline void init (hb_face_t *face) { topDict.init (); fontDicts.init (); @@ -447,12 +447,12 @@ struct cff2 } globalSubrs = &StructAtOffset (cff2, cff2->topDict + cff2->topDictSize); - varStore = &StructAtOffsetOrNull (cff2, topDict.vstoreOffset); + varStore = &StructAtOffsetOrNull (cff2, topDict.vstoreOffset); charStrings = &StructAtOffsetOrNull (cff2, topDict.charStringsOffset); fdArray = &StructAtOffsetOrNull (cff2, topDict.FDArrayOffset); fdSelect = &StructAtOffsetOrNull (cff2, topDict.FDSelectOffset); - if (((varStore != &Null(CFF2VariationStore)) && unlikely (!varStore->sanitize (&sc))) || + if (((varStore != &Null(cff2_variation_store_t)) && unlikely (!varStore->sanitize (&sc))) || (charStrings == &Null(CFF2CharStrings)) || unlikely (!charStrings->sanitize (&sc)) || (globalSubrs == &Null(CFF2Subrs)) || unlikely (!globalSubrs->sanitize (&sc)) || (fdArray == &Null(CFF2FDArray)) || unlikely (!fdArray->sanitize (&sc)) || @@ -493,7 +493,7 @@ struct cff2 } } - void fini () + inline void fini () { sc.end_processing (); fontDicts.fini_deep (); @@ -502,25 +502,25 @@ struct cff2 blob = nullptr; } - bool is_valid () const { return blob != nullptr; } + inline bool is_valid () const { return blob != nullptr; } protected: - hb_blob_t *blob; - hb_sanitize_context_t sc; + hb_blob_t *blob; + hb_sanitize_context_t sc; public: - cff2_top_dict_values_t topDict; - const CFF2Subrs *globalSubrs; - const CFF2VariationStore *varStore; - const CFF2CharStrings *charStrings; - const CFF2FDArray *fdArray; - const CFF2FDSelect *fdSelect; - unsigned int fdCount; + cff2_top_dict_values_t topDict; + const CFF2Subrs *globalSubrs; + const cff2_variation_store_t *varStore; + const CFF2CharStrings *charStrings; + const CFF2FDArray *fdArray; + const CFF2FDSelect *fdSelect; + unsigned int fdCount; - hb_vector_t fontDicts; - hb_vector_t privateDicts; + hb_vector_t fontDicts; + hb_vector_t privateDicts; - unsigned int num_glyphs; + unsigned int num_glyphs; }; struct accelerator_t : accelerator_templ_t @@ -532,7 +532,7 @@ struct cff2 typedef accelerator_templ_t accelerator_subset_t; - bool subset (hb_subset_plan_t *plan) const + inline bool subset (hb_subset_plan_t *plan) const { hb_blob_t *cff2_prime = nullptr; diff --git a/src/hb-subset-cff-common.hh b/src/hb-subset-cff-common.hh index fe8ecf991..65d499a35 100644 --- a/src/hb-subset-cff-common.hh +++ b/src/hb-subset-cff-common.hh @@ -37,18 +37,18 @@ namespace CFF { /* Used for writing a temporary charstring */ struct str_encoder_t { - str_encoder_t (str_buff_t &buff_) + inline str_encoder_t (str_buff_t &buff_) : buff (buff_), error (false) {} - void reset () { buff.resize (0); } + inline void reset () { buff.resize (0); } - void encode_byte (unsigned char b) + inline void encode_byte (unsigned char b) { if (unlikely (buff.push (b) == &Crap(unsigned char))) set_error (); } - void encode_int (int v) + inline void encode_int (int v) { if ((-1131 <= v) && (v <= 1131)) { @@ -79,7 +79,7 @@ struct str_encoder_t } } - void encode_num (const number_t& n) + inline void encode_num (const number_t& n) { if (n.in_int_range ()) { @@ -96,7 +96,7 @@ struct str_encoder_t } } - void encode_op (op_code_t op) + inline void encode_op (op_code_t op) { if (Is_OpCode_ESC (op)) { @@ -107,7 +107,7 @@ struct str_encoder_t encode_byte (op); } - void copy_str (const byte_str_t &str) + inline void copy_str (const byte_str_t &str) { unsigned int offset = buff.len; buff.resize (offset + str.len); @@ -119,17 +119,17 @@ struct str_encoder_t memcpy (&buff[offset], &str[0], str.len); } - bool is_error () const { return error; } + inline bool is_error () const { return error; } protected: - void set_error () { error = true; } + inline void set_error () { error = true; } str_buff_t &buff; bool error; }; struct cff_sub_table_offsets_t { - cff_sub_table_offsets_t () : privateDictsOffset (0) + inline cff_sub_table_offsets_t () : privateDictsOffset (0) { topDictInfo.init (); FDSelectInfo.init (); @@ -139,23 +139,23 @@ struct cff_sub_table_offsets_t { localSubrsInfos.init (); } - ~cff_sub_table_offsets_t () { localSubrsInfos.fini (); } + inline ~cff_sub_table_offsets_t () { localSubrsInfos.fini (); } - table_info_t topDictInfo; - table_info_t FDSelectInfo; - table_info_t FDArrayInfo; - table_info_t charStringsInfo; - unsigned int privateDictsOffset; - table_info_t globalSubrsInfo; + table_info_t topDictInfo; + table_info_t FDSelectInfo; + table_info_t FDArrayInfo; + table_info_t charStringsInfo; + unsigned int privateDictsOffset; + table_info_t globalSubrsInfo; hb_vector_t localSubrsInfos; }; template struct cff_top_dict_op_serializer_t : op_serializer_t { - bool serialize (hb_serialize_context_t *c, - const OPSTR &opstr, - const cff_sub_table_offsets_t &offsets) const + inline bool serialize (hb_serialize_context_t *c, + const OPSTR &opstr, + const cff_sub_table_offsets_t &offsets) const { TRACE_SERIALIZE (this); @@ -176,7 +176,7 @@ struct cff_top_dict_op_serializer_t : op_serializer_t return_trace (true); } - unsigned int calculate_serialized_size (const OPSTR &opstr) const + inline unsigned int calculate_serialized_size (const OPSTR &opstr) const { switch (opstr.op) { @@ -193,9 +193,9 @@ struct cff_top_dict_op_serializer_t : op_serializer_t 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 + inline bool serialize (hb_serialize_context_t *c, + const op_str_t &opstr, + const table_info_t &privateDictInfo) const { TRACE_SERIALIZE (this); @@ -222,7 +222,7 @@ struct cff_font_dict_op_serializer_t : op_serializer_t return_trace (true); } - unsigned int calculate_serialized_size (const op_str_t &opstr) const + inline unsigned int calculate_serialized_size (const op_str_t &opstr) const { if (opstr.op == OpCode_Private) return OpCode_Size (OpCode_longintdict) + 4 + OpCode_Size (OpCode_shortint) + 2 + OpCode_Size (OpCode_Private); @@ -233,12 +233,12 @@ struct cff_font_dict_op_serializer_t : op_serializer_t struct cff_private_dict_op_serializer_t : op_serializer_t { - cff_private_dict_op_serializer_t (bool desubroutinize_, bool drop_hints_) + inline 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, - const unsigned int subrsOffset) const + inline bool serialize (hb_serialize_context_t *c, + const op_str_t &opstr, + const unsigned int subrsOffset) const { TRACE_SERIALIZE (this); @@ -255,8 +255,8 @@ struct cff_private_dict_op_serializer_t : op_serializer_t return_trace (copy_opstr (c, opstr)); } - unsigned int calculate_serialized_size (const op_str_t &opstr, - bool has_localsubr=true) const + inline unsigned int calculate_serialized_size (const op_str_t &opstr, + bool has_localsubr=true) const { if (drop_hints && dict_opset_t::is_hint_op (opstr.op)) return 0; @@ -278,22 +278,22 @@ struct cff_private_dict_op_serializer_t : op_serializer_t struct flatten_param_t { - str_buff_t &flatStr; - bool drop_hints; + str_buff_t &flatStr; + bool drop_hints; }; template struct subr_flattener_t { - subr_flattener_t (const ACC &acc_, - const hb_vector_t &glyphs_, - bool drop_hints_) + inline subr_flattener_t (const ACC &acc_, + const hb_vector_t &glyphs_, + bool drop_hints_) : acc (acc_), glyphs (glyphs_), drop_hints (drop_hints_) {} - bool flatten (str_buff_vec_t &flat_charstrings) + inline bool flatten (str_buff_vec_t &flat_charstrings) { if (!flat_charstrings.resize (glyphs.len)) return false; @@ -322,10 +322,10 @@ struct subr_flattener_t struct subr_closures_t { - subr_closures_t () : valid (false), global_closure (nullptr) + inline subr_closures_t () : valid (false), global_closure (nullptr) { local_closures.init (); } - void init (unsigned int fd_count) + inline void init (unsigned int fd_count) { valid = true; global_closure = hb_set_create (); @@ -342,7 +342,7 @@ struct subr_closures_t } } - void fini () + inline void fini () { hb_set_destroy (global_closure); for (unsigned int i = 0; i < local_closures.len; i++) @@ -365,7 +365,7 @@ struct subr_closures_t struct parsed_cs_op_t : op_str_t { - void init (unsigned int subr_num_ = 0) + inline void init (unsigned int subr_num_ = 0) { op_str_t::init (); subr_num = subr_num_; @@ -374,16 +374,16 @@ struct parsed_cs_op_t : op_str_t skip_flag = false; } - void fini () { op_str_t::fini (); } + inline void fini () { op_str_t::fini (); } - bool for_drop () const { return drop_flag; } - void set_drop () { if (!for_keep ()) drop_flag = true; } + inline bool for_drop () const { return drop_flag; } + inline void set_drop () { if (!for_keep ()) drop_flag = true; } - bool for_keep () const { return keep_flag; } - void set_keep () { keep_flag = true; } + inline bool for_keep () const { return keep_flag; } + inline void set_keep () { keep_flag = true; } - bool for_skip () const { return skip_flag; } - void set_skip () { skip_flag = true; } + inline bool for_skip () const { return skip_flag; } + inline void set_skip () { skip_flag = true; } unsigned int subr_num; diff --git a/src/hb-subset-cff1.cc b/src/hb-subset-cff1.cc index 697773446..1f9040436 100644 --- a/src/hb-subset-cff1.cc +++ b/src/hb-subset-cff1.cc @@ -36,7 +36,7 @@ using namespace CFF; struct remap_sid_t : remap_t { - unsigned int add (unsigned int sid) + inline unsigned int add (unsigned int sid) { if ((sid != CFF_UNDEF_SID) && !is_std_std (sid)) return offset_sid (remap_t::add (unoffset_sid (sid))); @@ -44,7 +44,7 @@ struct remap_sid_t : remap_t return sid; } - unsigned int operator[] (unsigned int sid) const + inline unsigned int operator[] (unsigned int sid) const { if (is_std_std (sid) || (sid == CFF_UNDEF_SID)) return sid; @@ -54,14 +54,14 @@ struct remap_sid_t : remap_t static const unsigned int num_std_strings = 391; - static bool is_std_std (unsigned int sid) { return sid < num_std_strings; } - static unsigned int offset_sid (unsigned int sid) { return sid + num_std_strings; } - static unsigned int unoffset_sid (unsigned int sid) { return sid - num_std_strings; } + static inline bool is_std_std (unsigned int sid) { return sid < num_std_strings; } + static inline unsigned int offset_sid (unsigned int sid) { return sid + num_std_strings; } + static inline unsigned int unoffset_sid (unsigned int sid) { return sid - num_std_strings; } }; struct cff1_sub_table_offsets_t : cff_sub_table_offsets_t { - cff1_sub_table_offsets_t () + inline cff1_sub_table_offsets_t () : cff_sub_table_offsets_t (), nameIndexOffset (0), encodingOffset (0) @@ -71,35 +71,35 @@ struct cff1_sub_table_offsets_t : cff_sub_table_offsets_t privateDictInfo.init (); } - unsigned int nameIndexOffset; - table_info_t stringIndexInfo; - unsigned int encodingOffset; - table_info_t charsetInfo; - table_info_t privateDictInfo; + unsigned int nameIndexOffset; + table_info_t stringIndexInfo; + unsigned int encodingOffset; + table_info_t charsetInfo; + table_info_t privateDictInfo; }; /* a copy of a parsed out cff1_top_dict_values_t augmented with additional operators */ struct cff1_top_dict_values_mod_t : cff1_top_dict_values_t { - void init (const cff1_top_dict_values_t *base_= &Null(cff1_top_dict_values_t)) + inline void init (const cff1_top_dict_values_t *base_= &Null(cff1_top_dict_values_t)) { SUPER::init (); base = base_; } - void fini () { SUPER::fini (); } + inline void fini () { SUPER::fini (); } - unsigned get_count () const { return base->get_count () + SUPER::get_count (); } - const cff1_top_dict_val_t &get_value (unsigned int i) const + inline unsigned get_count () const { return base->get_count () + SUPER::get_count (); } + inline const cff1_top_dict_val_t &get_value (unsigned int i) const { if (i < base->get_count ()) return (*base)[i]; else return SUPER::values[i - base->get_count ()]; } - const cff1_top_dict_val_t &operator [] (unsigned int i) const { return get_value (i); } + inline const cff1_top_dict_val_t &operator [] (unsigned int i) const { return get_value (i); } - void reassignSIDs (const remap_sid_t& sidmap) + inline void reassignSIDs (const remap_sid_t& sidmap) { for (unsigned int i = 0; i < name_dict_values_t::ValCount; i++) nameSIDs[i] = sidmap[base->nameSIDs[i]]; @@ -113,7 +113,7 @@ struct cff1_top_dict_values_mod_t : cff1_top_dict_values_t struct top_dict_modifiers_t { top_dict_modifiers_t (const cff1_sub_table_offsets_t &offsets_, - const unsigned int (&nameSIDs_)[name_dict_values_t::ValCount]) + const unsigned int (&nameSIDs_)[name_dict_values_t::ValCount]) : offsets (offsets_), nameSIDs (nameSIDs_) {} @@ -124,9 +124,9 @@ struct top_dict_modifiers_t struct cff1_top_dict_op_serializer_t : cff_top_dict_op_serializer_t { - bool serialize (hb_serialize_context_t *c, - const cff1_top_dict_val_t &opstr, - const top_dict_modifiers_t &mod) const + inline bool serialize (hb_serialize_context_t *c, + const cff1_top_dict_val_t &opstr, + const top_dict_modifiers_t &mod) const { TRACE_SERIALIZE (this); @@ -181,7 +181,7 @@ struct cff1_top_dict_op_serializer_t : cff_top_dict_op_serializer_tget_count (); } + inline unsigned get_count () const { return base->get_count (); } - const op_str_t &operator [] (unsigned int i) const { return (*base)[i]; } + inline const op_str_t &operator [] (unsigned int i) const { return (*base)[i]; } - const cff1_font_dict_values_t *base; - table_info_t privateDictInfo; - unsigned int fontName; + const cff1_font_dict_values_t *base; + table_info_t privateDictInfo; + unsigned int fontName; }; struct cff1_font_dict_op_serializer_t : cff_font_dict_op_serializer_t { - bool serialize (hb_serialize_context_t *c, - const op_str_t &opstr, - const font_dict_values_mod_t &mod) const + inline bool serialize (hb_serialize_context_t *c, + const op_str_t &opstr, + const font_dict_values_mod_t &mod) const { TRACE_SERIALIZE (this); @@ -247,7 +247,7 @@ struct cff1_font_dict_op_serializer_t : cff_font_dict_op_serializer_t return_trace (SUPER::serialize (c, opstr, mod.privateDictInfo)); } - unsigned int calculate_serialized_size (const op_str_t &opstr) const + inline unsigned int calculate_serialized_size (const op_str_t &opstr) const { if (opstr.op == OpCode_FontName) return OpCode_Size (OpCode_shortint) + 2 + OpCode_Size (OpCode_FontName); @@ -261,7 +261,7 @@ struct cff1_font_dict_op_serializer_t : cff_font_dict_op_serializer_t struct cff1_cs_opset_flatten_t : cff1_cs_opset_t { - static void flush_args_and_op (op_code_t op, cff1_cs_interp_env_t &env, flatten_param_t& param) + static inline void flush_args_and_op (op_code_t op, cff1_cs_interp_env_t &env, flatten_param_t& param) { if (env.arg_start > 0) flush_width (env, param); @@ -287,7 +287,8 @@ struct cff1_cs_opset_flatten_t : cff1_cs_opset_t { /* replace the first glyph ID in the "glyph" field each range with a nLeft value */ - bool finalize (unsigned int last_glyph) + inline bool finalize (unsigned int last_glyph) { bool two_byte = false; for (unsigned int i = (*this).len; i > 0; i--) @@ -344,7 +345,7 @@ struct range_list_t : hb_vector_t struct cff1_cs_opset_subr_subset_t : cff1_cs_opset_t { - static void process_op (op_code_t op, cff1_cs_interp_env_t &env, subr_subset_param_t& param) + static inline void process_op (op_code_t op, cff1_cs_interp_env_t &env, subr_subset_param_t& param) { switch (op) { @@ -377,7 +378,7 @@ struct cff1_cs_opset_subr_subset_t : cff1_cs_opset_t { - static void finalize_parsed_str (cff1_cs_interp_env_t &env, subr_subset_param_t& param, parsed_cs_str_t &charstring) + static inline void finalize_parsed_str (cff1_cs_interp_env_t &env, subr_subset_param_t& param, parsed_cs_str_t &charstring) { /* insert width at the beginning of the charstring as necessary */ if (env.has_width) @@ -416,7 +417,7 @@ struct cff1_subr_subsetter_t : subr_subsetter_tglyphs.len); } - bool collect_sids_in_dicts (const OT::cff1::accelerator_subset_t &acc) + inline bool collect_sids_in_dicts (const OT::cff1::accelerator_subset_t &acc) { if (unlikely (!sidmap.reset (acc.stringIndex->count))) return false; @@ -586,7 +587,7 @@ struct cff_subset_plan { return true; } - bool create (const OT::cff1::accelerator_subset_t &acc, + inline bool create (const OT::cff1::accelerator_subset_t &acc, hb_subset_plan_t *plan) { /* make sure notdef is first */ @@ -821,46 +822,46 @@ struct cff_subset_plan { && (fontdicts_mod.len == subset_fdcount)); } - unsigned int get_final_size () const { return final_size; } + inline unsigned int get_final_size () const { return final_size; } - unsigned int final_size; - hb_vector_t topdict_sizes; - cff1_top_dict_values_mod_t topdict_mod; - cff1_sub_table_offsets_t offsets; + unsigned int final_size; + hb_vector_t topdict_sizes; + cff1_top_dict_values_mod_t topdict_mod; + cff1_sub_table_offsets_t offsets; unsigned int num_glyphs; unsigned int orig_fdcount; unsigned int subset_fdcount; unsigned int subset_fdselect_format; - hb_vector_t subset_fdselect_ranges; + hb_vector_t subset_fdselect_ranges; /* font dict index remap table from fullset FDArray to subset FDArray. * set to CFF_UNDEF_CODE if excluded from subset */ remap_t fdmap; - str_buff_vec_t subset_charstrings; - str_buff_vec_t subset_globalsubrs; - hb_vector_t subset_localsubrs; + str_buff_vec_t subset_charstrings; + str_buff_vec_t subset_globalsubrs; + hb_vector_t subset_localsubrs; hb_vector_t fontdicts_mod; - bool drop_hints; + bool drop_hints; - bool gid_renum; - bool subset_encoding; - uint8_t subset_enc_format; - unsigned int subset_enc_num_codes; - range_list_t subset_enc_code_ranges; - hb_vector_t subset_enc_supp_codes; + bool gid_renum; + bool subset_encoding; + uint8_t subset_enc_format; + unsigned int subset_enc_num_codes; + range_list_t subset_enc_code_ranges; + hb_vector_t subset_enc_supp_codes; - uint8_t subset_charset_format; - range_list_t subset_charset_ranges; - bool subset_charset; + uint8_t subset_charset_format; + range_list_t subset_charset_ranges; + bool subset_charset; - remap_sid_t sidmap; - unsigned int topDictModSIDs[name_dict_values_t::ValCount]; + remap_sid_t sidmap; + unsigned int topDictModSIDs[name_dict_values_t::ValCount]; - bool desubroutinize; - cff1_subr_subsetter_t subr_subsetter; + bool desubroutinize; + cff1_subr_subsetter_t subr_subsetter; }; static inline bool _write_cff1 (const cff_subset_plan &plan, diff --git a/src/hb-subset-cff2.cc b/src/hb-subset-cff2.cc index a63d1c207..785be8d5a 100644 --- a/src/hb-subset-cff2.cc +++ b/src/hb-subset-cff2.cc @@ -36,9 +36,9 @@ using namespace CFF; struct cff2_sub_table_offsets_t : cff_sub_table_offsets_t { - cff2_sub_table_offsets_t () - : cff_sub_table_offsets_t (), - varStoreOffset (0) + inline cff2_sub_table_offsets_t () + : cff_sub_table_offsets_t (), + varStoreOffset (0) {} unsigned int varStoreOffset; @@ -46,9 +46,9 @@ struct cff2_sub_table_offsets_t : cff_sub_table_offsets_t struct cff2_top_dict_op_serializer_t : cff_top_dict_op_serializer_t<> { - bool serialize (hb_serialize_context_t *c, - const op_str_t &opstr, - const cff2_sub_table_offsets_t &offsets) const + inline bool serialize (hb_serialize_context_t *c, + const op_str_t &opstr, + const cff2_sub_table_offsets_t &offsets) const { TRACE_SERIALIZE (this); @@ -77,7 +77,7 @@ struct cff2_top_dict_op_serializer_t : cff_top_dict_op_serializer_t<> struct cff2_cs_opset_flatten_t : cff2_cs_opset_t { - static void flush_args_and_op (op_code_t op, cff2_cs_interp_env_t &env, flatten_param_t& param) + static inline void flush_args_and_op (op_code_t op, cff2_cs_interp_env_t &env, flatten_param_t& param) { switch (op) { @@ -105,7 +105,7 @@ struct cff2_cs_opset_flatten_t : cff2_cs_opset_t { - static void process_op (op_code_t op, cff2_cs_interp_env_t &env, subr_subset_param_t& param) + static inline void process_op (op_code_t op, cff2_cs_interp_env_t &env, subr_subset_param_t& param) { switch (op) { @@ -208,9 +208,9 @@ struct cff2_cs_opset_subr_subset_t : cff2_cs_opset_t { - static void finalize_parsed_str (cff2_cs_interp_env_t &env, subr_subset_param_t& param, parsed_cs_str_t &charstring) + static inline void finalize_parsed_str (cff2_cs_interp_env_t &env, subr_subset_param_t& param, parsed_cs_str_t &charstring) { /* vsindex is inserted at the beginning of the charstring as necessary */ if (env.seen_vsindex ()) @@ -238,7 +238,7 @@ struct cff2_subr_subsetter_t : subr_subsetter_tcount; @@ -342,7 +342,7 @@ struct cff2_subset_plan { final_size += offsets.globalSubrsInfo.size; /* variation store */ - if (acc.varStore != &Null(CFF2VariationStore)) + if (acc.varStore != &Null(cff2_variation_store_t)) { offsets.varStoreOffset = final_size; final_size += acc.varStore->get_size (); @@ -412,26 +412,26 @@ struct cff2_subset_plan { return true; } - unsigned int get_final_size () const { return final_size; } + inline unsigned int get_final_size () const { return final_size; } - unsigned int final_size; - cff2_sub_table_offsets_t offsets; + unsigned int final_size; + cff2_sub_table_offsets_t offsets; - unsigned int orig_fdcount; - unsigned int subset_fdcount; - unsigned int subset_fdselect_format; - hb_vector_t subset_fdselect_ranges; + unsigned int orig_fdcount; + unsigned int subset_fdcount; + unsigned int subset_fdselect_format; + hb_vector_t subset_fdselect_ranges; remap_t fdmap; - str_buff_vec_t subset_charstrings; - str_buff_vec_t subset_globalsubrs; - hb_vector_t subset_localsubrs; - hb_vector_t privateDictInfos; + str_buff_vec_t subset_charstrings; + str_buff_vec_t subset_globalsubrs; + hb_vector_t subset_localsubrs; + hb_vector_t privateDictInfos; bool drop_hints; bool desubroutinize; - cff2_subr_subsetter_t subr_subsetter; + cff2_subr_subsetter_t subr_subsetter; }; static inline bool _write_cff2 (const cff2_subset_plan &plan, @@ -477,10 +477,10 @@ static inline bool _write_cff2 (const cff2_subset_plan &plan, } /* variation store */ - if (acc.varStore != &Null(CFF2VariationStore)) + if (acc.varStore != &Null(cff2_variation_store_t)) { assert (plan.offsets.varStoreOffset == c.head - c.start); - CFF2VariationStore *dest = c.start_embed (); + cff2_variation_store_t *dest = c.start_embed (); if (unlikely (!dest->serialize (&c, acc.varStore))) { DEBUG_MSG (SUBSET, nullptr, "failed to serialize CFF2 Variation Store"); diff --git a/src/hb-subset-cff2.hh b/src/hb-subset-cff2.hh index a07dc290e..4642f55ab 100644 --- a/src/hb-subset-cff2.hh +++ b/src/hb-subset-cff2.hh @@ -33,6 +33,6 @@ HB_INTERNAL bool hb_subset_cff2 (hb_subset_plan_t *plan, - hb_blob_t **cff2_prime /* OUT */); + hb_blob_t **cff2_prime /* OUT */); #endif /* HB_SUBSET_CFF2_HH */