X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fhb-ot-layout-gsubgpos-private.hh;h=86285d17ca87c9541467899cfab80dccc14a0e2c;hb=b3651231bf80bb7009214547a75ed90e21815c68;hp=042daa2a8fbe366db9774441cf7d45b0038b9692;hpb=6617eada95928457a25e29f793f1a93c6b3edaec;p=framework%2Fuifw%2Fharfbuzz.git diff --git a/src/hb-ot-layout-gsubgpos-private.hh b/src/hb-ot-layout-gsubgpos-private.hh index 042daa2..86285d1 100644 --- a/src/hb-ot-layout-gsubgpos-private.hh +++ b/src/hb-ot-layout-gsubgpos-private.hh @@ -1,5 +1,5 @@ /* - * Copyright (C) 2007,2008,2009 Red Hat, Inc. + * Copyright (C) 2007,2008,2009,2010 Red Hat, Inc. * * This is part of HarfBuzz, a text shaping library. * @@ -36,35 +36,30 @@ #endif #define TRACE_APPLY() \ - HB_STMT_START { \ - if (HB_DEBUG_APPLY) \ - _hb_trace ("APPLY", __PRETTY_FUNCTION__, this, apply_depth, HB_DEBUG_APPLY); \ - } HB_STMT_END - - -#define APPLY_ARG_DEF \ - hb_apply_context_t *context, \ - hb_ot_layout_context_t *layout_context, \ - hb_buffer_t *buffer, \ - unsigned int context_length HB_GNUC_UNUSED, \ - unsigned int apply_depth HB_GNUC_UNUSED -#define APPLY_ARG \ - context, \ - layout_context, \ - buffer, \ - context_length, \ - (HB_DEBUG_APPLY ? apply_depth + 1 : 0) + hb_trace_t trace (&context->debug_depth); \ + trace.log ("APPLY", HB_FUNC, this); + struct hb_apply_context_t { + unsigned int debug_depth; + hb_ot_layout_context_t *layout; + hb_buffer_t *buffer; + unsigned int context_length; unsigned int nesting_level_left; unsigned int lookup_flag; unsigned int property; /* propety of first glyph (TODO remove) */ }; + + +#undef BUFFER +#define BUFFER context->buffer + + typedef bool (*match_func_t) (hb_codepoint_t glyph_id, const USHORT &value, const char *data); -typedef bool (*apply_lookup_func_t) (APPLY_ARG_DEF, unsigned int lookup_index); +typedef bool (*apply_lookup_func_t) (hb_apply_context_t *context, unsigned int lookup_index); struct ContextFuncs { @@ -73,7 +68,7 @@ struct ContextFuncs }; -static inline bool match_glyph (hb_codepoint_t glyph_id, const USHORT &value, const char *data HB_GNUC_UNUSED) +static inline bool match_glyph (hb_codepoint_t glyph_id, const USHORT &value, const char *data HB_UNUSED) { return glyph_id == value; } @@ -91,7 +86,7 @@ static inline bool match_coverage (hb_codepoint_t glyph_id, const USHORT &value, } -static inline bool match_input (APPLY_ARG_DEF, +static inline bool match_input (hb_apply_context_t *context, unsigned int count, /* Including the first glyph (not matched) */ const USHORT input[], /* Array of input values--start with second glyph */ match_func_t match_func, @@ -99,54 +94,54 @@ static inline bool match_input (APPLY_ARG_DEF, unsigned int *context_length_out) { unsigned int i, j; - unsigned int end = MIN (buffer->in_length, buffer->in_pos + context_length); - if (HB_UNLIKELY (buffer->in_pos + count > end)) + unsigned int end = MIN (context->buffer->in_length, context->buffer->in_pos + context->context_length); + if (unlikely (context->buffer->in_pos + count > end)) return false; - for (i = 1, j = buffer->in_pos + 1; i < count; i++, j++) + for (i = 1, j = context->buffer->in_pos + 1; i < count; i++, j++) { - while (_hb_ot_layout_skip_mark (layout_context->face, IN_INFO (j), context->lookup_flag, NULL)) + while (_hb_ot_layout_skip_mark (context->layout->face, IN_INFO (j), context->lookup_flag, NULL)) { - if (HB_UNLIKELY (j + count - i == end)) + if (unlikely (j + count - i == end)) return false; j++; } - if (HB_LIKELY (!match_func (IN_GLYPH (j), input[i - 1], match_data))) + if (likely (!match_func (IN_GLYPH (j), input[i - 1], match_data))) return false; } - *context_length_out = j - buffer->in_pos; + *context_length_out = j - context->buffer->in_pos; return true; } -static inline bool match_backtrack (APPLY_ARG_DEF, +static inline bool match_backtrack (hb_apply_context_t *context, unsigned int count, const USHORT backtrack[], match_func_t match_func, const char *match_data) { - if (HB_UNLIKELY (buffer->out_pos < count)) + if (unlikely (context->buffer->out_pos < count)) return false; - for (unsigned int i = 0, j = buffer->out_pos - 1; i < count; i++, j--) + for (unsigned int i = 0, j = context->buffer->out_pos - 1; i < count; i++, j--) { - while (_hb_ot_layout_skip_mark (layout_context->face, OUT_INFO (j), context->lookup_flag, NULL)) + while (_hb_ot_layout_skip_mark (context->layout->face, OUT_INFO (j), context->lookup_flag, NULL)) { - if (HB_UNLIKELY (j + 1 == count - i)) + if (unlikely (j + 1 == count - i)) return false; j--; } - if (HB_LIKELY (!match_func (OUT_GLYPH (j), backtrack[i], match_data))) + if (likely (!match_func (OUT_GLYPH (j), backtrack[i], match_data))) return false; } return true; } -static inline bool match_lookahead (APPLY_ARG_DEF, +static inline bool match_lookahead (hb_apply_context_t *context, unsigned int count, const USHORT lookahead[], match_func_t match_func, @@ -154,20 +149,20 @@ static inline bool match_lookahead (APPLY_ARG_DEF, unsigned int offset) { unsigned int i, j; - unsigned int end = MIN (buffer->in_length, buffer->in_pos + context_length); - if (HB_UNLIKELY (buffer->in_pos + offset + count > end)) + unsigned int end = MIN (context->buffer->in_length, context->buffer->in_pos + context->context_length); + if (unlikely (context->buffer->in_pos + offset + count > end)) return false; - for (i = 0, j = buffer->in_pos + offset; i < count; i++, j++) + for (i = 0, j = context->buffer->in_pos + offset; i < count; i++, j++) { - while (_hb_ot_layout_skip_mark (layout_context->face, OUT_INFO (j), context->lookup_flag, NULL)) + while (_hb_ot_layout_skip_mark (context->layout->face, OUT_INFO (j), context->lookup_flag, NULL)) { - if (HB_UNLIKELY (j + count - i == end)) + if (unlikely (j + count - i == end)) return false; j++; } - if (HB_LIKELY (!match_func (IN_GLYPH (j), lookahead[i], match_data))) + if (likely (!match_func (IN_GLYPH (j), lookahead[i], match_data))) return false; } @@ -177,28 +172,27 @@ static inline bool match_lookahead (APPLY_ARG_DEF, struct LookupRecord { - static inline unsigned int get_size () { return sizeof (LookupRecord); } - - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); - return SANITIZE_SELF (); + return context->check_struct (this); } USHORT sequenceIndex; /* Index into current glyph * sequence--first glyph = 0 */ USHORT lookupListIndex; /* Lookup to apply to that * position--zero--based */ + public: + DEFINE_SIZE_STATIC (4); }; -ASSERT_SIZE (LookupRecord, 4); -static inline bool apply_lookup (APPLY_ARG_DEF, +static inline bool apply_lookup (hb_apply_context_t *context, unsigned int count, /* Including the first glyph */ unsigned int lookupCount, const LookupRecord lookupRecord[], /* Array of LookupRecords--in design order */ apply_lookup_func_t apply_func) { - unsigned int end = MIN (buffer->in_length, buffer->in_pos + context_length); - if (HB_UNLIKELY (buffer->in_pos + count > end)) + unsigned int end = MIN (context->buffer->in_length, context->buffer->in_pos + context->context_length); + if (unlikely (context->buffer->in_pos + count > end)) return false; /* TODO We don't support lookupRecord arrays that are not increasing: @@ -210,26 +204,26 @@ static inline bool apply_lookup (APPLY_ARG_DEF, */ for (unsigned int i = 0; i < count; /* NOP */) { - while (_hb_ot_layout_skip_mark (layout_context->face, IN_CURINFO (), context->lookup_flag, NULL)) + while (_hb_ot_layout_skip_mark (context->layout->face, IN_CURINFO (), context->lookup_flag, NULL)) { - if (HB_UNLIKELY (buffer->in_pos == end)) + if (unlikely (context->buffer->in_pos == end)) return true; /* No lookup applied for this index */ - _hb_buffer_next_glyph (buffer); + _hb_buffer_next_glyph (context->buffer); } if (lookupCount && i == lookupRecord->sequenceIndex) { - unsigned int old_pos = buffer->in_pos; + unsigned int old_pos = context->buffer->in_pos; /* Apply a lookup */ - bool done = apply_func (APPLY_ARG, lookupRecord->lookupListIndex); + bool done = apply_func (context, lookupRecord->lookupListIndex); lookupRecord++; lookupCount--; /* Err, this is wrong if the lookup jumped over some glyphs */ - i += buffer->in_pos - old_pos; - if (HB_UNLIKELY (buffer->in_pos == end)) + i += context->buffer->in_pos - old_pos; + if (unlikely (context->buffer->in_pos == end)) return true; if (!done) @@ -239,7 +233,7 @@ static inline bool apply_lookup (APPLY_ARG_DEF, { not_applied: /* No lookup applied for this index */ - _hb_buffer_next_glyph (buffer); + _hb_buffer_next_glyph (context->buffer); i++; } } @@ -256,18 +250,19 @@ struct ContextLookupContext const char *match_data; }; -static inline bool context_lookup (APPLY_ARG_DEF, +static inline bool context_lookup (hb_apply_context_t *context, unsigned int inputCount, /* Including the first glyph (not matched) */ const USHORT input[], /* Array of input values--start with second glyph */ unsigned int lookupCount, const LookupRecord lookupRecord[], ContextLookupContext &lookup_context) { - return match_input (APPLY_ARG, + hb_apply_context_t new_context = *context; + return match_input (context, inputCount, input, lookup_context.funcs.match, lookup_context.match_data, - &context_length) && - apply_lookup (APPLY_ARG, + &new_context.context_length) + && apply_lookup (&new_context, inputCount, lookupCount, lookupRecord, lookup_context.funcs.apply); @@ -278,23 +273,24 @@ struct Rule friend struct RuleSet; private: - inline bool apply (APPLY_ARG_DEF, ContextLookupContext &lookup_context) const + inline bool apply (hb_apply_context_t *context, ContextLookupContext &lookup_context) const { TRACE_APPLY (); - const LookupRecord &lookupRecord = StructAtOffset (input, input[0].get_size () * (inputCount ? inputCount - 1 : 0)); - return context_lookup (APPLY_ARG, + const LookupRecord *lookupRecord = &StructAtOffset (input, input[0].static_size * (inputCount ? inputCount - 1 : 0)); + return context_lookup (context, inputCount, input, - lookupCount, &lookupRecord, + lookupCount, lookupRecord, lookup_context); } public: - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); - if (!(SANITIZE (inputCount) && SANITIZE (lookupCount))) return false; - return SANITIZE_MEM (input, - input[0].get_size () * inputCount + - lookupRecordX[0].get_size () * lookupCount); + return inputCount.sanitize (context) + && lookupCount.sanitize (context) + && context->check_range (input, + input[0].static_size * inputCount + + lookupRecordX[0].static_size * lookupCount); } private: @@ -306,27 +302,28 @@ struct Rule * second glyph */ LookupRecord lookupRecordX[VAR]; /* Array of LookupRecords--in * design order */ + public: + DEFINE_SIZE_VAR2 (4, USHORT, LookupRecord); }; -ASSERT_SIZE_VAR2 (Rule, 4, USHORT, LookupRecord); struct RuleSet { - inline bool apply (APPLY_ARG_DEF, ContextLookupContext &lookup_context) const + inline bool apply (hb_apply_context_t *context, ContextLookupContext &lookup_context) const { TRACE_APPLY (); unsigned int num_rules = rule.len; for (unsigned int i = 0; i < num_rules; i++) { - if ((this+rule[i]).apply (APPLY_ARG, lookup_context)) + if ((this+rule[i]).apply (context, lookup_context)) return true; } return false; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); - return SANITIZE_THIS (rule); + return rule.sanitize (context, this); } private: @@ -341,11 +338,11 @@ struct ContextFormat1 friend struct Context; private: - inline bool apply (APPLY_ARG_DEF, apply_lookup_func_t apply_func) const + inline bool apply (hb_apply_context_t *context, apply_lookup_func_t apply_func) const { TRACE_APPLY (); unsigned int index = (this+coverage) (IN_CURGLYPH ()); - if (HB_LIKELY (index == NOT_COVERED)) + if (likely (index == NOT_COVERED)) return false; const RuleSet &rule_set = this+ruleSet[index]; @@ -353,12 +350,13 @@ struct ContextFormat1 {match_glyph, apply_func}, NULL }; - return rule_set.apply (APPLY_ARG, lookup_context); + return rule_set.apply (context, lookup_context); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); - return SANITIZE_THIS2 (coverage, ruleSet); + return coverage.sanitize (context, this) + && ruleSet.sanitize (context, this); } private: @@ -369,8 +367,9 @@ struct ContextFormat1 OffsetArrayOf ruleSet; /* Array of RuleSet tables * ordered by Coverage Index */ + public: + DEFINE_SIZE_STATIC (6); }; -ASSERT_SIZE (ContextFormat1, 6); struct ContextFormat2 @@ -378,11 +377,11 @@ struct ContextFormat2 friend struct Context; private: - inline bool apply (APPLY_ARG_DEF, apply_lookup_func_t apply_func) const + inline bool apply (hb_apply_context_t *context, apply_lookup_func_t apply_func) const { TRACE_APPLY (); unsigned int index = (this+coverage) (IN_CURGLYPH ()); - if (HB_LIKELY (index == NOT_COVERED)) + if (likely (index == NOT_COVERED)) return false; const ClassDef &class_def = this+classDef; @@ -395,12 +394,14 @@ struct ContextFormat2 {match_class, apply_func}, CharP(&class_def) }; - return rule_set.apply (APPLY_ARG, lookup_context); + return rule_set.apply (context, lookup_context); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); - return SANITIZE_THIS3 (coverage, classDef, ruleSet); + return coverage.sanitize (context, this) + && classDef.sanitize (context, this) + && ruleSet.sanitize (context, this); } private: @@ -414,8 +415,9 @@ struct ContextFormat2 OffsetArrayOf ruleSet; /* Array of RuleSet tables * ordered by class */ + public: + DEFINE_SIZE_STATIC (8); }; -ASSERT_SIZE (ContextFormat2, 8); struct ContextFormat3 @@ -423,33 +425,33 @@ struct ContextFormat3 friend struct Context; private: - inline bool apply (APPLY_ARG_DEF, apply_lookup_func_t apply_func) const + inline bool apply (hb_apply_context_t *context, apply_lookup_func_t apply_func) const { TRACE_APPLY (); unsigned int index = (this+coverage[0]) (IN_CURGLYPH ()); - if (HB_LIKELY (index == NOT_COVERED)) + if (likely (index == NOT_COVERED)) return false; - const LookupRecord &lookupRecord = StructAtOffset (coverage, coverage[0].get_size () * glyphCount); + const LookupRecord *lookupRecord = &StructAtOffset (coverage, coverage[0].static_size * glyphCount); struct ContextLookupContext lookup_context = { {match_coverage, apply_func}, CharP(this) }; - return context_lookup (APPLY_ARG, + return context_lookup (context, glyphCount, (const USHORT *) (coverage + 1), - lookupCount, &lookupRecord, + lookupCount, lookupRecord, lookup_context); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); - if (!SANITIZE_SELF ()) return false; + if (!context->check_struct (this)) return false; unsigned int count = glyphCount; - if (!SANITIZE_ARRAY (coverage, OffsetTo::get_size (), glyphCount)) return false; + if (!context->check_array (coverage, coverage[0].static_size, count)) return false; for (unsigned int i = 0; i < count; i++) - if (!SANITIZE_THIS (coverage[i])) return false; - LookupRecord &lookupRecord = StructAtOffset (coverage, OffsetTo::get_size () * glyphCount); - return SANITIZE_ARRAY (&lookupRecord, LookupRecord::get_size (), lookupCount); + if (!coverage[i].sanitize (context, this)) return false; + LookupRecord *lookupRecord = &StructAtOffset (coverage, coverage[0].static_size * count); + return context->check_array (lookupRecord, lookupRecord[0].static_size, lookupCount); } private: @@ -462,30 +464,31 @@ struct ContextFormat3 * table in glyph sequence order */ LookupRecord lookupRecordX[VAR]; /* Array of LookupRecords--in * design order */ + public: + DEFINE_SIZE_VAR2 (6, OffsetTo, LookupRecord); }; -ASSERT_SIZE_VAR2 (ContextFormat3, 6, OffsetTo, LookupRecord); struct Context { protected: - inline bool apply (APPLY_ARG_DEF, apply_lookup_func_t apply_func) const + inline bool apply (hb_apply_context_t *context, apply_lookup_func_t apply_func) const { TRACE_APPLY (); switch (u.format) { - case 1: return u.format1->apply (APPLY_ARG, apply_func); - case 2: return u.format2->apply (APPLY_ARG, apply_func); - case 3: return u.format3->apply (APPLY_ARG, apply_func); + case 1: return u.format1->apply (context, apply_func); + case 2: return u.format2->apply (context, apply_func); + case 3: return u.format3->apply (context, apply_func); default:return false; } } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); - if (!SANITIZE (u.format)) return false; + if (!u.format.sanitize (context)) return false; switch (u.format) { - case 1: return u.format1->sanitize (SANITIZE_ARG); - case 2: return u.format2->sanitize (SANITIZE_ARG); - case 3: return u.format3->sanitize (SANITIZE_ARG); + case 1: return u.format1->sanitize (context); + case 2: return u.format2->sanitize (context); + case 3: return u.format3->sanitize (context); default:return true; } } @@ -508,7 +511,7 @@ struct ChainContextLookupContext const char *match_data[3]; }; -static inline bool chain_context_lookup (APPLY_ARG_DEF, +static inline bool chain_context_lookup (hb_apply_context_t *context, unsigned int backtrackCount, const USHORT backtrack[], unsigned int inputCount, /* Including the first glyph (not matched) */ @@ -520,25 +523,24 @@ static inline bool chain_context_lookup (APPLY_ARG_DEF, ChainContextLookupContext &lookup_context) { /* First guess */ - if (HB_UNLIKELY (buffer->out_pos < backtrackCount || - buffer->in_pos + inputCount + lookaheadCount > buffer->in_length || - inputCount + lookaheadCount > context_length)) + if (unlikely (context->buffer->out_pos < backtrackCount || + context->buffer->in_pos + inputCount + lookaheadCount > context->buffer->in_length || + inputCount + lookaheadCount > context->context_length)) return false; - unsigned int offset; - return match_backtrack (APPLY_ARG, + hb_apply_context_t new_context = *context; + return match_backtrack (context, backtrackCount, backtrack, - lookup_context.funcs.match, lookup_context.match_data[0]) && - match_input (APPLY_ARG, + lookup_context.funcs.match, lookup_context.match_data[0]) + && match_input (context, inputCount, input, lookup_context.funcs.match, lookup_context.match_data[1], - &offset) && - match_lookahead (APPLY_ARG, + &new_context.context_length) + && match_lookahead (context, lookaheadCount, lookahead, lookup_context.funcs.match, lookup_context.match_data[2], - offset) && - (context_length = offset, true) && - apply_lookup (APPLY_ARG, + new_context.context_length) + && apply_lookup (&new_context, inputCount, lookupCount, lookupRecord, lookup_context.funcs.apply); @@ -549,13 +551,13 @@ struct ChainRule friend struct ChainRuleSet; private: - inline bool apply (APPLY_ARG_DEF, ChainContextLookupContext &lookup_context) const + inline bool apply (hb_apply_context_t *context, ChainContextLookupContext &lookup_context) const { TRACE_APPLY (); const HeadlessArrayOf &input = StructAfter > (backtrack); const ArrayOf &lookahead = StructAfter > (input); const ArrayOf &lookup = StructAfter > (lookahead); - return chain_context_lookup (APPLY_ARG, + return chain_context_lookup (context, backtrack.len, backtrack.array(), input.len, input.array(), lookahead.len, lookahead.array(), @@ -565,15 +567,15 @@ struct ChainRule } public: - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); - if (!SANITIZE (backtrack)) return false; + if (!backtrack.sanitize (context)) return false; HeadlessArrayOf &input = StructAfter > (backtrack); - if (!SANITIZE (input)) return false; + if (!input.sanitize (context)) return false; ArrayOf &lookahead = StructAfter > (input); - if (!SANITIZE (lookahead)) return false; + if (!lookahead.sanitize (context)) return false; ArrayOf &lookup = StructAfter > (lookahead); - return SANITIZE (lookup); + return lookup.sanitize (context); } private: @@ -590,46 +592,48 @@ struct ChainRule ArrayOf lookupX; /* Array of LookupRecords--in * design order) */ + public: + DEFINE_SIZE_STATIC (8); }; -ASSERT_SIZE (ChainRule, 8); struct ChainRuleSet { - inline bool apply (APPLY_ARG_DEF, ChainContextLookupContext &lookup_context) const + inline bool apply (hb_apply_context_t *context, ChainContextLookupContext &lookup_context) const { TRACE_APPLY (); unsigned int num_rules = rule.len; for (unsigned int i = 0; i < num_rules; i++) { - if ((this+rule[i]).apply (APPLY_ARG, lookup_context)) + if ((this+rule[i]).apply (context, lookup_context)) return true; } return false; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); - return SANITIZE_THIS (rule); + return rule.sanitize (context, this); } private: OffsetArrayOf rule; /* Array of ChainRule tables * ordered by preference */ + public: + DEFINE_SIZE_STATIC (2); }; -ASSERT_SIZE (ChainRuleSet, 2); struct ChainContextFormat1 { friend struct ChainContext; private: - inline bool apply (APPLY_ARG_DEF, apply_lookup_func_t apply_func) const + inline bool apply (hb_apply_context_t *context, apply_lookup_func_t apply_func) const { TRACE_APPLY (); unsigned int index = (this+coverage) (IN_CURGLYPH ()); - if (HB_LIKELY (index == NOT_COVERED)) + if (likely (index == NOT_COVERED)) return false; const ChainRuleSet &rule_set = this+ruleSet[index]; @@ -637,12 +641,13 @@ struct ChainContextFormat1 {match_glyph, apply_func}, {NULL, NULL, NULL} }; - return rule_set.apply (APPLY_ARG, lookup_context); + return rule_set.apply (context, lookup_context); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); - return SANITIZE_THIS2 (coverage, ruleSet); + return coverage.sanitize (context, this) + && ruleSet.sanitize (context, this); } private: @@ -653,19 +658,20 @@ struct ChainContextFormat1 OffsetArrayOf ruleSet; /* Array of ChainRuleSet tables * ordered by Coverage Index */ + public: + DEFINE_SIZE_STATIC (6); }; -ASSERT_SIZE (ChainContextFormat1, 6); struct ChainContextFormat2 { friend struct ChainContext; private: - inline bool apply (APPLY_ARG_DEF, apply_lookup_func_t apply_func) const + inline bool apply (hb_apply_context_t *context, apply_lookup_func_t apply_func) const { TRACE_APPLY (); unsigned int index = (this+coverage) (IN_CURGLYPH ()); - if (HB_LIKELY (index == NOT_COVERED)) + if (likely (index == NOT_COVERED)) return false; const ClassDef &backtrack_class_def = this+backtrackClassDef; @@ -683,14 +689,16 @@ struct ChainContextFormat2 CharP(&input_class_def), CharP(&lookahead_class_def)} }; - return rule_set.apply (APPLY_ARG, lookup_context); + return rule_set.apply (context, lookup_context); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); - return SANITIZE_THIS2 (coverage, backtrackClassDef) && - SANITIZE_THIS2 (inputClassDef, lookaheadClassDef) && - SANITIZE_THIS (ruleSet); + return coverage.sanitize (context, this) + && backtrackClassDef.sanitize (context, this) + && inputClassDef.sanitize (context, this) + && lookaheadClassDef.sanitize (context, this) + && ruleSet.sanitize (context, this); } private: @@ -713,8 +721,9 @@ struct ChainContextFormat2 OffsetArrayOf ruleSet; /* Array of ChainRuleSet tables * ordered by class */ + public: + DEFINE_SIZE_STATIC (12); }; -ASSERT_SIZE (ChainContextFormat2, 12); struct ChainContextFormat3 { @@ -722,13 +731,13 @@ struct ChainContextFormat3 private: - inline bool apply (APPLY_ARG_DEF, apply_lookup_func_t apply_func) const + inline bool apply (hb_apply_context_t *context, apply_lookup_func_t apply_func) const { TRACE_APPLY (); const OffsetArrayOf &input = StructAfter > (backtrack); unsigned int index = (this+input[0]) (IN_CURGLYPH ()); - if (HB_LIKELY (index == NOT_COVERED)) + if (likely (index == NOT_COVERED)) return false; const OffsetArrayOf &lookahead = StructAfter > (input); @@ -737,7 +746,7 @@ struct ChainContextFormat3 {match_coverage, apply_func}, {CharP(this), CharP(this), CharP(this)} }; - return chain_context_lookup (APPLY_ARG, + return chain_context_lookup (context, backtrack.len, (const USHORT *) backtrack.array(), input.len, (const USHORT *) input.array() + 1, lookahead.len, (const USHORT *) lookahead.array(), @@ -746,15 +755,15 @@ struct ChainContextFormat3 return false; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); - if (!SANITIZE_THIS (backtrack)) return false; + if (!backtrack.sanitize (context, this)) return false; OffsetArrayOf &input = StructAfter > (backtrack); - if (!SANITIZE_THIS (input)) return false; + if (!input.sanitize (context, this)) return false; OffsetArrayOf &lookahead = StructAfter > (input); - if (!SANITIZE_THIS (lookahead)) return false; + if (!lookahead.sanitize (context, this)) return false; ArrayOf &lookup = StructAfter > (lookahead); - return SANITIZE (lookup); + return lookup.sanitize (context); } private: @@ -774,30 +783,31 @@ struct ChainContextFormat3 ArrayOf lookupX; /* Array of LookupRecords--in * design order) */ + public: + DEFINE_SIZE_STATIC (10); }; -ASSERT_SIZE (ChainContextFormat3, 10); struct ChainContext { protected: - inline bool apply (APPLY_ARG_DEF, apply_lookup_func_t apply_func) const + inline bool apply (hb_apply_context_t *context, apply_lookup_func_t apply_func) const { TRACE_APPLY (); switch (u.format) { - case 1: return u.format1->apply (APPLY_ARG, apply_func); - case 2: return u.format2->apply (APPLY_ARG, apply_func); - case 3: return u.format3->apply (APPLY_ARG, apply_func); + case 1: return u.format1->apply (context, apply_func); + case 2: return u.format2->apply (context, apply_func); + case 3: return u.format3->apply (context, apply_func); default:return false; } } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); - if (!SANITIZE (u.format)) return false; + if (!u.format.sanitize (context)) return false; switch (u.format) { - case 1: return u.format1->sanitize (SANITIZE_ARG); - case 2: return u.format2->sanitize (SANITIZE_ARG); - case 3: return u.format3->sanitize (SANITIZE_ARG); + case 1: return u.format1->sanitize (context); + case 2: return u.format2->sanitize (context); + case 3: return u.format3->sanitize (context); default:return true; } } @@ -820,9 +830,9 @@ struct ExtensionFormat1 inline unsigned int get_type (void) const { return extensionLookupType; } inline unsigned int get_offset (void) const { return extensionOffset; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); - return SANITIZE_SELF (); + return context->check_struct (this); } private: @@ -832,8 +842,9 @@ struct ExtensionFormat1 * extension subtable). */ ULONG extensionOffset; /* Offset to the extension subtable, * of lookup type subtable. */ + public: + DEFINE_SIZE_STATIC (8); }; -ASSERT_SIZE (ExtensionFormat1, 8); struct Extension { @@ -852,11 +863,11 @@ struct Extension } } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); - if (!SANITIZE (u.format)) return false; + if (!u.format.sanitize (context)) return false; switch (u.format) { - case 1: return u.format1->sanitize (SANITIZE_ARG); + case 1: return u.format1->sanitize (context); default:return true; } } @@ -909,11 +920,12 @@ struct GSUBGPOS inline const Lookup& get_lookup (unsigned int i) const { return (this+lookupList)[i]; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); - if (!SANITIZE (version)) return false; - if (HB_UNLIKELY (version.major != 1)) return false; - return SANITIZE_THIS3 (scriptList, featureList, lookupList); + return version.sanitize (context) && likely (version.major == 1) + && scriptList.sanitize (context, this) + && featureList.sanitize (context, this) + && lookupList.sanitize (context, this); } protected: @@ -925,8 +937,9 @@ struct GSUBGPOS featureList; /* FeatureList table */ OffsetTo lookupList; /* LookupList table */ + public: + DEFINE_SIZE_STATIC (10); }; -ASSERT_SIZE (GSUBGPOS, 10); #endif /* HB_OT_LAYOUT_GSUBGPOS_PRIVATE_HH */