jdk-sandbox: comparison src/java.desktop/share/native/libfontmanager/harfbuzz/hb-ot-layout-gsubgpos-private.hh

equal deleted inserted replaced

-:9289c4214a35
+:25db2c8f3cf8
 set_t *set;
 unsigned int debug_depth;
 };
-struct hb_apply_context_t :
+struct hb_ot_apply_context_t :
-hb_dispatch_context_t<hb_apply_context_t, bool, HB_DEBUG_APPLY>
+hb_dispatch_context_t<hb_ot_apply_context_t, bool, HB_DEBUG_APPLY>
 {
 struct matcher_t
 {
 inline matcher_t (void) :
 lookup_props (0),
 syllable arg1(0),
 #undef arg1
 match_func (nullptr),
 match_data (nullptr) {};
-typedef bool (*match_func_t) (hb_codepoint_t glyph_id, const USHORT &value, const void *data);
+typedef bool (*match_func_t) (hb_codepoint_t glyph_id, const HBUINT16 &value, const void *data);
 inline void set_ignore_zwnj (bool ignore_zwnj_) { ignore_zwnj = ignore_zwnj_; }
 inline void set_ignore_zwj (bool ignore_zwj_) { ignore_zwj = ignore_zwj_; }
 inline void set_lookup_props (unsigned int lookup_props_) { lookup_props = lookup_props_; }
 inline void set_mask (hb_mask_t mask_) { mask = mask_; }
 MATCH_YES,
 MATCH_MAYBE
 };
 inline may_match_t may_match (const hb_glyph_info_t &info,
-const USHORT          *glyph_data) const
+const HBUINT16          *glyph_data) const
 {
 if (!(info.mask & mask) ||
 (syllable && syllable != info.syllable ()))
 return MATCH_NO;
 SKIP_YES,
 SKIP_MAYBE
 };
 inline may_skip_t
-may_skip (const hb_apply_context_t *c,
+may_skip (const hb_ot_apply_context_t *c,
 const hb_glyph_info_t    &info) const
 {
 if (!c->check_glyph_property (&info, lookup_props))
 return SKIP_YES;
 const void *match_data;
 };
 struct skipping_iterator_t
 {
-inline void init (hb_apply_context_t *c_, bool context_match = false)
+inline void init (hb_ot_apply_context_t *c_, bool context_match = false)
 {
 c = c_;
 match_glyph_data = nullptr;
 matcher.set_match_func (nullptr, nullptr);
 matcher.set_lookup_props (c->lookup_props);
 {
 matcher.set_lookup_props (lookup_props);
 }
 inline void set_match_func (matcher_t::match_func_t match_func_,
 const void *match_data_,
-const USHORT glyph_data[])
+const HBUINT16 glyph_data[])
 {
 matcher.set_match_func (match_func_, match_data_);
 match_glyph_data = glyph_data;
 }
 }
 inline void reject (void) { num_items++; match_glyph_data--; }
 inline matcher_t::may_skip_t
-may_skip (const hb_apply_context_t *c,
+may_skip (const hb_glyph_info_t    &info) const
-const hb_glyph_info_t    &info) const
 {
 return matcher.may_skip (c, info);
 }
 inline bool next (void)
 return false;
 }
 unsigned int idx;
 protected:
-hb_apply_context_t *c;
+hb_ot_apply_context_t *c;
 matcher_t matcher;
-const USHORT *match_glyph_data;
+const HBUINT16 *match_glyph_data;
 unsigned int num_items;
 unsigned int end;
 };
 inline const char *get_name (void) { return "APPLY"; }
-typedef return_t (*recurse_func_t) (hb_apply_context_t *c, unsigned int lookup_index);
+typedef return_t (*recurse_func_t) (hb_ot_apply_context_t *c, unsigned int lookup_index);
 template <typename T>
 inline return_t dispatch (const T &obj) { return obj.apply (this); }
 static return_t default_return_value (void) { return false; }
 bool stop_sublookup_iteration (return_t r) const { return r; }
-return_t recurse (unsigned int lookup_index)
+return_t recurse (unsigned int sub_lookup_index)
 {
-if (unlikely (nesting_level_left == 0 || !recurse_func))
+if (unlikely (nesting_level_left == 0 || !recurse_func || buffer->max_ops-- <= 0))
 return default_return_value ();
 nesting_level_left--;
-bool ret = recurse_func (this, lookup_index);
+bool ret = recurse_func (this, sub_lookup_index);
 nesting_level_left++;
 return ret;
 }
 skipping_iterator_t iter_input, iter_context;
 bool auto_zwnj;
 bool auto_zwj;
 bool has_glyph_classes;
-hb_apply_context_t (unsigned int table_index_,
+hb_ot_apply_context_t (unsigned int table_index_,
 hb_font_t *font_,
 hb_buffer_t *buffer_) :
 iter_input (), iter_context (),
 font (font_), face (font->face), buffer (buffer_),
 recurse_func (nullptr),
 }
 };
