diff --git a/src/hb-cff-interp-common.hh b/src/hb-cff-interp-common.hh index 00b1071a1..843256c6b 100644 --- a/src/hb-cff-interp-common.hh +++ b/src/hb-cff-interp-common.hh @@ -30,7 +30,7 @@ namespace CFF { using namespace OT; -typedef unsigned int OpCode; +typedef unsigned int op_code_t; /* === Dict operators === */ @@ -88,11 +88,11 @@ typedef unsigned int OpCode; /* Two byte escape operators 12, (0-41) */ #define OpCode_ESC_Base 256 -#define Make_OpCode_ESC(byte2) ((OpCode)(OpCode_ESC_Base + (byte2))) +#define Make_OpCode_ESC(byte2) ((op_code_t)(OpCode_ESC_Base + (byte2))) -inline OpCode Unmake_OpCode_ESC (OpCode op) { return (OpCode)(op - OpCode_ESC_Base); } -inline bool Is_OpCode_ESC (OpCode op) { return op >= OpCode_ESC_Base; } -inline unsigned int OpCode_Size (OpCode op) { return Is_OpCode_ESC (op) ? 2: 1; } +inline op_code_t Unmake_OpCode_ESC (op_code_t op) { return (op_code_t)(op - OpCode_ESC_Base); } +inline bool Is_OpCode_ESC (op_code_t op) { return op >= OpCode_ESC_Base; } +inline unsigned int OpCode_Size (op_code_t op) { return Is_OpCode_ESC (op) ? 2: 1; } #define OpCode_Copyright Make_OpCode_ESC(0) /* CFF Top */ #define OpCode_isFixedPitch Make_OpCode_ESC(1) /* CFF Top (false) */ @@ -215,7 +215,7 @@ inline unsigned int OpCode_Size (OpCode op) { return Is_OpCode_ESC (op) ? 2: 1; #define OpCode_Invalid 0xFFFFu -struct Number +struct number_t { void init () { set_real (0.0); } void fini () {} @@ -235,19 +235,19 @@ struct Number bool in_int_range () const { return ((double) (int16_t) to_int () == value); } - bool operator > (const Number &n) const + bool operator > (const number_t &n) const { return value > n.to_real (); } - bool operator < (const Number &n) const + bool operator < (const number_t &n) const { return n > *this; } - bool operator >= (const Number &n) const + bool operator >= (const number_t &n) const { return !(*this < n); } - bool operator <= (const Number &n) const + bool operator <= (const number_t &n) const { return !(*this > n); } - const Number &operator += (const Number &n) + 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, OpCode intOp, int value) + static bool serialize_int (hb_serialize_context_t *c, op_code_t intOp, int value) { TRACE_SERIALIZE (this); @@ -290,92 +290,73 @@ struct UnsizedByteStr : UnsizedArrayOf /* Defining null_size allows a Null object may be created. Should be safe because: * A descendent struct Dict uses a Null pointer to indicate a missing table, * checked before access. - * ByteStr, a wrapper struct pairing a byte pointer along with its length, always + * byte_str_t, a wrapper struct pairing a byte pointer along with its length, always * checks the length before access. A Null pointer is used as the initial pointer * along with zero length by the default ctor. */ DEFINE_SIZE_MIN(0); }; -struct ByteStr +/* Holder of a section of byte string within a CFFIndex entry */ +struct byte_str_t : hb_ubytes_t { - ByteStr () - : str (&Null(UnsizedByteStr)), len (0) {} - ByteStr (const UnsizedByteStr& s, unsigned int l) - : str (&s), len (l) {} - ByteStr (const char *s, unsigned int l=0) - : str ((const UnsizedByteStr *)s), len (l) {} + byte_str_t () + : hb_ubytes_t () {} + 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) + : hb_ubytes_t (s, l) {} + byte_str_t (const hb_ubytes_t &ub) /* conversion from hb_ubytes_t */ + : hb_ubytes_t (ub) {} + /* sub-string */ - ByteStr (const ByteStr &bs, unsigned int offset, unsigned int len_) - { - str = (const UnsizedByteStr *)&bs.str[offset]; - len = len_; - } - - bool sanitize (hb_sanitize_context_t *c) const { return str->sanitize (c, len); } - - const HBUINT8& operator [] (unsigned int i) const - { - if (likely (str && (i < len))) - return (*str)[i]; - else - return Null(HBUINT8); - } - - bool serialize (hb_serialize_context_t *c, const ByteStr &src) - { - TRACE_SERIALIZE (this); - HBUINT8 *dest = c->allocate_size (src.len); - if (unlikely (dest == nullptr)) - return_trace (false); - memcpy (dest, src.str, src.len); - return_trace (true); - } - - unsigned int get_size () const { return len; } + 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 - { return (offset + count <= len); } - - const UnsizedByteStr *str; - unsigned int len; + { return (offset + count <= length); } }; -struct SubByteStr +/* A byte string associated with the current offset and an error condition */ +struct byte_str_ref_t { - SubByteStr () + byte_str_ref_t () { init (); } void init () { - str = ByteStr (0); + str = byte_str_t (); offset = 0; error = false; } void fini () {} - SubByteStr (const ByteStr &str_, unsigned int offset_ = 0) + byte_str_ref_t (const byte_str_t &str_, unsigned int offset_ = 0) : str (str_), offset (offset_), error (false) {} - void reset (const ByteStr &str_, unsigned int offset_ = 0) + void reset (const byte_str_t &str_, unsigned int offset_ = 0) { str = str_; offset = offset_; error = false; } - const HBUINT8& operator [] (int i) { - if (unlikely ((unsigned int)(offset + i) >= str.len)) + const unsigned char& operator [] (int i) { + if (unlikely ((unsigned int)(offset + i) >= str.length)) { set_error (); - return Null(HBUINT8); + return Null(unsigned char); } else return str[offset + i]; } - operator ByteStr () const { return ByteStr (str, offset, str.len - offset); } + /* Conversion to byte_str_t */ + operator byte_str_t () const { return str.sub_str (offset, str.length - offset); } + + 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 { @@ -383,13 +364,13 @@ struct SubByteStr } void inc (unsigned int count=1) { - if (likely (!in_error () && (offset <= str.len) && (offset + count <= str.len))) + if (likely (!in_error () && (offset <= str.length) && (offset + count <= str.length))) { offset += count; } else { - offset = str.len; + offset = str.length; set_error (); } } @@ -397,18 +378,18 @@ struct SubByteStr void set_error () { error = true; } bool in_error () const { return error; } - ByteStr str; + byte_str_t str; unsigned int offset; /* beginning of the sub-string within str */ protected: bool error; }; -typedef hb_vector_t ByteStrArray; +typedef hb_vector_t byte_str_array_t; /* stack */ template -struct Stack +struct stack_t { void init () { @@ -505,8 +486,8 @@ struct Stack }; /* argument stack */ -template -struct ArgStack : Stack +template +struct arg_stack_t : stack_t { void push_int (int v) { @@ -541,18 +522,18 @@ struct ArgStack : Stack return (unsigned)i; } - void push_longint_from_substr (SubByteStr& substr) + void push_longint_from_substr (byte_str_ref_t& str_ref) { - push_int ((substr[0] << 24) | (substr[1] << 16) | (substr[2] << 8) | (substr[3])); - substr.inc (4); + 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 (SubByteStr& substr) + bool push_fixed_from_substr (byte_str_ref_t& str_ref) { - if (unlikely (!substr.avail (4))) + if (unlikely (!str_ref.avail (4))) return false; - push_fixed ((int32_t)*(const HBUINT32*)&substr[0]); - substr.inc (4); + push_fixed ((int32_t)*(const HBUINT32*)&str_ref[0]); + str_ref.inc (4); return true; } @@ -562,36 +543,36 @@ struct ArgStack : Stack } private: - typedef Stack S; + typedef stack_t S; }; /* an operator prefixed by its operands in a byte string */ -struct OpStr +struct op_str_t { void init () {} void fini () {} - OpCode op; - ByteStr str; + op_code_t op; + byte_str_t str; }; /* base of OP_SERIALIZER */ -struct OpSerializer +struct op_serializer_t { protected: - bool copy_opstr (hb_serialize_context_t *c, const OpStr& opstr) const + bool copy_opstr (hb_serialize_context_t *c, const op_str_t& opstr) const { TRACE_SERIALIZE (this); - HBUINT8 *d = c->allocate_size (opstr.str.len); + HBUINT8 *d = c->allocate_size (opstr.str.length); if (unlikely (d == nullptr)) return_trace (false); - memcpy (d, &opstr.str.str[0], opstr.str.len); + memcpy (d, &opstr.str[0], opstr.str.length); return_trace (true); } }; template -struct ParsedValues +struct parsed_values_t { void init () { @@ -600,23 +581,23 @@ struct ParsedValues } void fini () { values.fini_deep (); } - void add_op (OpCode op, const SubByteStr& substr = SubByteStr ()) + 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; - val->str = ByteStr (substr.str, opStart, substr.offset - opStart); - opStart = substr.offset; + val->str = str_ref.str.sub_str (opStart, str_ref.offset - opStart); + opStart = str_ref.offset; } - void add_op (OpCode op, const SubByteStr& substr, const VAL &v) + 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; - val->str = ByteStr (substr.str, opStart, substr.offset - opStart); - opStart = substr.offset; + val->str = str_ref.sub_str ( opStart, str_ref.offset - opStart); + opStart = str_ref.offset; } - bool has_op (OpCode op) const + 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; @@ -631,35 +612,35 @@ struct ParsedValues hb_vector_t values; }; -template -struct InterpEnv +template +struct interp_env_t { - void init (const ByteStr &str_) + void init (const byte_str_t &str_) { - substr.reset (str_); + str_ref.reset (str_); argStack.init (); error = false; } void fini () { argStack.fini (); } bool in_error () const - { return error || substr.in_error () || argStack.in_error (); } + { return error || str_ref.in_error () || argStack.in_error (); } void set_error () { error = true; } - OpCode fetch_op () + op_code_t fetch_op () { - OpCode op = OpCode_Invalid; - if (unlikely (!substr.avail ())) + op_code_t op = OpCode_Invalid; + if (unlikely (!str_ref.avail ())) return OpCode_Invalid; - op = (OpCode)(unsigned char)substr[0]; + op = (op_code_t)(unsigned char)str_ref[0]; if (op == OpCode_escape) { - if (unlikely (!substr.avail ())) + if (unlikely (!str_ref.avail ())) return OpCode_Invalid; - op = Make_OpCode_ESC(substr[1]); - substr.inc (); + op = Make_OpCode_ESC(str_ref[1]); + str_ref.inc (); } - substr.inc (); + str_ref.inc (); return op; } @@ -683,35 +664,35 @@ struct InterpEnv pop_n_args (argStack.get_count ()); } - SubByteStr substr; - ArgStack argStack; + byte_str_ref_t str_ref; + arg_stack_t argStack; protected: bool error; }; -typedef InterpEnv<> NumInterpEnv; +typedef interp_env_t<> num_interp_env_t; -template -struct OpSet +template +struct opset_t { - static void process_op (OpCode op, InterpEnv& env) + static void process_op (op_code_t op, interp_env_t& env) { switch (op) { case OpCode_shortint: - env.argStack.push_int ((int16_t)((env.substr[0] << 8) | env.substr[1])); - env.substr.inc (2); + env.argStack.push_int ((int16_t)((env.str_ref[0] << 8) | env.str_ref[1])); + env.str_ref.inc (2); break; case OpCode_TwoBytePosInt0: case OpCode_TwoBytePosInt1: case OpCode_TwoBytePosInt2: case OpCode_TwoBytePosInt3: - env.argStack.push_int ((int16_t)((op - OpCode_TwoBytePosInt0) * 256 + env.substr[0] + 108)); - env.substr.inc (); + env.argStack.push_int ((int16_t)((op - OpCode_TwoBytePosInt0) * 256 + env.str_ref[0] + 108)); + env.str_ref.inc (); break; case OpCode_TwoByteNegInt0: case OpCode_TwoByteNegInt1: case OpCode_TwoByteNegInt2: case OpCode_TwoByteNegInt3: - env.argStack.push_int ((int16_t)(-(op - OpCode_TwoByteNegInt0) * 256 - env.substr[0] - 108)); - env.substr.inc (); + env.argStack.push_int ((int16_t)(-(op - OpCode_TwoByteNegInt0) * 256 - env.str_ref[0] - 108)); + env.str_ref.inc (); break; default: @@ -730,9 +711,9 @@ struct OpSet }; template -struct Interpreter { +struct interpreter_t { - ~Interpreter() { fini (); } + ~interpreter_t() { fini (); } void fini () { env.fini (); } diff --git a/src/hb-cff-interp-cs-common.hh b/src/hb-cff-interp-cs-common.hh index e78d5571c..a2595baf7 100644 --- a/src/hb-cff-interp-cs-common.hh +++ b/src/hb-cff-interp-cs-common.hh @@ -33,34 +33,34 @@ namespace CFF { using namespace OT; -enum CSType { +enum cs_type_t { CSType_CharString, CSType_GlobalSubr, CSType_LocalSubr }; -struct CallContext +struct call_context_t { - void init (const SubByteStr substr_=SubByteStr (), CSType type_=CSType_CharString, unsigned int subr_num_=0) + void init (const byte_str_ref_t substr_=byte_str_ref_t (), cs_type_t type_=CSType_CharString, unsigned int subr_num_=0) { - substr = substr_; + str_ref = substr_; type = type_; subr_num = subr_num_; } void fini () {} - SubByteStr substr; - CSType type; + byte_str_ref_t str_ref; + cs_type_t type; unsigned int subr_num; }; /* call stack */ const unsigned int kMaxCallLimit = 10; -struct CallStack : Stack {}; +struct call_stack_t : stack_t {}; template -struct BiasedSubrs +struct biased_subrs_t { void init (const SUBRS &subrs_) { @@ -79,10 +79,10 @@ struct BiasedSubrs unsigned int get_count () const { return (subrs == nullptr)? 0: subrs->count; } unsigned int get_bias () const { return bias; } - ByteStr operator [] (unsigned int index) const + byte_str_t operator [] (unsigned int index) const { if (unlikely ((subrs == nullptr) || index >= subrs->count)) - return Null(ByteStr); + return Null(byte_str_t); else return (*subrs)[index]; } @@ -92,7 +92,7 @@ struct BiasedSubrs const SUBRS *subrs; }; -struct Point +struct point_t { void init () { @@ -106,21 +106,21 @@ struct Point y.set_int (_y); } - void move_x (const Number &dx) { x += dx; } - void move_y (const Number &dy) { y += dy; } - void move (const Number &dx, const Number &dy) { move_x (dx); move_y (dy); } - void move (const Point &d) { move_x (d.x); move_y (d.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); } - Number x; - Number y; + number_t x; + number_t y; }; template -struct CSInterpEnv : InterpEnv +struct cs_interp_env_t : interp_env_t { - void init (const ByteStr &str, const SUBRS &globalSubrs_, const SUBRS &localSubrs_) + void init (const byte_str_t &str, const SUBRS &globalSubrs_, const SUBRS &localSubrs_) { - InterpEnv::init (str); + interp_env_t::init (str); context.init (str, CSType_CharString); seen_moveto = true; @@ -134,7 +134,7 @@ struct CSInterpEnv : InterpEnv } void fini () { - InterpEnv::fini (); + interp_env_t::fini (); callStack.fini (); globalSubrs.fini (); @@ -146,7 +146,7 @@ struct CSInterpEnv : InterpEnv return callStack.in_error () || SUPER::in_error (); } - bool popSubrNum (const BiasedSubrs& biasedSubrs, unsigned int &subr_num) + 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 CSInterpEnv : InterpEnv return true; } - void callSubr (const BiasedSubrs& biasedSubrs, CSType type) + void callSubr (const biased_subrs_t& biasedSubrs, cs_type_t type) { unsigned int subr_num; @@ -167,19 +167,19 @@ struct CSInterpEnv : InterpEnv SUPER::set_error (); return; } - context.substr = SUPER::substr; + context.str_ref = SUPER::str_ref; callStack.push (context); context.init ( biasedSubrs[subr_num], type, subr_num); - SUPER::substr = context.substr; + SUPER::str_ref = context.str_ref; } void returnFromSubr () { - if (unlikely (SUPER::substr.in_error ())) + if (unlikely (SUPER::str_ref.in_error ())) SUPER::set_error (); context = callStack.pop (); - SUPER::substr = context.substr; + SUPER::str_ref = context.str_ref; } void determine_hintmask_size () @@ -195,14 +195,14 @@ struct CSInterpEnv : InterpEnv void set_endchar (bool endchar_flag_) { endchar_flag = endchar_flag_; } bool is_endchar () const { return endchar_flag; } - const Number &get_x () const { return pt.x; } - const Number &get_y () const { return pt.y; } - const Point &get_pt () const { return pt; } + 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; } - void moveto (const Point &pt_ ) { pt = pt_; } + void moveto (const point_t &pt_ ) { pt = pt_; } public: - CallContext context; + call_context_t context; bool endchar_flag; bool seen_moveto; bool seen_hintmask; @@ -210,18 +210,18 @@ struct CSInterpEnv : InterpEnv unsigned int hstem_count; unsigned int vstem_count; unsigned int hintmask_size; - CallStack callStack; - BiasedSubrs globalSubrs; - BiasedSubrs localSubrs; + call_stack_t callStack; + biased_subrs_t globalSubrs; + biased_subrs_t localSubrs; private: - Point pt; + point_t pt; - typedef InterpEnv SUPER; + typedef interp_env_t SUPER; }; template -struct PathProcsNull +struct path_procs_null_t { static void rmoveto (ENV &env, PARAM& param) {} static void hmoveto (ENV &env, PARAM& param) {} @@ -236,19 +236,19 @@ struct PathProcsNull 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 &pt) {} - static void line (ENV &env, PARAM& param, const Point &pt1) {} - static void curve (ENV &env, PARAM& param, const Point &pt1, const Point &pt2, const Point &pt3) {} + 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) {} }; -template > -struct CSOpSet : OpSet +template > +struct cs_opset_t : opset_t { - static void process_op (OpCode op, ENV &env, PARAM& param) + static void process_op (op_code_t op, ENV &env, PARAM& param) { switch (op) { @@ -262,7 +262,7 @@ struct CSOpSet : OpSet break; case OpCode_fixedcs: - env.argStack.push_fixed_from_substr (env.substr); + env.argStack.push_fixed_from_substr (env.str_ref); break; case OpCode_callsubr: @@ -370,37 +370,37 @@ struct CSOpSet : OpSet } } - static void process_hstem (OpCode op, ENV &env, PARAM& param) + static 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 (OpCode op, ENV &env, PARAM& param) + static 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 (OpCode op, ENV &env, PARAM& param) + static void process_hintmask (op_code_t op, ENV &env, PARAM& param) { env.determine_hintmask_size (); - if (likely (env.substr.avail (env.hintmask_size))) + if (likely (env.str_ref.avail (env.hintmask_size))) { OPSET::flush_hintmask (op, env, param); - env.substr.inc (env.hintmask_size); + env.str_ref.inc (env.hintmask_size); } } - static void process_post_flex (OpCode op, ENV &env, PARAM& param) + static void process_post_flex (op_code_t op, ENV &env, PARAM& param) { OPSET::flush_args_and_op (op, env, param); } - static void check_width (OpCode op, ENV &env, PARAM& param) + static void check_width (op_code_t op, ENV &env, PARAM& param) {} - static void process_post_move (OpCode op, ENV &env, PARAM& param) + static void process_post_move (op_code_t op, ENV &env, PARAM& param) { if (!env.seen_moveto) { @@ -410,12 +410,12 @@ struct CSOpSet : OpSet OPSET::flush_args_and_op (op, env, param); } - static void process_post_path (OpCode op, ENV &env, PARAM& param) + static 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 (OpCode op, ENV &env, PARAM& param) + static void flush_args_and_op (op_code_t op, ENV &env, PARAM& param) { OPSET::flush_args (env, param); OPSET::flush_op (op, env, param); @@ -426,16 +426,16 @@ struct CSOpSet : OpSet env.pop_n_args (env.argStack.get_count ()); } - static void flush_op (OpCode op, ENV &env, PARAM& param) + static void flush_op (op_code_t op, ENV &env, PARAM& param) { } - static void flush_hintmask (OpCode op, ENV &env, PARAM& param) + static void flush_hintmask (op_code_t op, ENV &env, PARAM& param) { OPSET::flush_args_and_op (op, env, param); } - static bool is_number_op (OpCode op) + static bool is_number_op (op_code_t op) { switch (op) { @@ -454,31 +454,31 @@ struct CSOpSet : OpSet } protected: - typedef OpSet SUPER; + typedef opset_t SUPER; }; template -struct PathProcs +struct path_procs_t { static void rmoveto (ENV &env, PARAM& param) { - Point pt1 = env.get_pt (); - const Number &dy = env.pop_arg (); - const Number &dx = env.pop_arg (); + point_t pt1 = env.get_pt (); + const number_t &dy = env.pop_arg (); + const number_t &dx = env.pop_arg (); pt1.move (dx, dy); PATH::moveto (env, param, pt1); } static void hmoveto (ENV &env, PARAM& param) { - Point pt1 = env.get_pt (); + point_t pt1 = env.get_pt (); pt1.move_x (env.pop_arg ()); PATH::moveto (env, param, pt1); } static void vmoveto (ENV &env, PARAM& param) { - Point pt1 = env.get_pt (); + point_t pt1 = env.get_pt (); pt1.move_y (env.pop_arg ()); PATH::moveto (env, param, pt1); } @@ -487,7 +487,7 @@ struct PathProcs { for (unsigned int i = 0; i + 2 <= env.argStack.get_count (); i += 2) { - Point pt1 = env.get_pt (); + point_t pt1 = env.get_pt (); pt1.move (env.eval_arg (i), env.eval_arg (i+1)); PATH::line (env, param, pt1); } @@ -495,7 +495,7 @@ struct PathProcs static void hlineto (ENV &env, PARAM& param) { - Point pt1; + point_t pt1; unsigned int i = 0; for (; i + 2 <= env.argStack.get_count (); i += 2) { @@ -515,7 +515,7 @@ struct PathProcs static void vlineto (ENV &env, PARAM& param) { - Point pt1; + point_t pt1; unsigned int i = 0; for (; i + 2 <= env.argStack.get_count (); i += 2) { @@ -537,11 +537,11 @@ struct PathProcs { for (unsigned int i = 0; i + 6 <= env.argStack.get_count (); i += 6) { - Point pt1 = env.get_pt (); + point_t pt1 = env.get_pt (); pt1.move (env.eval_arg (i), env.eval_arg (i+1)); - Point pt2 = pt1; + point_t pt2 = pt1; pt2.move (env.eval_arg (i+2), env.eval_arg (i+3)); - Point pt3 = pt2; + point_t pt3 = pt2; pt3.move (env.eval_arg (i+4), env.eval_arg (i+5)); PATH::curve (env, param, pt1, pt2, pt3); } @@ -552,17 +552,17 @@ struct PathProcs unsigned int i = 0; for (; i + 6 <= env.argStack.get_count (); i += 6) { - Point pt1 = env.get_pt (); + point_t pt1 = env.get_pt (); pt1.move (env.eval_arg (i), env.eval_arg (i+1)); - Point pt2 = pt1; + point_t pt2 = pt1; pt2.move (env.eval_arg (i+2), env.eval_arg (i+3)); - Point pt3 = pt2; + point_t pt3 = pt2; pt3.move (env.eval_arg (i+4), env.eval_arg (i+5)); PATH::curve (env, param, pt1, pt2, pt3); } for (; i + 2 <= env.argStack.get_count (); i += 2) { - Point pt1 = env.get_pt (); + point_t pt1 = env.get_pt (); pt1.move (env.eval_arg (i), env.eval_arg (i+1)); PATH::line (env, param, pt1); } @@ -574,17 +574,17 @@ struct PathProcs unsigned int line_limit = (env.argStack.get_count () % 6); for (; i + 2 <= line_limit; i += 2) { - Point pt1 = env.get_pt (); + point_t pt1 = env.get_pt (); pt1.move (env.eval_arg (i), env.eval_arg (i+1)); PATH::line (env, param, pt1); } for (; i + 6 <= env.argStack.get_count (); i += 6) { - Point pt1 = env.get_pt (); + point_t pt1 = env.get_pt (); pt1.move (env.eval_arg (i), env.eval_arg (i+1)); - Point pt2 = pt1; + point_t pt2 = pt1; pt2.move (env.eval_arg (i+2), env.eval_arg (i+3)); - Point pt3 = pt2; + point_t pt3 = pt2; pt3.move (env.eval_arg (i+4), env.eval_arg (i+5)); PATH::curve (env, param, pt1, pt2, pt3); } @@ -593,15 +593,15 @@ struct PathProcs static void vvcurveto (ENV &env, PARAM& param) { unsigned int i = 0; - Point pt1 = env.get_pt (); + point_t pt1 = env.get_pt (); if ((env.argStack.get_count () & 1) != 0) pt1.move_x (env.eval_arg (i++)); for (; i + 4 <= env.argStack.get_count (); i += 4) { pt1.move_y (env.eval_arg (i)); - Point pt2 = pt1; + point_t pt2 = pt1; pt2.move (env.eval_arg (i+1), env.eval_arg (i+2)); - Point pt3 = pt2; + point_t pt3 = pt2; pt3.move_y (env.eval_arg (i+3)); PATH::curve (env, param, pt1, pt2, pt3); pt1 = env.get_pt (); @@ -611,15 +611,15 @@ struct PathProcs static void hhcurveto (ENV &env, PARAM& param) { unsigned int i = 0; - Point pt1 = env.get_pt (); + point_t pt1 = env.get_pt (); if ((env.argStack.get_count () & 1) != 0) pt1.move_y (env.eval_arg (i++)); for (; i + 4 <= env.argStack.get_count (); i += 4) { pt1.move_x (env.eval_arg (i)); - Point pt2 = pt1; + point_t pt2 = pt1; pt2.move (env.eval_arg (i+1), env.eval_arg (i+2)); - Point pt3 = pt2; + point_t pt3 = pt2; pt3.move_x (env.eval_arg (i+3)); PATH::curve (env, param, pt1, pt2, pt3); pt1 = env.get_pt (); @@ -628,15 +628,15 @@ struct PathProcs static void vhcurveto (ENV &env, PARAM& param) { - Point pt1, pt2, pt3; + point_t pt1, pt2, pt3; unsigned int i = 0; if ((env.argStack.get_count () % 8) >= 4) { - Point pt1 = env.get_pt (); + point_t pt1 = env.get_pt (); pt1.move_y (env.eval_arg (i)); - Point pt2 = pt1; + point_t pt2 = pt1; pt2.move (env.eval_arg (i+1), env.eval_arg (i+2)); - Point pt3 = pt2; + point_t pt3 = pt2; pt3.move_x (env.eval_arg (i+3)); i += 4; @@ -689,15 +689,15 @@ struct PathProcs static void hvcurveto (ENV &env, PARAM& param) { - Point pt1, pt2, pt3; + point_t pt1, pt2, pt3; unsigned int i = 0; if ((env.argStack.get_count () % 8) >= 4) { - Point pt1 = env.get_pt (); + point_t pt1 = env.get_pt (); pt1.move_x (env.eval_arg (i)); - Point pt2 = pt1; + point_t pt2 = pt1; pt2.move (env.eval_arg (i+1), env.eval_arg (i+2)); - Point pt3 = pt2; + point_t pt3 = pt2; pt3.move_y (env.eval_arg (i+3)); i += 4; @@ -749,31 +749,31 @@ struct PathProcs } /* default actions to be overridden */ - static void moveto (ENV &env, PARAM& param, const Point &pt) + static void moveto (ENV &env, PARAM& param, const point_t &pt) { env.moveto (pt); } - static void line (ENV &env, PARAM& param, const Point &pt1) + static void line (ENV &env, PARAM& param, const point_t &pt1) { PATH::moveto (env, param, pt1); } - static void curve (ENV &env, PARAM& param, const Point &pt1, const Point &pt2, const Point &pt3) + static 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) { if (likely (env.argStack.get_count () == 7)) { - Point pt1 = env.get_pt (); + point_t pt1 = env.get_pt (); pt1.move_x (env.eval_arg (0)); - Point pt2 = pt1; + point_t pt2 = pt1; pt2.move (env.eval_arg (1), env.eval_arg (2)); - Point pt3 = pt2; + point_t pt3 = pt2; pt3.move_x (env.eval_arg (3)); - Point pt4 = pt3; + point_t pt4 = pt3; pt4.move_x (env.eval_arg (4)); - Point pt5 = pt4; + point_t pt5 = pt4; pt5.move_x (env.eval_arg (5)); pt5.y = pt1.y; - Point pt6 = pt5; + point_t pt6 = pt5; pt6.move_x (env.eval_arg (6)); curve2 (env, param, pt1, pt2, pt3, pt4, pt5, pt6); @@ -786,17 +786,17 @@ struct PathProcs { if (likely (env.argStack.get_count () == 13)) { - Point pt1 = env.get_pt (); + point_t pt1 = env.get_pt (); pt1.move (env.eval_arg (0), env.eval_arg (1)); - Point pt2 = pt1; + point_t pt2 = pt1; pt2.move (env.eval_arg (2), env.eval_arg (3)); - Point pt3 = pt2; + point_t pt3 = pt2; pt3.move (env.eval_arg (4), env.eval_arg (5)); - Point pt4 = pt3; + point_t pt4 = pt3; pt4.move (env.eval_arg (6), env.eval_arg (7)); - Point pt5 = pt4; + point_t pt5 = pt4; pt5.move (env.eval_arg (8), env.eval_arg (9)); - Point pt6 = pt5; + point_t pt6 = pt5; pt6.move (env.eval_arg (10), env.eval_arg (11)); curve2 (env, param, pt1, pt2, pt3, pt4, pt5, pt6); @@ -809,17 +809,17 @@ struct PathProcs { if (likely (env.argStack.get_count () == 9)) { - Point pt1 = env.get_pt (); + point_t pt1 = env.get_pt (); pt1.move (env.eval_arg (0), env.eval_arg (1)); - Point pt2 = pt1; + point_t pt2 = pt1; pt2.move (env.eval_arg (2), env.eval_arg (3)); - Point pt3 = pt2; + point_t pt3 = pt2; pt3.move_x (env.eval_arg (4)); - Point pt4 = pt3; + point_t pt4 = pt3; pt4.move_x (env.eval_arg (5)); - Point pt5 = pt4; + point_t pt5 = pt4; pt5.move (env.eval_arg (6), env.eval_arg (7)); - Point pt6 = pt5; + point_t pt6 = pt5; pt6.move_x (env.eval_arg (8)); pt6.y = env.get_pt ().y; @@ -833,22 +833,22 @@ struct PathProcs { if (likely (env.argStack.get_count () == 11)) { - Point d; + point_t d; d.init (); for (unsigned int i = 0; i < 10; i += 2) d.move (env.eval_arg (i), env.eval_arg (i+1)); - Point pt1 = env.get_pt (); + point_t pt1 = env.get_pt (); pt1.move (env.eval_arg (0), env.eval_arg (1)); - Point pt2 = pt1; + point_t pt2 = pt1; pt2.move (env.eval_arg (2), env.eval_arg (3)); - Point pt3 = pt2; + point_t pt3 = pt2; pt3.move (env.eval_arg (4), env.eval_arg (5)); - Point pt4 = pt3; + point_t pt4 = pt3; pt4.move (env.eval_arg (6), env.eval_arg (7)); - Point pt5 = pt4; + point_t pt5 = pt4; pt5.move (env.eval_arg (8), env.eval_arg (9)); - Point pt6 = pt5; + point_t pt6 = pt5; if (fabs (d.x.to_real ()) > fabs (d.y.to_real ())) { @@ -869,8 +869,8 @@ struct PathProcs protected: static void curve2 (ENV &env, PARAM& param, - const Point &pt1, const Point &pt2, const Point &pt3, - const Point &pt4, const Point &pt5, const Point &pt6) + const point_t &pt1, const point_t &pt2, const point_t &pt3, + const point_t &pt4, const point_t &pt5, const point_t &pt6) { PATH::curve (env, param, pt1, pt2, pt3); PATH::curve (env, param, pt4, pt5, pt6); @@ -878,7 +878,7 @@ struct PathProcs }; template -struct CSInterpreter : Interpreter +struct cs_interpreter_t : interpreter_t { bool interpret (PARAM& param) { @@ -896,7 +896,7 @@ struct CSInterpreter : Interpreter } private: - typedef Interpreter SUPER; + typedef interpreter_t SUPER; }; } /* namespace CFF */ diff --git a/src/hb-cff-interp-dict-common.hh b/src/hb-cff-interp-dict-common.hh index 8000d76b8..2c54909a1 100644 --- a/src/hb-cff-interp-dict-common.hh +++ b/src/hb-cff-interp-dict-common.hh @@ -35,28 +35,28 @@ namespace CFF { using namespace OT; /* an opstr and the parsed out dict value(s) */ -struct DictVal : OpStr +struct dict_val_t : op_str_t { void init () { single_val.set_int (0); } void fini () {} - Number single_val; + number_t single_val; }; -typedef DictVal NumDictVal; +typedef dict_val_t num_dict_val_t; -template struct DictValues : ParsedValues {}; +template struct dict_values_t : parsed_values_t {}; -template -struct TopDictValues : DictValues +template +struct top_dict_values_t : dict_values_t { void init () { - DictValues::init (); + dict_values_t::init (); charStringsOffset = 0; FDArrayOffset = 0; } - void fini () { DictValues::fini (); } + void fini () { dict_values_t::fini (); } unsigned int calculate_serialized_op_size (const OPSTR& opstr) const { @@ -67,7 +67,7 @@ struct TopDictValues : DictValues return OpCode_Size (OpCode_longintdict) + 4 + OpCode_Size (opstr.op); default: - return opstr.str.len; + return opstr.str.length; } } @@ -75,26 +75,26 @@ struct TopDictValues : DictValues unsigned int FDArrayOffset; }; -struct DictOpSet : OpSet +struct dict_opset_t : opset_t { - static void process_op (OpCode op, InterpEnv& env) + static void process_op (op_code_t op, interp_env_t& env) { switch (op) { case OpCode_longintdict: /* 5-byte integer */ - env.argStack.push_longint_from_substr (env.substr); + env.argStack.push_longint_from_substr (env.str_ref); break; case OpCode_BCD: /* real number */ - env.argStack.push_real (parse_bcd (env.substr)); + env.argStack.push_real (parse_bcd (env.str_ref)); break; default: - OpSet::process_op (op, env); + opset_t::process_op (op, env); break; } } - static double parse_bcd (SubByteStr& substr) + static double parse_bcd (byte_str_ref_t& str_ref) { bool neg = false; double int_part = 0; @@ -115,13 +115,13 @@ struct DictOpSet : OpSet char d; if ((i & 1) == 0) { - if (!substr.avail ()) + if (!str_ref.avail ()) { - substr.set_error (); + str_ref.set_error (); return 0.0; } - byte = substr[0]; - substr.inc (); + byte = str_ref[0]; + str_ref.inc (); d = byte >> 4; } else @@ -130,7 +130,7 @@ struct DictOpSet : OpSet switch (d) { case RESERVED: - substr.set_error (); + str_ref.set_error (); return value; case END: @@ -162,7 +162,7 @@ struct DictOpSet : OpSet case NEG: if (i != 0) { - substr.set_error (); + str_ref.set_error (); return 0.0; } neg = true; @@ -171,7 +171,7 @@ struct DictOpSet : OpSet case DECIMAL: if (part != INT_PART) { - substr.set_error (); + str_ref.set_error (); return value; } part = FRAC_PART; @@ -184,7 +184,7 @@ struct DictOpSet : OpSet case EXP_POS: if (part == EXP_PART) { - substr.set_error (); + str_ref.set_error (); return value; } part = EXP_PART; @@ -220,7 +220,7 @@ struct DictOpSet : OpSet return value; } - static bool is_hint_op (OpCode op) + static bool is_hint_op (op_code_t op) { switch (op) { @@ -245,10 +245,10 @@ struct DictOpSet : OpSet } }; -template -struct TopDictOpSet : DictOpSet +template +struct top_dict_opset_t : dict_opset_t { - static void process_op (OpCode op, InterpEnv& env, TopDictValues & dictval) + static void process_op (op_code_t op, interp_env_t& env, top_dict_values_t & dictval) { switch (op) { case OpCode_CharStrings: @@ -263,19 +263,19 @@ struct TopDictOpSet : DictOpSet env.clear_args (); break; default: - DictOpSet::process_op (op, env); + dict_opset_t::process_op (op, env); break; } } }; -template -struct DictInterpreter : Interpreter +template +struct dict_interpreter_t : interpreter_t { bool interpret (PARAM& param) { param.init (); - while (SUPER::env.substr.avail ()) + while (SUPER::env.str_ref.avail ()) { OPSET::process_op (SUPER::env.fetch_op (), SUPER::env, param); if (unlikely (SUPER::env.in_error ())) @@ -286,7 +286,7 @@ struct DictInterpreter : Interpreter } private: - typedef Interpreter SUPER; + typedef interpreter_t SUPER; }; } /* namespace CFF */ diff --git a/src/hb-cff1-interp-cs.hh b/src/hb-cff1-interp-cs.hh index 68e1d81d7..c7209ed80 100644 --- a/src/hb-cff1-interp-cs.hh +++ b/src/hb-cff1-interp-cs.hh @@ -33,12 +33,12 @@ namespace CFF { using namespace OT; -typedef BiasedSubrs CFF1BiasedSubrs; +typedef biased_subrs_t cff1_biased_subrs_t; -struct CFF1CSInterpEnv : CSInterpEnv +struct cff1_cs_interp_env_t : cs_interp_env_t { template - void init (const ByteStr &str, ACC &acc, unsigned int fd) + void init (const byte_str_t &str, ACC &acc, unsigned int fd) { SUPER::init (str, *acc.globalSubrs, *acc.privateDicts[fd].localSubrs); processed_width = false; @@ -74,20 +74,20 @@ struct CFF1CSInterpEnv : CSInterpEnv bool processed_width; bool has_width; unsigned int arg_start; - Number width; + number_t width; bool in_seac; private: - typedef CSInterpEnv SUPER; + typedef cs_interp_env_t SUPER; }; -template > -struct CFF1CSOpSet : CSOpSet +template > +struct cff1_cs_opset_t : cs_opset_t { /* PostScript-originated legacy opcodes (OpCode_add etc) are unsupported */ /* Type 1-originated deprecated opcodes, seac behavior of endchar and dotsection are supported */ - static void process_op (OpCode op, CFF1CSInterpEnv &env, PARAM& param) + static void process_op (op_code_t op, cff1_cs_interp_env_t &env, PARAM& param) { switch (op) { case OpCode_dotsection: @@ -109,7 +109,7 @@ struct CFF1CSOpSet : CSOpSet } } - static void check_width (OpCode op, CFF1CSInterpEnv &env, PARAM& param) + static void check_width (op_code_t op, cff1_cs_interp_env_t &env, PARAM& param) { if (!env.processed_width) { @@ -139,22 +139,22 @@ struct CFF1CSOpSet : CSOpSet } } - static void process_seac (CFF1CSInterpEnv &env, PARAM& param) + static void process_seac (cff1_cs_interp_env_t &env, PARAM& param) { } - static void flush_args (CFF1CSInterpEnv &env, PARAM& param) + static void flush_args (cff1_cs_interp_env_t &env, PARAM& param) { SUPER::flush_args (env, param); env.clear_args (); /* pop off width */ } private: - typedef CSOpSet SUPER; + typedef cs_opset_t SUPER; }; template -struct CFF1CSInterpreter : CSInterpreter {}; +struct cff1_cs_interpreter_t : cs_interpreter_t {}; } /* namespace CFF */ diff --git a/src/hb-cff2-interp-cs.hh b/src/hb-cff2-interp-cs.hh index c998d781f..49e5ee739 100644 --- a/src/hb-cff2-interp-cs.hh +++ b/src/hb-cff2-interp-cs.hh @@ -33,26 +33,26 @@ namespace CFF { using namespace OT; -struct BlendArg : Number +struct blend_arg_t : number_t { void init () { - Number::init (); + number_t::init (); deltas.init (); } void fini () { - Number::fini (); + number_t::fini (); deltas.fini_deep (); } - void set_int (int v) { reset_blends (); Number::set_int (v); } - void set_fixed (int32_t v) { reset_blends (); Number::set_fixed (v); } - void set_real (double v) { reset_blends (); Number::set_real (v); } + void set_int (int v) { reset_blends (); number_t::set_int (v); } + void set_fixed (int32_t v) { reset_blends (); number_t::set_fixed (v); } + void set_real (double v) { reset_blends (); number_t::set_real (v); } void set_blends (unsigned int numValues_, unsigned int valueIndex_, - unsigned int numBlends, hb_array_t blends_) + unsigned int numBlends, hb_array_t blends_) { numValues = numValues_; valueIndex = valueIndex_; @@ -70,16 +70,16 @@ struct BlendArg : Number unsigned int numValues; unsigned int valueIndex; - hb_vector_t deltas; + hb_vector_t deltas; }; -typedef InterpEnv BlendInterpEnv; -typedef BiasedSubrs CFF2BiasedSubrs; +typedef interp_env_t BlendInterpEnv; +typedef biased_subrs_t cff2_biased_subrs_t; -struct CFF2CSInterpEnv : CSInterpEnv +struct cff2_cs_interp_env_t : cs_interp_env_t { template - void init (const ByteStr &str, ACC &acc, unsigned int fd, + 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); @@ -100,9 +100,9 @@ struct CFF2CSInterpEnv : CSInterpEnv SUPER::fini (); } - OpCode fetch_op () + op_code_t fetch_op () { - if (this->substr.avail ()) + if (this->str_ref.avail ()) return SUPER::fetch_op (); /* make up return or endchar op */ @@ -112,16 +112,16 @@ struct CFF2CSInterpEnv : CSInterpEnv return OpCode_return; } - const BlendArg& eval_arg (unsigned int i) + const blend_arg_t& eval_arg (unsigned int i) { - BlendArg &arg = argStack[i]; + blend_arg_t &arg = argStack[i]; blend_arg (arg); return arg; } - const BlendArg& pop_arg () + const blend_arg_t& pop_arg () { - BlendArg &arg = argStack.pop (); + blend_arg_t &arg = argStack.pop (); blend_arg (arg); return arg; } @@ -163,7 +163,7 @@ struct CFF2CSInterpEnv : CSInterpEnv bool seen_vsindex () const { return seen_vsindex_; } protected: - void blend_arg (BlendArg &arg) + void blend_arg (blend_arg_t &arg) { if (do_blend && arg.blending ()) { @@ -191,12 +191,12 @@ struct CFF2CSInterpEnv : CSInterpEnv bool seen_vsindex_; bool seen_blend; - typedef CSInterpEnv SUPER; + typedef cs_interp_env_t SUPER; }; -template > -struct CFF2CSOpSet : CSOpSet +template > +struct cff2_cs_opset_t : cs_opset_t { - static void process_op (OpCode op, CFF2CSInterpEnv &env, PARAM& param) + static 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 CFF2CSOpSet : CSOpSet } } - static void process_blend (CFF2CSInterpEnv &env, PARAM& param) + static void process_blend (cff2_cs_interp_env_t &env, PARAM& param) { unsigned int n, k; @@ -245,7 +245,7 @@ struct CFF2CSOpSet : CSOpSet } for (unsigned int i = 0; i < n; i++) { - const hb_array_t blends = env.argStack.get_subarray (start + n + (i * k)); + const hb_array_t blends = env.argStack.get_subarray (start + n + (i * k)); env.argStack[start + i].set_blends (n, i, k, blends); } @@ -253,18 +253,18 @@ struct CFF2CSOpSet : CSOpSet env.argStack.pop (k * n); } - static void process_vsindex (CFF2CSInterpEnv &env, PARAM& param) + static void process_vsindex (cff2_cs_interp_env_t &env, PARAM& param) { env.process_vsindex (); env.clear_args (); } private: - typedef CSOpSet SUPER; + typedef cs_opset_t SUPER; }; template -struct CFF2CSInterpreter : CSInterpreter {}; +struct cff2_cs_interpreter_t : cs_interpreter_t {}; } /* namespace CFF */ diff --git a/src/hb-ot-cff-common.hh b/src/hb-ot-cff-common.hh index 115e297bf..05eaf64cf 100644 --- a/src/hb-ot-cff-common.hh +++ b/src/hb-ot-cff-common.hh @@ -55,14 +55,14 @@ inline unsigned int calcOffSize(unsigned int dataSize) return size; } -struct code_pair +struct code_pair_t { hb_codepoint_t code; hb_codepoint_t glyph; }; -typedef hb_vector_t StrBuff; -struct StrBuffArray : hb_vector_t +typedef hb_vector_t str_buff_t; +struct str_buff_vec_t : hb_vector_t { void fini () { SUPER::fini_deep (); } @@ -75,7 +75,7 @@ struct StrBuffArray : hb_vector_t } private: - typedef hb_vector_t SUPER; + typedef hb_vector_t SUPER; }; /* CFF INDEX */ @@ -117,7 +117,7 @@ struct CFFIndex bool serialize (hb_serialize_context_t *c, unsigned int offSize_, - const ByteStrArray &byteArray) + const byte_str_array_t &byteArray) { TRACE_SERIALIZE (this); if (byteArray.length == 0) @@ -148,10 +148,11 @@ struct CFFIndex /* serialize data */ for (unsigned int i = 0; i < byteArray.length; i++) { - ByteStr *dest = c->start_embed (); - if (unlikely (dest == nullptr || - !dest->serialize (c, byteArray[i]))) + const byte_str_t &bs = byteArray[i]; + unsigned char *dest = c->allocate_size (bs.length); + if (unlikely (dest == nullptr)) return_trace (false); + memcpy (dest, &bs[0], bs.length); } } return_trace (true); @@ -159,14 +160,14 @@ struct CFFIndex bool serialize (hb_serialize_context_t *c, unsigned int offSize_, - const StrBuffArray &buffArray) + const str_buff_vec_t &buffArray) { - ByteStrArray byteArray; + byte_str_array_t byteArray; byteArray.init (); byteArray.resize (buffArray.length); for (unsigned int i = 0; i < byteArray.length; i++) { - byteArray[i] = ByteStr (buffArray[i].arrayZ (), buffArray[i].length); + byteArray[i] = byte_str_t (buffArray[i].arrayZ (), buffArray[i].length); } bool result = this->serialize (c, offSize_, byteArray); byteArray.fini (); @@ -205,17 +206,17 @@ struct CFFIndex return 0; } - const char *data_base () const - { return (const char *)this + min_size + offset_array_size (); } + 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; } - ByteStr operator [] (unsigned int index) const + byte_str_t operator [] (unsigned int index) const { if (likely (index < count)) - return ByteStr (data_base () + offset_at (index) - 1, length_at (index)); + return byte_str_t (data_base () + offset_at (index) - 1, length_at (index)); else - return Null(ByteStr); + return Null(byte_str_t); } unsigned int get_size () const @@ -255,11 +256,11 @@ struct CFFIndex template struct CFFIndexOf : CFFIndex { - const ByteStr operator [] (unsigned int index) const + const byte_str_t operator [] (unsigned int index) const { if (likely (index < CFFIndex::count)) - return ByteStr (CFFIndex::data_base () + CFFIndex::offset_at (index) - 1, CFFIndex::length_at (index)); - return Null(ByteStr); + return byte_str_t (CFFIndex::data_base () + CFFIndex::offset_at (index) - 1, CFFIndex::length_at (index)); + return Null(byte_str_t); } template @@ -363,7 +364,7 @@ struct Dict : UnsizedByteStr } template - static bool serialize_int_op (hb_serialize_context_t *c, OpCode op, int value, OpCode intOp) + static 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))) @@ -383,18 +384,18 @@ struct Dict : UnsizedByteStr return_trace (true); } - static bool serialize_uint4_op (hb_serialize_context_t *c, OpCode op, int value) + static 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, OpCode op, int value) + static 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, OpCode op, int value) + static 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, OpCode op, int value) + static bool serialize_offset2_op (hb_serialize_context_t *c, op_code_t op, int value) { return serialize_uint2_op (c, op, value); } @@ -404,7 +405,7 @@ struct TopDict : Dict {}; struct FontDict : Dict {}; struct PrivateDict : Dict {}; -struct TableInfo +struct table_info_t { void init () { offSize = offset = size = 0; } @@ -415,7 +416,7 @@ struct TableInfo /* used to remap font index or SID from fullset to subset. * set to CFF_UNDEF_CODE if excluded from subset */ -struct Remap : hb_vector_t +struct remap_t : hb_vector_t { void init () { SUPER::init (); } @@ -507,9 +508,9 @@ struct FDArray : CFFIndexOf unsigned int offSize_, const hb_vector_t &fontDicts, unsigned int fdCount, - const Remap &fdmap, + const remap_t &fdmap, OP_SERIALIZER& opszr, - const hb_vector_t &privateInfos) + const hb_vector_t &privateInfos) { TRACE_SERIALIZE (this); if (unlikely (!c->extend_min (*this))) return_trace (false); @@ -545,7 +546,7 @@ struct FDArray : CFFIndexOf static unsigned int calculate_serialized_size (unsigned int &offSize_ /* OUT */, const hb_vector_t &fontDicts, unsigned int fdCount, - const Remap &fdmap, + const remap_t &fdmap, OP_SERIALIZER& opszr) { unsigned int dictsSize = 0; diff --git a/src/hb-ot-cff1-table.cc b/src/hb-ot-cff1-table.cc index 51cecb6f5..8773c05a2 100644 --- a/src/hb-ot-cff1-table.cc +++ b/src/hb-ot-cff1-table.cc @@ -161,7 +161,7 @@ hb_codepoint_t OT::cff1::lookup_standard_encoding_for_sid (hb_codepoint_t code) return CFF_UNDEF_SID; } -struct Bounds +struct bounds_t { void init () { @@ -169,7 +169,7 @@ struct Bounds max.set_int (-0x80000000, -0x80000000); } - void update (const Point &pt) + 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 if (pt.y > max.y) max.y = pt.y; } - void merge (const Bounds &b) + void merge (const bounds_t &b) { if (empty ()) *this = b; @@ -190,7 +190,7 @@ struct Bounds } } - void offset (const Point &delta) + void offset (const point_t &delta) { if (!empty ()) { @@ -202,11 +202,11 @@ struct Bounds bool empty () const { return (min.x >= max.x) || (min.y >= max.y); } - Point min; - Point max; + point_t min; + point_t max; }; -struct ExtentsParam +struct extents_param_t { void init (const OT::cff1::accelerator_t *_cff) { @@ -220,20 +220,20 @@ struct ExtentsParam bool is_path_open () const { return path_open; } bool path_open; - Bounds bounds; + bounds_t bounds; const OT::cff1::accelerator_t *cff; }; -struct CFF1PathProcs_Extents : PathProcs +struct cff1_path_procs_extents_t : path_procs_t { - static void moveto (CFF1CSInterpEnv &env, ExtentsParam& param, const Point &pt) + static 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 (CFF1CSInterpEnv &env, ExtentsParam& param, const Point &pt1) + static 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 CFF1PathProcs_Extents : PathProcs +struct cff1_cs_opset_extents_t : cff1_cs_opset_t { - static void process_seac (CFF1CSInterpEnv &env, ExtentsParam& param) + static void process_seac (cff1_cs_interp_env_t &env, extents_param_t& param) { unsigned int n = env.argStack.get_count (); - Point delta; + point_t delta; delta.x = env.argStack[n-4]; delta.y = env.argStack[n-3]; hb_codepoint_t base = param.cff->std_code_to_glyph (env.argStack[n-2].to_int ()); hb_codepoint_t accent = param.cff->std_code_to_glyph (env.argStack[n-1].to_int ()); - Bounds base_bounds, accent_bounds; + bounds_t base_bounds, accent_bounds; if (likely (!env.in_seac && base && accent && _get_bounds (param.cff, base, base_bounds, true) && _get_bounds (param.cff, accent, accent_bounds, true))) @@ -286,17 +286,17 @@ struct CFF1CSOpSet_Extents : CFF1CSOpSetis_valid () || (glyph >= cff->num_glyphs))) return false; unsigned int fd = cff->fdSelect->get_fd (glyph); - CFF1CSInterpreter interp; - const ByteStr str = (*cff->charStrings)[glyph]; + cff1_cs_interpreter_t interp; + const byte_str_t str = (*cff->charStrings)[glyph]; interp.env.init (str, *cff, fd); interp.env.set_in_seac (in_seac); - ExtentsParam param; + extents_param_t param; param.init (cff); if (unlikely (!interp.interpret (param))) return false; bounds = param.bounds; @@ -305,7 +305,7 @@ bool _get_bounds (const OT::cff1::accelerator_t *cff, hb_codepoint_t glyph, Boun bool OT::cff1::accelerator_t::get_extents (hb_codepoint_t glyph, hb_glyph_extents_t *extents) const { - Bounds bounds; + bounds_t bounds; if (!_get_bounds (this, glyph, bounds)) return false; @@ -334,7 +334,7 @@ bool OT::cff1::accelerator_t::get_extents (hb_codepoint_t glyph, hb_glyph_extent return true; } -struct GetSeacParam +struct get_seac_param_t { void init (const OT::cff1::accelerator_t *_cff) { @@ -350,9 +350,9 @@ struct GetSeacParam hb_codepoint_t accent; }; -struct CFF1CSOpSet_Seac : CFF1CSOpSet +struct cff1_cs_opset_seac_t : cff1_cs_opset_t { - static void process_seac (CFF1CSInterpEnv &env, GetSeacParam& param) + static 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 (); @@ -368,10 +368,10 @@ bool OT::cff1::accelerator_t::get_seac_components (hb_codepoint_t glyph, hb_code if (unlikely (!is_valid () || (glyph >= num_glyphs))) return false; unsigned int fd = fdSelect->get_fd (glyph); - CFF1CSInterpreter interp; - const ByteStr str = (*charStrings)[glyph]; + cff1_cs_interpreter_t interp; + const byte_str_t str = (*charStrings)[glyph]; interp.env.init (str, *this, fd); - GetSeacParam param; + get_seac_param_t param; param.init (this); if (unlikely (!interp.interpret (param))) return false; diff --git a/src/hb-ot-cff1-table.hh b/src/hb-ot-cff1-table.hh index 59618cbcf..ee1327757 100644 --- a/src/hb-ot-cff1-table.hh +++ b/src/hb-ot-cff1-table.hh @@ -193,8 +193,8 @@ struct 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) + const hb_vector_t& code_ranges, + const hb_vector_t& supp_codes) { TRACE_SERIALIZE (this); Encoding *dest = c->extend_min (*this); @@ -467,7 +467,7 @@ struct Charset { bool serialize (hb_serialize_context_t *c, uint8_t format, unsigned int num_glyphs, - const hb_vector_t& sid_ranges) + const hb_vector_t& sid_ranges) { TRACE_SERIALIZE (this); Charset *dest = c->extend_min (*this); @@ -573,7 +573,7 @@ struct Charset { struct CFF1StringIndex : CFF1Index { bool serialize (hb_serialize_context_t *c, const CFF1StringIndex &strings, - unsigned int offSize_, const Remap &sidmap) + unsigned int offSize_, const remap_t &sidmap) { TRACE_SERIALIZE (this); if (unlikely ((strings.count == 0) || (sidmap.get_count () == 0))) @@ -584,7 +584,7 @@ struct CFF1StringIndex : CFF1Index return_trace (true); } - ByteStrArray bytesArray; + byte_str_array_t bytesArray; bytesArray.init (); if (!bytesArray.resize (sidmap.get_count ())) return_trace (false); @@ -601,7 +601,7 @@ struct CFF1StringIndex : CFF1Index } /* in parallel to above */ - unsigned int calculate_serialized_size (unsigned int &offSize /*OUT*/, const Remap &sidmap) const + unsigned int calculate_serialized_size (unsigned int &offSize /*OUT*/, const remap_t &sidmap) const { offSize = 0; if ((count == 0) || (sidmap.get_count () == 0)) @@ -617,18 +617,18 @@ struct CFF1StringIndex : CFF1Index } }; -struct CFF1TopDictInterpEnv : NumInterpEnv +struct cff1_top_dict_interp_env_t : num_interp_env_t { - CFF1TopDictInterpEnv () - : NumInterpEnv(), prev_offset(0), last_offset(0) {} + cff1_top_dict_interp_env_t () + : num_interp_env_t(), prev_offset(0), last_offset(0) {} unsigned int prev_offset; unsigned int last_offset; }; -struct NameDictValues +struct name_dict_values_t { - enum NameDictValIndex + enum name_dict_val_index_t { version, notice, @@ -657,7 +657,7 @@ struct NameDictValues unsigned int operator[] (unsigned int i) const { assert (i < ValCount); return values[i]; } - static enum NameDictValIndex name_op_to_index (OpCode op) + static 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 @@ -685,16 +685,16 @@ struct NameDictValues unsigned int values[ValCount]; }; -struct CFF1TopDictVal : OpStr +struct cff1_top_dict_val_t : op_str_t { unsigned int last_arg_offset; }; -struct CFF1TopDictValues : TopDictValues +struct cff1_top_dict_values_t : top_dict_values_t { void init () { - TopDictValues::init (); + top_dict_values_t::init (); nameSIDs.init (); ros_supplement = 0; @@ -704,12 +704,12 @@ struct CFF1TopDictValues : TopDictValues FDSelectOffset = 0; privateDictInfo.init (); } - void fini () { TopDictValues::fini (); } + void fini () { top_dict_values_t::fini (); } bool is_CID () const - { return nameSIDs[NameDictValues::registry] != CFF_UNDEF_SID; } + { return nameSIDs[name_dict_values_t::registry] != CFF_UNDEF_SID; } - NameDictValues nameSIDs; + name_dict_values_t nameSIDs; unsigned int ros_supplement_offset; unsigned int ros_supplement; unsigned int cidCount; @@ -717,14 +717,14 @@ struct CFF1TopDictValues : TopDictValues unsigned int EncodingOffset; unsigned int CharsetOffset; unsigned int FDSelectOffset; - TableInfo privateDictInfo; + table_info_t privateDictInfo; }; -struct CFF1TopDictOpSet : TopDictOpSet +struct cff1_top_dict_opset_t : top_dict_opset_t { - static void process_op (OpCode op, CFF1TopDictInterpEnv& env, CFF1TopDictValues& dictval) + static void process_op (op_code_t op, cff1_top_dict_interp_env_t& env, cff1_top_dict_values_t& dictval) { - CFF1TopDictVal val; + cff1_top_dict_val_t val; val.last_arg_offset = (env.last_offset-1) - dictval.opStart; /* offset to the last argument */ switch (op) { @@ -736,7 +736,7 @@ struct CFF1TopDictOpSet : TopDictOpSet case OpCode_Weight: case OpCode_PostScript: case OpCode_BaseFontName: - dictval.nameSIDs[NameDictValues::name_op_to_index (op)] = env.argStack.pop_uint (); + dictval.nameSIDs[name_dict_values_t::name_op_to_index (op)] = env.argStack.pop_uint (); env.clear_args (); break; case OpCode_isFixedPitch: @@ -765,8 +765,8 @@ struct CFF1TopDictOpSet : TopDictOpSet case OpCode_ROS: dictval.ros_supplement = env.argStack.pop_uint (); - dictval.nameSIDs[NameDictValues::ordering] = env.argStack.pop_uint (); - dictval.nameSIDs[NameDictValues::registry] = env.argStack.pop_uint (); + dictval.nameSIDs[name_dict_values_t::ordering] = env.argStack.pop_uint (); + dictval.nameSIDs[name_dict_values_t::registry] = env.argStack.pop_uint (); env.clear_args (); break; @@ -794,8 +794,8 @@ struct CFF1TopDictOpSet : TopDictOpSet break; default: - env.last_offset = env.substr.offset; - TopDictOpSet::process_op (op, env, dictval); + env.last_offset = env.str_ref.offset; + top_dict_opset_t::process_op (op, env, dictval); /* Record this operand below if stack is empty, otherwise done */ if (!env.argStack.is_empty ()) return; break; @@ -803,27 +803,27 @@ struct CFF1TopDictOpSet : TopDictOpSet if (unlikely (env.in_error ())) return; - dictval.add_op (op, env.substr, val); + dictval.add_op (op, env.str_ref, val); } }; -struct CFF1FontDictValues : DictValues +struct cff1_font_dict_values_t : dict_values_t { void init () { - DictValues::init (); + dict_values_t::init (); privateDictInfo.init (); fontName = CFF_UNDEF_SID; } - void fini () { DictValues::fini (); } + void fini () { dict_values_t::fini (); } - TableInfo privateDictInfo; + table_info_t privateDictInfo; unsigned int fontName; }; -struct CFF1FontDictOpSet : DictOpSet +struct cff1_font_dict_opset_t : dict_opset_t { - static void process_op (OpCode op, NumInterpEnv& env, CFF1FontDictValues& dictval) + static void process_op (op_code_t op, num_interp_env_t& env, cff1_font_dict_values_t& dictval) { switch (op) { case OpCode_FontName: @@ -841,36 +841,36 @@ struct CFF1FontDictOpSet : DictOpSet break; default: - DictOpSet::process_op (op, env); + dict_opset_t::process_op (op, env); if (!env.argStack.is_empty ()) return; break; } if (unlikely (env.in_error ())) return; - dictval.add_op (op, env.substr); + dictval.add_op (op, env.str_ref); } }; template -struct CFF1PrivateDictValues_Base : DictValues +struct cff1_private_dict_values_base_t : dict_values_t { void init () { - DictValues::init (); + dict_values_t::init (); subrsOffset = 0; localSubrs = &Null(CFF1Subrs); } - void fini () { DictValues::fini (); } + void fini () { dict_values_t::fini (); } unsigned int calculate_serialized_size () const { unsigned int size = 0; - for (unsigned int i = 0; i < DictValues::get_count; i++) - if (DictValues::get_value (i).op == OpCode_Subrs) + for (unsigned int i = 0; i < dict_values_t::get_count; i++) + if (dict_values_t::get_value (i).op == OpCode_Subrs) size += OpCode_Size (OpCode_shortint) + 2 + OpCode_Size (OpCode_Subrs); else - size += DictValues::get_value (i).str.len; + size += dict_values_t::get_value (i).str.length; return size; } @@ -878,14 +878,14 @@ struct CFF1PrivateDictValues_Base : DictValues const CFF1Subrs *localSubrs; }; -typedef CFF1PrivateDictValues_Base CFF1PrivateDictValues_Subset; -typedef CFF1PrivateDictValues_Base CFF1PrivateDictValues; +typedef cff1_private_dict_values_base_t cff1_private_dict_values_subset_t; +typedef cff1_private_dict_values_base_t cff1_private_dict_values_t; -struct CFF1PrivateDictOpSet : DictOpSet +struct cff1_private_dict_opset_t : dict_opset_t { - static void process_op (OpCode op, NumInterpEnv& env, CFF1PrivateDictValues& dictval) + static void process_op (op_code_t op, num_interp_env_t& env, cff1_private_dict_values_t& dictval) { - NumDictVal val; + num_dict_val_t val; val.init (); switch (op) { @@ -917,20 +917,20 @@ struct CFF1PrivateDictOpSet : DictOpSet break; default: - DictOpSet::process_op (op, env); + dict_opset_t::process_op (op, env); if (!env.argStack.is_empty ()) return; break; } if (unlikely (env.in_error ())) return; - dictval.add_op (op, env.substr, val); + dictval.add_op (op, env.str_ref, val); } }; -struct CFF1PrivateDictOpSet_Subset : DictOpSet +struct cff1_private_dict_opset_subset : dict_opset_t { - static void process_op (OpCode op, NumInterpEnv& env, CFF1PrivateDictValues_Subset& dictval) + static void process_op (op_code_t op, num_interp_env_t& env, cff1_private_dict_values_subset_t& dictval) { switch (op) { case OpCode_BlueValues: @@ -959,20 +959,19 @@ struct CFF1PrivateDictOpSet_Subset : DictOpSet break; default: - DictOpSet::process_op (op, env); + dict_opset_t::process_op (op, env); if (!env.argStack.is_empty ()) return; break; } if (unlikely (env.in_error ())) return; - dictval.add_op (op, env.substr); + dictval.add_op (op, env.str_ref); } }; -typedef DictInterpreter CFF1TopDict_Interpreter; -typedef DictInterpreter CFF1FontDict_Interpreter; -typedef DictInterpreter CFF1PrivateDict_Interpreter; +typedef dict_interpreter_t cff1_top_dict_interpreter_t; +typedef dict_interpreter_t cff1_font_dict_interpreter_t; typedef CFF1Index CFF1NameIndex; typedef CFF1IndexOf CFF1TopDictIndex; @@ -1023,9 +1022,9 @@ struct cff1 { fini (); return; } { /* parse top dict */ - const ByteStr topDictStr = (*topDictIndex)[0]; + const byte_str_t topDictStr = (*topDictIndex)[0]; if (unlikely (!topDictStr.sanitize (&sc))) { fini (); return; } - CFF1TopDict_Interpreter top_interp; + cff1_top_dict_interpreter_t top_interp; top_interp.env.init (topDictStr); topDict.init (); if (unlikely (!top_interp.interpret (topDict))) { fini (); return; } @@ -1082,24 +1081,24 @@ struct cff1 { for (unsigned int i = 0; i < fdCount; i++) { - ByteStr fontDictStr = (*fdArray)[i]; + byte_str_t fontDictStr = (*fdArray)[i]; if (unlikely (!fontDictStr.sanitize (&sc))) { fini (); return; } - CFF1FontDictValues *font; - CFF1FontDict_Interpreter font_interp; + cff1_font_dict_values_t *font; + cff1_font_dict_interpreter_t font_interp; font_interp.env.init (fontDictStr); font = fontDicts.push (); - if (unlikely (font == &Crap(CFF1FontDictValues))) { fini (); return; } + if (unlikely (font == &Crap(cff1_font_dict_values_t))) { fini (); return; } font->init (); if (unlikely (!font_interp.interpret (*font))) { fini (); return; } PRIVDICTVAL *priv = &privateDicts[i]; - const ByteStr privDictStr (StructAtOffset (cff, font->privateDictInfo.offset), font->privateDictInfo.size); + const byte_str_t privDictStr (StructAtOffset (cff, font->privateDictInfo.offset), font->privateDictInfo.size); if (unlikely (!privDictStr.sanitize (&sc))) { fini (); return; } - DictInterpreter priv_interp; + dict_interpreter_t priv_interp; priv_interp.env.init (privDictStr); priv->init (); if (unlikely (!priv_interp.interpret (*priv))) { fini (); return; } - priv->localSubrs = &StructAtOffsetOrNull (privDictStr.str, priv->subrsOffset); + priv->localSubrs = &StructAtOffsetOrNull (&privDictStr, priv->subrsOffset); if (priv->localSubrs != &Null(CFF1Subrs) && unlikely (!priv->localSubrs->sanitize (&sc))) { fini (); return; } @@ -1107,17 +1106,17 @@ struct cff1 } else /* non-CID */ { - CFF1TopDictValues *font = &topDict; + cff1_top_dict_values_t *font = &topDict; PRIVDICTVAL *priv = &privateDicts[0]; - const ByteStr privDictStr (StructAtOffset (cff, font->privateDictInfo.offset), font->privateDictInfo.size); + const byte_str_t privDictStr (StructAtOffset (cff, font->privateDictInfo.offset), font->privateDictInfo.size); if (unlikely (!privDictStr.sanitize (&sc))) { fini (); return; } - DictInterpreter priv_interp; + dict_interpreter_t priv_interp; priv_interp.env.init (privDictStr); priv->init (); if (unlikely (!priv_interp.interpret (*priv))) { fini (); return; } - priv->localSubrs = &StructAtOffsetOrNull (privDictStr.str, priv->subrsOffset); + priv->localSubrs = &StructAtOffsetOrNull (&privDictStr, priv->subrsOffset); if (priv->localSubrs != &Null(CFF1Subrs) && unlikely (!priv->localSubrs->sanitize (&sc))) { fini (); return; } @@ -1167,20 +1166,20 @@ struct cff1 const CFF1FDSelect *fdSelect; unsigned int fdCount; - CFF1TopDictValues topDict; - hb_vector_t fontDicts; + cff1_top_dict_values_t topDict; + hb_vector_t fontDicts; hb_vector_t privateDicts; unsigned int num_glyphs; }; - struct accelerator_t : accelerator_templ_t + struct accelerator_t : accelerator_templ_t { HB_INTERNAL bool get_extents (hb_codepoint_t glyph, hb_glyph_extents_t *extents) const; HB_INTERNAL bool get_seac_components (hb_codepoint_t glyph, hb_codepoint_t *base, hb_codepoint_t *accent) const; }; - struct accelerator_subset_t : accelerator_templ_t + struct accelerator_subset_t : accelerator_templ_t { void init (hb_face_t *face) { @@ -1257,7 +1256,7 @@ struct cff1 const Encoding *encoding; private: - typedef accelerator_templ_t SUPER; + typedef accelerator_templ_t SUPER; }; bool subset (hb_subset_plan_t *plan) const diff --git a/src/hb-ot-cff2-table.cc b/src/hb-ot-cff2-table.cc index 7188a3bfe..7daa53656 100644 --- a/src/hb-ot-cff2-table.cc +++ b/src/hb-ot-cff2-table.cc @@ -29,7 +29,7 @@ using namespace CFF; -struct ExtentsParam +struct extents_param_t { void init () { @@ -44,7 +44,7 @@ struct ExtentsParam void end_path () { path_open = false; } bool is_path_open () const { return path_open; } - void update_bounds (const Point &pt) + 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; @@ -53,21 +53,21 @@ struct ExtentsParam } bool path_open; - Number min_x; - Number min_y; - Number max_x; - Number max_y; + number_t min_x; + number_t min_y; + number_t max_x; + number_t max_y; }; -struct CFF2PathProcs_Extents : PathProcs +struct cff2_path_procs_extents_t : path_procs_t { - static void moveto (CFF2CSInterpEnv &env, ExtentsParam& param, const Point &pt) + static 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 (CFF2CSInterpEnv &env, ExtentsParam& param, const Point &pt1) + static 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 CFF2PathProcs_Extents : PathProcs {}; +struct cff2_cs_opset_extents_t : cff2_cs_opset_t {}; bool OT::cff2::accelerator_t::get_extents (hb_font_t *font, hb_codepoint_t glyph, @@ -104,10 +104,10 @@ bool OT::cff2::accelerator_t::get_extents (hb_font_t *font, unsigned int num_coords; const int *coords = hb_font_get_var_coords_normalized (font, &num_coords); unsigned int fd = fdSelect->get_fd (glyph); - CFF2CSInterpreter interp; - const ByteStr str = (*charStrings)[glyph]; + cff2_cs_interpreter_t interp; + const byte_str_t str = (*charStrings)[glyph]; interp.env.init (str, *this, fd, coords, num_coords); - ExtentsParam param; + extents_param_t param; param.init (); if (unlikely (!interp.interpret (param))) return false; diff --git a/src/hb-ot-cff2-table.hh b/src/hb-ot-cff2-table.hh index 25c41ef8c..7b1c6ee4a 100644 --- a/src/hb-ot-cff2-table.hh +++ b/src/hb-ot-cff2-table.hh @@ -136,22 +136,22 @@ struct CFF2VariationStore DEFINE_SIZE_MIN (2 + VariationStore::min_size); }; -struct CFF2TopDictValues : TopDictValues<> +struct cff2_top_dict_values_t : top_dict_values_t<> { void init () { - TopDictValues<>::init (); + top_dict_values_t<>::init (); vstoreOffset = 0; FDSelectOffset = 0; } - void fini () { TopDictValues<>::fini (); } + void fini () { top_dict_values_t<>::fini (); } unsigned int calculate_serialized_size () const { unsigned int size = 0; for (unsigned int i = 0; i < get_count (); i++) { - OpCode op = get_value (i).op; + op_code_t op = get_value (i).op; switch (op) { case OpCode_vstore: @@ -159,7 +159,7 @@ struct CFF2TopDictValues : TopDictValues<> size += OpCode_Size (OpCode_longintdict) + 4 + OpCode_Size (op); break; default: - size += TopDictValues<>::calculate_serialized_op_size (get_value (i)); + size += top_dict_values_t<>::calculate_serialized_op_size (get_value (i)); break; } } @@ -170,16 +170,16 @@ struct CFF2TopDictValues : TopDictValues<> unsigned int FDSelectOffset; }; -struct CFF2TopDictOpSet : TopDictOpSet<> +struct cff2_top_dict_opset_t : top_dict_opset_t<> { - static void process_op (OpCode op, NumInterpEnv& env, CFF2TopDictValues& dictval) + static void process_op (op_code_t op, num_interp_env_t& env, cff2_top_dict_values_t& dictval) { switch (op) { case OpCode_FontMatrix: { - DictVal val; + dict_val_t val; val.init (); - dictval.add_op (op, env.substr); + dictval.add_op (op, env.str_ref); env.clear_args (); } break; @@ -201,27 +201,27 @@ struct CFF2TopDictOpSet : TopDictOpSet<> if (unlikely (env.in_error ())) return; - dictval.add_op (op, env.substr); + dictval.add_op (op, env.str_ref); } - typedef TopDictOpSet<> SUPER; + typedef top_dict_opset_t<> SUPER; }; -struct CFF2FontDictValues : DictValues +struct cff2_font_dict_values_t : dict_values_t { void init () { - DictValues::init (); + dict_values_t::init (); privateDictInfo.init (); } - void fini () { DictValues::fini (); } + void fini () { dict_values_t::fini (); } - TableInfo privateDictInfo; + table_info_t privateDictInfo; }; -struct CFF2FontDictOpSet : DictOpSet +struct cff2_font_dict_opset_t : dict_opset_t { - static void process_op (OpCode op, NumInterpEnv& env, CFF2FontDictValues& dictval) + static void process_op (op_code_t op, num_interp_env_t& env, cff2_font_dict_values_t& dictval) { switch (op) { case OpCode_Private: @@ -238,33 +238,33 @@ struct CFF2FontDictOpSet : DictOpSet if (unlikely (env.in_error ())) return; - dictval.add_op (op, env.substr); + dictval.add_op (op, env.str_ref); } private: - typedef DictOpSet SUPER; + typedef dict_opset_t SUPER; }; template -struct CFF2PrivateDictValues_Base : DictValues +struct cff2_private_dict_values_base_t : dict_values_t { void init () { - DictValues::init (); + dict_values_t::init (); subrsOffset = 0; localSubrs = &Null(CFF2Subrs); ivs = 0; } - void fini () { DictValues::fini (); } + void fini () { dict_values_t::fini (); } unsigned int calculate_serialized_size () const { unsigned int size = 0; - for (unsigned int i = 0; i < DictValues::get_count; i++) - if (DictValues::get_value (i).op == OpCode_Subrs) + for (unsigned int i = 0; i < dict_values_t::get_count; i++) + if (dict_values_t::get_value (i).op == OpCode_Subrs) size += OpCode_Size (OpCode_shortint) + 2 + OpCode_Size (OpCode_Subrs); else - size += DictValues::get_value (i).str.len; + size += dict_values_t::get_value (i).str.length; return size; } @@ -273,14 +273,14 @@ struct CFF2PrivateDictValues_Base : DictValues unsigned int ivs; }; -typedef CFF2PrivateDictValues_Base CFF2PrivateDictValues_Subset; -typedef CFF2PrivateDictValues_Base CFF2PrivateDictValues; +typedef cff2_private_dict_values_base_t cff2_private_dict_values_subset_t; +typedef cff2_private_dict_values_base_t cff2_private_dict_values_t; -struct CFF2PrivDictInterpEnv : NumInterpEnv +struct cff2_priv_dict_interp_env_t : num_interp_env_t { - void init (const ByteStr &str) + void init (const byte_str_t &str) { - NumInterpEnv::init (str); + num_interp_env_t::init (str); ivs = 0; seen_vsindex = false; } @@ -302,11 +302,11 @@ struct CFF2PrivDictInterpEnv : NumInterpEnv bool seen_vsindex; }; -struct CFF2PrivateDictOpSet : DictOpSet +struct cff2_private_dict_opset_t : dict_opset_t { - static void process_op (OpCode op, CFF2PrivDictInterpEnv& env, CFF2PrivateDictValues& dictval) + static void process_op (op_code_t op, cff2_priv_dict_interp_env_t& env, cff2_private_dict_values_t& dictval) { - NumDictVal val; + num_dict_val_t val; val.init (); switch (op) { @@ -341,20 +341,20 @@ struct CFF2PrivateDictOpSet : DictOpSet break; default: - DictOpSet::process_op (op, env); + dict_opset_t::process_op (op, env); if (!env.argStack.is_empty ()) return; break; } if (unlikely (env.in_error ())) return; - dictval.add_op (op, env.substr, val); + dictval.add_op (op, env.str_ref, val); } }; -struct CFF2PrivateDictOpSet_Subset : DictOpSet +struct cff2_private_dict_opset_subset_t : dict_opset_t { - static void process_op (OpCode op, CFF2PrivDictInterpEnv& env, CFF2PrivateDictValues_Subset& dictval) + static 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: @@ -390,15 +390,15 @@ struct CFF2PrivateDictOpSet_Subset : DictOpSet if (unlikely (env.in_error ())) return; - dictval.add_op (op, env.substr); + dictval.add_op (op, env.str_ref); } private: - typedef DictOpSet SUPER; + typedef dict_opset_t SUPER; }; -typedef DictInterpreter CFF2TopDict_Interpreter; -typedef DictInterpreter CFF2FontDict_Interpreter; +typedef dict_interpreter_t cff2_top_dict_interpreter_t; +typedef dict_interpreter_t cff2_font_dict_interpreter_t; }; /* namespace CFF */ @@ -438,9 +438,9 @@ struct cff2 { fini (); return; } { /* parse top dict */ - ByteStr topDictStr (cff2 + cff2->topDict, cff2->topDictSize); + byte_str_t topDictStr (cff2 + cff2->topDict, cff2->topDictSize); if (unlikely (!topDictStr.sanitize (&sc))) { fini (); return; } - CFF2TopDict_Interpreter top_interp; + cff2_top_dict_interpreter_t top_interp; top_interp.env.init (topDictStr); topDict.init (); if (unlikely (!top_interp.interpret (topDict))) { fini (); return; } @@ -469,24 +469,24 @@ struct cff2 /* parse font dicts and gather private dicts */ for (unsigned int i = 0; i < fdCount; i++) { - const ByteStr fontDictStr = (*fdArray)[i]; + const byte_str_t fontDictStr = (*fdArray)[i]; if (unlikely (!fontDictStr.sanitize (&sc))) { fini (); return; } - CFF2FontDictValues *font; - CFF2FontDict_Interpreter font_interp; + cff2_font_dict_values_t *font; + cff2_font_dict_interpreter_t font_interp; font_interp.env.init (fontDictStr); font = fontDicts.push (); - if (unlikely (font == &Crap(CFF2FontDictValues))) { fini (); return; } + if (unlikely (font == &Crap(cff2_font_dict_values_t))) { fini (); return; } font->init (); if (unlikely (!font_interp.interpret (*font))) { fini (); return; } - const ByteStr privDictStr (StructAtOffsetOrNull (cff2, font->privateDictInfo.offset), font->privateDictInfo.size); + const byte_str_t privDictStr (StructAtOffsetOrNull (cff2, font->privateDictInfo.offset), font->privateDictInfo.size); if (unlikely (!privDictStr.sanitize (&sc))) { fini (); return; } - DictInterpreter priv_interp; + dict_interpreter_t priv_interp; priv_interp.env.init(privDictStr); privateDicts[i].init (); if (unlikely (!priv_interp.interpret (privateDicts[i]))) { fini (); return; } - privateDicts[i].localSubrs = &StructAtOffsetOrNull (privDictStr.str, privateDicts[i].subrsOffset); + privateDicts[i].localSubrs = &StructAtOffsetOrNull (&privDictStr[0], privateDicts[i].subrsOffset); if (privateDicts[i].localSubrs != &Null(CFF2Subrs) && unlikely (!privateDicts[i].localSubrs->sanitize (&sc))) { fini (); return; } @@ -505,32 +505,32 @@ struct cff2 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: - CFF2TopDictValues 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 CFF2VariationStore *varStore; + const CFF2CharStrings *charStrings; + const CFF2FDArray *fdArray; + const CFF2FDSelect *fdSelect; + unsigned int fdCount; - hb_vector_t fontDicts; + hb_vector_t fontDicts; hb_vector_t privateDicts; - unsigned int num_glyphs; + unsigned int num_glyphs; }; - struct accelerator_t : accelerator_templ_t + struct accelerator_t : accelerator_templ_t { HB_INTERNAL bool get_extents (hb_font_t *font, hb_codepoint_t glyph, hb_glyph_extents_t *extents) const; }; - typedef accelerator_templ_t accelerator_subset_t; + typedef accelerator_templ_t accelerator_subset_t; bool subset (hb_subset_plan_t *plan) const { diff --git a/src/hb-subset-cff-common.cc b/src/hb-subset-cff-common.cc index c7c9225a9..47efadff8 100644 --- a/src/hb-subset-cff-common.cc +++ b/src/hb-subset-cff-common.cc @@ -49,8 +49,8 @@ hb_plan_subset_cff_fdselect (const hb_vector_t &glyphs, unsigned int &subset_fd_count /* OUT */, unsigned int &subset_fdselect_size /* OUT */, unsigned int &subset_fdselect_format /* OUT */, - hb_vector_t &fdselect_ranges /* OUT */, - Remap &fdmap /* OUT */) + hb_vector_t &fdselect_ranges /* OUT */, + remap_t &fdmap /* OUT */) { subset_fd_count = 0; subset_fdselect_size = 0; @@ -76,7 +76,7 @@ hb_plan_subset_cff_fdselect (const hb_vector_t &glyphs, { num_ranges++; prev_fd = fd; - code_pair pair = { fd, i }; + code_pair_t pair = { fd, i }; fdselect_ranges.push (pair); } } @@ -148,7 +148,7 @@ serialize_fdselect_3_4 (hb_serialize_context_t *c, const unsigned int num_glyphs, const FDSelect &src, unsigned int size, - const hb_vector_t &fdselect_ranges) + const hb_vector_t &fdselect_ranges) { TRACE_SERIALIZE (this); FDSELECT3_4 *p = c->allocate_size (size); @@ -174,7 +174,7 @@ hb_serialize_cff_fdselect (hb_serialize_context_t *c, unsigned int fd_count, unsigned int fdselect_format, unsigned int size, - const hb_vector_t &fdselect_ranges) + const hb_vector_t &fdselect_ranges) { TRACE_SERIALIZE (this); FDSelect *p = c->allocate_min (); diff --git a/src/hb-subset-cff-common.hh b/src/hb-subset-cff-common.hh index df87ca514..512649a8d 100644 --- a/src/hb-subset-cff-common.hh +++ b/src/hb-subset-cff-common.hh @@ -35,16 +35,16 @@ namespace CFF { /* Used for writing a temporary charstring */ -struct StrEncoder +struct str_encoder_t { - StrEncoder (StrBuff &buff_) + str_encoder_t (str_buff_t &buff_) : buff (buff_), error (false) {} void reset () { buff.resize (0); } void encode_byte (unsigned char b) { - if (unlikely (buff.push ((const char)b) == &Crap(char))) + if (unlikely (buff.push (b) == &Crap(unsigned char))) set_error (); } @@ -79,7 +79,7 @@ struct StrEncoder } } - void encode_num (const Number& n) + void encode_num (const number_t& n) { if (n.in_int_range ()) { @@ -96,7 +96,7 @@ struct StrEncoder } } - void encode_op (OpCode op) + void encode_op (op_code_t op) { if (Is_OpCode_ESC (op)) { @@ -107,16 +107,16 @@ struct StrEncoder encode_byte (op); } - void copy_str (const ByteStr &str) + void copy_str (const byte_str_t &str) { unsigned int offset = buff.length; - buff.resize (offset + str.len); - if (unlikely (buff.length < offset + str.len)) + buff.resize (offset + str.length); + if (unlikely (buff.length < offset + str.length)) { set_error (); return; } - memcpy (&buff[offset], &str.str[0], str.len); + memcpy (&buff[offset], &str[0], str.length); } bool is_error () const { return error; } @@ -124,12 +124,12 @@ struct StrEncoder protected: void set_error () { error = true; } - StrBuff &buff; + str_buff_t &buff; bool error; }; -struct CFFSubTableOffsets { - CFFSubTableOffsets () : privateDictsOffset (0) +struct cff_sub_table_offsets_t { + cff_sub_table_offsets_t () : privateDictsOffset (0) { topDictInfo.init (); FDSelectInfo.init (); @@ -139,23 +139,23 @@ struct CFFSubTableOffsets { localSubrsInfos.init (); } - ~CFFSubTableOffsets () { localSubrsInfos.fini (); } + ~cff_sub_table_offsets_t () { localSubrsInfos.fini (); } - TableInfo topDictInfo; - TableInfo FDSelectInfo; - TableInfo FDArrayInfo; - TableInfo charStringsInfo; + table_info_t topDictInfo; + table_info_t FDSelectInfo; + table_info_t FDArrayInfo; + table_info_t charStringsInfo; unsigned int privateDictsOffset; - TableInfo globalSubrsInfo; - hb_vector_t localSubrsInfos; + table_info_t globalSubrsInfo; + hb_vector_t localSubrsInfos; }; -template -struct CFFTopDict_OpSerializer : OpSerializer +template +struct cff_top_dict_op_serializer_t : op_serializer_t { bool serialize (hb_serialize_context_t *c, const OPSTR &opstr, - const CFFSubTableOffsets &offsets) const + const cff_sub_table_offsets_t &offsets) const { TRACE_SERIALIZE (this); @@ -186,16 +186,16 @@ struct CFFTopDict_OpSerializer : OpSerializer return OpCode_Size (OpCode_longintdict) + 4 + OpCode_Size (opstr.op); default: - return opstr.str.len; + return opstr.str.length; } } }; -struct CFFFontDict_OpSerializer : OpSerializer +struct cff_font_dict_op_serializer_t : op_serializer_t { bool serialize (hb_serialize_context_t *c, - const OpStr &opstr, - const TableInfo &privateDictInfo) const + const op_str_t &opstr, + const table_info_t &privateDictInfo) const { TRACE_SERIALIZE (this); @@ -215,34 +215,34 @@ struct CFFFontDict_OpSerializer : OpSerializer } else { - HBUINT8 *d = c->allocate_size (opstr.str.len); + HBUINT8 *d = c->allocate_size (opstr.str.length); if (unlikely (d == nullptr)) return_trace (false); - memcpy (d, &opstr.str.str[0], opstr.str.len); + memcpy (d, &opstr.str[0], opstr.str.length); } return_trace (true); } - unsigned int calculate_serialized_size (const OpStr &opstr) const + 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); else - return opstr.str.len; + return opstr.str.length; } }; -struct CFFPrivateDict_OpSerializer : OpSerializer +struct cff_private_dict_op_serializer_t : op_serializer_t { - CFFPrivateDict_OpSerializer (bool desubroutinize_, bool drop_hints_) + 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 OpStr &opstr, + const op_str_t &opstr, const unsigned int subrsOffset) const { TRACE_SERIALIZE (this); - if (drop_hints && DictOpSet::is_hint_op (opstr.op)) + if (drop_hints && dict_opset_t::is_hint_op (opstr.op)) return true; if (opstr.op == OpCode_Subrs) { @@ -255,10 +255,10 @@ struct CFFPrivateDict_OpSerializer : OpSerializer return_trace (copy_opstr (c, opstr)); } - unsigned int calculate_serialized_size (const OpStr &opstr, + unsigned int calculate_serialized_size (const op_str_t &opstr, bool has_localsubr=true) const { - if (drop_hints && DictOpSet::is_hint_op (opstr.op)) + if (drop_hints && dict_opset_t::is_hint_op (opstr.op)) return 0; if (opstr.op == OpCode_Subrs) { @@ -268,7 +268,7 @@ struct CFFPrivateDict_OpSerializer : OpSerializer return OpCode_Size (OpCode_shortint) + 2 + OpCode_Size (opstr.op); } else - return opstr.str.len; + return opstr.str.length; } protected: @@ -276,16 +276,16 @@ struct CFFPrivateDict_OpSerializer : OpSerializer const bool drop_hints; }; -struct FlattenParam +struct flatten_param_t { - StrBuff &flatStr; + str_buff_t &flatStr; bool drop_hints; }; template -struct SubrFlattener +struct subr_flattener_t { - SubrFlattener (const ACC &acc_, + subr_flattener_t (const ACC &acc_, const hb_vector_t &glyphs_, bool drop_hints_) : acc (acc_), @@ -293,7 +293,7 @@ struct SubrFlattener drop_hints (drop_hints_) {} - bool flatten (StrBuffArray &flat_charstrings) + bool flatten (str_buff_vec_t &flat_charstrings) { if (!flat_charstrings.resize (glyphs.length)) return false; @@ -302,13 +302,13 @@ struct SubrFlattener for (unsigned int i = 0; i < glyphs.length; i++) { hb_codepoint_t glyph = glyphs[i]; - const ByteStr str = (*acc.charStrings)[glyph]; + const byte_str_t str = (*acc.charStrings)[glyph]; unsigned int fd = acc.fdSelect->get_fd (glyph); if (unlikely (fd >= acc.fdCount)) return false; - CSInterpreter interp; + cs_interpreter_t interp; interp.env.init (str, acc, fd); - FlattenParam param = { flat_charstrings[i], drop_hints }; + flatten_param_t param = { flat_charstrings[i], drop_hints }; if (unlikely (!interp.interpret (param))) return false; } @@ -320,9 +320,9 @@ struct SubrFlattener bool drop_hints; }; -struct SubrClosures +struct subr_closures_t { - SubrClosures () : valid (false), global_closure (nullptr) + subr_closures_t () : valid (false), global_closure (nullptr) { local_closures.init (); } void init (unsigned int fd_count) @@ -363,18 +363,18 @@ struct SubrClosures hb_vector_t local_closures; }; -struct ParsedCSOp : OpStr +struct parsed_cs_op_t : op_str_t { void init (unsigned int subr_num_ = 0) { - OpStr::init (); + op_str_t::init (); subr_num = subr_num_; drop_flag = false; keep_flag = false; skip_flag = false; } - void fini () { OpStr::fini (); } + void fini () { op_str_t::fini (); } bool for_drop () const { return drop_flag; } void set_drop () { if (!for_keep ()) drop_flag = true; } @@ -393,7 +393,7 @@ struct ParsedCSOp : OpStr bool skip_flag : 1; }; -struct ParsedCStr : ParsedValues +struct parsed_cs_str_t : parsed_values_t { void init () { @@ -403,13 +403,13 @@ struct ParsedCStr : ParsedValues has_prefix_ = false; } - void add_op (OpCode op, const SubByteStr& substr) + void add_op (op_code_t op, const byte_str_ref_t& str_ref) { if (!is_parsed ()) - SUPER::add_op (op, substr); + SUPER::add_op (op, str_ref); } - void add_call_op (OpCode op, const SubByteStr& substr, unsigned int subr_num) + void add_call_op (op_code_t op, const byte_str_ref_t& str_ref, unsigned int subr_num) { if (!is_parsed ()) { @@ -417,13 +417,13 @@ struct ParsedCStr : ParsedValues if (likely (parsed_len > 0)) values[parsed_len-1].set_skip (); - ParsedCSOp val; + parsed_cs_op_t val; val.init (subr_num); - SUPER::add_op (op, substr, val); + SUPER::add_op (op, str_ref, val); } } - void set_prefix (const Number &num, OpCode op = OpCode_Invalid) + void set_prefix (const number_t &num, op_code_t op = OpCode_Invalid) { has_prefix_ = true; prefix_op_ = op; @@ -446,22 +446,22 @@ struct ParsedCStr : ParsedValues void set_vsindex_dropped () { vsindex_dropped = true; } bool has_prefix () const { return has_prefix_; } - OpCode prefix_op () const { return prefix_op_; } - const Number &prefix_num () const { return prefix_num_; } + op_code_t prefix_op () const { return prefix_op_; } + const number_t &prefix_num () const { return prefix_num_; } protected: bool parsed; bool hint_dropped; bool vsindex_dropped; bool has_prefix_; - OpCode prefix_op_; - Number prefix_num_; + op_code_t prefix_op_; + number_t prefix_num_; private: - typedef ParsedValues SUPER; + typedef parsed_values_t SUPER; }; -struct ParsedCStrs : hb_vector_t +struct parsed_cs_str_vec_t : hb_vector_t { void init (unsigned int len_ = 0) { @@ -473,13 +473,13 @@ struct ParsedCStrs : hb_vector_t void fini () { SUPER::fini_deep (); } private: - typedef hb_vector_t SUPER; + typedef hb_vector_t SUPER; }; -struct SubrSubsetParam +struct subr_subset_param_t { - void init (ParsedCStr *parsed_charstring_, - ParsedCStrs *parsed_global_subrs_, ParsedCStrs *parsed_local_subrs_, + void init (parsed_cs_str_t *parsed_charstring_, + parsed_cs_str_vec_t *parsed_global_subrs_, parsed_cs_str_vec_t *parsed_local_subrs_, hb_set_t *global_closure_, hb_set_t *local_closure_, bool drop_hints_) { @@ -492,7 +492,7 @@ struct SubrSubsetParam drop_hints = drop_hints_; } - ParsedCStr *get_parsed_str_for_context (CallContext &context) + parsed_cs_str_t *get_parsed_str_for_context (call_context_t &context) { switch (context.type) { @@ -515,7 +515,7 @@ struct SubrSubsetParam template void set_current_str (ENV &env, bool calling) { - ParsedCStr *parsed_str = get_parsed_str_for_context (env.context); + parsed_cs_str_t *parsed_str = get_parsed_str_for_context (env.context); if (likely (parsed_str != nullptr)) { /* If the called subroutine is parsed partially but not completely yet, @@ -530,17 +530,17 @@ struct SubrSubsetParam env.set_error (); } - ParsedCStr *current_parsed_str; + parsed_cs_str_t *current_parsed_str; - ParsedCStr *parsed_charstring; - ParsedCStrs *parsed_global_subrs; - ParsedCStrs *parsed_local_subrs; + parsed_cs_str_t *parsed_charstring; + parsed_cs_str_vec_t *parsed_global_subrs; + parsed_cs_str_vec_t *parsed_local_subrs; hb_set_t *global_closure; hb_set_t *local_closure; bool drop_hints; }; -struct SubrRemap : Remap +struct subr_remap_t : remap_t { void create (hb_set_t *closure) { @@ -567,7 +567,7 @@ struct SubrRemap : Remap if (old_num >= length) return CFF_UNDEF_CODE; else - return Remap::operator[] (old_num); + return remap_t::operator[] (old_num); } int biased_num (unsigned int old_num) const @@ -580,15 +580,15 @@ struct SubrRemap : Remap int bias; }; -struct SubrRemaps +struct subr_remap_ts { - SubrRemaps () + subr_remap_ts () { global_remap.init (); local_remaps.init (); } - ~SubrRemaps () { fini (); } + ~subr_remap_ts () { fini (); } void init (unsigned int fdCount) { @@ -597,7 +597,7 @@ struct SubrRemaps local_remaps[i].init (); } - void create (SubrClosures& closures) + void create (subr_closures_t& closures) { global_remap.create (closures.global_closure); for (unsigned int i = 0; i < local_remaps.length; i++) @@ -610,21 +610,21 @@ struct SubrRemaps local_remaps.fini_deep (); } - SubrRemap global_remap; - hb_vector_t local_remaps; + subr_remap_t global_remap; + hb_vector_t local_remaps; }; template -struct SubrSubsetter +struct subr_subsetter_t { - SubrSubsetter () + subr_subsetter_t () { parsed_charstrings.init (); parsed_global_subrs.init (); parsed_local_subrs.init (); } - ~SubrSubsetter () + ~subr_subsetter_t () { closures.fini (); remaps.fini (); @@ -666,15 +666,15 @@ struct SubrSubsetter for (unsigned int i = 0; i < glyphs.length; i++) { hb_codepoint_t glyph = glyphs[i]; - const ByteStr str = (*acc.charStrings)[glyph]; + const byte_str_t str = (*acc.charStrings)[glyph]; unsigned int fd = acc.fdSelect->get_fd (glyph); if (unlikely (fd >= acc.fdCount)) return false; - CSInterpreter interp; + cs_interpreter_t interp; interp.env.init (str, acc, fd); - SubrSubsetParam param; + subr_subset_param_t param; param.init (&parsed_charstrings[i], &parsed_global_subrs, &parsed_local_subrs[fd], closures.global_closure, closures.local_closures[fd], @@ -695,13 +695,13 @@ struct SubrSubsetter unsigned int fd = acc.fdSelect->get_fd (glyphs[i]); if (unlikely (fd >= acc.fdCount)) return false; - SubrSubsetParam param; + subr_subset_param_t param; param.init (&parsed_charstrings[i], &parsed_global_subrs, &parsed_local_subrs[fd], closures.global_closure, closures.local_closures[fd], drop_hints); - DropHintsParam drop; + drop_hints_param_t drop; if (drop_hints_in_str (parsed_charstrings[i], param, drop)) { parsed_charstrings[i].set_hint_dropped (); @@ -717,7 +717,7 @@ struct SubrSubsetter unsigned int fd = acc.fdSelect->get_fd (glyphs[i]); if (unlikely (fd >= acc.fdCount)) return false; - SubrSubsetParam param; + subr_subset_param_t param; param.init (&parsed_charstrings[i], &parsed_global_subrs, &parsed_local_subrs[fd], closures.global_closure, closures.local_closures[fd], @@ -731,7 +731,7 @@ struct SubrSubsetter return true; } - bool encode_charstrings (ACC &acc, const hb_vector_t &glyphs, StrBuffArray &buffArray) const + bool encode_charstrings (ACC &acc, const hb_vector_t &glyphs, str_buff_vec_t &buffArray) const { if (unlikely (!buffArray.resize (glyphs.length))) return false; @@ -746,7 +746,7 @@ struct SubrSubsetter return true; } - bool encode_subrs (const ParsedCStrs &subrs, const SubrRemap& remap, unsigned int fd, StrBuffArray &buffArray) const + bool encode_subrs (const parsed_cs_str_vec_t &subrs, const subr_remap_t& remap, unsigned int fd, str_buff_vec_t &buffArray) const { unsigned int count = remap.get_count (); @@ -764,20 +764,20 @@ struct SubrSubsetter return true; } - bool encode_globalsubrs (StrBuffArray &buffArray) + bool encode_globalsubrs (str_buff_vec_t &buffArray) { return encode_subrs (parsed_global_subrs, remaps.global_remap, 0, buffArray); } - bool encode_localsubrs (unsigned int fd, StrBuffArray &buffArray) const + bool encode_localsubrs (unsigned int fd, str_buff_vec_t &buffArray) const { return encode_subrs (parsed_local_subrs[fd], remaps.local_remaps[fd], fd, buffArray); } protected: - struct DropHintsParam + struct drop_hints_param_t { - DropHintsParam () + drop_hints_param_t () : seen_moveto (false), ends_in_hint (false), vsindex_dropped (false) {} @@ -787,9 +787,9 @@ struct SubrSubsetter bool vsindex_dropped; }; - bool drop_hints_in_subr (ParsedCStr &str, unsigned int pos, - ParsedCStrs &subrs, unsigned int subr_num, - const SubrSubsetParam ¶m, DropHintsParam &drop) + bool drop_hints_in_subr (parsed_cs_str_t &str, unsigned int pos, + parsed_cs_str_vec_t &subrs, unsigned int subr_num, + const subr_subset_param_t ¶m, drop_hints_param_t &drop) { drop.ends_in_hint = false; bool has_hint = drop_hints_in_str (subrs[subr_num], param, drop); @@ -809,7 +809,7 @@ struct SubrSubsetter } /* returns true if it sees a hint op before the first moveto */ - bool drop_hints_in_str (ParsedCStr &str, const SubrSubsetParam ¶m, DropHintsParam &drop) + bool drop_hints_in_str (parsed_cs_str_t &str, const subr_subset_param_t ¶m, drop_hints_param_t &drop) { bool seen_hint = false; @@ -868,7 +868,7 @@ struct SubrSubsetter { for (int i = pos - 1; i >= 0; i--) { - ParsedCSOp &csop = str.values[(unsigned)i]; + parsed_cs_op_t &csop = str.values[(unsigned)i]; if (csop.for_drop ()) break; csop.set_drop (); @@ -882,16 +882,16 @@ struct SubrSubsetter return seen_hint; } - void collect_subr_refs_in_subr (ParsedCStr &str, unsigned int pos, - unsigned int subr_num, ParsedCStrs &subrs, + void collect_subr_refs_in_subr (parsed_cs_str_t &str, unsigned int pos, + unsigned int subr_num, parsed_cs_str_vec_t &subrs, hb_set_t *closure, - const SubrSubsetParam ¶m) + const subr_subset_param_t ¶m) { hb_set_add (closure, subr_num); collect_subr_refs_in_str (subrs[subr_num], param); } - void collect_subr_refs_in_str (ParsedCStr &str, const SubrSubsetParam ¶m) + void collect_subr_refs_in_str (parsed_cs_str_t &str, const subr_subset_param_t ¶m) { for (unsigned int pos = 0; pos < str.values.length; pos++) { @@ -917,10 +917,10 @@ struct SubrSubsetter } } - bool encode_str (const ParsedCStr &str, const unsigned int fd, StrBuff &buff) const + bool encode_str (const parsed_cs_str_t &str, const unsigned int fd, str_buff_t &buff) const { buff.init (); - StrEncoder encoder (buff); + str_encoder_t encoder (buff); encoder.reset (); /* if a prefix (CFF1 width or CFF2 vsindex) has been removed along with hints, * re-insert it at the beginning of charstreing */ @@ -932,7 +932,7 @@ struct SubrSubsetter } for (unsigned int i = 0; i < str.get_count(); i++) { - const ParsedCSOp &opstr = str.values[i]; + const parsed_cs_op_t &opstr = str.values[i]; if (!opstr.for_drop () && !opstr.for_skip ()) { switch (opstr.op) @@ -957,13 +957,13 @@ struct SubrSubsetter } protected: - SubrClosures closures; + subr_closures_t closures; - ParsedCStrs parsed_charstrings; - ParsedCStrs parsed_global_subrs; - hb_vector_t parsed_local_subrs; + parsed_cs_str_vec_t parsed_charstrings; + parsed_cs_str_vec_t parsed_global_subrs; + hb_vector_t parsed_local_subrs; - SubrRemaps remaps; + subr_remap_ts remaps; private: typedef typename SUBRS::count_type subr_count_type; @@ -977,8 +977,8 @@ hb_plan_subset_cff_fdselect (const hb_vector_t &glyphs, unsigned int &subset_fd_count /* OUT */, unsigned int &subset_fdselect_size /* OUT */, unsigned int &subset_fdselect_format /* OUT */, - hb_vector_t &fdselect_ranges /* OUT */, - CFF::Remap &fdmap /* OUT */); + hb_vector_t &fdselect_ranges /* OUT */, + CFF::remap_t &fdmap /* OUT */); HB_INTERNAL bool hb_serialize_cff_fdselect (hb_serialize_context_t *c, @@ -987,6 +987,6 @@ hb_serialize_cff_fdselect (hb_serialize_context_t *c, unsigned int fd_count, unsigned int fdselect_format, unsigned int size, - const hb_vector_t &fdselect_ranges); + const hb_vector_t &fdselect_ranges); #endif /* HB_SUBSET_CFF_COMMON_HH */ diff --git a/src/hb-subset-cff1.cc b/src/hb-subset-cff1.cc index b5c5ddeb5..0eb84c88b 100644 --- a/src/hb-subset-cff1.cc +++ b/src/hb-subset-cff1.cc @@ -34,12 +34,12 @@ using namespace CFF; -struct RemapSID : Remap +struct remap_sid_t : remap_t { unsigned int add (unsigned int sid) { if ((sid != CFF_UNDEF_SID) && !is_std_std (sid)) - return offset_sid (Remap::add (unoffset_sid (sid))); + return offset_sid (remap_t::add (unoffset_sid (sid))); else return sid; } @@ -49,7 +49,7 @@ struct RemapSID : Remap if (is_std_std (sid) || (sid == CFF_UNDEF_SID)) return sid; else - return offset_sid (Remap::operator [] (unoffset_sid (sid))); + return offset_sid (remap_t::operator [] (unoffset_sid (sid))); } static const unsigned int num_std_strings = 391; @@ -59,10 +59,10 @@ struct RemapSID : Remap static unsigned int unoffset_sid (unsigned int sid) { return sid - num_std_strings; } }; -struct CFF1SubTableOffsets : CFFSubTableOffsets +struct cff1_sub_table_offsets_t : cff_sub_table_offsets_t { - CFF1SubTableOffsets () - : CFFSubTableOffsets (), + cff1_sub_table_offsets_t () + : cff_sub_table_offsets_t (), nameIndexOffset (0), encodingOffset (0) { @@ -72,16 +72,16 @@ struct CFF1SubTableOffsets : CFFSubTableOffsets } unsigned int nameIndexOffset; - TableInfo stringIndexInfo; + table_info_t stringIndexInfo; unsigned int encodingOffset; - TableInfo charsetInfo; - TableInfo privateDictInfo; + table_info_t charsetInfo; + table_info_t privateDictInfo; }; -/* a copy of a parsed out CFF1TopDictValues augmented with additional operators */ -struct CFF1TopDictValuesMod : CFF1TopDictValues +/* 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 CFF1TopDictValues *base_= &Null(CFF1TopDictValues)) + void init (const cff1_top_dict_values_t *base_= &Null(cff1_top_dict_values_t)) { SUPER::init (); base = base_; @@ -90,47 +90,47 @@ struct CFF1TopDictValuesMod : CFF1TopDictValues void fini () { SUPER::fini (); } unsigned get_count () const { return base->get_count () + SUPER::get_count (); } - const CFF1TopDictVal &get_value (unsigned int i) const + 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 CFF1TopDictVal &operator [] (unsigned int i) const { return get_value (i); } + const cff1_top_dict_val_t &operator [] (unsigned int i) const { return get_value (i); } - void reassignSIDs (const RemapSID& sidmap) + void reassignSIDs (const remap_sid_t& sidmap) { - for (unsigned int i = 0; i < NameDictValues::ValCount; i++) + for (unsigned int i = 0; i < name_dict_values_t::ValCount; i++) nameSIDs[i] = sidmap[base->nameSIDs[i]]; } protected: - typedef CFF1TopDictValues SUPER; - const CFF1TopDictValues *base; + typedef cff1_top_dict_values_t SUPER; + const cff1_top_dict_values_t *base; }; -struct TopDictModifiers +struct top_dict_modifiers_t { - TopDictModifiers (const CFF1SubTableOffsets &offsets_, - const unsigned int (&nameSIDs_)[NameDictValues::ValCount]) + top_dict_modifiers_t (const cff1_sub_table_offsets_t &offsets_, + const unsigned int (&nameSIDs_)[name_dict_values_t::ValCount]) : offsets (offsets_), nameSIDs (nameSIDs_) {} - const CFF1SubTableOffsets &offsets; - const unsigned int (&nameSIDs)[NameDictValues::ValCount]; + const cff1_sub_table_offsets_t &offsets; + const unsigned int (&nameSIDs)[name_dict_values_t::ValCount]; }; -struct CFF1TopDict_OpSerializer : CFFTopDict_OpSerializer +struct cff1_top_dict_op_serializer_t : cff_top_dict_op_serializer_t { bool serialize (hb_serialize_context_t *c, - const CFF1TopDictVal &opstr, - const TopDictModifiers &mod) const + const cff1_top_dict_val_t &opstr, + const top_dict_modifiers_t &mod) const { TRACE_SERIALIZE (this); - OpCode op = opstr.op; + op_code_t op = opstr.op; switch (op) { case OpCode_charset: @@ -160,31 +160,30 @@ struct CFF1TopDict_OpSerializer : CFFTopDict_OpSerializer case OpCode_PostScript: case OpCode_BaseFontName: case OpCode_FontName: - return_trace (FontDict::serialize_offset2_op(c, op, mod.nameSIDs[NameDictValues::name_op_to_index (op)])); + return_trace (FontDict::serialize_offset2_op(c, op, mod.nameSIDs[name_dict_values_t::name_op_to_index (op)])); case OpCode_ROS: { /* for registry & ordering, reassigned SIDs are serialized * for supplement, the original byte string is copied along with the op code */ - OpStr supp_op; + op_str_t supp_op; supp_op.op = op; - supp_op.str.str = opstr.str.str + opstr.last_arg_offset; - if ( unlikely (!(opstr.str.len >= opstr.last_arg_offset + 3))) + if ( unlikely (!(opstr.str.length >= opstr.last_arg_offset + 3))) return_trace (false); - supp_op.str.len = opstr.str.len - opstr.last_arg_offset; - return_trace (UnsizedByteStr::serialize_int2 (c, mod.nameSIDs[NameDictValues::registry]) && - UnsizedByteStr::serialize_int2 (c, mod.nameSIDs[NameDictValues::ordering]) && + supp_op.str = byte_str_t (&opstr.str + opstr.last_arg_offset, opstr.str.length - opstr.last_arg_offset); + return_trace (UnsizedByteStr::serialize_int2 (c, mod.nameSIDs[name_dict_values_t::registry]) && + UnsizedByteStr::serialize_int2 (c, mod.nameSIDs[name_dict_values_t::ordering]) && copy_opstr (c, supp_op)); } default: - return_trace (CFFTopDict_OpSerializer::serialize (c, opstr, mod.offsets)); + return_trace (cff_top_dict_op_serializer_t::serialize (c, opstr, mod.offsets)); } return_trace (true); } - unsigned int calculate_serialized_size (const CFF1TopDictVal &opstr) const + unsigned int calculate_serialized_size (const cff1_top_dict_val_t &opstr) const { - OpCode op = opstr.op; + op_code_t op = opstr.op; switch (op) { case OpCode_charset: @@ -206,19 +205,19 @@ struct CFF1TopDict_OpSerializer : CFFTopDict_OpSerializer return OpCode_Size (OpCode_shortint) + 2 + OpCode_Size (op); case OpCode_ROS: - return ((OpCode_Size (OpCode_shortint) + 2) * 2) + (opstr.str.len - opstr.last_arg_offset)/* supplement + op */; + return ((OpCode_Size (OpCode_shortint) + 2) * 2) + (opstr.str.length - opstr.last_arg_offset)/* supplement + op */; default: - return CFFTopDict_OpSerializer::calculate_serialized_size (opstr); + return cff_top_dict_op_serializer_t::calculate_serialized_size (opstr); } } }; -struct FontDictValuesMod +struct font_dict_values_mod_t { - void init (const CFF1FontDictValues *base_, + void init (const cff1_font_dict_values_t *base_, unsigned int fontName_, - const TableInfo &privateDictInfo_) + const table_info_t &privateDictInfo_) { base = base_; fontName = fontName_; @@ -227,18 +226,18 @@ struct FontDictValuesMod unsigned get_count () const { return base->get_count (); } - const OpStr &operator [] (unsigned int i) const { return (*base)[i]; } + const op_str_t &operator [] (unsigned int i) const { return (*base)[i]; } - const CFF1FontDictValues *base; - TableInfo privateDictInfo; + const cff1_font_dict_values_t *base; + table_info_t privateDictInfo; unsigned int fontName; }; -struct CFF1FontDict_OpSerializer : CFFFontDict_OpSerializer +struct cff1_font_dict_op_serializer_t : cff_font_dict_op_serializer_t { bool serialize (hb_serialize_context_t *c, - const OpStr &opstr, - const FontDictValuesMod &mod) const + const op_str_t &opstr, + const font_dict_values_mod_t &mod) const { TRACE_SERIALIZE (this); @@ -248,7 +247,7 @@ struct CFF1FontDict_OpSerializer : CFFFontDict_OpSerializer return_trace (SUPER::serialize (c, opstr, mod.privateDictInfo)); } - unsigned int calculate_serialized_size (const OpStr &opstr) const + 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); @@ -257,12 +256,12 @@ struct CFF1FontDict_OpSerializer : CFFFontDict_OpSerializer } private: - typedef CFFFontDict_OpSerializer SUPER; + typedef cff_font_dict_op_serializer_t SUPER; }; -struct CFF1CSOpSet_Flatten : CFF1CSOpSet +struct cff1_cs_opset_flatten_t : cff1_cs_opset_t { - static void flush_args_and_op (OpCode op, CFF1CSInterpEnv &env, FlattenParam& param) + static 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); @@ -288,43 +287,43 @@ struct CFF1CSOpSet_Flatten : CFF1CSOpSet break; } } - static void flush_args (CFF1CSInterpEnv &env, FlattenParam& param) + static void flush_args (cff1_cs_interp_env_t &env, flatten_param_t& param) { - StrEncoder encoder (param.flatStr); + str_encoder_t encoder (param.flatStr); for (unsigned int i = env.arg_start; i < env.argStack.get_count (); i++) encoder.encode_num (env.eval_arg (i)); SUPER::flush_args (env, param); } - static void flush_op (OpCode op, CFF1CSInterpEnv &env, FlattenParam& param) + static void flush_op (op_code_t op, cff1_cs_interp_env_t &env, flatten_param_t& param) { - StrEncoder encoder (param.flatStr); + str_encoder_t encoder (param.flatStr); encoder.encode_op (op); } - static void flush_width (CFF1CSInterpEnv &env, FlattenParam& param) + static void flush_width (cff1_cs_interp_env_t &env, flatten_param_t& param) { assert (env.has_width); - StrEncoder encoder (param.flatStr); + str_encoder_t encoder (param.flatStr); encoder.encode_num (env.width); } - static void flush_hintmask (OpCode op, CFF1CSInterpEnv &env, FlattenParam& param) + static void flush_hintmask (op_code_t op, cff1_cs_interp_env_t &env, flatten_param_t& param) { SUPER::flush_hintmask (op, env, param); if (!param.drop_hints) { - StrEncoder encoder (param.flatStr); + str_encoder_t encoder (param.flatStr); for (unsigned int i = 0; i < env.hintmask_size; i++) - encoder.encode_byte (env.substr[i]); + encoder.encode_byte (env.str_ref[i]); } } private: - typedef CFF1CSOpSet SUPER; + typedef cff1_cs_opset_t SUPER; }; -struct RangeList : hb_vector_t +struct range_list_t : hb_vector_t { /* replace the first glyph ID in the "glyph" field each range with a nLeft value */ bool finalize (unsigned int last_glyph) @@ -332,7 +331,7 @@ struct RangeList : hb_vector_t bool two_byte = false; for (unsigned int i = (*this).length; i > 0; i--) { - code_pair &pair = (*this)[i - 1]; + code_pair_t &pair = (*this)[i - 1]; unsigned int nLeft = last_glyph - pair.glyph - 1; if (nLeft >= 0x100) two_byte = true; @@ -343,21 +342,21 @@ struct RangeList : hb_vector_t } }; -struct CFF1CSOpSet_SubrSubset : CFF1CSOpSet +struct cff1_cs_opset_subr_subset_t : cff1_cs_opset_t { - static void process_op (OpCode op, CFF1CSInterpEnv &env, SubrSubsetParam& param) + static void process_op (op_code_t op, cff1_cs_interp_env_t &env, subr_subset_param_t& param) { switch (op) { case OpCode_return: - param.current_parsed_str->add_op (op, env.substr); + param.current_parsed_str->add_op (op, env.str_ref); param.current_parsed_str->set_parsed (); env.returnFromSubr (); param.set_current_str (env, false); break; case OpCode_endchar: - param.current_parsed_str->add_op (op, env.substr); + param.current_parsed_str->add_op (op, env.str_ref); param.current_parsed_str->set_parsed (); SUPER::process_op (op, env, param); break; @@ -372,30 +371,30 @@ struct CFF1CSOpSet_SubrSubset : CFF1CSOpSetadd_op (op, env.substr); + param.current_parsed_str->add_op (op, env.str_ref); break; } } protected: - static void process_call_subr (OpCode op, CSType type, - CFF1CSInterpEnv &env, SubrSubsetParam& param, - CFF1BiasedSubrs& subrs, hb_set_t *closure) + static void process_call_subr (op_code_t op, cs_type_t type, + cff1_cs_interp_env_t &env, subr_subset_param_t& param, + cff1_biased_subrs_t& subrs, hb_set_t *closure) { - SubByteStr substr = env.substr; + byte_str_ref_t str_ref = env.str_ref; env.callSubr (subrs, type); - param.current_parsed_str->add_call_op (op, substr, env.context.subr_num); + param.current_parsed_str->add_call_op (op, str_ref, env.context.subr_num); hb_set_add (closure, env.context.subr_num); param.set_current_str (env, true); } private: - typedef CFF1CSOpSet SUPER; + typedef cff1_cs_opset_t SUPER; }; -struct CFF1SubrSubsetter : SubrSubsetter +struct cff1_subr_subsetter_t : subr_subsetter_t { - static void finalize_parsed_str (CFF1CSInterpEnv &env, SubrSubsetParam& param, ParsedCStr &charstring) + static 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) @@ -407,7 +406,7 @@ struct CFF1SubrSubsetter : SubrSubsetterset_parsed (); for (unsigned int i = 0; i < env.callStack.get_count (); i++) { - ParsedCStr *parsed_str = param.get_parsed_str_for_context (env.callStack[i]); + parsed_cs_str_t *parsed_str = param.get_parsed_str_for_context (env.callStack[i]); if (likely (parsed_str != nullptr)) parsed_str->set_parsed (); else @@ -439,7 +438,7 @@ struct cff_subset_plan { subset_enc_supp_codes.init (); subset_charset_ranges.init (); sidmap.init (); - for (unsigned int i = 0; i < NameDictValues::ValCount; i++) + for (unsigned int i = 0; i < name_dict_values_t::ValCount; i++) topDictModSIDs[i] = CFF_UNDEF_SID; } @@ -485,7 +484,7 @@ struct cff_subset_plan { if (code != last_code + 1) { - code_pair pair = { code, glyph }; + code_pair_t pair = { code, glyph }; subset_enc_code_ranges.push (pair); } last_code = code; @@ -496,7 +495,7 @@ struct cff_subset_plan { encoding->get_supplement_codes (sid, supp_codes); for (unsigned int i = 0; i < supp_codes.length; i++) { - code_pair pair = { supp_codes[i], sid }; + code_pair_t pair = { supp_codes[i], sid }; subset_enc_supp_codes.push (pair); } supp_size += SuppEncoding::static_size * supp_codes.length; @@ -538,7 +537,7 @@ struct cff_subset_plan { if (sid != last_sid + 1) { - code_pair pair = { sid, glyph }; + code_pair_t pair = { sid, glyph }; subset_charset_ranges.push (pair); } last_sid = sid; @@ -569,7 +568,7 @@ struct cff_subset_plan { if (unlikely (!sidmap.reset (acc.stringIndex->count))) return false; - for (unsigned int i = 0; i < NameDictValues::ValCount; i++) + for (unsigned int i = 0; i < name_dict_values_t::ValCount; i++) { unsigned int sid = acc.topDict.nameSIDs[i]; if (sid != CFF_UNDEF_SID) @@ -633,12 +632,12 @@ struct cff_subset_plan { topdict_mod.add_op (OpCode_charset); } offsets.topDictInfo.offset = final_size; - CFF1TopDict_OpSerializer topSzr; + cff1_top_dict_op_serializer_t topSzr; unsigned int topDictSize = TopDict::calculate_serialized_size (topdict_mod, topSzr); offsets.topDictInfo.offSize = calcOffSize(topDictSize); if (unlikely (offsets.topDictInfo.offSize > 4)) return false; - final_size += CFF1IndexOf::calculate_serialized_size + final_size += CFF1IndexOf::calculate_serialized_size (offsets.topDictInfo.offSize, &topdict_mod, 1, topdict_sizes, topSzr); } @@ -682,7 +681,7 @@ struct cff_subset_plan { if (desubroutinize) { /* Flatten global & local subrs */ - SubrFlattener + subr_flattener_t flattener(acc, plan->glyphs, plan->drop_hints); if (!flattener.flatten (subset_charstrings)) return false; @@ -767,7 +766,7 @@ struct cff_subset_plan { /* FDArray (FDIndex) */ if (acc.fdArray != &Null(CFF1FDArray)) { offsets.FDArrayInfo.offset = final_size; - CFF1FontDict_OpSerializer fontSzr; + cff1_font_dict_op_serializer_t fontSzr; unsigned int dictsSize = 0; for (unsigned int i = 0; i < acc.fontDicts.length; i++) if (fdmap.includes (i)) @@ -796,12 +795,12 @@ struct cff_subset_plan { if (fdmap.includes (i)) { bool has_localsubrs = offsets.localSubrsInfos[i].size > 0; - CFFPrivateDict_OpSerializer privSzr (desubroutinize, plan->drop_hints); + cff_private_dict_op_serializer_t privSzr (desubroutinize, plan->drop_hints); unsigned int priv_size = PrivateDict::calculate_serialized_size (acc.privateDicts[i], privSzr, has_localsubrs); - TableInfo privInfo = { final_size, priv_size, 0 }; - FontDictValuesMod fontdict_mod; + table_info_t privInfo = { final_size, priv_size, 0 }; + font_dict_values_mod_t fontdict_mod; if (!acc.is_CID ()) - fontdict_mod.init ( &Null(CFF1FontDictValues), CFF_UNDEF_SID, privInfo ); + fontdict_mod.init ( &Null(cff1_font_dict_values_t), CFF_UNDEF_SID, privInfo ); else fontdict_mod.init ( &acc.fontDicts[i], sidmap[acc.fontDicts[i].fontName], privInfo ); fontdicts_mod.push (fontdict_mod); @@ -825,43 +824,43 @@ struct cff_subset_plan { unsigned int get_final_size () const { return final_size; } unsigned int final_size; - hb_vector_t topdict_sizes; - CFF1TopDictValuesMod topdict_mod; - CFF1SubTableOffsets offsets; + 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 fdmap; + remap_t fdmap; - StrBuffArray subset_charstrings; - StrBuffArray subset_globalsubrs; - hb_vector_t subset_localsubrs; - hb_vector_t fontdicts_mod; + 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; - RangeList 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; - RangeList subset_charset_ranges; - bool subset_charset; + uint8_t subset_charset_format; + range_list_t subset_charset_ranges; + bool subset_charset; - RemapSID sidmap; - unsigned int topDictModSIDs[NameDictValues::ValCount]; + remap_sid_t sidmap; + unsigned int topDictModSIDs[name_dict_values_t::ValCount]; - bool desubroutinize; - CFF1SubrSubsetter subr_subsetter; + bool desubroutinize; + cff1_subr_subsetter_t subr_subsetter; }; static inline bool _write_cff1 (const cff_subset_plan &plan, @@ -872,9 +871,6 @@ static inline bool _write_cff1 (const cff_subset_plan &plan, { hb_serialize_context_t c (dest, dest_sz); - char RETURN_OP[1] = { OpCode_return }; - const ByteStr NULL_SUBR (RETURN_OP, 1); - OT::cff1 *cff = c.start_serialize (); if (unlikely (!c.extend_min (*cff))) return false; @@ -902,8 +898,8 @@ static inline bool _write_cff1 (const cff_subset_plan &plan, assert (plan.offsets.topDictInfo.offset == c.head - c.start); CFF1IndexOf *dest = c.start_embed< CFF1IndexOf > (); if (dest == nullptr) return false; - CFF1TopDict_OpSerializer topSzr; - TopDictModifiers modifier (plan.offsets, plan.topDictModSIDs); + cff1_top_dict_op_serializer_t topSzr; + top_dict_modifiers_t modifier (plan.offsets, plan.topDictModSIDs); if (unlikely (!dest->serialize (&c, plan.offsets.topDictInfo.offSize, &plan.topdict_mod, 1, plan.topdict_sizes, topSzr, modifier))) @@ -992,7 +988,7 @@ static inline bool _write_cff1 (const cff_subset_plan &plan, assert (plan.offsets.FDArrayInfo.offset == c.head - c.start); CFF1FDArray *fda = c.start_embed (); if (unlikely (fda == nullptr)) return false; - CFF1FontDict_OpSerializer fontSzr; + cff1_font_dict_op_serializer_t fontSzr; if (unlikely (!fda->serialize (&c, plan.offsets.FDArrayInfo.offSize, plan.fontdicts_mod, fontSzr))) @@ -1024,7 +1020,7 @@ static inline bool _write_cff1 (const cff_subset_plan &plan, if (unlikely (pd == nullptr)) return false; unsigned int priv_size = plan.fontdicts_mod[plan.fdmap[i]].privateDictInfo.size; bool result; - CFFPrivateDict_OpSerializer privSzr (plan.desubroutinize, plan.drop_hints); + cff_private_dict_op_serializer_t privSzr (plan.desubroutinize, plan.drop_hints); /* N.B. local subrs immediately follows its corresponding private dict. i.e., subr offset == private dict size */ unsigned int subroffset = (plan.offsets.localSubrsInfos[i].size > 0)? priv_size: 0; result = pd->serialize (&c, acc.privateDicts[i], privSzr, subroffset); @@ -1054,9 +1050,9 @@ static inline bool _write_cff1 (const cff_subset_plan &plan, static bool _hb_subset_cff1 (const OT::cff1::accelerator_subset_t &acc, - const char *data, - hb_subset_plan_t *plan, - hb_blob_t **prime /* OUT */) + const char *data, + hb_subset_plan_t *plan, + hb_blob_t **prime /* OUT */) { cff_subset_plan cff_plan; diff --git a/src/hb-subset-cff2.cc b/src/hb-subset-cff2.cc index 59fd6a26b..8d32b7d66 100644 --- a/src/hb-subset-cff2.cc +++ b/src/hb-subset-cff2.cc @@ -34,21 +34,21 @@ using namespace CFF; -struct CFF2SubTableOffsets : CFFSubTableOffsets +struct cff2_sub_table_offsets_t : cff_sub_table_offsets_t { - CFF2SubTableOffsets () - : CFFSubTableOffsets (), + cff2_sub_table_offsets_t () + : cff_sub_table_offsets_t (), varStoreOffset (0) {} unsigned int varStoreOffset; }; -struct CFF2TopDict_OpSerializer : CFFTopDict_OpSerializer<> +struct cff2_top_dict_op_serializer_t : cff_top_dict_op_serializer_t<> { bool serialize (hb_serialize_context_t *c, - const OpStr &opstr, - const CFF2SubTableOffsets &offsets) const + const op_str_t &opstr, + const cff2_sub_table_offsets_t &offsets) const { TRACE_SERIALIZE (this); @@ -58,11 +58,11 @@ struct CFF2TopDict_OpSerializer : CFFTopDict_OpSerializer<> return_trace (FontDict::serialize_offset4_op(c, opstr.op, offsets.varStoreOffset)); default: - return_trace (CFFTopDict_OpSerializer<>::serialize (c, opstr, offsets)); + return_trace (cff_top_dict_op_serializer_t<>::serialize (c, opstr, offsets)); } } - unsigned int calculate_serialized_size (const OpStr &opstr) const + unsigned int calculate_serialized_size (const op_str_t &opstr) const { switch (opstr.op) { @@ -70,14 +70,14 @@ struct CFF2TopDict_OpSerializer : CFFTopDict_OpSerializer<> return OpCode_Size (OpCode_longintdict) + 4 + OpCode_Size (opstr.op); default: - return CFFTopDict_OpSerializer<>::calculate_serialized_size (opstr); + return cff_top_dict_op_serializer_t<>::calculate_serialized_size (opstr); } } }; -struct CFF2CSOpSet_Flatten : CFF2CSOpSet +struct cff2_cs_opset_flatten_t : cff2_cs_opset_t { - static void flush_args_and_op (OpCode op, CFF2CSInterpEnv &env, FlattenParam& param) + static void flush_args_and_op (op_code_t op, cff2_cs_interp_env_t &env, flatten_param_t& param) { switch (op) { @@ -105,11 +105,11 @@ struct CFF2CSOpSet_Flatten : CFF2CSOpSet } } - static void flush_args (CFF2CSInterpEnv &env, FlattenParam& param) + static void flush_args (cff2_cs_interp_env_t &env, flatten_param_t& param) { for (unsigned int i = 0; i < env.argStack.get_count ();) { - const BlendArg &arg = env.argStack[i]; + const blend_arg_t &arg = env.argStack[i]; if (arg.blending ()) { if (unlikely (!((arg.numValues > 0) && (env.argStack.get_count () >= arg.numValues)))) @@ -122,7 +122,7 @@ struct CFF2CSOpSet_Flatten : CFF2CSOpSet } else { - StrEncoder encoder (param.flatStr); + str_encoder_t encoder (param.flatStr); encoder.encode_num (arg); i++; } @@ -130,13 +130,13 @@ struct CFF2CSOpSet_Flatten : CFF2CSOpSet SUPER::flush_args (env, param); } - static void flatten_blends (const BlendArg &arg, unsigned int i, CFF2CSInterpEnv &env, FlattenParam& param) + static void flatten_blends (const blend_arg_t &arg, unsigned int i, cff2_cs_interp_env_t &env, flatten_param_t& param) { /* flatten the default values */ - StrEncoder encoder (param.flatStr); + str_encoder_t encoder (param.flatStr); for (unsigned int j = 0; j < arg.numValues; j++) { - const BlendArg &arg1 = env.argStack[i + j]; + const blend_arg_t &arg1 = env.argStack[i + j]; if (unlikely (!((arg1.blending () && (arg.numValues == arg1.numValues) && (arg1.valueIndex == j) && (arg1.deltas.length == env.get_region_count ()))))) { @@ -148,7 +148,7 @@ struct CFF2CSOpSet_Flatten : CFF2CSOpSet /* flatten deltas for each value */ for (unsigned int j = 0; j < arg.numValues; j++) { - const BlendArg &arg1 = env.argStack[i + j]; + const blend_arg_t &arg1 = env.argStack[i + j]; for (unsigned int k = 0; k < arg1.deltas.length; k++) encoder.encode_num (arg1.deltas[k]); } @@ -157,7 +157,7 @@ struct CFF2CSOpSet_Flatten : CFF2CSOpSet encoder.encode_op (OpCode_blendcs); } - static void flush_op (OpCode op, CFF2CSInterpEnv &env, FlattenParam& param) + static void flush_op (op_code_t op, cff2_cs_interp_env_t &env, flatten_param_t& param) { switch (op) { @@ -165,19 +165,19 @@ struct CFF2CSOpSet_Flatten : CFF2CSOpSet case OpCode_endchar: return; default: - StrEncoder encoder (param.flatStr); + str_encoder_t encoder (param.flatStr); encoder.encode_op (op); } } private: - typedef CFF2CSOpSet SUPER; - typedef CSOpSet CSOPSET; + typedef cff2_cs_opset_t SUPER; + typedef cs_opset_t CSOPSET; }; -struct CFF2CSOpSet_SubrSubset : CFF2CSOpSet +struct cff2_cs_opset_subr_subset_t : cff2_cs_opset_t { - static void process_op (OpCode op, CFF2CSInterpEnv &env, SubrSubsetParam& param) + static void process_op (op_code_t op, cff2_cs_interp_env_t &env, subr_subset_param_t& param) { switch (op) { @@ -202,35 +202,35 @@ struct CFF2CSOpSet_SubrSubset : CFF2CSOpSetadd_op (op, env.substr); + param.current_parsed_str->add_op (op, env.str_ref); break; } } protected: - static void process_call_subr (OpCode op, CSType type, - CFF2CSInterpEnv &env, SubrSubsetParam& param, - CFF2BiasedSubrs& subrs, hb_set_t *closure) + static void process_call_subr (op_code_t op, cs_type_t type, + cff2_cs_interp_env_t &env, subr_subset_param_t& param, + cff2_biased_subrs_t& subrs, hb_set_t *closure) { - SubByteStr substr = env.substr; + byte_str_ref_t str_ref = env.str_ref; env.callSubr (subrs, type); - param.current_parsed_str->add_call_op (op, substr, env.context.subr_num); + param.current_parsed_str->add_call_op (op, str_ref, env.context.subr_num); hb_set_add (closure, env.context.subr_num); param.set_current_str (env, true); } private: - typedef CFF2CSOpSet SUPER; + typedef cff2_cs_opset_t SUPER; }; -struct CFF2SubrSubsetter : SubrSubsetter +struct cff2_subr_subsetter_t : subr_subsetter_t { - static void finalize_parsed_str (CFF2CSInterpEnv &env, SubrSubsetParam& param, ParsedCStr &charstring) + static 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 ()) { - Number ivs; + number_t ivs; ivs.set_int ((int)env.get_ivs ()); charstring.set_prefix (ivs, OpCode_vsindexcs); } @@ -278,7 +278,7 @@ struct cff2_subset_plan { /* top dict */ { - CFF2TopDict_OpSerializer topSzr; + cff2_top_dict_op_serializer_t topSzr; offsets.topDictInfo.size = TopDict::calculate_serialized_size (acc.topDict, topSzr); final_size += offsets.topDictInfo.size; } @@ -286,7 +286,7 @@ struct cff2_subset_plan { if (desubroutinize) { /* Flatten global & local subrs */ - SubrFlattener + subr_flattener_t flattener(acc, plan->glyphs, plan->drop_hints); if (!flattener.flatten (subset_charstrings)) return false; @@ -370,7 +370,7 @@ struct cff2_subset_plan { /* FDArray (FDIndex) */ { offsets.FDArrayInfo.offset = final_size; - CFFFontDict_OpSerializer fontSzr; + cff_font_dict_op_serializer_t fontSzr; unsigned int dictsSize = 0; for (unsigned int i = 0; i < acc.fontDicts.length; i++) if (fdmap.includes (i)) @@ -395,9 +395,9 @@ struct cff2_subset_plan { if (fdmap.includes (i)) { bool has_localsubrs = offsets.localSubrsInfos[i].size > 0; - CFFPrivateDict_OpSerializer privSzr (desubroutinize, drop_hints); + cff_private_dict_op_serializer_t privSzr (desubroutinize, drop_hints); unsigned int priv_size = PrivateDict::calculate_serialized_size (acc.privateDicts[i], privSzr, has_localsubrs); - TableInfo privInfo = { final_size, priv_size, 0 }; + table_info_t privInfo = { final_size, priv_size, 0 }; privateDictInfos.push (privInfo); final_size += privInfo.size; @@ -415,23 +415,23 @@ struct cff2_subset_plan { unsigned int get_final_size () const { return final_size; } unsigned int final_size; - CFF2SubTableOffsets offsets; + 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; + hb_vector_t subset_fdselect_ranges; - Remap fdmap; + remap_t fdmap; - StrBuffArray subset_charstrings; - StrBuffArray 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; - CFF2SubrSubsetter subr_subsetter; + cff2_subr_subsetter_t subr_subsetter; }; static inline bool _write_cff2 (const cff2_subset_plan &plan, @@ -456,7 +456,7 @@ static inline bool _write_cff2 (const cff2_subset_plan &plan, assert (cff2->topDict == c.head - c.start); cff2->topDictSize.set (plan.offsets.topDictInfo.size); TopDict &dict = cff2 + cff2->topDict; - CFF2TopDict_OpSerializer topSzr; + cff2_top_dict_op_serializer_t topSzr; if (unlikely (!dict.serialize (&c, acc.topDict, topSzr, plan.offsets))) { DEBUG_MSG (SUBSET, nullptr, "failed to serialize CFF2 top dict"); @@ -507,7 +507,7 @@ static inline bool _write_cff2 (const cff2_subset_plan &plan, assert (plan.offsets.FDArrayInfo.offset == c.head - c.start); CFF2FDArray *fda = c.start_embed (); if (unlikely (fda == nullptr)) return false; - CFFFontDict_OpSerializer fontSzr; + cff_font_dict_op_serializer_t fontSzr; if (unlikely (!fda->serialize (&c, plan.offsets.FDArrayInfo.offSize, acc.fontDicts, plan.subset_fdcount, plan.fdmap, fontSzr, plan.privateDictInfos))) @@ -539,7 +539,7 @@ static inline bool _write_cff2 (const cff2_subset_plan &plan, if (unlikely (pd == nullptr)) return false; unsigned int priv_size = plan.privateDictInfos[plan.fdmap[i]].size; bool result; - CFFPrivateDict_OpSerializer privSzr (plan.desubroutinize, plan.drop_hints); + cff_private_dict_op_serializer_t privSzr (plan.desubroutinize, plan.drop_hints); /* N.B. local subrs immediately follows its corresponding private dict. i.e., subr offset == private dict size */ unsigned int subroffset = (plan.offsets.localSubrsInfos[i].size > 0)? priv_size: 0; result = pd->serialize (&c, acc.privateDicts[i], privSzr, subroffset);