X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fhb-ot-layout-gsubgpos-private.hh;h=4d6656ac8a54e86f74844cf2350102a8aaec67a6;hb=b9452bfc1696457e156e79037c863903da5454fc;hp=979026dac50fe480e50c909bfff597e973b553cf;hpb=807c5b03a2251a3c29a520852639421783101b55;p=framework%2Fuifw%2Fharfbuzz.git diff --git a/src/hb-ot-layout-gsubgpos-private.hh b/src/hb-ot-layout-gsubgpos-private.hh index 979026d..4d6656a 100644 --- a/src/hb-ot-layout-gsubgpos-private.hh +++ b/src/hb-ot-layout-gsubgpos-private.hh @@ -1,5 +1,6 @@ /* - * Copyright (C) 2007,2008,2009 Red Hat, Inc. + * Copyright © 2007,2008,2009,2010 Red Hat, Inc. + * Copyright © 2010 Google, Inc. * * This is part of HarfBuzz, a text shaping library. * @@ -22,67 +23,78 @@ * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. * * Red Hat Author(s): Behdad Esfahbod + * Google Author(s): Behdad Esfahbod */ #ifndef HB_OT_LAYOUT_GSUBGPOS_PRIVATE_HH #define HB_OT_LAYOUT_GSUBGPOS_PRIVATE_HH -#include "hb-buffer-private.h" +#include "hb-buffer-private.hh" #include "hb-ot-layout-gdef-private.hh" +HB_BEGIN_DECLS + + +/* buffer var allocations */ +#define lig_id() var2.u16[0] /* unique ligature id */ +#define lig_comp() var2.u16[1] /* component number in the ligature (0 = base) */ + #ifndef HB_DEBUG_APPLY -#define HB_DEBUG_APPLY HB_DEBUG+0 +#define HB_DEBUG_APPLY (HB_DEBUG+0) #endif -static HB_GNUC_UNUSED inline hb_bool_t /* always returns TRUE */ -_hb_trace_apply (const char *obj, - unsigned int apply_depth, - const char *function) +#define TRACE_APPLY() \ + hb_trace_t trace (&c->debug_depth, "APPLY", HB_FUNC, this); \ + + +HB_BEGIN_DECLS + +struct hb_apply_context_t { - /* The following check is written in such a skewed way just - * to quiet compiler warning. The simple version would have been: - * if (apply_depth < HB_DEBUG_APPLY) - */ - if (HB_DEBUG_APPLY && (int) apply_depth < HB_DEBUG_APPLY) - fprintf (stderr, "APPLY(%p) %-*d-> %s\n", - (obj == CharP(&_NullPool)) ? 0 : obj, - apply_depth, apply_depth, - function); - return TRUE; -} + unsigned int debug_depth; + hb_font_t *font; + hb_face_t *face; + hb_buffer_t *buffer; + hb_direction_t direction; + hb_mask_t lookup_mask; + unsigned int context_length; + unsigned int nesting_level_left; + unsigned int lookup_props; + unsigned int property; /* propety of first glyph */ + + + inline void replace_glyph (hb_codepoint_t glyph_index) const + { + clear_property (); + buffer->replace_glyph (glyph_index); + } + inline void replace_glyphs_be16 (unsigned int num_in, + unsigned int num_out, + const uint16_t *glyph_data_be) const + { + clear_property (); + buffer->replace_glyphs_be16 (num_in, num_out, glyph_data_be); + } + + inline void guess_glyph_class (unsigned int klass) + { + /* XXX if ! has gdef */ + buffer->info[buffer->i].props_cache() = klass; + } + + private: + inline void clear_property (void) const + { + /* XXX if has gdef */ + buffer->info[buffer->i].props_cache() = 0; + } +}; + + -#define TRACE_APPLY() _hb_trace_apply (CharP(this), apply_depth, __PRETTY_FUNCTION__) - - -#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 */ \ - unsigned int apply_depth HB_GNUC_UNUSED -#define APPLY_ARG \ - context, \ - buffer, \ - context_length, \ - nesting_level_left, \ - lookup_flag, \ - property, \ - (HB_DEBUG_APPLY ? apply_depth+1 : 0) -#define APPLY_ARG_INIT \ - context, \ - buffer, \ - context_length, \ - nesting_level_left, \ - lookup_flag, \ - property, \ - 1 - - -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 (*match_func_t) (hb_codepoint_t glyph_id, const USHORT &value, const void *data); +typedef bool (*apply_lookup_func_t) (hb_apply_context_t *c, unsigned int lookup_index); struct ContextFuncs { @@ -91,163 +103,167 @@ 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 void *data HB_UNUSED) { return glyph_id == value; } -static inline bool match_class (hb_codepoint_t glyph_id, const USHORT &value, const char *data) +static inline bool match_class (hb_codepoint_t glyph_id, const USHORT &value, const void *data) { const ClassDef &class_def = *reinterpret_cast(data); return class_def.get_class (glyph_id) == value; } -static inline bool match_coverage (hb_codepoint_t glyph_id, const USHORT &value, const char *data) +static inline bool match_coverage (hb_codepoint_t glyph_id, const USHORT &value, const void *data) { const OffsetTo &coverage = (const OffsetTo&)value; return (data+coverage) (glyph_id) != NOT_COVERED; } -static inline bool match_input (APPLY_ARG_DEF, +static inline bool match_input (hb_apply_context_t *c, 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, - const char *match_data, + const void *match_data, 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 (c->buffer->len, c->buffer->i + c->context_length); + if (unlikely (c->buffer->i + count > end)) return false; - for (i = 1, j = buffer->in_pos + 1; i < count; i++, j++) + for (i = 1, j = c->buffer->i + 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 (c->face, &c->buffer->info[j], c->lookup_props, 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 (c->buffer->info[j].codepoint, input[i - 1], match_data))) return false; } - *context_length_out = j - buffer->in_pos; + *context_length_out = j - c->buffer->i; return true; } -static inline bool match_backtrack (APPLY_ARG_DEF, +static inline bool match_backtrack (hb_apply_context_t *c, unsigned int count, const USHORT backtrack[], match_func_t match_func, - const char *match_data) + const void *match_data) { - if (HB_UNLIKELY (buffer->out_pos < count)) + if (unlikely (c->buffer->backtrack_len () < count)) return false; - for (unsigned int i = 0, j = buffer->out_pos - 1; i < count; i++, j--) + for (unsigned int i = 0, j = c->buffer->backtrack_len () - 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 (c->face, &c->buffer->out_info[j], c->lookup_props, 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 (c->buffer->out_info[j].codepoint, 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 *c, unsigned int count, const USHORT lookahead[], match_func_t match_func, - const char *match_data, + const void *match_data, 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 (c->buffer->len, c->buffer->i + c->context_length); + if (unlikely (c->buffer->i + offset + count > end)) return false; - for (i = 0, j = buffer->in_pos + offset; i < count; i++, j++) + for (i = 0, j = c->buffer->i + 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 (c->face, &c->buffer->info[j], c->lookup_props, 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 (c->buffer->info[j].codepoint, lookahead[i], match_data))) return false; } return true; } +HB_END_DECLS + struct LookupRecord { - static inline unsigned int get_size () { return sizeof (LookupRecord); } - - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return SANITIZE_SELF (); + return c->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, + +HB_BEGIN_DECLS + +static inline bool apply_lookup (hb_apply_context_t *c, 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 (c->buffer->len, c->buffer->i + c->context_length); + if (unlikely (count == 0 || c->buffer->i + count > end)) return false; /* TODO We don't support lookupRecord arrays that are not increasing: * Should be easy for in_place ones at least. */ - /* Note: If sublookup is reverse, i will underflow after the first loop + /* Note: If sublookup is reverse, it will underflow after the first loop * and we jump out of it. Not entirely disastrous. So we don't check * for reverse lookup here. */ 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 (c->face, &c->buffer->info[c->buffer->i], c->lookup_props, NULL)) { - if (HB_UNLIKELY (buffer->in_pos == end)) + if (unlikely (c->buffer->i == end)) return true; /* No lookup applied for this index */ - _hb_buffer_next_glyph (buffer); + c->buffer->next_glyph (); } if (lookupCount && i == lookupRecord->sequenceIndex) { - unsigned int old_pos = buffer->in_pos; + unsigned int old_pos = c->buffer->i; /* Apply a lookup */ - bool done = apply_func (APPLY_ARG, lookupRecord->lookupListIndex); + bool done = apply_func (c, 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 += c->buffer->i - old_pos; + if (unlikely (c->buffer->i == end)) return true; if (!done) @@ -257,7 +273,7 @@ static inline bool apply_lookup (APPLY_ARG_DEF, { not_applied: /* No lookup applied for this index */ - _hb_buffer_next_glyph (buffer); + c->buffer->next_glyph (); i++; } } @@ -265,27 +281,30 @@ static inline bool apply_lookup (APPLY_ARG_DEF, return true; } +HB_END_DECLS + /* Contextual lookups */ struct ContextLookupContext { ContextFuncs funcs; - const char *match_data; + const void *match_data; }; -static inline bool context_lookup (APPLY_ARG_DEF, +static inline bool context_lookup (hb_apply_context_t *c, 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 = *c; + return match_input (c, 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 +315,24 @@ struct Rule friend struct RuleSet; private: - inline bool apply (APPLY_ARG_DEF, ContextLookupContext &lookup_context) const + inline bool apply (hb_apply_context_t *c, 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 (c, inputCount, input, - lookupCount, &lookupRecord, + lookupCount, lookupRecord, lookup_context); } public: - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *c) { 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 (c) + && lookupCount.sanitize (c) + && c->check_range (input, + input[0].static_size * inputCount + + lookupRecordX[0].static_size * lookupCount); } private: @@ -324,33 +344,36 @@ struct Rule * second glyph */ LookupRecord lookupRecordX[VAR]; /* Array of LookupRecords--in * design order */ + public: + DEFINE_SIZE_ARRAY2 (4, input, lookupRecordX); }; -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 *c, 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 (c, lookup_context)) return true; } return false; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return SANITIZE_THIS (rule); + return rule.sanitize (c, this); } private: OffsetArrayOf rule; /* Array of Rule tables * ordered by preference */ + public: + DEFINE_SIZE_ARRAY (2, rule); }; @@ -359,11 +382,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 *c, apply_lookup_func_t apply_func) const { TRACE_APPLY (); - unsigned int index = (this+coverage) (IN_CURGLYPH ()); - if (HB_LIKELY (index == NOT_COVERED)) + unsigned int index = (this+coverage) (c->buffer->info[c->buffer->i].codepoint); + if (likely (index == NOT_COVERED)) return false; const RuleSet &rule_set = this+ruleSet[index]; @@ -371,12 +394,13 @@ struct ContextFormat1 {match_glyph, apply_func}, NULL }; - return rule_set.apply (APPLY_ARG, lookup_context); + return rule_set.apply (c, lookup_context); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return SANITIZE_THIS2 (coverage, ruleSet); + return coverage.sanitize (c, this) + && ruleSet.sanitize (c, this); } private: @@ -387,8 +411,9 @@ struct ContextFormat1 OffsetArrayOf ruleSet; /* Array of RuleSet tables * ordered by Coverage Index */ + public: + DEFINE_SIZE_ARRAY (6, ruleSet); }; -ASSERT_SIZE (ContextFormat1, 6); struct ContextFormat2 @@ -396,29 +421,28 @@ 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 *c, apply_lookup_func_t apply_func) const { TRACE_APPLY (); - unsigned int index = (this+coverage) (IN_CURGLYPH ()); - if (HB_LIKELY (index == NOT_COVERED)) + unsigned int index = (this+coverage) (c->buffer->info[c->buffer->i].codepoint); + if (likely (index == NOT_COVERED)) return false; const ClassDef &class_def = this+classDef; - index = class_def (IN_CURGLYPH ()); + index = class_def (c->buffer->info[c->buffer->i].codepoint); const RuleSet &rule_set = this+ruleSet[index]; - /* LONGTERMTODO: Old code fetches glyph classes at most once and caches - * them across subrule lookups. Not sure it's worth it. - */ struct ContextLookupContext lookup_context = { - {match_class, apply_func}, - CharP(&class_def) + {match_class, apply_func}, + &class_def }; - return rule_set.apply (APPLY_ARG, lookup_context); + return rule_set.apply (c, lookup_context); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return SANITIZE_THIS3 (coverage, classDef, ruleSet); + return coverage.sanitize (c, this) + && classDef.sanitize (c, this) + && ruleSet.sanitize (c, this); } private: @@ -432,8 +456,9 @@ struct ContextFormat2 OffsetArrayOf ruleSet; /* Array of RuleSet tables * ordered by class */ + public: + DEFINE_SIZE_ARRAY (8, ruleSet); }; -ASSERT_SIZE (ContextFormat2, 8); struct ContextFormat3 @@ -441,33 +466,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 *c, apply_lookup_func_t apply_func) const { TRACE_APPLY (); - unsigned int index = (this+coverage[0]) (IN_CURGLYPH ()); - if (HB_LIKELY (index == NOT_COVERED)) + unsigned int index = (this+coverage[0]) (c->buffer->info[c->buffer->i].codepoint); + 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) + this }; - return context_lookup (APPLY_ARG, + return context_lookup (c, glyphCount, (const USHORT *) (coverage + 1), - lookupCount, &lookupRecord, + lookupCount, lookupRecord, lookup_context); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (!SANITIZE_SELF ()) return false; + if (!c->check_struct (this)) return false; unsigned int count = glyphCount; - if (!SANITIZE_ARRAY (coverage, OffsetTo::get_size (), glyphCount)) return false; + if (!c->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 (c, this)) return false; + LookupRecord *lookupRecord = &StructAtOffset (coverage, coverage[0].static_size * count); + return c->check_array (lookupRecord, lookupRecord[0].static_size, lookupCount); } private: @@ -480,30 +505,31 @@ struct ContextFormat3 * table in glyph sequence order */ LookupRecord lookupRecordX[VAR]; /* Array of LookupRecords--in * design order */ + public: + DEFINE_SIZE_ARRAY2 (6, coverage, lookupRecordX); }; -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 *c, 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 (c, apply_func); + case 2: return u.format2.apply (c, apply_func); + case 3: return u.format3.apply (c, apply_func); default:return false; } } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (!SANITIZE (u.format)) return false; + if (!u.format.sanitize (c)) 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 (c); + case 2: return u.format2.sanitize (c); + case 3: return u.format3.sanitize (c); default:return true; } } @@ -511,9 +537,9 @@ struct Context private: union { USHORT format; /* Format identifier */ - ContextFormat1 format1[VAR]; - ContextFormat2 format2[VAR]; - ContextFormat3 format3[VAR]; + ContextFormat1 format1; + ContextFormat2 format2; + ContextFormat3 format3; } u; }; @@ -523,10 +549,10 @@ struct Context struct ChainContextLookupContext { ContextFuncs funcs; - const char *match_data[3]; + const void *match_data[3]; }; -static inline bool chain_context_lookup (APPLY_ARG_DEF, +static inline bool chain_context_lookup (hb_apply_context_t *c, unsigned int backtrackCount, const USHORT backtrack[], unsigned int inputCount, /* Including the first glyph (not matched) */ @@ -538,25 +564,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 (c->buffer->backtrack_len () < backtrackCount || + c->buffer->i + inputCount + lookaheadCount > c->buffer->len || + inputCount + lookaheadCount > c->context_length)) return false; - unsigned int offset; - return match_backtrack (APPLY_ARG, + hb_apply_context_t new_context = *c; + return match_backtrack (c, 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 (c, inputCount, input, lookup_context.funcs.match, lookup_context.match_data[1], - &offset) && - match_lookahead (APPLY_ARG, + &new_context.context_length) + && match_lookahead (c, 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); @@ -567,31 +592,30 @@ struct ChainRule friend struct ChainRuleSet; private: - inline bool apply (APPLY_ARG_DEF, ChainContextLookupContext &lookup_context) const + inline bool apply (hb_apply_context_t *c, 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, - backtrack.len, backtrack.array(), - input.len, input.array(), - lookahead.len, lookahead.array(), - lookup.len, lookup.array(), + return chain_context_lookup (c, + backtrack.len, backtrack.array, + input.len, input.array, + lookahead.len, lookahead.array, + lookup.len, lookup.array, lookup_context); - return false; } public: - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (!SANITIZE (backtrack)) return false; + if (!backtrack.sanitize (c)) return false; HeadlessArrayOf &input = StructAfter > (backtrack); - if (!SANITIZE (input)) return false; + if (!input.sanitize (c)) return false; ArrayOf &lookahead = StructAfter > (input); - if (!SANITIZE (lookahead)) return false; + if (!lookahead.sanitize (c)) return false; ArrayOf &lookup = StructAfter > (lookahead); - return SANITIZE (lookup); + return lookup.sanitize (c); } private: @@ -608,46 +632,48 @@ struct ChainRule ArrayOf lookupX; /* Array of LookupRecords--in * design order) */ + public: + DEFINE_SIZE_MIN (8); }; -ASSERT_SIZE (ChainRule, 8); struct ChainRuleSet { - inline bool apply (APPLY_ARG_DEF, ChainContextLookupContext &lookup_context) const + inline bool apply (hb_apply_context_t *c, 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 (c, lookup_context)) return true; } return false; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return SANITIZE_THIS (rule); + return rule.sanitize (c, this); } private: OffsetArrayOf rule; /* Array of ChainRule tables * ordered by preference */ + public: + DEFINE_SIZE_ARRAY (2, rule); }; -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 *c, apply_lookup_func_t apply_func) const { TRACE_APPLY (); - unsigned int index = (this+coverage) (IN_CURGLYPH ()); - if (HB_LIKELY (index == NOT_COVERED)) + unsigned int index = (this+coverage) (c->buffer->info[c->buffer->i].codepoint); + if (likely (index == NOT_COVERED)) return false; const ChainRuleSet &rule_set = this+ruleSet[index]; @@ -655,12 +681,13 @@ struct ChainContextFormat1 {match_glyph, apply_func}, {NULL, NULL, NULL} }; - return rule_set.apply (APPLY_ARG, lookup_context); + return rule_set.apply (c, lookup_context); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return SANITIZE_THIS2 (coverage, ruleSet); + return coverage.sanitize (c, this) + && ruleSet.sanitize (c, this); } private: @@ -671,44 +698,44 @@ struct ChainContextFormat1 OffsetArrayOf ruleSet; /* Array of ChainRuleSet tables * ordered by Coverage Index */ + public: + DEFINE_SIZE_ARRAY (6, ruleSet); }; -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 *c, apply_lookup_func_t apply_func) const { TRACE_APPLY (); - unsigned int index = (this+coverage) (IN_CURGLYPH ()); - if (HB_LIKELY (index == NOT_COVERED)) + unsigned int index = (this+coverage) (c->buffer->info[c->buffer->i].codepoint); + if (likely (index == NOT_COVERED)) return false; const ClassDef &backtrack_class_def = this+backtrackClassDef; const ClassDef &input_class_def = this+inputClassDef; const ClassDef &lookahead_class_def = this+lookaheadClassDef; - index = input_class_def (IN_CURGLYPH ()); + index = input_class_def (c->buffer->info[c->buffer->i].codepoint); const ChainRuleSet &rule_set = this+ruleSet[index]; - /* LONGTERMTODO: Old code fetches glyph classes at most once and caches - * them across subrule lookups. Not sure it's worth it. - */ struct ChainContextLookupContext lookup_context = { - {match_class, apply_func}, - {CharP(&backtrack_class_def), - CharP(&input_class_def), - CharP(&lookahead_class_def)} + {match_class, apply_func}, + {&backtrack_class_def, + &input_class_def, + &lookahead_class_def} }; - return rule_set.apply (APPLY_ARG, lookup_context); + return rule_set.apply (c, lookup_context); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return SANITIZE_THIS2 (coverage, backtrackClassDef) && - SANITIZE_THIS2 (inputClassDef, lookaheadClassDef) && - SANITIZE_THIS (ruleSet); + return coverage.sanitize (c, this) + && backtrackClassDef.sanitize (c, this) + && inputClassDef.sanitize (c, this) + && lookaheadClassDef.sanitize (c, this) + && ruleSet.sanitize (c, this); } private: @@ -731,8 +758,9 @@ struct ChainContextFormat2 OffsetArrayOf ruleSet; /* Array of ChainRuleSet tables * ordered by class */ + public: + DEFINE_SIZE_ARRAY (12, ruleSet); }; -ASSERT_SIZE (ChainContextFormat2, 12); struct ChainContextFormat3 { @@ -740,39 +768,38 @@ struct ChainContextFormat3 private: - inline bool apply (APPLY_ARG_DEF, apply_lookup_func_t apply_func) const + inline bool apply (hb_apply_context_t *c, 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)) + unsigned int index = (this+input[0]) (c->buffer->info[c->buffer->i].codepoint); + 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}, - {CharP(this), CharP(this), CharP(this)} + {this, this, this} }; - return chain_context_lookup (APPLY_ARG, - backtrack.len, (const USHORT *) backtrack.array(), - input.len, (const USHORT *) input.array() + 1, - lookahead.len, (const USHORT *) lookahead.array(), - lookup.len, lookup.array(), + return chain_context_lookup (c, + backtrack.len, (const USHORT *) backtrack.array, + input.len, (const USHORT *) input.array + 1, + lookahead.len, (const USHORT *) lookahead.array, + lookup.len, lookup.array, lookup_context); - return false; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (!SANITIZE_THIS (backtrack)) return false; + if (!backtrack.sanitize (c, this)) return false; OffsetArrayOf &input = StructAfter > (backtrack); - if (!SANITIZE_THIS (input)) return false; + if (!input.sanitize (c, this)) return false; OffsetArrayOf &lookahead = StructAfter > (input); - if (!SANITIZE_THIS (lookahead)) return false; + if (!lookahead.sanitize (c, this)) return false; ArrayOf &lookup = StructAfter > (lookahead); - return SANITIZE (lookup); + return lookup.sanitize (c); } private: @@ -792,30 +819,31 @@ struct ChainContextFormat3 ArrayOf lookupX; /* Array of LookupRecords--in * design order) */ + public: + DEFINE_SIZE_MIN (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 *c, 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 (c, apply_func); + case 2: return u.format2.apply (c, apply_func); + case 3: return u.format3.apply (c, apply_func); default:return false; } } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (!SANITIZE (u.format)) return false; + if (!u.format.sanitize (c)) 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 (c); + case 2: return u.format2.sanitize (c); + case 3: return u.format3.sanitize (c); default:return true; } } @@ -823,9 +851,9 @@ struct ChainContext private: union { USHORT format; /* Format identifier */ - ChainContextFormat1 format1[VAR]; - ChainContextFormat2 format2[VAR]; - ChainContextFormat3 format3[VAR]; + ChainContextFormat1 format1; + ChainContextFormat2 format2; + ChainContextFormat3 format3; } u; }; @@ -838,9 +866,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 *c) { TRACE_SANITIZE (); - return SANITIZE_SELF (); + return c->check_struct (this); } private: @@ -850,31 +878,32 @@ 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 { inline unsigned int get_type (void) const { switch (u.format) { - case 1: return u.format1->get_type (); + case 1: return u.format1.get_type (); default:return 0; } } inline unsigned int get_offset (void) const { switch (u.format) { - case 1: return u.format1->get_offset (); + case 1: return u.format1.get_offset (); default:return 0; } } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (!SANITIZE (u.format)) return false; + if (!u.format.sanitize (c)) return false; switch (u.format) { - case 1: return u.format1->sanitize (SANITIZE_ARG); + case 1: return u.format1.sanitize (c); default:return true; } } @@ -882,7 +911,7 @@ struct Extension private: union { USHORT format; /* Format identifier */ - ExtensionFormat1 format1[VAR]; + ExtensionFormat1 format1; } u; }; @@ -927,11 +956,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 *c) { TRACE_SANITIZE (); - if (!SANITIZE (version)) return false; - if (HB_UNLIKELY (version.major != 1)) return false; - return SANITIZE_THIS3 (scriptList, featureList, lookupList); + return version.sanitize (c) && likely (version.major == 1) + && scriptList.sanitize (c, this) + && featureList.sanitize (c, this) + && lookupList.sanitize (c, this); } protected: @@ -943,8 +973,11 @@ struct GSUBGPOS featureList; /* FeatureList table */ OffsetTo lookupList; /* LookupList table */ + public: + DEFINE_SIZE_STATIC (10); }; -ASSERT_SIZE (GSUBGPOS, 10); +HB_END_DECLS + #endif /* HB_OT_LAYOUT_GSUBGPOS_PRIVATE_HH */