X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fhb-ot-layout-gsubgpos-private.hh;h=86285d17ca87c9541467899cfab80dccc14a0e2c;hb=b3651231bf80bb7009214547a75ed90e21815c68;hp=7be8edf91e259b307093edc4402f0b03e51a55f4;hpb=2cb08458f674301cde9d962c13911035a251f7c5;p=framework%2Fuifw%2Fharfbuzz.git diff --git a/src/hb-ot-layout-gsubgpos-private.hh b/src/hb-ot-layout-gsubgpos-private.hh index 7be8edf..86285d1 100644 --- a/src/hb-ot-layout-gsubgpos-private.hh +++ b/src/hb-ot-layout-gsubgpos-private.hh @@ -1,7 +1,7 @@ /* - * Copyright (C) 2007,2008,2009 Red Hat, Inc. + * Copyright (C) 2007,2008,2009,2010 Red Hat, Inc. * - * This is part of HarfBuzz, an OpenType Layout engine library. + * This is part of HarfBuzz, a text shaping library. * * Permission is hereby granted, without written agreement and without * license or royalty fees, to use, copy, modify, and distribute this @@ -32,57 +32,34 @@ #ifndef HB_DEBUG_APPLY -#define HB_DEBUG_APPLY HB_DEBUG +#define HB_DEBUG_APPLY HB_DEBUG+0 #endif -#if HB_DEBUG_APPLY -#include -#define TRACE_APPLY_ARG_DEF , unsigned int apply_depth HB_GNUC_UNUSED -#define TRACE_APPLY_ARG , apply_depth + 1 -#define TRACE_APPLY_ARG_INIT , 1 #define TRACE_APPLY() \ - HB_STMT_START { \ - if (apply_depth < HB_DEBUG_APPLY) \ - fprintf (stderr, "APPLY(%p) %-*d-> %s\n", \ - (ConstCharP (this) == ConstCharP (&NullPool)) ? 0 : this, \ - apply_depth, apply_depth, \ - __PRETTY_FUNCTION__); \ - } HB_STMT_END -#else -#define TRACE_APPLY_ARG_DEF -#define TRACE_APPLY_ARG -#define TRACE_APPLY_ARG_INIT -#define TRACE_APPLY() HB_STMT_START {} HB_STMT_END -#endif + 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) */ +}; + + -#define APPLY_ARG_DEF \ - hb_ot_layout_context_t *context, \ - hb_buffer_t *buffer, \ - unsigned int context_length HB_GNUC_UNUSED, \ - unsigned int nesting_level_left HB_GNUC_UNUSED, \ - unsigned int lookup_flag HB_GNUC_UNUSED, \ - unsigned int property HB_GNUC_UNUSED /* propety of first glyph */ \ - TRACE_APPLY_ARG_DEF -#define APPLY_ARG \ - context, \ - buffer, \ - context_length, \ - nesting_level_left, \ - lookup_flag, \ - property \ - TRACE_APPLY_ARG -#define APPLY_ARG_INIT \ - context, \ - buffer, \ - context_length, \ - nesting_level_left, \ - lookup_flag, \ - property \ - TRACE_APPLY_ARG_INIT + +#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 { @@ -91,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; } @@ -109,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, @@ -117,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 (context->face, IN_INFO (j), 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 (context->face, OUT_INFO (j), 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, @@ -172,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 (context->face, OUT_INFO (j), 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; } @@ -195,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: @@ -228,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 (context->face, IN_CURINFO (), 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) @@ -257,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++; } } @@ -274,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); @@ -296,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 = &CONST_CAST (LookupRecord, 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, 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: @@ -324,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: @@ -359,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]; @@ -371,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: @@ -387,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 @@ -396,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; @@ -411,14 +392,16 @@ struct ContextFormat2 */ struct ContextLookupContext lookup_context = { {match_class, apply_func}, - ConstCharP(&class_def) + 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: @@ -432,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 @@ -441,32 +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 = &CONST_CAST(LookupRecord, coverage, coverage[0].get_size () * glyphCount); + const LookupRecord *lookupRecord = &StructAtOffset (coverage, coverage[0].static_size * glyphCount); struct ContextLookupContext lookup_context = { {match_coverage, apply_func}, - ConstCharP(this) + CharP(this) }; - return context_lookup (APPLY_ARG, + return context_lookup (context, glyphCount, (const USHORT *) (coverage + 1), 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 (!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 = &CAST(LookupRecord, coverage, coverage[0].get_size () * glyphCount); - return SANITIZE_MEM (lookupRecord, lookupRecord[0].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: @@ -479,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; } } @@ -525,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) */ @@ -537,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); @@ -566,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(), @@ -582,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: @@ -607,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]; @@ -654,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: @@ -670,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; @@ -696,18 +685,20 @@ struct ChainContextFormat2 */ struct ChainContextLookupContext lookup_context = { {match_class, apply_func}, - {ConstCharP(&backtrack_class_def), - ConstCharP(&input_class_def), - ConstCharP(&lookahead_class_def)} + {CharP(&backtrack_class_def), + 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: @@ -730,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 { @@ -739,22 +731,22 @@ 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); const ArrayOf &lookup = StructAfter > (lookahead); struct ChainContextLookupContext lookup_context = { {match_coverage, apply_func}, - {ConstCharP(this), ConstCharP(this), ConstCharP(this)} + {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(), @@ -763,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: @@ -791,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; } } @@ -835,17 +828,11 @@ struct ExtensionFormat1 protected: inline unsigned int get_type (void) const { return extensionLookupType; } - inline unsigned int get_offset (void) const { return (extensionOffset[0] << 16) + extensionOffset[1]; } - inline const LookupSubTable& get_subtable (void) const - { - unsigned int offset = get_offset (); - if (HB_UNLIKELY (!offset)) return Null(LookupSubTable); - return CONST_CAST (LookupSubTable, *this, offset); - } + 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: @@ -853,12 +840,11 @@ struct ExtensionFormat1 USHORT extensionLookupType; /* Lookup type of subtable referenced * by ExtensionOffset (i.e. the * extension subtable). */ - USHORT extensionOffset[2]; /* Offset to the extension subtable, - * of lookup type subtable. - * Defined as two shorts to avoid - * alignment requirements. */ + ULONG extensionOffset; /* Offset to the extension subtable, + * of lookup type subtable. */ + public: + DEFINE_SIZE_STATIC (8); }; -ASSERT_SIZE (ExtensionFormat1, 8); struct Extension { @@ -869,19 +855,19 @@ struct Extension default:return 0; } } - inline const LookupSubTable& get_subtable (void) const + inline unsigned int get_offset (void) const { switch (u.format) { - case 1: return u.format1->get_subtable (); - default:return Null(LookupSubTable); + case 1: return u.format1->get_offset (); + default:return 0; } } - 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; } } @@ -903,8 +889,6 @@ struct GSUBGPOS static const hb_tag_t GSUBTag = HB_OT_TAG_GSUB; static const hb_tag_t GPOSTag = HB_OT_TAG_GPOS; - STATIC_DEFINE_GET_FOR_DATA_CHECK_MAJOR_VERSION (GSUBGPOS, 1, 1); - inline unsigned int get_script_count (void) const { return (this+scriptList).len; } inline const Tag& get_script_tag (unsigned int i) const @@ -936,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 (version.major != 1) return true; - 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: @@ -952,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 */