-typedef bool (*intersects_func_t) (hb_set_t *glyphs, const USHORT &value, const void *data);
+typedef bool (*intersects_func_t) (hb_set_t *glyphs, const HBUINT16 &value, const void *data);
-typedef void (*collect_glyphs_func_t) (hb_set_t *glyphs, const USHORT &value, const void *data);
+typedef void (*collect_glyphs_func_t) (hb_set_t *glyphs, const HBUINT16 &value, const void *data);
-typedef bool (*match_func_t) (hb_codepoint_t glyph_id, const USHORT &value, const void *data);
+typedef bool (*match_func_t) (hb_codepoint_t glyph_id, const HBUINT16 &value, const void *data);
 struct ContextClosureFuncs
 {
 intersects_func_t intersects;
 };
 {
 match_func_t match;
 };
-static inline bool intersects_glyph (hb_set_t *glyphs, const USHORT &value, const void *data HB_UNUSED)
+static inline bool intersects_glyph (hb_set_t *glyphs, const HBUINT16 &value, const void *data HB_UNUSED)
 {
 return glyphs->has (value);
 }
-static inline bool intersects_class (hb_set_t *glyphs, const USHORT &value, const void *data)
+static inline bool intersects_class (hb_set_t *glyphs, const HBUINT16 &value, const void *data)
 {
 const ClassDef &class_def = *reinterpret_cast<const ClassDef *>(data);
 return class_def.intersects_class (glyphs, value);
 }
-static inline bool intersects_coverage (hb_set_t *glyphs, const USHORT &value, const void *data)
+static inline bool intersects_coverage (hb_set_t *glyphs, const HBUINT16 &value, const void *data)
 {
 const OffsetTo<Coverage> &coverage = (const OffsetTo<Coverage>&)value;
 return (data+coverage).intersects (glyphs);
 }
 static inline bool intersects_array (hb_closure_context_t *c,
 unsigned int count,
-const USHORT values[],
+const HBUINT16 values[],
 intersects_func_t intersects_func,
 const void *intersects_data)
 {
 for (unsigned int i = 0; i < count; i++)
 if (likely (!intersects_func (c->glyphs, values[i], intersects_data)))
 return false;
 return true;
 }
-static inline void collect_glyph (hb_set_t *glyphs, const USHORT &value, const void *data HB_UNUSED)
+static inline void collect_glyph (hb_set_t *glyphs, const HBUINT16 &value, const void *data HB_UNUSED)
 {
 glyphs->add (value);
 }
-static inline void collect_class (hb_set_t *glyphs, const USHORT &value, const void *data)
+static inline void collect_class (hb_set_t *glyphs, const HBUINT16 &value, const void *data)
 {
 const ClassDef &class_def = *reinterpret_cast<const ClassDef *>(data);
 class_def.add_class (glyphs, value);
 }
-static inline void collect_coverage (hb_set_t *glyphs, const USHORT &value, const void *data)
+static inline void collect_coverage (hb_set_t *glyphs, const HBUINT16 &value, const void *data)
 {
 const OffsetTo<Coverage> &coverage = (const OffsetTo<Coverage>&)value;
 (data+coverage).add_coverage (glyphs);
 }
 static inline void collect_array (hb_collect_glyphs_context_t *c HB_UNUSED,
 hb_set_t *glyphs,
 unsigned int count,
-const USHORT values[],
+const HBUINT16 values[],
 collect_glyphs_func_t collect_func,
 const void *collect_data)
 {
 for (unsigned int i = 0; i < count; i++)
 collect_func (glyphs, values[i], collect_data);
 }
-static inline bool match_glyph (hb_codepoint_t glyph_id, const USHORT &value, const void *data HB_UNUSED)
+static inline bool match_glyph (hb_codepoint_t glyph_id, const HBUINT16 &value, const void *data HB_UNUSED)
 {
 return glyph_id == value;
 }
-static inline bool match_class (hb_codepoint_t glyph_id, const USHORT &value, const void *data)
+static inline bool match_class (hb_codepoint_t glyph_id, const HBUINT16 &value, const void *data)
 {
 const ClassDef &class_def = *reinterpret_cast<const ClassDef *>(data);
 return class_def.get_class (glyph_id) == value;
 }
-static inline bool match_coverage (hb_codepoint_t glyph_id, const USHORT &value, const void *data)
+static inline bool match_coverage (hb_codepoint_t glyph_id, const HBUINT16 &value, const void *data)
 {
 const OffsetTo<Coverage> &coverage = (const OffsetTo<Coverage>&)value;
 return (data+coverage).get_coverage (glyph_id) != NOT_COVERED;
 }
 static inline bool would_match_input (hb_would_apply_context_t *c,
 unsigned int count, /* Including the first glyph (not matched) */
-const USHORT input[], /* Array of input values--start with second glyph */
+const HBUINT16 input[], /* Array of input values--start with second glyph */
 match_func_t match_func,
 const void *match_data)
 {
 if (count != c->len)
 return false;
 if (likely (!match_func (c->glyphs[i], input[i - 1], match_data)))
 return false;
 return true;
 }
-static inline bool match_input (hb_apply_context_t *c,
+static inline bool match_input (hb_ot_apply_context_t *c,
 unsigned int count, /* Including the first glyph (not matched) */
-const USHORT input[], /* Array of input values--start with second glyph */
+const HBUINT16 input[], /* Array of input values--start with second glyph */
 match_func_t match_func,
 const void *match_data,
 unsigned int *end_offset,
 unsigned int match_positions[HB_MAX_CONTEXT_LENGTH],
 bool *p_is_mark_ligature = nullptr,
 if (unlikely (count > HB_MAX_CONTEXT_LENGTH)) return_trace (false);
 hb_buffer_t *buffer = c->buffer;
-hb_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;
+hb_ot_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;
 skippy_iter.reset (buffer->idx, count - 1);
 skippy_iter.set_match_func (match_func, match_data, input);
 /*
 * This is perhaps the trickiest part of OpenType...  Remarks:
 *     break Indic stuff when a matra wants to ligate with a conjunct,
 *
 *   o If two marks want to ligate and they belong to different components of the
 *     same ligature glyph, and said ligature glyph is to be ignored according to
 *     mark-filtering rules, then allow.
-*     https://github.com/behdad/harfbuzz/issues/545
+*     https://github.com/harfbuzz/harfbuzz/issues/545
 */
 bool is_mark_ligature = _hb_glyph_info_is_mark (&buffer->cur());
 unsigned int total_component_count = 0;
 break;
 }
 j--;
 }
-if (found && skippy_iter.may_skip (c, out[j]) == hb_apply_context_t::matcher_t::SKIP_YES)
+if (found && skippy_iter.may_skip (out[j]) == hb_ot_apply_context_t::matcher_t::SKIP_YES)
 ligbase = LIGBASE_MAY_SKIP;
 else
 ligbase = LIGBASE_MAY_NOT_SKIP;
 }
 if (p_total_component_count)
 *p_total_component_count = total_component_count;
 return_trace (true);
 }
-static inline bool ligate_input (hb_apply_context_t *c,
+static inline bool ligate_input (hb_ot_apply_context_t *c,
 unsigned int count, /* Including the first glyph */
 unsigned int match_positions[HB_MAX_CONTEXT_LENGTH], /* Including the first glyph */
 unsigned int match_length,
 hb_codepoint_t lig_glyph,
 bool is_mark_ligature,
 }
 }
 return_trace (true);
 }
-static inline bool match_backtrack (hb_apply_context_t *c,
+static inline bool match_backtrack (hb_ot_apply_context_t *c,
 unsigned int count,
-const USHORT backtrack[],
+const HBUINT16 backtrack[],
 match_func_t match_func,
 const void *match_data,
 unsigned int *match_start)
 {
 TRACE_APPLY (nullptr);
-hb_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_context;
+hb_ot_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_context;
 skippy_iter.reset (c->buffer->backtrack_len (), count);
 skippy_iter.set_match_func (match_func, match_data, backtrack);
 for (unsigned int i = 0; i < count; i++)
 if (!skippy_iter.prev ())
 *match_start = skippy_iter.idx;
 return_trace (true);
 }
-static inline bool match_lookahead (hb_apply_context_t *c,
+static inline bool match_lookahead (hb_ot_apply_context_t *c,
 unsigned int count,
-const USHORT lookahead[],
+const HBUINT16 lookahead[],
 match_func_t match_func,
 const void *match_data,
 unsigned int offset,
 unsigned int *end_index)
 {
 TRACE_APPLY (nullptr);
-hb_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_context;
+hb_ot_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_context;
 skippy_iter.reset (c->buffer->idx + offset - 1, count);
 skippy_iter.set_match_func (match_func, match_data, lookahead);
 for (unsigned int i = 0; i < count; i++)
 if (!skippy_iter.next ())
 {
 TRACE_SANITIZE (this);
 return_trace (c->check_struct (this));
 }
-USHORT        sequenceIndex;          /* Index into current glyph
+HBUINT16      sequenceIndex;          /* Index into current glyph
 * sequence--first glyph = 0 */
-USHORT        lookupListIndex;        /* Lookup to apply to that
+HBUINT16      lookupListIndex;        /* Lookup to apply to that
 * position--zero--based */
 public:
 DEFINE_SIZE_STATIC (4);
 };
 {
 for (unsigned int i = 0; i < lookupCount; i++)
 c->recurse (lookupRecord[i].lookupListIndex);
 }
-static inline bool apply_lookup (hb_apply_context_t *c,
+static inline bool apply_lookup (hb_ot_apply_context_t *c,
 unsigned int count, /* Including the first glyph */
 unsigned int match_positions[HB_MAX_CONTEXT_LENGTH], /* Including the first glyph */
 unsigned int lookupCount,
 const LookupRecord lookupRecord[], /* Array of LookupRecords--in design order */
 unsigned int match_length)
 /* Don't recurse to ourself at same position.
 * Note that this test is too naive, it doesn't catch longer loops. */
 if (idx == 0 && lookupRecord[i].lookupListIndex == c->lookup_index)
 continue;
-buffer->move_to (match_positions[idx]);
+if (unlikely (!buffer->move_to (match_positions[idx])))
+break;
+if (unlikely (buffer->max_ops <= 0))
+break;
 unsigned int orig_len = buffer->backtrack_len () + buffer->lookahead_len ();
 if (!c->recurse (lookupRecord[i].lookupListIndex))
 continue;
 const void *match_data;
 };
 static inline void context_closure_lookup (hb_closure_context_t *c,
 unsigned int inputCount, /* Including the first glyph (not matched) */
-const USHORT input[], /* Array of input values--start with second glyph */
+const HBUINT16 input[], /* Array of input values--start with second glyph */
 unsigned int lookupCount,
 const LookupRecord lookupRecord[],
 ContextClosureLookupContext &lookup_context)
 {
 if (intersects_array (c,
 lookupCount, lookupRecord);
 }
 static inline void context_collect_glyphs_lookup (hb_collect_glyphs_context_t *c,
 unsigned int inputCount, /* Including the first glyph (not matched) */
-const USHORT input[], /* Array of input values--start with second glyph */
+const HBUINT16 input[], /* Array of input values--start with second glyph */
 unsigned int lookupCount,
 const LookupRecord lookupRecord[],
 ContextCollectGlyphsLookupContext &lookup_context)
 {
 collect_array (c, c->input,
 lookupCount, lookupRecord);
 }
 static inline bool context_would_apply_lookup (hb_would_apply_context_t *c,
 unsigned int inputCount, /* Including the first glyph (not matched) */
-const USHORT input[], /* Array of input values--start with second glyph */
+const HBUINT16 input[], /* Array of input values--start with second glyph */
 unsigned int lookupCount HB_UNUSED,
 const LookupRecord lookupRecord[] HB_UNUSED,
 ContextApplyLookupContext &lookup_context)
 {
 return would_match_input (c,
 inputCount, input,
 lookup_context.funcs.match, lookup_context.match_data);
 }
-static inline bool context_apply_lookup (hb_apply_context_t *c,
+static inline bool context_apply_lookup (hb_ot_apply_context_t *c,
 unsigned int inputCount, /* Including the first glyph (not matched) */
-const USHORT input[], /* Array of input values--start with second glyph */
+const HBUINT16 input[], /* Array of input values--start with second glyph */
 unsigned int lookupCount,
 const LookupRecord lookupRecord[],
 ContextApplyLookupContext &lookup_context)
 {
 unsigned int match_length = 0;
 TRACE_WOULD_APPLY (this);
 const LookupRecord *lookupRecord = &StructAtOffset<LookupRecord> (inputZ, inputZ[0].static_size * (inputCount ? inputCount - 1 : 0));
 return_trace (context_would_apply_lookup (c, inputCount, inputZ, lookupCount, lookupRecord, lookup_context));
 }
-inline bool apply (hb_apply_context_t *c, ContextApplyLookupContext &lookup_context) const
+inline bool apply (hb_ot_apply_context_t *c, ContextApplyLookupContext &lookup_context) const
 {
 TRACE_APPLY (this);
 const LookupRecord *lookupRecord = &StructAtOffset<LookupRecord> (inputZ, inputZ[0].static_size * (inputCount ? inputCount - 1 : 0));
 return_trace (context_apply_lookup (c, inputCount, inputZ, lookupCount, lookupRecord, lookup_context));
 }
 TRACE_SANITIZE (this);
 return_trace (inputCount.sanitize (c) &&
 lookupCount.sanitize (c) &&
 c->check_range (inputZ,
 inputZ[0].static_size * inputCount +
-lookupRecordX[0].static_size * lookupCount));
+LookupRecord::static_size * lookupCount));
 }
 protected:
-USHORT        inputCount;             /* Total number of glyphs in input
+HBUINT16      inputCount;             /* Total number of glyphs in input
 * glyph sequence--includes the first
 * glyph */
-USHORT        lookupCount;            /* Number of LookupRecords */
+HBUINT16      lookupCount;            /* Number of LookupRecords */
-USHORT        inputZ[VAR];            /* Array of match inputs--start with
+HBUINT16      inputZ[VAR];            /* Array of match inputs--start with
 * second glyph */
-LookupRecord  lookupRecordX[VAR];     /* Array of LookupRecords--in
+/*LookupRecord  lookupRecordX[VAR];*/   /* Array of LookupRecords--in
 * design order */
 public:
-DEFINE_SIZE_ARRAY2 (4, inputZ, lookupRecordX);
+DEFINE_SIZE_ARRAY (4, inputZ);
 };
 struct RuleSet
 {
 inline void closure (hb_closure_context_t *c, ContextClosureLookupContext &lookup_context) const
 return_trace (true);
 }
 return_trace (false);
 }
-inline bool apply (hb_apply_context_t *c, ContextApplyLookupContext &lookup_context) const
+inline bool apply (hb_ot_apply_context_t *c, ContextApplyLookupContext &lookup_context) const
 {
 TRACE_APPLY (this);
 unsigned int num_rules = rule.len;
 for (unsigned int i = 0; i < num_rules; i++)
 {
 inline const Coverage &get_coverage (void) const
 {
 return this+coverage;
 }
-inline bool apply (hb_apply_context_t *c) const
+inline bool apply (hb_ot_apply_context_t *c) const
 {
 TRACE_APPLY (this);
 unsigned int index = (this+coverage).get_coverage (c->buffer->cur().codepoint);
 if (likely (index == NOT_COVERED))
 return_trace (false);
 TRACE_SANITIZE (this);
 return_trace (coverage.sanitize (c, this) && ruleSet.sanitize (c, this));
 }
 protected:
-USHORT        format;                 /* Format identifier--format = 1 */
+HBUINT16      format;                 /* Format identifier--format = 1 */
 OffsetTo<Coverage>
 coverage;               /* Offset to Coverage table--from
 * beginning of table */
 OffsetArrayOf<RuleSet>
 ruleSet;                /* Array of RuleSet tables
 inline const Coverage &get_coverage (void) const
 {
 return this+coverage;
 }
-inline bool apply (hb_apply_context_t *c) const
+inline bool apply (hb_ot_apply_context_t *c) const
 {
 TRACE_APPLY (this);
 unsigned int index = (this+coverage).get_coverage (c->buffer->cur().codepoint);
 if (likely (index == NOT_COVERED)) return_trace (false);
 TRACE_SANITIZE (this);
 return_trace (coverage.sanitize (c, this) && classDef.sanitize (c, this) && ruleSet.sanitize (c, this));
 }
 protected:
-USHORT        format;                 /* Format identifier--format = 2 */
+HBUINT16      format;                 /* Format identifier--format = 2 */
 OffsetTo<Coverage>
 coverage;               /* Offset to Coverage table--from
 * beginning of table */
 OffsetTo<ClassDef>
 classDef;               /* Offset to glyph ClassDef table--from
 struct ContextClosureLookupContext lookup_context = {
 {intersects_coverage},
 this
 };
 context_closure_lookup (c,
-glyphCount, (const USHORT *) (coverageZ + 1),
+glyphCount, (const HBUINT16 *) (coverageZ + 1),
 lookupCount, lookupRecord,
 lookup_context);
 }
 inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
 {collect_coverage},
 this
 };
 context_collect_glyphs_lookup (c,
-glyphCount, (const USHORT *) (coverageZ + 1),
+glyphCount, (const HBUINT16 *) (coverageZ + 1),
 lookupCount, lookupRecord,
 lookup_context);
 }
 inline bool would_apply (hb_would_apply_context_t *c) const
 const LookupRecord *lookupRecord = &StructAtOffset<LookupRecord> (coverageZ, coverageZ[0].static_size * glyphCount);
 struct ContextApplyLookupContext lookup_context = {
 {match_coverage},
 this
 };
-return_trace (context_would_apply_lookup (c, glyphCount, (const USHORT *) (coverageZ + 1), lookupCount, lookupRecord, lookup_context));
+return_trace (context_would_apply_lookup (c, glyphCount, (const HBUINT16 *) (coverageZ + 1), lookupCount, lookupRecord, lookup_context));
 }
 inline const Coverage &get_coverage (void) const
 {
 return this+coverageZ[0];
 }
-inline bool apply (hb_apply_context_t *c) const
+inline bool apply (hb_ot_apply_context_t *c) const
 {
 TRACE_APPLY (this);
 unsigned int index = (this+coverageZ[0]).get_coverage (c->buffer->cur().codepoint);
 if (likely (index == NOT_COVERED)) return_trace (false);
 const LookupRecord *lookupRecord = &StructAtOffset<LookupRecord> (coverageZ, coverageZ[0].static_size * glyphCount);
 struct ContextApplyLookupContext lookup_context = {
 {match_coverage},
 this
 };
-return_trace (context_apply_lookup (c, glyphCount, (const USHORT *) (coverageZ + 1), lookupCount, lookupRecord, lookup_context));
+return_trace (context_apply_lookup (c, glyphCount, (const HBUINT16 *) (coverageZ + 1), lookupCount, lookupRecord, lookup_context));
 }
 inline bool sanitize (hb_sanitize_context_t *c) const
 {
 TRACE_SANITIZE (this);
 const LookupRecord *lookupRecord = &StructAtOffset<LookupRecord> (coverageZ, coverageZ[0].static_size * count);
 return_trace (c->check_array (lookupRecord, lookupRecord[0].static_size, lookupCount));
 }
 protected:
-USHORT        format;                 /* Format identifier--format = 3 */
+HBUINT16      format;                 /* Format identifier--format = 3 */
-USHORT        glyphCount;             /* Number of glyphs in the input glyph
+HBUINT16      glyphCount;             /* Number of glyphs in the input glyph
 * sequence */
-USHORT        lookupCount;            /* Number of LookupRecords */
+HBUINT16      lookupCount;            /* Number of LookupRecords */
 OffsetTo<Coverage>
 coverageZ[VAR];         /* Array of offsets to Coverage
 * table in glyph sequence order */
-LookupRecord  lookupRecordX[VAR];     /* Array of LookupRecords--in
+/*LookupRecord  lookupRecordX[VAR];*/   /* Array of LookupRecords--in
 * design order */
 public:
-DEFINE_SIZE_ARRAY2 (6, coverageZ, lookupRecordX);
+DEFINE_SIZE_ARRAY (6, coverageZ);
 };
 struct Context
 {
 template <typename context_t>
 }
 }
 protected:
 union {
-USHORT                format;         /* Format identifier */
+HBUINT16              format;         /* Format identifier */
 ContextFormat1        format1;
 ContextFormat2        format2;
 ContextFormat3        format3;
 } u;
 };
 const void *match_data[3];
 };
 static inline void chain_context_closure_lookup (hb_closure_context_t *c,
 unsigned int backtrackCount,
-const USHORT backtrack[],
+const HBUINT16 backtrack[],
 unsigned int inputCount, /* Including the first glyph (not matched) */
-const USHORT input[], /* Array of input values--start with second glyph */
+const HBUINT16 input[], /* Array of input values--start with second glyph */
 unsigned int lookaheadCount,
-const USHORT lookahead[],
+const HBUINT16 lookahead[],
 unsigned int lookupCount,
 const LookupRecord lookupRecord[],
 ChainContextClosureLookupContext &lookup_context)
 {
 if (intersects_array (c,
 lookupCount, lookupRecord);
 }
 static inline void chain_context_collect_glyphs_lookup (hb_collect_glyphs_context_t *c,
 unsigned int backtrackCount,
-const USHORT backtrack[],
+const HBUINT16 backtrack[],
 unsigned int inputCount, /* Including the first glyph (not matched) */
-const USHORT input[], /* Array of input values--start with second glyph */
+const HBUINT16 input[], /* Array of input values--start with second glyph */
 unsigned int lookaheadCount,
-const USHORT lookahead[],
+const HBUINT16 lookahead[],
 unsigned int lookupCount,
 const LookupRecord lookupRecord[],
 ChainContextCollectGlyphsLookupContext &lookup_context)
 {
 collect_array (c, c->before,
 lookupCount, lookupRecord);
 }
 static inline bool chain_context_would_apply_lookup (hb_would_apply_context_t *c,
 unsigned int backtrackCount,
-const USHORT backtrack[] HB_UNUSED,
+const HBUINT16 backtrack[] HB_UNUSED,
 unsigned int inputCount, /* Including the first glyph (not matched) */
-const USHORT input[], /* Array of input values--start with second glyph */
+const HBUINT16 input[], /* Array of input values--start with second glyph */
 unsigned int lookaheadCount,
-const USHORT lookahead[] HB_UNUSED,
+const HBUINT16 lookahead[] HB_UNUSED,
 unsigned int lookupCount HB_UNUSED,
 const LookupRecord lookupRecord[] HB_UNUSED,
 ChainContextApplyLookupContext &lookup_context)
 {
 return (c->zero_context ? !backtrackCount && !lookaheadCount : true)
 && would_match_input (c,
 inputCount, input,
 lookup_context.funcs.match, lookup_context.match_data[1]);
 }
-static inline bool chain_context_apply_lookup (hb_apply_context_t *c,
+static inline bool chain_context_apply_lookup (hb_ot_apply_context_t *c,
 unsigned int backtrackCount,
-const USHORT backtrack[],
+const HBUINT16 backtrack[],
 unsigned int inputCount, /* Including the first glyph (not matched) */
-const USHORT input[], /* Array of input values--start with second glyph */
+const HBUINT16 input[], /* Array of input values--start with second glyph */
 unsigned int lookaheadCount,
-const USHORT lookahead[],
+const HBUINT16 lookahead[],
 unsigned int lookupCount,
 const LookupRecord lookupRecord[],
 ChainContextApplyLookupContext &lookup_context)
 {
 unsigned int start_index = 0, match_length = 0, end_index = 0;
 struct ChainRule
 {
 inline void closure (hb_closure_context_t *c, ChainContextClosureLookupContext &lookup_context) const
 {
 TRACE_CLOSURE (this);
-const HeadlessArrayOf<USHORT> &input = StructAfter<HeadlessArrayOf<USHORT> > (backtrack);
+const HeadlessArrayOf<HBUINT16> &input = StructAfter<HeadlessArrayOf<HBUINT16> > (backtrack);
-const ArrayOf<USHORT> &lookahead = StructAfter<ArrayOf<USHORT> > (input);
+const ArrayOf<HBUINT16> &lookahead = StructAfter<ArrayOf<HBUINT16> > (input);
 const ArrayOf<LookupRecord> &lookup = StructAfter<ArrayOf<LookupRecord> > (lookahead);
 chain_context_closure_lookup (c,
 backtrack.len, backtrack.array,
 input.len, input.array,
 lookahead.len, lookahead.array,
 }
 inline void collect_glyphs (hb_collect_glyphs_context_t *c, ChainContextCollectGlyphsLookupContext &lookup_context) const
 {
 TRACE_COLLECT_GLYPHS (this);
-const HeadlessArrayOf<USHORT> &input = StructAfter<HeadlessArrayOf<USHORT> > (backtrack);
+const HeadlessArrayOf<HBUINT16> &input = StructAfter<HeadlessArrayOf<HBUINT16> > (backtrack);
-const ArrayOf<USHORT> &lookahead = StructAfter<ArrayOf<USHORT> > (input);
+const ArrayOf<HBUINT16> &lookahead = StructAfter<ArrayOf<HBUINT16> > (input);
 const ArrayOf<LookupRecord> &lookup = StructAfter<ArrayOf<LookupRecord> > (lookahead);
 chain_context_collect_glyphs_lookup (c,
 backtrack.len, backtrack.array,
 input.len, input.array,
 lookahead.len, lookahead.array,
 }
 inline bool would_apply (hb_would_apply_context_t *c, ChainContextApplyLookupContext &lookup_context) const
 {
 TRACE_WOULD_APPLY (this);
-const HeadlessArrayOf<USHORT> &input = StructAfter<HeadlessArrayOf<USHORT> > (backtrack);
+const HeadlessArrayOf<HBUINT16> &input = StructAfter<HeadlessArrayOf<HBUINT16> > (backtrack);
-const ArrayOf<USHORT> &lookahead = StructAfter<ArrayOf<USHORT> > (input);
+const ArrayOf<HBUINT16> &lookahead = StructAfter<ArrayOf<HBUINT16> > (input);
 const ArrayOf<LookupRecord> &lookup = StructAfter<ArrayOf<LookupRecord> > (lookahead);
 return_trace (chain_context_would_apply_lookup (c,
 backtrack.len, backtrack.array,
 input.len, input.array,
 lookahead.len, lookahead.array, lookup.len,
 lookup.array, lookup_context));
 }
-inline bool apply (hb_apply_context_t *c, ChainContextApplyLookupContext &lookup_context) const
+inline bool apply (hb_ot_apply_context_t *c, ChainContextApplyLookupContext &lookup_context) const
 {
 TRACE_APPLY (this);
-const HeadlessArrayOf<USHORT> &input = StructAfter<HeadlessArrayOf<USHORT> > (backtrack);
+const HeadlessArrayOf<HBUINT16> &input = StructAfter<HeadlessArrayOf<HBUINT16> > (backtrack);
-const ArrayOf<USHORT> &lookahead = StructAfter<ArrayOf<USHORT> > (input);
+const ArrayOf<HBUINT16> &lookahead = StructAfter<ArrayOf<HBUINT16> > (input);
 const ArrayOf<LookupRecord> &lookup = StructAfter<ArrayOf<LookupRecord> > (lookahead);
 return_trace (chain_context_apply_lookup (c,
 backtrack.len, backtrack.array,
 input.len, input.array,
 lookahead.len, lookahead.array, lookup.len,
 inline bool sanitize (hb_sanitize_context_t *c) const
 {
 TRACE_SANITIZE (this);
 if (!backtrack.sanitize (c)) return_trace (false);
-const HeadlessArrayOf<USHORT> &input = StructAfter<HeadlessArrayOf<USHORT> > (backtrack);
+const HeadlessArrayOf<HBUINT16> &input = StructAfter<HeadlessArrayOf<HBUINT16> > (backtrack);
 if (!input.sanitize (c)) return_trace (false);
-const ArrayOf<USHORT> &lookahead = StructAfter<ArrayOf<USHORT> > (input);
+const ArrayOf<HBUINT16> &lookahead = StructAfter<ArrayOf<HBUINT16> > (input);
 if (!lookahead.sanitize (c)) return_trace (false);
 const ArrayOf<LookupRecord> &lookup = StructAfter<ArrayOf<LookupRecord> > (lookahead);
 return_trace (lookup.sanitize (c));
 }
 protected:
-ArrayOf<USHORT>
+ArrayOf<HBUINT16>
 backtrack;              /* Array of backtracking values
 * (to be matched before the input
 * sequence) */
-HeadlessArrayOf<USHORT>
+HeadlessArrayOf<HBUINT16>
 inputX;                 /* Array of input values (start with
 * second glyph) */
-ArrayOf<USHORT>
+ArrayOf<HBUINT16>
 lookaheadX;             /* Array of lookahead values's (to be
 * matched after the input sequence) */
 ArrayOf<LookupRecord>
 lookupX;                /* Array of LookupRecords--in
 * design order) */
 return_trace (true);
 return_trace (false);
 }
-inline bool apply (hb_apply_context_t *c, ChainContextApplyLookupContext &lookup_context) const
+inline bool apply (hb_ot_apply_context_t *c, ChainContextApplyLookupContext &lookup_context) const
 {
 TRACE_APPLY (this);
 unsigned int num_rules = rule.len;
 for (unsigned int i = 0; i < num_rules; i++)
 if ((this+rule[i]).apply (c, lookup_context))
 inline const Coverage &get_coverage (void) const
 {
 return this+coverage;
 }
-inline bool apply (hb_apply_context_t *c) const
+inline bool apply (hb_ot_apply_context_t *c) const
 {
 TRACE_APPLY (this);
 unsigned int index = (this+coverage).get_coverage (c->buffer->cur().codepoint);
 if (likely (index == NOT_COVERED)) return_trace (false);
 TRACE_SANITIZE (this);
 return_trace (coverage.sanitize (c, this) && ruleSet.sanitize (c, this));
 }
 protected:
-USHORT        format;                 /* Format identifier--format = 1 */
+HBUINT16      format;                 /* Format identifier--format = 1 */
 OffsetTo<Coverage>
 coverage;               /* Offset to Coverage table--from
 * beginning of table */
 OffsetArrayOf<ChainRuleSet>
 ruleSet;                /* Array of ChainRuleSet tables
 inline const Coverage &get_coverage (void) const
 {
 return this+coverage;
 }
-inline bool apply (hb_apply_context_t *c) const
+inline bool apply (hb_ot_apply_context_t *c) const
 {
 TRACE_APPLY (this);
 unsigned int index = (this+coverage).get_coverage (c->buffer->cur().codepoint);
 if (likely (index == NOT_COVERED)) return_trace (false);
 lookaheadClassDef.sanitize (c, this) &&
 ruleSet.sanitize (c, this));
 }
 protected:
-USHORT        format;                 /* Format identifier--format = 2 */
+HBUINT16      format;                 /* Format identifier--format = 2 */
 OffsetTo<Coverage>
 coverage;               /* Offset to Coverage table--from
 * beginning of table */
 OffsetTo<ClassDef>
 backtrackClassDef;      /* Offset to glyph ClassDef table
 struct ChainContextClosureLookupContext lookup_context = {
 {intersects_coverage},
 {this, this, this}
 };
 chain_context_closure_lookup (c,
-backtrack.len, (const USHORT *) backtrack.array,
+backtrack.len, (const HBUINT16 *) backtrack.array,
-input.len, (const USHORT *) input.array + 1,
+input.len, (const HBUINT16 *) input.array + 1,
-lookahead.len, (const USHORT *) lookahead.array,
+lookahead.len, (const HBUINT16 *) lookahead.array,
 lookup.len, lookup.array,
 lookup_context);
 }
 inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
 struct ChainContextCollectGlyphsLookupContext lookup_context = {
 {collect_coverage},
 {this, this, this}
 };
 chain_context_collect_glyphs_lookup (c,
-backtrack.len, (const USHORT *) backtrack.array,
+backtrack.len, (const HBUINT16 *) backtrack.array,
-input.len, (const USHORT *) input.array + 1,
+input.len, (const HBUINT16 *) input.array + 1,
-lookahead.len, (const USHORT *) lookahead.array,
+lookahead.len, (const HBUINT16 *) lookahead.array,
 lookup.len, lookup.array,
 lookup_context);
 }
 inline bool would_apply (hb_would_apply_context_t *c) const
 struct ChainContextApplyLookupContext lookup_context = {
 {match_coverage},
 {this, this, this}
 };
 return_trace (chain_context_would_apply_lookup (c,
-backtrack.len, (const USHORT *) backtrack.array,
+backtrack.len, (const HBUINT16 *) backtrack.array,
-input.len, (const USHORT *) input.array + 1,
+input.len, (const HBUINT16 *) input.array + 1,
-lookahead.len, (const USHORT *) lookahead.array,
+lookahead.len, (const HBUINT16 *) lookahead.array,
 lookup.len, lookup.array, lookup_context));
 }
 inline const Coverage &get_coverage (void) const
 {
 const OffsetArrayOf<Coverage> &input = StructAfter<OffsetArrayOf<Coverage> > (backtrack);
 return this+input[0];
 }
-inline bool apply (hb_apply_context_t *c) const
+inline bool apply (hb_ot_apply_context_t *c) const
 {
 TRACE_APPLY (this);
 const OffsetArrayOf<Coverage> &input = StructAfter<OffsetArrayOf<Coverage> > (backtrack);
 unsigned int index = (this+input[0]).get_coverage (c->buffer->cur().codepoint);
 struct ChainContextApplyLookupContext lookup_context = {
 {match_coverage},
 {this, this, this}
 };
 return_trace (chain_context_apply_lookup (c,
-backtrack.len, (const USHORT *) backtrack.array,
+backtrack.len, (const HBUINT16 *) backtrack.array,
-input.len, (const USHORT *) input.array + 1,
+input.len, (const HBUINT16 *) input.array + 1,
-lookahead.len, (const USHORT *) lookahead.array,
+lookahead.len, (const HBUINT16 *) lookahead.array,
 lookup.len, lookup.array, lookup_context));
 }
 inline bool sanitize (hb_sanitize_context_t *c) const
 {
 const ArrayOf<LookupRecord> &lookup = StructAfter<ArrayOf<LookupRecord> > (lookahead);
 return_trace (lookup.sanitize (c));
 }
 protected:
-USHORT        format;                 /* Format identifier--format = 3 */
+HBUINT16      format;                 /* Format identifier--format = 3 */
 OffsetArrayOf<Coverage>
 backtrack;              /* Array of coverage tables
 * in backtracking sequence, in  glyph
 * sequence order */
 OffsetArrayOf<Coverage>
 }
 }
 protected:
 union {
-USHORT                format; /* Format identifier */
+HBUINT16              format; /* Format identifier */
 ChainContextFormat1   format1;
 ChainContextFormat2   format2;
 ChainContextFormat3   format3;
 } u;
 };
 /* This is called from may_dispatch() above with hb_sanitize_context_t. */
 inline bool sanitize (hb_sanitize_context_t *c) const
 {
 TRACE_SANITIZE (this);
-return_trace (c->check_struct (this) && extensionOffset != 0);
+return_trace (c->check_struct (this) &&
+extensionOffset != 0 &&
+extensionLookupType != T::LookupSubTable::Extension);
 }
 protected:
-USHORT        format;                 /* Format identifier. Set to 1. */
+HBUINT16      format;                 /* Format identifier. Set to 1. */
-USHORT        extensionLookupType;    /* Lookup type of subtable referenced
+HBUINT16      extensionLookupType;    /* Lookup type of subtable referenced
 * by ExtensionOffset (i.e. the
 * extension subtable). */
-ULONG         extensionOffset;        /* Offset to the extension subtable,
+HBUINT32      extensionOffset;        /* Offset to the extension subtable,
 * of lookup type subtable. */
 public:
 DEFINE_SIZE_STATIC (8);
 };
 }
 }
 protected:
 union {
-USHORT                format;         /* Format identifier */
+HBUINT16              format;         /* Format identifier */
 ExtensionFormat1<T>   format1;
 } u;
 };
 * GSUB/GPOS Common
 */
 struct GSUBGPOS
 {
-static const hb_tag_t GSUBTag = HB_OT_TAG_GSUB;
-static const hb_tag_t GPOSTag = HB_OT_TAG_GPOS;
 inline unsigned int get_script_count (void) const
 { return (this+scriptList).len; }
 inline const Tag& get_script_tag (unsigned int i) const
 { return (this+scriptList).get_tag (i); }
 inline unsigned int get_script_tags (unsigned int start_offset,

changeset 50352	25db2c8f3cf8
parent 48274	51772bf1fb0c
child 50826	f5b95be8b6e2