From d7cfb3b2d1dd2e9fdae2b3e540bbe313660895e8 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 13 May 2010 14:18:49 -0400 Subject: [PATCH] s/\/c/g --- src/hb-open-file-private.hh | 28 +-- src/hb-open-type-private.hh | 100 ++++---- src/hb-ot-layout-common-private.hh | 84 +++---- src/hb-ot-layout-gdef-private.hh | 98 ++++---- src/hb-ot-layout-gpos-private.hh | 460 +++++++++++++++++------------------ src/hb-ot-layout-gsub-private.hh | 306 +++++++++++------------ src/hb-ot-layout-gsubgpos-private.hh | 258 ++++++++++---------- src/hb-ot-layout.cc | 24 +- 8 files changed, 679 insertions(+), 679 deletions(-) diff --git a/src/hb-open-file-private.hh b/src/hb-open-file-private.hh index c56ce8f..905f50f 100644 --- a/src/hb-open-file-private.hh +++ b/src/hb-open-file-private.hh @@ -48,9 +48,9 @@ struct TTCHeader; typedef struct TableDirectory { - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return context->check_struct (this); + return c->check_struct (this); } Tag tag; /* 4-byte identifier. */ @@ -98,10 +98,10 @@ typedef struct OffsetTable } public: - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return context->check_struct (this) - && context->check_array (tableDir, TableDirectory::static_size, numTables); + return c->check_struct (this) + && c->check_array (tableDir, TableDirectory::static_size, numTables); } private: @@ -127,9 +127,9 @@ struct TTCHeaderVersion1 inline unsigned int get_face_count (void) const { return table.len; } inline const OpenTypeFontFace& get_face (unsigned int i) const { return this+table[i]; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return table.sanitize (context, this); + return table.sanitize (c, this); } private: @@ -166,12 +166,12 @@ struct TTCHeader } } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (unlikely (!u.header.version.sanitize (context))) return false; + if (unlikely (!u.header.version.sanitize (c))) return false; switch (u.header.version) { case 2: /* version 2 is compatible with version 1 */ - case 1: return u.version1.sanitize (context); + case 1: return u.version1.sanitize (c); default:return true; } } @@ -228,15 +228,15 @@ struct OpenTypeFontFile } } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (unlikely (!u.tag.sanitize (context))) return false; + if (unlikely (!u.tag.sanitize (c))) return false; switch (u.tag) { case CFFTag: /* All the non-collection tags */ case TrueTag: case Typ1Tag: - case TrueTypeTag: return u.fontFace.sanitize (context); - case TTCTag: return u.ttcHeader.sanitize (context); + case TrueTypeTag: return u.fontFace.sanitize (c); + case TTCTag: return u.ttcHeader.sanitize (c); default: return true; } } diff --git a/src/hb-open-type-private.hh b/src/hb-open-type-private.hh index a57bef5..16cc376 100644 --- a/src/hb-open-type-private.hh +++ b/src/hb-open-type-private.hh @@ -176,7 +176,7 @@ struct hb_trace_t<0> { #define TRACE_SANITIZE() \ - hb_trace_t trace (&context->debug_depth, "SANITIZE", HB_FUNC, this); \ + hb_trace_t trace (&c->debug_depth, "SANITIZE", HB_FUNC, this); \ struct hb_sanitize_context_t @@ -278,7 +278,7 @@ template struct Sanitizer { static hb_blob_t *sanitize (hb_blob_t *blob) { - hb_sanitize_context_t context[1] = {{0}}; + hb_sanitize_context_t c[1] = {{0}}; bool sane; /* TODO is_sane() stuff */ @@ -287,36 +287,36 @@ struct Sanitizer if (HB_DEBUG_SANITIZE) fprintf (stderr, "Sanitizer %p start %s\n", blob, HB_FUNC); - context->init (blob); + c->init (blob); - if (unlikely (!context->start)) { - context->finish (); + if (unlikely (!c->start)) { + c->finish (); return blob; } - Type *t = CastP (const_cast (context->start)); + Type *t = CastP (const_cast (c->start)); - sane = t->sanitize (context); + sane = t->sanitize (c); if (sane) { - if (context->edit_count) { + if (c->edit_count) { if (HB_DEBUG_SANITIZE) fprintf (stderr, "Sanitizer %p passed first round with %d edits; doing a second round %s\n", - blob, context->edit_count, HB_FUNC); + blob, c->edit_count, HB_FUNC); /* sanitize again to ensure no toe-stepping */ - context->edit_count = 0; - sane = t->sanitize (context); - if (context->edit_count) { + c->edit_count = 0; + sane = t->sanitize (c); + if (c->edit_count) { if (HB_DEBUG_SANITIZE) fprintf (stderr, "Sanitizer %p requested %d edits in second round; FAILLING %s\n", - blob, context->edit_count, HB_FUNC); + blob, c->edit_count, HB_FUNC); sane = false; } } - context->finish (); + c->finish (); } else { - unsigned int edit_count = context->edit_count; - context->finish (); + unsigned int edit_count = c->edit_count; + c->finish (); if (edit_count && !hb_blob_is_writable (blob) && hb_blob_try_writable (blob)) { /* ok, we made it writable by relocating. try again */ if (HB_DEBUG_SANITIZE) @@ -391,9 +391,9 @@ struct IntType inline operator Type(void) const { return v; } inline bool operator == (const IntType &o) const { return v == o.v; } inline bool operator != (const IntType &o) const { return v != o.v; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return likely (context->check_struct (this)); + return likely (c->check_struct (this)); } protected: BEInt v; @@ -459,9 +459,9 @@ struct FixedVersion { inline operator uint32_t (void) const { return (major << 16) + minor; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return context->check_struct (this); + return c->check_struct (this); } USHORT major; @@ -487,28 +487,28 @@ struct GenericOffsetTo : OffsetType return StructAtOffset (base, offset); } - inline bool sanitize (hb_sanitize_context_t *context, void *base) { + inline bool sanitize (hb_sanitize_context_t *c, void *base) { TRACE_SANITIZE (); - if (unlikely (!context->check_struct (this))) return false; + if (unlikely (!c->check_struct (this))) return false; unsigned int offset = *this; if (unlikely (!offset)) return true; Type &obj = StructAtOffset (base, offset); - return likely (obj.sanitize (context)) || neuter (context); + return likely (obj.sanitize (c)) || neuter (c); } template - inline bool sanitize (hb_sanitize_context_t *context, void *base, T user_data) { + inline bool sanitize (hb_sanitize_context_t *c, void *base, T user_data) { TRACE_SANITIZE (); - if (unlikely (!context->check_struct (this))) return false; + if (unlikely (!c->check_struct (this))) return false; unsigned int offset = *this; if (unlikely (!offset)) return true; Type &obj = StructAtOffset (base, offset); - return likely (obj.sanitize (context, user_data)) || neuter (context); + return likely (obj.sanitize (c, user_data)) || neuter (c); } private: /* Set the offset to Null */ - inline bool neuter (hb_sanitize_context_t *context) { - if (context->can_edit (this, this->static_size)) { + inline bool neuter (hb_sanitize_context_t *c) { + if (c->can_edit (this, this->static_size)) { this->set (0); /* 0 is Null offset */ return true; } @@ -552,9 +552,9 @@ struct GenericArrayOf inline unsigned int get_size () const { return len.static_size + len * Type::static_size; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (unlikely (!sanitize_shallow (context))) return false; + if (unlikely (!sanitize_shallow (c))) return false; /* Note: for structs that do not reference other structs, * we do not need to call their sanitize() as we already did * a bound check on the aggregate array size, hence the return. @@ -565,35 +565,35 @@ struct GenericArrayOf * other structs. */ unsigned int count = len; for (unsigned int i = 0; i < count; i++) - if (array[i].sanitize (context)) + if (array[i].sanitize (c)) return false; return true; } - inline bool sanitize (hb_sanitize_context_t *context, void *base) { + inline bool sanitize (hb_sanitize_context_t *c, void *base) { TRACE_SANITIZE (); - if (unlikely (!sanitize_shallow (context))) return false; + if (unlikely (!sanitize_shallow (c))) return false; unsigned int count = len; for (unsigned int i = 0; i < count; i++) - if (unlikely (!array[i].sanitize (context, base))) + if (unlikely (!array[i].sanitize (c, base))) return false; return true; } template - inline bool sanitize (hb_sanitize_context_t *context, void *base, T user_data) { + inline bool sanitize (hb_sanitize_context_t *c, void *base, T user_data) { TRACE_SANITIZE (); - if (unlikely (!sanitize_shallow (context))) return false; + if (unlikely (!sanitize_shallow (c))) return false; unsigned int count = len; for (unsigned int i = 0; i < count; i++) - if (unlikely (!array[i].sanitize (context, base, user_data))) + if (unlikely (!array[i].sanitize (c, base, user_data))) return false; return true; } private: - inline bool sanitize_shallow (hb_sanitize_context_t *context) { + inline bool sanitize_shallow (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return context->check_struct (this) - && context->check_array (this, Type::static_size, len); + return c->check_struct (this) + && c->check_array (this, Type::static_size, len); } public: @@ -633,14 +633,14 @@ struct OffsetListOf : OffsetArrayOf return this+this->array[i]; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return OffsetArrayOf::sanitize (context, this); + return OffsetArrayOf::sanitize (c, this); } template - inline bool sanitize (hb_sanitize_context_t *context, T user_data) { + inline bool sanitize (hb_sanitize_context_t *c, T user_data) { TRACE_SANITIZE (); - return OffsetArrayOf::sanitize (context, this, user_data); + return OffsetArrayOf::sanitize (c, this, user_data); } }; @@ -658,14 +658,14 @@ struct HeadlessArrayOf inline unsigned int get_size () const { return len.static_size + (len ? len - 1 : 0) * Type::static_size; } - inline bool sanitize_shallow (hb_sanitize_context_t *context) { - return context->check_struct (this) - && context->check_array (this, Type::static_size, len); + inline bool sanitize_shallow (hb_sanitize_context_t *c) { + return c->check_struct (this) + && c->check_array (this, Type::static_size, len); } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (unlikely (!sanitize_shallow (context))) return false; + if (unlikely (!sanitize_shallow (c))) return false; /* Note: for structs that do not reference other structs, * we do not need to call their sanitize() as we already did * a bound check on the aggregate array size, hence the return. @@ -677,7 +677,7 @@ struct HeadlessArrayOf unsigned int count = len ? len - 1 : 0; Type *a = array; for (unsigned int i = 0; i < count; i++) - if (unlikely (!a[i].sanitize (context))) + if (unlikely (!a[i].sanitize (c))) return false; return true; } diff --git a/src/hb-ot-layout-common-private.hh b/src/hb-ot-layout-common-private.hh index 8c04150..4ab4ee5 100644 --- a/src/hb-ot-layout-common-private.hh +++ b/src/hb-ot-layout-common-private.hh @@ -51,10 +51,10 @@ template struct Record { - inline bool sanitize (hb_sanitize_context_t *context, void *base) { + inline bool sanitize (hb_sanitize_context_t *c, void *base) { TRACE_SANITIZE (); - return context->check_struct (this) - && offset.sanitize (context, base); + return c->check_struct (this) + && offset.sanitize (c, base); } Tag tag; /* 4-byte Tag identifier */ @@ -110,9 +110,9 @@ struct RecordListOf : RecordArrayOf inline const Type& operator [] (unsigned int i) const { return this+RecordArrayOf::operator [](i).offset; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return RecordArrayOf::sanitize (context, this); + return RecordArrayOf::sanitize (c, this); } }; @@ -158,10 +158,10 @@ struct LangSys return reqFeatureIndex;; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return context->check_struct (this) - && featureIndex.sanitize (context); + return c->check_struct (this) + && featureIndex.sanitize (c); } Offset lookupOrder; /* = Null (reserved for an offset to a @@ -197,10 +197,10 @@ struct Script inline bool has_default_lang_sys (void) const { return defaultLangSys != 0; } inline const LangSys& get_default_lang_sys (void) const { return this+defaultLangSys; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return defaultLangSys.sanitize (context, this) - && langSys.sanitize (context, this); + return defaultLangSys.sanitize (c, this) + && langSys.sanitize (c, this); } private: @@ -228,10 +228,10 @@ struct Feature unsigned int *lookup_tags /* OUT */) const { return lookupIndex.get_indexes (start_index, lookup_count, lookup_tags); } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return context->check_struct (this) - && lookupIndex.sanitize (context); + return c->check_struct (this) + && lookupIndex.sanitize (c); } /* LONGTERMTODO: implement get_feature_parameters() */ @@ -280,15 +280,15 @@ struct Lookup return flag; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); /* Real sanitize of the subtables is done by GSUB/GPOS/... */ - if (!(context->check_struct (this) - && subTable.sanitize (context))) return false; + if (!(c->check_struct (this) + && subTable.sanitize (c))) return false; if (unlikely (lookupFlag & LookupFlag::UseMarkFilteringSet)) { USHORT &markFilteringSet = StructAfter (subTable); - if (!markFilteringSet.sanitize (context)) return false; + if (!markFilteringSet.sanitize (c)) return false; } return true; } @@ -330,9 +330,9 @@ struct CoverageFormat1 return NOT_COVERED; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return glyphArray.sanitize (context); + return glyphArray.sanitize (c); } private: @@ -356,9 +356,9 @@ struct CoverageRangeRecord } public: - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return context->check_struct (this); + return c->check_struct (this); } private: @@ -389,9 +389,9 @@ struct CoverageFormat2 return NOT_COVERED; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return rangeRecord.sanitize (context); + return rangeRecord.sanitize (c); } private: @@ -417,12 +417,12 @@ struct Coverage } } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (!u.format.sanitize (context)) return false; + if (!u.format.sanitize (c)) return false; switch (u.format) { - case 1: return u.format1.sanitize (context); - case 2: return u.format2.sanitize (context); + case 1: return u.format1.sanitize (c); + case 2: return u.format2.sanitize (c); default:return true; } } @@ -454,10 +454,10 @@ struct ClassDefFormat1 return 0; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return context->check_struct (this) - && classValue.sanitize (context); + return c->check_struct (this) + && classValue.sanitize (c); } USHORT classFormat; /* Format identifier--format = 1 */ @@ -481,9 +481,9 @@ struct ClassRangeRecord } public: - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return context->check_struct (this); + return c->check_struct (this); } private: @@ -513,9 +513,9 @@ struct ClassDefFormat2 return 0; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return rangeRecord.sanitize (context); + return rangeRecord.sanitize (c); } USHORT classFormat; /* Format identifier--format = 2 */ @@ -539,12 +539,12 @@ struct ClassDef } } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (!u.format.sanitize (context)) return false; + if (!u.format.sanitize (c)) return false; switch (u.format) { - case 1: return u.format1.sanitize (context); - case 2: return u.format2.sanitize (context); + case 1: return u.format1.sanitize (c); + case 2: return u.format2.sanitize (c); default:return true; } } @@ -598,10 +598,10 @@ struct Device return USHORT::static_size * (4 + ((endSize - startSize) >> (4 - f))); } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return context->check_struct (this) - && context->check_range (this, this->get_size ()); + return c->check_struct (this) + && c->check_range (this, this->get_size ()); } private: diff --git a/src/hb-ot-layout-gdef-private.hh b/src/hb-ot-layout-gdef-private.hh index d43a4c2..63fbee7 100644 --- a/src/hb-ot-layout-gdef-private.hh +++ b/src/hb-ot-layout-gdef-private.hh @@ -66,10 +66,10 @@ struct AttachList return points.len; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return coverage.sanitize (context, this) - && attachPoint.sanitize (context, this); + return coverage.sanitize (c, this) + && attachPoint.sanitize (c, this); } private: @@ -92,15 +92,15 @@ struct CaretValueFormat1 friend struct CaretValue; private: - inline int get_caret_value (hb_ot_layout_context_t *context, hb_codepoint_t glyph_id HB_UNUSED) const + inline int get_caret_value (hb_ot_layout_context_t *c, hb_codepoint_t glyph_id HB_UNUSED) const { /* TODO vertical */ - return _hb_16dot16_mul_round (context->font->x_scale, coordinate); + return _hb_16dot16_mul_round (c->font->x_scale, coordinate); } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return context->check_struct (this); + return c->check_struct (this); } private: @@ -115,19 +115,19 @@ struct CaretValueFormat2 friend struct CaretValue; private: - inline int get_caret_value (hb_ot_layout_context_t *context, hb_codepoint_t glyph_id) const + inline int get_caret_value (hb_ot_layout_context_t *c, hb_codepoint_t glyph_id) const { /* TODO vertical */ hb_position_t x, y; - if (hb_font_get_contour_point (context->font, context->face, caretValuePoint, glyph_id, &x, &y)) + if (hb_font_get_contour_point (c->font, c->face, caretValuePoint, glyph_id, &x, &y)) return x; else return 0; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return context->check_struct (this); + return c->check_struct (this); } private: @@ -141,17 +141,17 @@ struct CaretValueFormat3 { friend struct CaretValue; - inline int get_caret_value (hb_ot_layout_context_t *context, hb_codepoint_t glyph_id HB_UNUSED) const + inline int get_caret_value (hb_ot_layout_context_t *c, hb_codepoint_t glyph_id HB_UNUSED) const { /* TODO vertical */ - return _hb_16dot16_mul_round (context->font->x_scale, coordinate) + - ((this+deviceTable).get_delta (context->font->x_ppem) << 16); + return _hb_16dot16_mul_round (c->font->x_scale, coordinate) + + ((this+deviceTable).get_delta (c->font->x_ppem) << 16); } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return context->check_struct (this) - && deviceTable.sanitize (context, this); + return c->check_struct (this) + && deviceTable.sanitize (c, this); } private: @@ -167,23 +167,23 @@ struct CaretValueFormat3 struct CaretValue { - inline int get_caret_value (hb_ot_layout_context_t *context, hb_codepoint_t glyph_id) const + inline int get_caret_value (hb_ot_layout_context_t *c, hb_codepoint_t glyph_id) const { switch (u.format) { - case 1: return u.format1.get_caret_value (context, glyph_id); - case 2: return u.format2.get_caret_value (context, glyph_id); - case 3: return u.format3.get_caret_value (context, glyph_id); + case 1: return u.format1.get_caret_value (c, glyph_id); + case 2: return u.format2.get_caret_value (c, glyph_id); + case 3: return u.format3.get_caret_value (c, glyph_id); default:return 0; } } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (!u.format.sanitize (context)) return false; + if (!u.format.sanitize (c)) return false; switch (u.format) { - case 1: return u.format1.sanitize (context); - case 2: return u.format2.sanitize (context); - case 3: return u.format3.sanitize (context); + case 1: return u.format1.sanitize (c); + case 2: return u.format2.sanitize (c); + case 3: return u.format3.sanitize (c); default:return true; } } @@ -201,7 +201,7 @@ struct CaretValue struct LigGlyph { - inline unsigned int get_lig_carets (hb_ot_layout_context_t *context, + inline unsigned int get_lig_carets (hb_ot_layout_context_t *c, hb_codepoint_t glyph_id, unsigned int start_offset, unsigned int *caret_count /* IN/OUT */, @@ -211,15 +211,15 @@ struct LigGlyph const OffsetTo *array = carets.sub_array (start_offset, caret_count); unsigned int count = *caret_count; for (unsigned int i = 0; i < count; i++) - caret_array[i] = (this+array[i]).get_caret_value (context, glyph_id); + caret_array[i] = (this+array[i]).get_caret_value (c, glyph_id); } return carets.len; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return carets.sanitize (context, this); + return carets.sanitize (c, this); } private: @@ -233,7 +233,7 @@ struct LigGlyph struct LigCaretList { - inline unsigned int get_lig_carets (hb_ot_layout_context_t *context, + inline unsigned int get_lig_carets (hb_ot_layout_context_t *c, hb_codepoint_t glyph_id, unsigned int start_offset, unsigned int *caret_count /* IN/OUT */, @@ -247,13 +247,13 @@ struct LigCaretList return 0; } const LigGlyph &lig_glyph = this+ligGlyph[index]; - return lig_glyph.get_lig_carets (context, glyph_id, start_offset, caret_count, caret_array); + return lig_glyph.get_lig_carets (c, glyph_id, start_offset, caret_count, caret_array); } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return coverage.sanitize (context, this) - && ligGlyph.sanitize (context, this); + return coverage.sanitize (c, this) + && ligGlyph.sanitize (c, this); } private: @@ -273,9 +273,9 @@ struct MarkGlyphSetsFormat1 inline bool covers (unsigned int set_index, hb_codepoint_t glyph_id) const { return (this+coverage[set_index]).get_coverage (glyph_id) != NOT_COVERED; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return coverage.sanitize (context, this); + return coverage.sanitize (c, this); } private: @@ -297,11 +297,11 @@ struct MarkGlyphSets } } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (!u.format.sanitize (context)) return false; + if (!u.format.sanitize (c)) return false; switch (u.format) { - case 1: return u.format1.sanitize (context); + case 1: return u.format1.sanitize (c); default:return true; } } @@ -348,25 +348,25 @@ struct GDEF { return (this+attachList).get_attach_points (glyph_id, start_offset, point_count, point_array); } inline bool has_lig_carets () const { return ligCaretList != 0; } - inline unsigned int get_lig_carets (hb_ot_layout_context_t *context, + inline unsigned int get_lig_carets (hb_ot_layout_context_t *c, hb_codepoint_t glyph_id, unsigned int start_offset, unsigned int *caret_count /* IN/OUT */, int *caret_array /* OUT */) const - { return (this+ligCaretList).get_lig_carets (context, glyph_id, start_offset, caret_count, caret_array); } + { return (this+ligCaretList).get_lig_carets (c, glyph_id, start_offset, caret_count, caret_array); } inline bool has_mark_sets () const { return version >= 0x00010002 && markGlyphSetsDef[0] != 0; } inline bool mark_set_covers (unsigned int set_index, hb_codepoint_t glyph_id) const { return version >= 0x00010002 && (this+markGlyphSetsDef[0]).covers (set_index, glyph_id); } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return version.sanitize (context) && likely (version.major == 1) - && glyphClassDef.sanitize (context, this) - && attachList.sanitize (context, this) - && ligCaretList.sanitize (context, this) - && markAttachClassDef.sanitize (context, this) - && (version < 0x00010002 || markGlyphSetsDef[0].sanitize (context, this)); + return version.sanitize (c) && likely (version.major == 1) + && glyphClassDef.sanitize (c, this) + && attachList.sanitize (c, this) + && ligCaretList.sanitize (c, this) + && markAttachClassDef.sanitize (c, this) + && (version < 0x00010002 || markGlyphSetsDef[0].sanitize (c, this)); } private: diff --git a/src/hb-ot-layout-gpos-private.hh b/src/hb-ot-layout-gpos-private.hh index b12a046..b072ca9 100644 --- a/src/hb-ot-layout-gpos-private.hh +++ b/src/hb-ot-layout-gpos-private.hh @@ -31,7 +31,7 @@ #undef BUFFER -#define BUFFER context->buffer +#define BUFFER c->buffer #define HB_OT_LAYOUT_GPOS_NO_LAST ((unsigned int) -1) @@ -133,7 +133,7 @@ struct ValueFormat : USHORT } private: - inline bool sanitize_value_devices (hb_sanitize_context_t *context, void *base, Value *values) { + inline bool sanitize_value_devices (hb_sanitize_context_t *c, void *base, Value *values) { unsigned int format = *this; if (format & xPlacement) values++; @@ -141,10 +141,10 @@ struct ValueFormat : USHORT if (format & xAdvance) values++; if (format & yAdvance) values++; - if ((format & xPlaDevice) && !get_device (values++).sanitize (context, base)) return false; - if ((format & yPlaDevice) && !get_device (values++).sanitize (context, base)) return false; - if ((format & xAdvDevice) && !get_device (values++).sanitize (context, base)) return false; - if ((format & yAdvDevice) && !get_device (values++).sanitize (context, base)) return false; + if ((format & xPlaDevice) && !get_device (values++).sanitize (c, base)) return false; + if ((format & yPlaDevice) && !get_device (values++).sanitize (c, base)) return false; + if ((format & xAdvDevice) && !get_device (values++).sanitize (c, base)) return false; + if ((format & yAdvDevice) && !get_device (values++).sanitize (c, base)) return false; return true; } @@ -164,22 +164,22 @@ struct ValueFormat : USHORT return (format & devices) != 0; } - inline bool sanitize_value (hb_sanitize_context_t *context, void *base, Value *values) { + inline bool sanitize_value (hb_sanitize_context_t *c, void *base, Value *values) { TRACE_SANITIZE (); - return context->check_range (values, get_size ()) - && (!has_device () || sanitize_value_devices (context, base, values)); + return c->check_range (values, get_size ()) + && (!has_device () || sanitize_value_devices (c, base, values)); } - inline bool sanitize_values (hb_sanitize_context_t *context, void *base, Value *values, unsigned int count) { + inline bool sanitize_values (hb_sanitize_context_t *c, void *base, Value *values, unsigned int count) { TRACE_SANITIZE (); unsigned int len = get_len (); - if (!context->check_array (values, get_size (), count)) return false; + if (!c->check_array (values, get_size (), count)) return false; if (!has_device ()) return true; for (unsigned int i = 0; i < count; i++) { - if (!sanitize_value_devices (context, base, values)) + if (!sanitize_value_devices (c, base, values)) return false; values += len; } @@ -188,13 +188,13 @@ struct ValueFormat : USHORT } /* Just sanitize referenced Device tables. Doesn't check the values themselves. */ - inline bool sanitize_values_stride_unsafe (hb_sanitize_context_t *context, void *base, Value *values, unsigned int count, unsigned int stride) { + inline bool sanitize_values_stride_unsafe (hb_sanitize_context_t *c, void *base, Value *values, unsigned int count, unsigned int stride) { TRACE_SANITIZE (); if (!has_device ()) return true; for (unsigned int i = 0; i < count; i++) { - if (!sanitize_value_devices (context, base, values)) + if (!sanitize_value_devices (c, base, values)) return false; values += stride; } @@ -216,9 +216,9 @@ struct AnchorFormat1 *y = _hb_16dot16_mul_round (layout->font->y_scale, yCoordinate); } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return context->check_struct (this); + return c->check_struct (this); } private: @@ -248,9 +248,9 @@ struct AnchorFormat2 *y = y_ppem && ret ? cy : _hb_16dot16_mul_round (layout->font->y_scale, yCoordinate); } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return context->check_struct (this); + return c->check_struct (this); } private: @@ -280,11 +280,11 @@ struct AnchorFormat3 *y += (this+yDeviceTable).get_delta (layout->font->y_ppem) << 16; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return context->check_struct (this) - && xDeviceTable.sanitize (context, this) - && yDeviceTable.sanitize (context, this); + return c->check_struct (this) + && xDeviceTable.sanitize (c, this) + && yDeviceTable.sanitize (c, this); } private: @@ -317,13 +317,13 @@ struct Anchor } } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (!u.format.sanitize (context)) return false; + if (!u.format.sanitize (c)) return false; switch (u.format) { - case 1: return u.format1.sanitize (context); - case 2: return u.format2.sanitize (context); - case 3: return u.format3.sanitize (context); + case 1: return u.format1.sanitize (c); + case 2: return u.format2.sanitize (c); + case 3: return u.format3.sanitize (c); default:return true; } } @@ -347,14 +347,14 @@ struct AnchorMatrix return this+matrix[row * cols + col]; } - inline bool sanitize (hb_sanitize_context_t *context, unsigned int cols) { + inline bool sanitize (hb_sanitize_context_t *c, unsigned int cols) { TRACE_SANITIZE (); - if (!context->check_struct (this)) return false; + if (!c->check_struct (this)) return false; if (unlikely (cols >= ((unsigned int) -1) / rows)) return false; unsigned int count = rows * cols; - if (!context->check_array (matrix, matrix[0].static_size, count)) return false; + if (!c->check_array (matrix, matrix[0].static_size, count)) return false; for (unsigned int i = 0; i < count; i++) - if (!matrix[i].sanitize (context, this)) return false; + if (!matrix[i].sanitize (c, this)) return false; return true; } @@ -372,10 +372,10 @@ struct MarkRecord { friend struct MarkArray; - inline bool sanitize (hb_sanitize_context_t *context, void *base) { + inline bool sanitize (hb_sanitize_context_t *c, void *base) { TRACE_SANITIZE (); - return context->check_struct (this) - && markAnchor.sanitize (context, base); + return c->check_struct (this) + && markAnchor.sanitize (c, base); } private: @@ -389,7 +389,7 @@ struct MarkRecord struct MarkArray : ArrayOf /* Array of MarkRecords--in Coverage order */ { - inline bool apply (hb_apply_context_t *context, + inline bool apply (hb_apply_context_t *c, unsigned int mark_index, unsigned int glyph_index, const AnchorMatrix &anchors, unsigned int class_count, unsigned int glyph_pos) const @@ -403,23 +403,23 @@ struct MarkArray : ArrayOf /* Array of MarkRecords--in Coverage orde hb_position_t mark_x, mark_y, base_x, base_y; - mark_anchor.get_anchor (context->layout, IN_CURGLYPH (), &mark_x, &mark_y); - glyph_anchor.get_anchor (context->layout, IN_GLYPH (glyph_pos), &base_x, &base_y); + mark_anchor.get_anchor (c->layout, IN_CURGLYPH (), &mark_x, &mark_y); + glyph_anchor.get_anchor (c->layout, IN_GLYPH (glyph_pos), &base_x, &base_y); - hb_internal_glyph_position_t *o = POSITION (context->buffer->in_pos); + hb_internal_glyph_position_t *o = POSITION (c->buffer->in_pos); o->x_advance = 0; o->y_advance = 0; o->x_offset = base_x - mark_x; o->y_offset = base_y - mark_y; - o->back = context->buffer->in_pos - glyph_pos; + o->back = c->buffer->in_pos - glyph_pos; - context->buffer->in_pos++; + c->buffer->in_pos++; return true; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return ArrayOf::sanitize (context, this); + return ArrayOf::sanitize (c, this); } }; @@ -431,24 +431,24 @@ struct SinglePosFormat1 friend struct SinglePos; private: - inline bool apply (hb_apply_context_t *context) const + inline bool apply (hb_apply_context_t *c) const { TRACE_APPLY (); unsigned int index = (this+coverage) (IN_CURGLYPH ()); if (likely (index == NOT_COVERED)) return false; - valueFormat.apply_value (context->layout, this, values, CURPOSITION ()); + valueFormat.apply_value (c->layout, this, values, CURPOSITION ()); - context->buffer->in_pos++; + c->buffer->in_pos++; return true; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return context->check_struct (this) - && coverage.sanitize (context, this) - && valueFormat.sanitize_value (context, this, values); + return c->check_struct (this) + && coverage.sanitize (c, this) + && valueFormat.sanitize_value (c, this, values); } private: @@ -470,7 +470,7 @@ struct SinglePosFormat2 friend struct SinglePos; private: - inline bool apply (hb_apply_context_t *context) const + inline bool apply (hb_apply_context_t *c) const { TRACE_APPLY (); unsigned int index = (this+coverage) (IN_CURGLYPH ()); @@ -480,19 +480,19 @@ struct SinglePosFormat2 if (likely (index >= valueCount)) return false; - valueFormat.apply_value (context->layout, this, + valueFormat.apply_value (c->layout, this, &values[index * valueFormat.get_len ()], CURPOSITION ()); - context->buffer->in_pos++; + c->buffer->in_pos++; return true; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return context->check_struct (this) - && coverage.sanitize (context, this) - && valueFormat.sanitize_values (context, this, values, valueCount); + return c->check_struct (this) + && coverage.sanitize (c, this) + && valueFormat.sanitize_values (c, this, values, valueCount); } private: @@ -514,22 +514,22 @@ struct SinglePos friend struct PosLookupSubTable; private: - inline bool apply (hb_apply_context_t *context) const + inline bool apply (hb_apply_context_t *c) const { TRACE_APPLY (); switch (u.format) { - case 1: return u.format1.apply (context); - case 2: return u.format2.apply (context); + case 1: return u.format1.apply (c); + case 2: return u.format2.apply (c); default:return false; } } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (!u.format.sanitize (context)) return false; + if (!u.format.sanitize (c)) return false; switch (u.format) { - case 1: return u.format1.sanitize (context); - case 2: return u.format2.sanitize (context); + case 1: return u.format1.sanitize (c); + case 2: return u.format2.sanitize (c); default:return true; } } @@ -561,7 +561,7 @@ struct PairSet { friend struct PairPosFormat1; - inline bool apply (hb_apply_context_t *context, + inline bool apply (hb_apply_context_t *c, const ValueFormat *valueFormats, unsigned int pos) const { @@ -576,11 +576,11 @@ struct PairSet { if (IN_GLYPH (pos) == record->secondGlyph) { - valueFormats[0].apply_value (context->layout, this, &record->values[0], CURPOSITION ()); - valueFormats[1].apply_value (context->layout, this, &record->values[len1], POSITION (pos)); + valueFormats[0].apply_value (c->layout, this, &record->values[0], CURPOSITION ()); + valueFormats[1].apply_value (c->layout, this, &record->values[len1], POSITION (pos)); if (len2) pos++; - context->buffer->in_pos = pos; + c->buffer->in_pos = pos; return true; } record = &StructAtOffset (record, record_size); @@ -596,15 +596,15 @@ struct PairSet unsigned int stride; /* 1 + len1 + len2 */ }; - inline bool sanitize (hb_sanitize_context_t *context, const sanitize_closure_t *closure) { + inline bool sanitize (hb_sanitize_context_t *c, const sanitize_closure_t *closure) { TRACE_SANITIZE (); - if (!(context->check_struct (this) - && context->check_array (array, USHORT::static_size * closure->stride, len))) return false; + if (!(c->check_struct (this) + && c->check_array (array, USHORT::static_size * closure->stride, len))) return false; unsigned int count = len; PairValueRecord *record = CastP (array); - return closure->valueFormats[0].sanitize_values_stride_unsafe (context, closure->base, &record->values[0], count, closure->stride) - && closure->valueFormats[1].sanitize_values_stride_unsafe (context, closure->base, &record->values[closure->len1], count, closure->stride); + return closure->valueFormats[0].sanitize_values_stride_unsafe (c, closure->base, &record->values[0], count, closure->stride) + && closure->valueFormats[1].sanitize_values_stride_unsafe (c, closure->base, &record->values[closure->len1], count, closure->stride); } private: @@ -620,29 +620,29 @@ struct PairPosFormat1 friend struct PairPos; private: - inline bool apply (hb_apply_context_t *context) const + inline bool apply (hb_apply_context_t *c) const { TRACE_APPLY (); - unsigned int end = MIN (context->buffer->in_length, context->buffer->in_pos + context->context_length); - if (unlikely (context->buffer->in_pos + 2 > end)) + unsigned int end = MIN (c->buffer->in_length, c->buffer->in_pos + c->context_length); + if (unlikely (c->buffer->in_pos + 2 > end)) return false; unsigned int index = (this+coverage) (IN_CURGLYPH ()); if (likely (index == NOT_COVERED)) return false; - unsigned int j = context->buffer->in_pos + 1; - while (_hb_ot_layout_skip_mark (context->layout->face, IN_INFO (j), context->lookup_flag, NULL)) + unsigned int j = c->buffer->in_pos + 1; + while (_hb_ot_layout_skip_mark (c->layout->face, IN_INFO (j), c->lookup_flag, NULL)) { if (unlikely (j == end)) return false; j++; } - return (this+pairSet[index]).apply (context, &valueFormat1, j); + return (this+pairSet[index]).apply (c, &valueFormat1, j); } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); unsigned int len1 = valueFormat1.get_len (); @@ -654,9 +654,9 @@ struct PairPosFormat1 1 + len1 + len2 }; - return context->check_struct (this) - && coverage.sanitize (context, this) - && pairSet.sanitize (context, this, &closure); + return c->check_struct (this) + && coverage.sanitize (c, this) + && pairSet.sanitize (c, this, &closure); } private: @@ -682,19 +682,19 @@ struct PairPosFormat2 friend struct PairPos; private: - inline bool apply (hb_apply_context_t *context) const + inline bool apply (hb_apply_context_t *c) const { TRACE_APPLY (); - unsigned int end = MIN (context->buffer->in_length, context->buffer->in_pos + context->context_length); - if (unlikely (context->buffer->in_pos + 2 > end)) + unsigned int end = MIN (c->buffer->in_length, c->buffer->in_pos + c->context_length); + if (unlikely (c->buffer->in_pos + 2 > end)) return false; unsigned int index = (this+coverage) (IN_CURGLYPH ()); if (likely (index == NOT_COVERED)) return false; - unsigned int j = context->buffer->in_pos + 1; - while (_hb_ot_layout_skip_mark (context->layout->face, IN_INFO (j), context->lookup_flag, NULL)) + unsigned int j = c->buffer->in_pos + 1; + while (_hb_ot_layout_skip_mark (c->layout->face, IN_INFO (j), c->lookup_flag, NULL)) { if (unlikely (j == end)) return false; @@ -711,31 +711,31 @@ struct PairPosFormat2 return false; const Value *v = &values[record_len * (klass1 * class2Count + klass2)]; - valueFormat1.apply_value (context->layout, this, v, CURPOSITION ()); - valueFormat2.apply_value (context->layout, this, v + len1, POSITION (j)); + valueFormat1.apply_value (c->layout, this, v, CURPOSITION ()); + valueFormat2.apply_value (c->layout, this, v + len1, POSITION (j)); if (len2) j++; - context->buffer->in_pos = j; + c->buffer->in_pos = j; return true; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (!(context->check_struct (this) - && coverage.sanitize (context, this) - && classDef1.sanitize (context, this) - && classDef2.sanitize (context, this))) return false; + if (!(c->check_struct (this) + && coverage.sanitize (c, this) + && classDef1.sanitize (c, this) + && classDef2.sanitize (c, this))) return false; unsigned int len1 = valueFormat1.get_len (); unsigned int len2 = valueFormat2.get_len (); unsigned int stride = len1 + len2; unsigned int record_size = valueFormat1.get_size () + valueFormat2.get_size (); unsigned int count = (unsigned int) class1Count * (unsigned int) class2Count; - return context->check_array (values, record_size, count) && - valueFormat1.sanitize_values_stride_unsafe (context, this, &values[0], count, stride) && - valueFormat2.sanitize_values_stride_unsafe (context, this, &values[len1], count, stride); + return c->check_array (values, record_size, count) && + valueFormat1.sanitize_values_stride_unsafe (c, this, &values[0], count, stride) && + valueFormat2.sanitize_values_stride_unsafe (c, this, &values[len1], count, stride); } private: @@ -773,22 +773,22 @@ struct PairPos friend struct PosLookupSubTable; private: - inline bool apply (hb_apply_context_t *context) const + inline bool apply (hb_apply_context_t *c) const { TRACE_APPLY (); switch (u.format) { - case 1: return u.format1.apply (context); - case 2: return u.format2.apply (context); + case 1: return u.format1.apply (c); + case 2: return u.format2.apply (c); default:return false; } } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (!u.format.sanitize (context)) return false; + if (!u.format.sanitize (c)) return false; switch (u.format) { - case 1: return u.format1.sanitize (context); - case 2: return u.format2.sanitize (context); + case 1: return u.format1.sanitize (c); + case 2: return u.format2.sanitize (c); default:return true; } } @@ -806,10 +806,10 @@ struct EntryExitRecord { friend struct CursivePosFormat1; - inline bool sanitize (hb_sanitize_context_t *context, void *base) { + inline bool sanitize (hb_sanitize_context_t *c, void *base) { TRACE_SANITIZE (); - return entryAnchor.sanitize (context, base) - && exitAnchor.sanitize (context, base); + return entryAnchor.sanitize (c, base) + && exitAnchor.sanitize (c, base); } private: @@ -830,7 +830,7 @@ struct CursivePosFormat1 friend struct CursivePos; private: - inline bool apply (hb_apply_context_t *context) const + inline bool apply (hb_apply_context_t *c) const { TRACE_APPLY (); /* Now comes the messiest part of the whole OpenType @@ -950,12 +950,12 @@ struct CursivePosFormat1 Since horizontal advance widths or vertical advance heights can be used alone but not together, no ambiguity occurs. */ - struct hb_ot_layout_context_t::info_t::gpos_t *gpi = &context->layout->info.gpos; + struct hb_ot_layout_context_t::info_t::gpos_t *gpi = &c->layout->info.gpos; hb_codepoint_t last_pos = gpi->last; gpi->last = HB_OT_LAYOUT_GPOS_NO_LAST; /* We don't handle mark glyphs here. */ - if (context->property == HB_OT_LAYOUT_GLYPH_CLASS_MARK) + if (c->property == HB_OT_LAYOUT_GLYPH_CLASS_MARK) return false; unsigned int index = (this+coverage) (IN_CURGLYPH ()); @@ -968,14 +968,14 @@ struct CursivePosFormat1 goto end; hb_position_t entry_x, entry_y; - (this+record.entryAnchor).get_anchor (context->layout, IN_CURGLYPH (), &entry_x, &entry_y); + (this+record.entryAnchor).get_anchor (c->layout, IN_CURGLYPH (), &entry_x, &entry_y); /* TODO vertical */ - if (context->buffer->direction == HB_DIRECTION_RTL) + if (c->buffer->direction == HB_DIRECTION_RTL) { /* advance is absolute, not relative */ - POSITION (context->buffer->in_pos)->x_advance = entry_x - gpi->anchor_x; + POSITION (c->buffer->in_pos)->x_advance = entry_x - gpi->anchor_x; } else { @@ -983,32 +983,32 @@ struct CursivePosFormat1 POSITION (last_pos)->x_advance = gpi->anchor_x - entry_x; } - if (context->lookup_flag & LookupFlag::RightToLeft) + if (c->lookup_flag & LookupFlag::RightToLeft) { - POSITION (last_pos)->cursive_chain = last_pos - context->buffer->in_pos; + POSITION (last_pos)->cursive_chain = last_pos - c->buffer->in_pos; POSITION (last_pos)->y_offset = entry_y - gpi->anchor_y; } else { - POSITION (context->buffer->in_pos)->cursive_chain = context->buffer->in_pos - last_pos; - POSITION (context->buffer->in_pos)->y_offset = gpi->anchor_y - entry_y; + POSITION (c->buffer->in_pos)->cursive_chain = c->buffer->in_pos - last_pos; + POSITION (c->buffer->in_pos)->y_offset = gpi->anchor_y - entry_y; } end: if (record.exitAnchor) { - gpi->last = context->buffer->in_pos; - (this+record.exitAnchor).get_anchor (context->layout, IN_CURGLYPH (), &gpi->anchor_x, &gpi->anchor_y); + gpi->last = c->buffer->in_pos; + (this+record.exitAnchor).get_anchor (c->layout, IN_CURGLYPH (), &gpi->anchor_x, &gpi->anchor_y); } - context->buffer->in_pos++; + c->buffer->in_pos++; return true; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return coverage.sanitize (context, this) - && entryExitRecord.sanitize (context, this); + return coverage.sanitize (c, this) + && entryExitRecord.sanitize (c, this); } private: @@ -1028,20 +1028,20 @@ struct CursivePos friend struct PosLookupSubTable; private: - inline bool apply (hb_apply_context_t *context) const + inline bool apply (hb_apply_context_t *c) const { TRACE_APPLY (); switch (u.format) { - case 1: return u.format1.apply (context); + case 1: return u.format1.apply (c); default:return false; } } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (!u.format.sanitize (context)) return false; + if (!u.format.sanitize (c)) return false; switch (u.format) { - case 1: return u.format1.sanitize (context); + case 1: return u.format1.sanitize (c); default:return true; } } @@ -1064,7 +1064,7 @@ struct MarkBasePosFormat1 friend struct MarkBasePos; private: - inline bool apply (hb_apply_context_t *context) const + inline bool apply (hb_apply_context_t *c) const { TRACE_APPLY (); unsigned int mark_index = (this+markCoverage) (IN_CURGLYPH ()); @@ -1073,13 +1073,13 @@ struct MarkBasePosFormat1 /* now we search backwards for a non-mark glyph */ unsigned int property; - unsigned int j = context->buffer->in_pos; + unsigned int j = c->buffer->in_pos; do { if (unlikely (!j)) return false; j--; - } while (_hb_ot_layout_skip_mark (context->layout->face, IN_INFO (j), LookupFlag::IgnoreMarks, &property)); + } while (_hb_ot_layout_skip_mark (c->layout->face, IN_INFO (j), LookupFlag::IgnoreMarks, &property)); /* The following assertion is too strong, so we've disabled it. */ if (false && !(property & HB_OT_LAYOUT_GLYPH_CLASS_BASE_GLYPH)) @@ -1089,16 +1089,16 @@ struct MarkBasePosFormat1 if (base_index == NOT_COVERED) return false; - return (this+markArray).apply (context, mark_index, base_index, this+baseArray, classCount, j); + return (this+markArray).apply (c, mark_index, base_index, this+baseArray, classCount, j); } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return context->check_struct (this) - && markCoverage.sanitize (context, this) - && baseCoverage.sanitize (context, this) - && markArray.sanitize (context, this) - && baseArray.sanitize (context, this, (unsigned int) classCount); + return c->check_struct (this) + && markCoverage.sanitize (c, this) + && baseCoverage.sanitize (c, this) + && markArray.sanitize (c, this) + && baseArray.sanitize (c, this, (unsigned int) classCount); } private: @@ -1125,20 +1125,20 @@ struct MarkBasePos friend struct PosLookupSubTable; private: - inline bool apply (hb_apply_context_t *context) const + inline bool apply (hb_apply_context_t *c) const { TRACE_APPLY (); switch (u.format) { - case 1: return u.format1.apply (context); + case 1: return u.format1.apply (c); default:return false; } } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (!u.format.sanitize (context)) return false; + if (!u.format.sanitize (c)) return false; switch (u.format) { - case 1: return u.format1.sanitize (context); + case 1: return u.format1.sanitize (c); default:return true; } } @@ -1166,7 +1166,7 @@ struct MarkLigPosFormat1 friend struct MarkLigPos; private: - inline bool apply (hb_apply_context_t *context) const + inline bool apply (hb_apply_context_t *c) const { TRACE_APPLY (); unsigned int mark_index = (this+markCoverage) (IN_CURGLYPH ()); @@ -1175,13 +1175,13 @@ struct MarkLigPosFormat1 /* now we search backwards for a non-mark glyph */ unsigned int property; - unsigned int j = context->buffer->in_pos; + unsigned int j = c->buffer->in_pos; do { if (unlikely (!j)) return false; j--; - } while (_hb_ot_layout_skip_mark (context->layout->face, IN_INFO (j), LookupFlag::IgnoreMarks, &property)); + } while (_hb_ot_layout_skip_mark (c->layout->face, IN_INFO (j), LookupFlag::IgnoreMarks, &property)); /* The following assertion is too strong, so we've disabled it. */ if (false && !(property & HB_OT_LAYOUT_GLYPH_CLASS_LIGATURE)) @@ -1203,25 +1203,25 @@ struct MarkLigPosFormat1 * is identical to the ligature ID of the found ligature. If yes, we * can directly use the component index. If not, we attach the mark * glyph to the last component of the ligature. */ - if (IN_LIGID (j) && IN_LIGID (j) == IN_LIGID (context->buffer->in_pos) && IN_COMPONENT (context->buffer->in_pos)) + if (IN_LIGID (j) && IN_LIGID (j) == IN_LIGID (c->buffer->in_pos) && IN_COMPONENT (c->buffer->in_pos)) { - comp_index = IN_COMPONENT (context->buffer->in_pos) - 1; + comp_index = IN_COMPONENT (c->buffer->in_pos) - 1; if (comp_index >= comp_count) comp_index = comp_count - 1; } else comp_index = comp_count - 1; - return (this+markArray).apply (context, mark_index, comp_index, lig_attach, classCount, j); + return (this+markArray).apply (c, mark_index, comp_index, lig_attach, classCount, j); } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return context->check_struct (this) - && markCoverage.sanitize (context, this) - && ligatureCoverage.sanitize (context, this) - && markArray.sanitize (context, this) - && ligatureArray.sanitize (context, this, (unsigned int) classCount); + return c->check_struct (this) + && markCoverage.sanitize (c, this) + && ligatureCoverage.sanitize (c, this) + && markArray.sanitize (c, this) + && ligatureArray.sanitize (c, this, (unsigned int) classCount); } private: @@ -1249,20 +1249,20 @@ struct MarkLigPos friend struct PosLookupSubTable; private: - inline bool apply (hb_apply_context_t *context) const + inline bool apply (hb_apply_context_t *c) const { TRACE_APPLY (); switch (u.format) { - case 1: return u.format1.apply (context); + case 1: return u.format1.apply (c); default:return false; } } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (!u.format.sanitize (context)) return false; + if (!u.format.sanitize (c)) return false; switch (u.format) { - case 1: return u.format1.sanitize (context); + case 1: return u.format1.sanitize (c); default:return true; } } @@ -1285,7 +1285,7 @@ struct MarkMarkPosFormat1 friend struct MarkMarkPos; private: - inline bool apply (hb_apply_context_t *context) const + inline bool apply (hb_apply_context_t *c) const { TRACE_APPLY (); unsigned int mark1_index = (this+mark1Coverage) (IN_CURGLYPH ()); @@ -1294,13 +1294,13 @@ struct MarkMarkPosFormat1 /* now we search backwards for a suitable mark glyph until a non-mark glyph */ unsigned int property; - unsigned int j = context->buffer->in_pos; + unsigned int j = c->buffer->in_pos; do { if (unlikely (!j)) return false; j--; - } while (_hb_ot_layout_skip_mark (context->layout->face, IN_INFO (j), context->lookup_flag, &property)); + } while (_hb_ot_layout_skip_mark (c->layout->face, IN_INFO (j), c->lookup_flag, &property)); if (!(property & HB_OT_LAYOUT_GLYPH_CLASS_MARK)) return false; @@ -1308,24 +1308,24 @@ struct MarkMarkPosFormat1 /* Two marks match only if they belong to the same base, or same component * of the same ligature. That is, the component numbers must match, and * if those are non-zero, the ligid number should also match. */ - if ((IN_COMPONENT (j) != IN_COMPONENT (context->buffer->in_pos)) || - (IN_COMPONENT (j) && IN_LIGID (j) != IN_LIGID (context->buffer->in_pos))) + if ((IN_COMPONENT (j) != IN_COMPONENT (c->buffer->in_pos)) || + (IN_COMPONENT (j) && IN_LIGID (j) != IN_LIGID (c->buffer->in_pos))) return false; unsigned int mark2_index = (this+mark2Coverage) (IN_GLYPH (j)); if (mark2_index == NOT_COVERED) return false; - return (this+mark1Array).apply (context, mark1_index, mark2_index, this+mark2Array, classCount, j); + return (this+mark1Array).apply (c, mark1_index, mark2_index, this+mark2Array, classCount, j); } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return context->check_struct (this) - && mark1Coverage.sanitize (context, this) - && mark2Coverage.sanitize (context, this) - && mark1Array.sanitize (context, this) - && mark2Array.sanitize (context, this, (unsigned int) classCount); + return c->check_struct (this) + && mark1Coverage.sanitize (c, this) + && mark2Coverage.sanitize (c, this) + && mark1Array.sanitize (c, this) + && mark2Array.sanitize (c, this, (unsigned int) classCount); } private: @@ -1354,20 +1354,20 @@ struct MarkMarkPos friend struct PosLookupSubTable; private: - inline bool apply (hb_apply_context_t *context) const + inline bool apply (hb_apply_context_t *c) const { TRACE_APPLY (); switch (u.format) { - case 1: return u.format1.apply (context); + case 1: return u.format1.apply (c); default:return false; } } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (!u.format.sanitize (context)) return false; + if (!u.format.sanitize (c)) return false; switch (u.format) { - case 1: return u.format1.sanitize (context); + case 1: return u.format1.sanitize (c); default:return true; } } @@ -1380,17 +1380,17 @@ struct MarkMarkPos }; -static inline bool position_lookup (hb_apply_context_t *context, unsigned int lookup_index); +static inline bool position_lookup (hb_apply_context_t *c, unsigned int lookup_index); struct ContextPos : Context { friend struct PosLookupSubTable; private: - inline bool apply (hb_apply_context_t *context) const + inline bool apply (hb_apply_context_t *c) const { TRACE_APPLY (); - return Context::apply (context, position_lookup); + return Context::apply (c, position_lookup); } }; @@ -1399,10 +1399,10 @@ struct ChainContextPos : ChainContext friend struct PosLookupSubTable; private: - inline bool apply (hb_apply_context_t *context) const + inline bool apply (hb_apply_context_t *c) const { TRACE_APPLY (); - return ChainContext::apply (context, position_lookup); + return ChainContext::apply (c, position_lookup); } }; @@ -1419,9 +1419,9 @@ struct ExtensionPos : Extension return StructAtOffset (this, offset); } - inline bool apply (hb_apply_context_t *context) const; + inline bool apply (hb_apply_context_t *c) const; - inline bool sanitize (hb_sanitize_context_t *context); + inline bool sanitize (hb_sanitize_context_t *c); }; @@ -1447,35 +1447,35 @@ struct PosLookupSubTable Extension = 9 }; - inline bool apply (hb_apply_context_t *context, unsigned int lookup_type) const + inline bool apply (hb_apply_context_t *c, unsigned int lookup_type) const { TRACE_APPLY (); switch (lookup_type) { - case Single: return u.single.apply (context); - case Pair: return u.pair.apply (context); - case Cursive: return u.cursive.apply (context); - case MarkBase: return u.markBase.apply (context); - case MarkLig: return u.markLig.apply (context); - case MarkMark: return u.markMark.apply (context); - case Context: return u.context.apply (context); - case ChainContext: return u.chainContext.apply (context); - case Extension: return u.extension.apply (context); + case Single: return u.single.apply (c); + case Pair: return u.pair.apply (c); + case Cursive: return u.cursive.apply (c); + case MarkBase: return u.markBase.apply (c); + case MarkLig: return u.markLig.apply (c); + case MarkMark: return u.markMark.apply (c); + case Context: return u.c.apply (c); + case ChainContext: return u.chainContext.apply (c); + case Extension: return u.extension.apply (c); default:return false; } } - inline bool sanitize (hb_sanitize_context_t *context, unsigned int lookup_type) { + inline bool sanitize (hb_sanitize_context_t *c, unsigned int lookup_type) { TRACE_SANITIZE (); switch (lookup_type) { - case Single: return u.single.sanitize (context); - case Pair: return u.pair.sanitize (context); - case Cursive: return u.cursive.sanitize (context); - case MarkBase: return u.markBase.sanitize (context); - case MarkLig: return u.markLig.sanitize (context); - case MarkMark: return u.markMark.sanitize (context); - case Context: return u.context.sanitize (context); - case ChainContext: return u.chainContext.sanitize (context); - case Extension: return u.extension.sanitize (context); + case Single: return u.single.sanitize (c); + case Pair: return u.pair.sanitize (c); + case Cursive: return u.cursive.sanitize (c); + case MarkBase: return u.markBase.sanitize (c); + case MarkLig: return u.markLig.sanitize (c); + case MarkMark: return u.markMark.sanitize (c); + case Context: return u.c.sanitize (c); + case ChainContext: return u.chainContext.sanitize (c); + case Extension: return u.extension.sanitize (c); default:return true; } } @@ -1489,7 +1489,7 @@ struct PosLookupSubTable MarkBasePos markBase; MarkLigPos markLig; MarkMarkPos markMark; - ContextPos context; + ContextPos c; ChainContextPos chainContext; ExtensionPos extension; } u; @@ -1509,19 +1509,19 @@ struct PosLookup : Lookup unsigned int nesting_level_left) const { unsigned int lookup_type = get_type (); - hb_apply_context_t context[1] = {{0}}; + hb_apply_context_t c[1] = {{0}}; - context->layout = layout; - context->buffer = buffer; - context->context_length = context_length; - context->nesting_level_left = nesting_level_left; - context->lookup_flag = get_flag (); + c->layout = layout; + c->buffer = buffer; + c->context_length = context_length; + c->nesting_level_left = nesting_level_left; + c->lookup_flag = get_flag (); - if (!_hb_ot_layout_check_glyph_property (context->layout->face, IN_CURINFO (), context->lookup_flag, &context->property)) + if (!_hb_ot_layout_check_glyph_property (c->layout->face, IN_CURINFO (), c->lookup_flag, &c->property)) return false; for (unsigned int i = 0; i < get_subtable_count (); i++) - if (get_subtable (i).apply (context, lookup_type)) + if (get_subtable (i).apply (c, lookup_type)) return true; return false; @@ -1564,11 +1564,11 @@ struct PosLookup : Lookup return ret; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (unlikely (!Lookup::sanitize (context))) return false; + if (unlikely (!Lookup::sanitize (c))) return false; OffsetArrayOf &list = CastR > (subTable); - return list.sanitize (context, this, get_type ()); + return list.sanitize (c, this, get_type ()); } }; @@ -1591,11 +1591,11 @@ struct GPOS : GSUBGPOS hb_mask_t mask) const { return get_lookup (lookup_index).apply_string (layout, buffer, mask); } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (unlikely (!GSUBGPOS::sanitize (context))) return false; + if (unlikely (!GSUBGPOS::sanitize (c))) return false; OffsetTo &list = CastR > (lookupList); - return list.sanitize (context, this); + return list.sanitize (c, this); } public: DEFINE_SIZE_STATIC (10); @@ -1604,33 +1604,33 @@ struct GPOS : GSUBGPOS /* Out-of-class implementation for methods recursing */ -inline bool ExtensionPos::apply (hb_apply_context_t *context) const +inline bool ExtensionPos::apply (hb_apply_context_t *c) const { TRACE_APPLY (); - return get_subtable ().apply (context, get_type ()); + return get_subtable ().apply (c, get_type ()); } -inline bool ExtensionPos::sanitize (hb_sanitize_context_t *context) +inline bool ExtensionPos::sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (unlikely (!Extension::sanitize (context))) return false; + if (unlikely (!Extension::sanitize (c))) return false; unsigned int offset = get_offset (); if (unlikely (!offset)) return true; - return StructAtOffset (this, offset).sanitize (context, get_type ()); + return StructAtOffset (this, offset).sanitize (c, get_type ()); } -static inline bool position_lookup (hb_apply_context_t *context, unsigned int lookup_index) +static inline bool position_lookup (hb_apply_context_t *c, unsigned int lookup_index) { - const GPOS &gpos = *(context->layout->face->ot_layout.gpos); + const GPOS &gpos = *(c->layout->face->ot_layout.gpos); const PosLookup &l = gpos.get_lookup (lookup_index); - if (unlikely (context->nesting_level_left == 0)) + if (unlikely (c->nesting_level_left == 0)) return false; - if (unlikely (context->context_length < 1)) + if (unlikely (c->context_length < 1)) return false; - return l.apply_once (context->layout, context->buffer, context->context_length, context->nesting_level_left - 1); + return l.apply_once (c->layout, c->buffer, c->context_length, c->nesting_level_left - 1); } diff --git a/src/hb-ot-layout-gsub-private.hh b/src/hb-ot-layout-gsub-private.hh index 2b5919e..766bae9 100644 --- a/src/hb-ot-layout-gsub-private.hh +++ b/src/hb-ot-layout-gsub-private.hh @@ -31,7 +31,7 @@ #undef BUFFER -#define BUFFER context->buffer +#define BUFFER c->buffer struct SingleSubstFormat1 @@ -40,7 +40,7 @@ struct SingleSubstFormat1 private: - inline bool apply (hb_apply_context_t *context) const + inline bool apply (hb_apply_context_t *c) const { TRACE_APPLY (); hb_codepoint_t glyph_id = IN_CURGLYPH (); @@ -49,19 +49,19 @@ struct SingleSubstFormat1 return false; glyph_id += deltaGlyphID; - context->buffer->replace_glyph (glyph_id); + c->buffer->replace_glyph (glyph_id); /* We inherit the old glyph class to the substituted glyph */ - if (_hb_ot_layout_has_new_glyph_classes (context->layout->face)) - _hb_ot_layout_set_glyph_property (context->layout->face, glyph_id, context->property); + if (_hb_ot_layout_has_new_glyph_classes (c->layout->face)) + _hb_ot_layout_set_glyph_property (c->layout->face, glyph_id, c->property); return true; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return coverage.sanitize (context, this) - && deltaGlyphID.sanitize (context); + return coverage.sanitize (c, this) + && deltaGlyphID.sanitize (c); } private: @@ -81,7 +81,7 @@ struct SingleSubstFormat2 private: - inline bool apply (hb_apply_context_t *context) const + inline bool apply (hb_apply_context_t *c) const { TRACE_APPLY (); hb_codepoint_t glyph_id = IN_CURGLYPH (); @@ -93,19 +93,19 @@ struct SingleSubstFormat2 return false; glyph_id = substitute[index]; - context->buffer->replace_glyph (glyph_id); + c->buffer->replace_glyph (glyph_id); /* We inherit the old glyph class to the substituted glyph */ - if (_hb_ot_layout_has_new_glyph_classes (context->layout->face)) - _hb_ot_layout_set_glyph_property (context->layout->face, glyph_id, context->property); + if (_hb_ot_layout_has_new_glyph_classes (c->layout->face)) + _hb_ot_layout_set_glyph_property (c->layout->face, glyph_id, c->property); return true; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return coverage.sanitize (context, this) - && substitute.sanitize (context); + return coverage.sanitize (c, this) + && substitute.sanitize (c); } private: @@ -126,22 +126,22 @@ struct SingleSubst private: - inline bool apply (hb_apply_context_t *context) const + inline bool apply (hb_apply_context_t *c) const { TRACE_APPLY (); switch (u.format) { - case 1: return u.format1.apply (context); - case 2: return u.format2.apply (context); + case 1: return u.format1.apply (c); + case 2: return u.format2.apply (c); default:return false; } } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (!u.format.sanitize (context)) return false; + if (!u.format.sanitize (c)) return false; switch (u.format) { - case 1: return u.format1.sanitize (context); - case 2: return u.format2.sanitize (context); + case 1: return u.format1.sanitize (c); + case 2: return u.format2.sanitize (c); default:return true; } } @@ -160,35 +160,35 @@ struct Sequence friend struct MultipleSubstFormat1; private: - inline bool apply (hb_apply_context_t *context) const + inline bool apply (hb_apply_context_t *c) const { TRACE_APPLY (); if (unlikely (!substitute.len)) return false; - context->buffer->add_output_glyphs_be16 (1, + c->buffer->add_output_glyphs_be16 (1, substitute.len, (const uint16_t *) substitute.array, 0xFFFF, 0xFFFF); /* This is a guess only ... */ - if (_hb_ot_layout_has_new_glyph_classes (context->layout->face)) + if (_hb_ot_layout_has_new_glyph_classes (c->layout->face)) { - unsigned int property = context->property; + unsigned int property = c->property; if (property == HB_OT_LAYOUT_GLYPH_CLASS_LIGATURE) property = HB_OT_LAYOUT_GLYPH_CLASS_BASE_GLYPH; unsigned int count = substitute.len; for (unsigned int n = 0; n < count; n++) - _hb_ot_layout_set_glyph_property (context->layout->face, substitute[n], property); + _hb_ot_layout_set_glyph_property (c->layout->face, substitute[n], property); } return true; } public: - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return substitute.sanitize (context); + return substitute.sanitize (c); } private: @@ -204,7 +204,7 @@ struct MultipleSubstFormat1 private: - inline bool apply (hb_apply_context_t *context) const + inline bool apply (hb_apply_context_t *c) const { TRACE_APPLY (); @@ -212,13 +212,13 @@ struct MultipleSubstFormat1 if (likely (index == NOT_COVERED)) return false; - return (this+sequence[index]).apply (context); + return (this+sequence[index]).apply (c); } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return coverage.sanitize (context, this) - && sequence.sanitize (context, this); + return coverage.sanitize (c, this) + && sequence.sanitize (c, this); } private: @@ -239,20 +239,20 @@ struct MultipleSubst private: - inline bool apply (hb_apply_context_t *context) const + inline bool apply (hb_apply_context_t *c) const { TRACE_APPLY (); switch (u.format) { - case 1: return u.format1.apply (context); + case 1: return u.format1.apply (c); default:return false; } } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (!u.format.sanitize (context)) return false; + if (!u.format.sanitize (c)) return false; switch (u.format) { - case 1: return u.format1.sanitize (context); + case 1: return u.format1.sanitize (c); default:return true; } } @@ -274,7 +274,7 @@ struct AlternateSubstFormat1 private: - inline bool apply (hb_apply_context_t *context) const + inline bool apply (hb_apply_context_t *c) const { TRACE_APPLY (); hb_codepoint_t glyph_id = IN_CURGLYPH (); @@ -291,9 +291,9 @@ struct AlternateSubstFormat1 unsigned int alt_index = 0; /* XXX callback to user to choose alternate - if (context->layout->face->altfunc) - alt_index = (context->layout->face->altfunc)(context->layout->layout, context->buffer, - context->buffer->out_pos, glyph_id, + if (c->layout->face->altfunc) + alt_index = (c->layout->face->altfunc)(c->layout->layout, c->buffer, + c->buffer->out_pos, glyph_id, alt_set.len, alt_set.array); */ @@ -302,19 +302,19 @@ struct AlternateSubstFormat1 glyph_id = alt_set[alt_index]; - context->buffer->replace_glyph (glyph_id); + c->buffer->replace_glyph (glyph_id); /* We inherit the old glyph class to the substituted glyph */ - if (_hb_ot_layout_has_new_glyph_classes (context->layout->face)) - _hb_ot_layout_set_glyph_property (context->layout->face, glyph_id, context->property); + if (_hb_ot_layout_has_new_glyph_classes (c->layout->face)) + _hb_ot_layout_set_glyph_property (c->layout->face, glyph_id, c->property); return true; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return coverage.sanitize (context, this) - && alternateSet.sanitize (context, this); + return coverage.sanitize (c, this) + && alternateSet.sanitize (c, this); } private: @@ -335,20 +335,20 @@ struct AlternateSubst private: - inline bool apply (hb_apply_context_t *context) const + inline bool apply (hb_apply_context_t *c) const { TRACE_APPLY (); switch (u.format) { - case 1: return u.format1.apply (context); + case 1: return u.format1.apply (c); default:return false; } } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (!u.format.sanitize (context)) return false; + if (!u.format.sanitize (c)) return false; switch (u.format) { - case 1: return u.format1.sanitize (context); + case 1: return u.format1.sanitize (c); default:return true; } } @@ -366,19 +366,19 @@ struct Ligature friend struct LigatureSet; private: - inline bool apply (hb_apply_context_t *context, bool is_mark) const + inline bool apply (hb_apply_context_t *c, bool is_mark) const { TRACE_APPLY (); unsigned int i, j; unsigned int count = component.len; - unsigned int end = MIN (context->buffer->in_length, context->buffer->in_pos + context->context_length); - if (unlikely (context->buffer->in_pos + count > end)) + unsigned int end = MIN (c->buffer->in_length, c->buffer->in_pos + c->context_length); + if (unlikely (c->buffer->in_pos + count > end)) return false; - for (i = 1, j = context->buffer->in_pos + 1; i < count; i++, j++) + for (i = 1, j = c->buffer->in_pos + 1; i < count; i++, j++) { unsigned int property; - while (_hb_ot_layout_skip_mark (context->layout->face, IN_INFO (j), context->lookup_flag, &property)) + while (_hb_ot_layout_skip_mark (c->layout->face, IN_INFO (j), c->lookup_flag, &property)) { if (unlikely (j + count - i == end)) return false; @@ -392,23 +392,23 @@ struct Ligature return false; } /* This is just a guess ... */ - if (_hb_ot_layout_has_new_glyph_classes (context->layout->face)) - _hb_ot_layout_set_glyph_class (context->layout->face, ligGlyph, + if (_hb_ot_layout_has_new_glyph_classes (c->layout->face)) + _hb_ot_layout_set_glyph_class (c->layout->face, ligGlyph, is_mark ? HB_OT_LAYOUT_GLYPH_CLASS_MARK : HB_OT_LAYOUT_GLYPH_CLASS_LIGATURE); - if (j == context->buffer->in_pos + i) /* No input glyphs skipped */ + if (j == c->buffer->in_pos + i) /* No input glyphs skipped */ /* We don't use a new ligature ID if there are no skipped glyphs and the ligature already has an ID. */ - context->buffer->add_output_glyphs_be16 (i, + c->buffer->add_output_glyphs_be16 (i, 1, (const uint16_t *) &ligGlyph, 0, - IN_LIGID (context->buffer->in_pos) && !IN_COMPONENT (context->buffer->in_pos) ? - 0xFFFF : context->buffer->allocate_lig_id ()); + IN_LIGID (c->buffer->in_pos) && !IN_COMPONENT (c->buffer->in_pos) ? + 0xFFFF : c->buffer->allocate_lig_id ()); else { - unsigned int lig_id = context->buffer->allocate_lig_id (); - context->buffer->add_output_glyph (ligGlyph, 0xFFFF, lig_id); + unsigned int lig_id = c->buffer->allocate_lig_id (); + c->buffer->add_output_glyph (ligGlyph, 0xFFFF, lig_id); /* Now we must do a second loop to copy the skipped glyphs to `out' and assign component values to it. We start with the @@ -419,10 +419,10 @@ struct Ligature for ( i = 1; i < count; i++ ) { - while (_hb_ot_layout_skip_mark (context->layout->face, IN_CURINFO (), context->lookup_flag, NULL)) - context->buffer->add_output_glyph (IN_CURGLYPH (), i, lig_id); + while (_hb_ot_layout_skip_mark (c->layout->face, IN_CURINFO (), c->lookup_flag, NULL)) + c->buffer->add_output_glyph (IN_CURGLYPH (), i, lig_id); - (context->buffer->in_pos)++; + (c->buffer->in_pos)++; } } @@ -430,10 +430,10 @@ struct Ligature } public: - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return ligGlyph.sanitize (context) - && component.sanitize (context); + return ligGlyph.sanitize (c) + && component.sanitize (c); } private: @@ -451,14 +451,14 @@ struct LigatureSet friend struct LigatureSubstFormat1; private: - inline bool apply (hb_apply_context_t *context, bool is_mark) const + inline bool apply (hb_apply_context_t *c, bool is_mark) const { TRACE_APPLY (); unsigned int num_ligs = ligature.len; for (unsigned int i = 0; i < num_ligs; i++) { const Ligature &lig = this+ligature[i]; - if (lig.apply (context, is_mark)) + if (lig.apply (c, is_mark)) return true; } @@ -466,9 +466,9 @@ struct LigatureSet } public: - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return ligature.sanitize (context, this); + return ligature.sanitize (c, this); } private: @@ -484,25 +484,25 @@ struct LigatureSubstFormat1 friend struct LigatureSubst; private: - inline bool apply (hb_apply_context_t *context) const + inline bool apply (hb_apply_context_t *c) const { TRACE_APPLY (); hb_codepoint_t glyph_id = IN_CURGLYPH (); - bool first_is_mark = !!(context->property & HB_OT_LAYOUT_GLYPH_CLASS_MARK); + bool first_is_mark = !!(c->property & HB_OT_LAYOUT_GLYPH_CLASS_MARK); unsigned int index = (this+coverage) (glyph_id); if (likely (index == NOT_COVERED)) return false; const LigatureSet &lig_set = this+ligatureSet[index]; - return lig_set.apply (context, first_is_mark); + return lig_set.apply (c, first_is_mark); } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return coverage.sanitize (context, this) - && ligatureSet.sanitize (context, this); + return coverage.sanitize (c, this) + && ligatureSet.sanitize (c, this); } private: @@ -522,20 +522,20 @@ struct LigatureSubst friend struct SubstLookupSubTable; private: - inline bool apply (hb_apply_context_t *context) const + inline bool apply (hb_apply_context_t *c) const { TRACE_APPLY (); switch (u.format) { - case 1: return u.format1.apply (context); + case 1: return u.format1.apply (c); default:return false; } } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (!u.format.sanitize (context)) return false; + if (!u.format.sanitize (c)) return false; switch (u.format) { - case 1: return u.format1.sanitize (context); + case 1: return u.format1.sanitize (c); default:return true; } } @@ -549,17 +549,17 @@ struct LigatureSubst -static inline bool substitute_lookup (hb_apply_context_t *context, unsigned int lookup_index); +static inline bool substitute_lookup (hb_apply_context_t *c, unsigned int lookup_index); struct ContextSubst : Context { friend struct SubstLookupSubTable; private: - inline bool apply (hb_apply_context_t *context) const + inline bool apply (hb_apply_context_t *c) const { TRACE_APPLY (); - return Context::apply (context, substitute_lookup); + return Context::apply (c, substitute_lookup); } }; @@ -568,10 +568,10 @@ struct ChainContextSubst : ChainContext friend struct SubstLookupSubTable; private: - inline bool apply (hb_apply_context_t *context) const + inline bool apply (hb_apply_context_t *c) const { TRACE_APPLY (); - return ChainContext::apply (context, substitute_lookup); + return ChainContext::apply (c, substitute_lookup); } }; @@ -589,9 +589,9 @@ struct ExtensionSubst : Extension return StructAtOffset (this, offset); } - inline bool apply (hb_apply_context_t *context) const; + inline bool apply (hb_apply_context_t *c) const; - inline bool sanitize (hb_sanitize_context_t *context); + inline bool sanitize (hb_sanitize_context_t *c); inline bool is_reverse (void) const; }; @@ -602,10 +602,10 @@ struct ReverseChainSingleSubstFormat1 friend struct ReverseChainSingleSubst; private: - inline bool apply (hb_apply_context_t *context) const + inline bool apply (hb_apply_context_t *c) const { TRACE_APPLY (); - if (unlikely (context->context_length != NO_CONTEXT)) + if (unlikely (c->context_length != NO_CONTEXT)) return false; /* No chaining to this type */ unsigned int index = (this+coverage) (IN_CURGLYPH ()); @@ -615,32 +615,32 @@ struct ReverseChainSingleSubstFormat1 const OffsetArrayOf &lookahead = StructAfter > (backtrack); const ArrayOf &substitute = StructAfter > (lookahead); - if (match_backtrack (context, + if (match_backtrack (c, backtrack.len, (USHORT *) backtrack.array, match_coverage, this) && - match_lookahead (context, + match_lookahead (c, lookahead.len, (USHORT *) lookahead.array, match_coverage, this, 1)) { IN_CURGLYPH () = substitute[index]; - context->buffer->in_pos--; /* Reverse! */ + c->buffer->in_pos--; /* Reverse! */ return true; } return false; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (!(coverage.sanitize (context, this) - && backtrack.sanitize (context, this))) + if (!(coverage.sanitize (c, this) + && backtrack.sanitize (c, this))) return false; OffsetArrayOf &lookahead = StructAfter > (backtrack); - if (!lookahead.sanitize (context, this)) + if (!lookahead.sanitize (c, this)) return false; ArrayOf &substitute = StructAfter > (lookahead); - return substitute.sanitize (context); + return substitute.sanitize (c); } private: @@ -668,20 +668,20 @@ struct ReverseChainSingleSubst friend struct SubstLookupSubTable; private: - inline bool apply (hb_apply_context_t *context) const + inline bool apply (hb_apply_context_t *c) const { TRACE_APPLY (); switch (u.format) { - case 1: return u.format1.apply (context); + case 1: return u.format1.apply (c); default:return false; } } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (!u.format.sanitize (context)) return false; + if (!u.format.sanitize (c)) return false; switch (u.format) { - case 1: return u.format1.sanitize (context); + case 1: return u.format1.sanitize (c); default:return true; } } @@ -714,33 +714,33 @@ struct SubstLookupSubTable ReverseChainSingle = 8 }; - inline bool apply (hb_apply_context_t *context, unsigned int lookup_type) const + inline bool apply (hb_apply_context_t *c, unsigned int lookup_type) const { TRACE_APPLY (); switch (lookup_type) { - case Single: return u.single.apply (context); - case Multiple: return u.multiple.apply (context); - case Alternate: return u.alternate.apply (context); - case Ligature: return u.ligature.apply (context); - case Context: return u.context.apply (context); - case ChainContext: return u.chainContext.apply (context); - case Extension: return u.extension.apply (context); - case ReverseChainSingle: return u.reverseChainContextSingle.apply (context); + case Single: return u.single.apply (c); + case Multiple: return u.multiple.apply (c); + case Alternate: return u.alternate.apply (c); + case Ligature: return u.ligature.apply (c); + case Context: return u.c.apply (c); + case ChainContext: return u.chainContext.apply (c); + case Extension: return u.extension.apply (c); + case ReverseChainSingle: return u.reverseChainContextSingle.apply (c); default:return false; } } - inline bool sanitize (hb_sanitize_context_t *context, unsigned int lookup_type) { + inline bool sanitize (hb_sanitize_context_t *c, unsigned int lookup_type) { TRACE_SANITIZE (); switch (lookup_type) { - case Single: return u.single.sanitize (context); - case Multiple: return u.multiple.sanitize (context); - case Alternate: return u.alternate.sanitize (context); - case Ligature: return u.ligature.sanitize (context); - case Context: return u.context.sanitize (context); - case ChainContext: return u.chainContext.sanitize (context); - case Extension: return u.extension.sanitize (context); - case ReverseChainSingle: return u.reverseChainContextSingle.sanitize (context); + case Single: return u.single.sanitize (c); + case Multiple: return u.multiple.sanitize (c); + case Alternate: return u.alternate.sanitize (c); + case Ligature: return u.ligature.sanitize (c); + case Context: return u.c.sanitize (c); + case ChainContext: return u.chainContext.sanitize (c); + case Extension: return u.extension.sanitize (c); + case ReverseChainSingle: return u.reverseChainContextSingle.sanitize (c); default:return true; } } @@ -752,7 +752,7 @@ struct SubstLookupSubTable MultipleSubst multiple; AlternateSubst alternate; LigatureSubst ligature; - ContextSubst context; + ContextSubst c; ChainContextSubst chainContext; ExtensionSubst extension; ReverseChainSingleSubst reverseChainContextSingle; @@ -785,15 +785,15 @@ struct SubstLookup : Lookup unsigned int nesting_level_left) const { unsigned int lookup_type = get_type (); - hb_apply_context_t context[1] = {{0}}; + hb_apply_context_t c[1] = {{0}}; - context->layout = layout; - context->buffer = buffer; - context->context_length = context_length; - context->nesting_level_left = nesting_level_left; - context->lookup_flag = get_flag (); + c->layout = layout; + c->buffer = buffer; + c->context_length = context_length; + c->nesting_level_left = nesting_level_left; + c->lookup_flag = get_flag (); - if (!_hb_ot_layout_check_glyph_property (context->layout->face, IN_CURINFO (), context->lookup_flag, &context->property)) + if (!_hb_ot_layout_check_glyph_property (c->layout->face, IN_CURINFO (), c->lookup_flag, &c->property)) return false; if (unlikely (lookup_type == SubstLookupSubTable::Extension)) @@ -812,7 +812,7 @@ struct SubstLookup : Lookup unsigned int count = get_subtable_count (); for (unsigned int i = 0; i < count; i++) - if (get_subtable (i).apply (context, lookup_type)) + if (get_subtable (i).apply (c, lookup_type)) return true; return false; @@ -865,11 +865,11 @@ struct SubstLookup : Lookup return ret; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (unlikely (!Lookup::sanitize (context))) return false; + if (unlikely (!Lookup::sanitize (c))) return false; OffsetArrayOf &list = CastR > (subTable); - return list.sanitize (context, this, get_type ()); + return list.sanitize (c, this, get_type ()); } }; @@ -892,11 +892,11 @@ struct GSUB : GSUBGPOS hb_mask_t mask) const { return get_lookup (lookup_index).apply_string (layout, buffer, mask); } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (unlikely (!GSUBGPOS::sanitize (context))) return false; + if (unlikely (!GSUBGPOS::sanitize (c))) return false; OffsetTo &list = CastR > (lookupList); - return list.sanitize (context, this); + return list.sanitize (c, this); } public: DEFINE_SIZE_STATIC (10); @@ -905,19 +905,19 @@ struct GSUB : GSUBGPOS /* Out-of-class implementation for methods recursing */ -inline bool ExtensionSubst::apply (hb_apply_context_t *context) const +inline bool ExtensionSubst::apply (hb_apply_context_t *c) const { TRACE_APPLY (); - return get_subtable ().apply (context, get_type ()); + return get_subtable ().apply (c, get_type ()); } -inline bool ExtensionSubst::sanitize (hb_sanitize_context_t *context) +inline bool ExtensionSubst::sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (unlikely (!Extension::sanitize (context))) return false; + if (unlikely (!Extension::sanitize (c))) return false; unsigned int offset = get_offset (); if (unlikely (!offset)) return true; - return StructAtOffset (this, offset).sanitize (context, get_type ()); + return StructAtOffset (this, offset).sanitize (c, get_type ()); } inline bool ExtensionSubst::is_reverse (void) const @@ -928,18 +928,18 @@ inline bool ExtensionSubst::is_reverse (void) const return SubstLookup::lookup_type_is_reverse (type); } -static inline bool substitute_lookup (hb_apply_context_t *context, unsigned int lookup_index) +static inline bool substitute_lookup (hb_apply_context_t *c, unsigned int lookup_index) { - const GSUB &gsub = *(context->layout->face->ot_layout.gsub); + const GSUB &gsub = *(c->layout->face->ot_layout.gsub); const SubstLookup &l = gsub.get_lookup (lookup_index); - if (unlikely (context->nesting_level_left == 0)) + if (unlikely (c->nesting_level_left == 0)) return false; - if (unlikely (context->context_length < 1)) + if (unlikely (c->context_length < 1)) return false; - return l.apply_once (context->layout, context->buffer, context->context_length, context->nesting_level_left - 1); + return l.apply_once (c->layout, c->buffer, c->context_length, c->nesting_level_left - 1); } diff --git a/src/hb-ot-layout-gsubgpos-private.hh b/src/hb-ot-layout-gsubgpos-private.hh index cefde13..71c2975 100644 --- a/src/hb-ot-layout-gsubgpos-private.hh +++ b/src/hb-ot-layout-gsubgpos-private.hh @@ -36,7 +36,7 @@ #endif #define TRACE_APPLY() \ - hb_trace_t trace (&context->debug_depth, "APPLY", HB_FUNC, this); \ + hb_trace_t trace (&c->debug_depth, "APPLY", HB_FUNC, this); \ struct hb_apply_context_t @@ -54,11 +54,11 @@ struct hb_apply_context_t #undef BUFFER -#define BUFFER context->buffer +#define BUFFER c->buffer 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 *context, unsigned int lookup_index); +typedef bool (*apply_lookup_func_t) (hb_apply_context_t *c, unsigned int lookup_index); struct ContextFuncs { @@ -85,7 +85,7 @@ static inline bool match_coverage (hb_codepoint_t glyph_id, const USHORT &value, } -static inline bool match_input (hb_apply_context_t *context, +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, @@ -93,13 +93,13 @@ static inline bool match_input (hb_apply_context_t *context, unsigned int *context_length_out) { unsigned int i, j; - unsigned int end = MIN (context->buffer->in_length, context->buffer->in_pos + context->context_length); - if (unlikely (context->buffer->in_pos + count > end)) + unsigned int end = MIN (c->buffer->in_length, c->buffer->in_pos + c->context_length); + if (unlikely (c->buffer->in_pos + count > end)) return false; - for (i = 1, j = context->buffer->in_pos + 1; i < count; i++, j++) + for (i = 1, j = c->buffer->in_pos + 1; i < count; i++, j++) { - while (_hb_ot_layout_skip_mark (context->layout->face, IN_INFO (j), context->lookup_flag, NULL)) + while (_hb_ot_layout_skip_mark (c->layout->face, IN_INFO (j), c->lookup_flag, NULL)) { if (unlikely (j + count - i == end)) return false; @@ -110,23 +110,23 @@ static inline bool match_input (hb_apply_context_t *context, return false; } - *context_length_out = j - context->buffer->in_pos; + *context_length_out = j - c->buffer->in_pos; return true; } -static inline bool match_backtrack (hb_apply_context_t *context, +static inline bool match_backtrack (hb_apply_context_t *c, unsigned int count, const USHORT backtrack[], match_func_t match_func, const void *match_data) { - if (unlikely (context->buffer->out_pos < count)) + if (unlikely (c->buffer->out_pos < count)) return false; - for (unsigned int i = 0, j = context->buffer->out_pos - 1; i < count; i++, j--) + for (unsigned int i = 0, j = c->buffer->out_pos - 1; i < count; i++, j--) { - while (_hb_ot_layout_skip_mark (context->layout->face, OUT_INFO (j), context->lookup_flag, NULL)) + while (_hb_ot_layout_skip_mark (c->layout->face, OUT_INFO (j), c->lookup_flag, NULL)) { if (unlikely (j + 1 == count - i)) return false; @@ -140,7 +140,7 @@ static inline bool match_backtrack (hb_apply_context_t *context, return true; } -static inline bool match_lookahead (hb_apply_context_t *context, +static inline bool match_lookahead (hb_apply_context_t *c, unsigned int count, const USHORT lookahead[], match_func_t match_func, @@ -148,13 +148,13 @@ static inline bool match_lookahead (hb_apply_context_t *context, unsigned int offset) { unsigned int i, j; - unsigned int end = MIN (context->buffer->in_length, context->buffer->in_pos + context->context_length); - if (unlikely (context->buffer->in_pos + offset + count > end)) + unsigned int end = MIN (c->buffer->in_length, c->buffer->in_pos + c->context_length); + if (unlikely (c->buffer->in_pos + offset + count > end)) return false; - for (i = 0, j = context->buffer->in_pos + offset; i < count; i++, j++) + for (i = 0, j = c->buffer->in_pos + offset; i < count; i++, j++) { - while (_hb_ot_layout_skip_mark (context->layout->face, OUT_INFO (j), context->lookup_flag, NULL)) + while (_hb_ot_layout_skip_mark (c->layout->face, OUT_INFO (j), c->lookup_flag, NULL)) { if (unlikely (j + count - i == end)) return false; @@ -171,9 +171,9 @@ static inline bool match_lookahead (hb_apply_context_t *context, struct LookupRecord { - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return context->check_struct (this); + return c->check_struct (this); } USHORT sequenceIndex; /* Index into current glyph @@ -184,14 +184,14 @@ struct LookupRecord DEFINE_SIZE_STATIC (4); }; -static inline bool apply_lookup (hb_apply_context_t *context, +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 (context->buffer->in_length, context->buffer->in_pos + context->context_length); - if (unlikely (context->buffer->in_pos + count > end)) + unsigned int end = MIN (c->buffer->in_length, c->buffer->in_pos + c->context_length); + if (unlikely (c->buffer->in_pos + count > end)) return false; /* TODO We don't support lookupRecord arrays that are not increasing: @@ -203,26 +203,26 @@ static inline bool apply_lookup (hb_apply_context_t *context, */ for (unsigned int i = 0; i < count; /* NOP */) { - while (_hb_ot_layout_skip_mark (context->layout->face, IN_CURINFO (), context->lookup_flag, NULL)) + while (_hb_ot_layout_skip_mark (c->layout->face, IN_CURINFO (), c->lookup_flag, NULL)) { - if (unlikely (context->buffer->in_pos == end)) + if (unlikely (c->buffer->in_pos == end)) return true; /* No lookup applied for this index */ - context->buffer->next_glyph (); + c->buffer->next_glyph (); } if (lookupCount && i == lookupRecord->sequenceIndex) { - unsigned int old_pos = context->buffer->in_pos; + unsigned int old_pos = c->buffer->in_pos; /* Apply a lookup */ - bool done = apply_func (context, lookupRecord->lookupListIndex); + bool done = apply_func (c, lookupRecord->lookupListIndex); lookupRecord++; lookupCount--; /* Err, this is wrong if the lookup jumped over some glyphs */ - i += context->buffer->in_pos - old_pos; - if (unlikely (context->buffer->in_pos == end)) + i += c->buffer->in_pos - old_pos; + if (unlikely (c->buffer->in_pos == end)) return true; if (!done) @@ -232,7 +232,7 @@ static inline bool apply_lookup (hb_apply_context_t *context, { not_applied: /* No lookup applied for this index */ - context->buffer->next_glyph (); + c->buffer->next_glyph (); i++; } } @@ -249,15 +249,15 @@ struct ContextLookupContext const void *match_data; }; -static inline bool context_lookup (hb_apply_context_t *context, +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) { - hb_apply_context_t new_context = *context; - return match_input (context, + hb_apply_context_t new_context = *c; + return match_input (c, inputCount, input, lookup_context.funcs.match, lookup_context.match_data, &new_context.context_length) @@ -272,22 +272,22 @@ struct Rule friend struct RuleSet; private: - inline bool apply (hb_apply_context_t *context, 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].static_size * (inputCount ? inputCount - 1 : 0)); - return context_lookup (context, + return context_lookup (c, inputCount, input, lookupCount, lookupRecord, lookup_context); } public: - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return inputCount.sanitize (context) - && lookupCount.sanitize (context) - && context->check_range (input, + return inputCount.sanitize (c) + && lookupCount.sanitize (c) + && c->check_range (input, input[0].static_size * inputCount + lookupRecordX[0].static_size * lookupCount); } @@ -307,22 +307,22 @@ struct Rule struct RuleSet { - inline bool apply (hb_apply_context_t *context, 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 (context, lookup_context)) + if ((this+rule[i]).apply (c, lookup_context)) return true; } return false; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return rule.sanitize (context, this); + return rule.sanitize (c, this); } private: @@ -339,7 +339,7 @@ struct ContextFormat1 friend struct Context; private: - inline bool apply (hb_apply_context_t *context, 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 ()); @@ -351,13 +351,13 @@ struct ContextFormat1 {match_glyph, apply_func}, NULL }; - return rule_set.apply (context, lookup_context); + return rule_set.apply (c, lookup_context); } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return coverage.sanitize (context, this) - && ruleSet.sanitize (context, this); + return coverage.sanitize (c, this) + && ruleSet.sanitize (c, this); } private: @@ -378,7 +378,7 @@ struct ContextFormat2 friend struct Context; private: - inline bool apply (hb_apply_context_t *context, 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 ()); @@ -395,14 +395,14 @@ struct ContextFormat2 {match_class, apply_func}, &class_def }; - return rule_set.apply (context, lookup_context); + return rule_set.apply (c, lookup_context); } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return coverage.sanitize (context, this) - && classDef.sanitize (context, this) - && ruleSet.sanitize (context, this); + return coverage.sanitize (c, this) + && classDef.sanitize (c, this) + && ruleSet.sanitize (c, this); } private: @@ -426,7 +426,7 @@ struct ContextFormat3 friend struct Context; private: - inline bool apply (hb_apply_context_t *context, 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 ()); @@ -438,21 +438,21 @@ struct ContextFormat3 {match_coverage, apply_func}, this }; - return context_lookup (context, + return context_lookup (c, glyphCount, (const USHORT *) (coverage + 1), lookupCount, lookupRecord, lookup_context); } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (!context->check_struct (this)) return false; + if (!c->check_struct (this)) return false; unsigned int count = glyphCount; - if (!context->check_array (coverage, coverage[0].static_size, count)) return false; + if (!c->check_array (coverage, coverage[0].static_size, count)) return false; for (unsigned int i = 0; i < count; i++) - if (!coverage[i].sanitize (context, this)) return false; + if (!coverage[i].sanitize (c, this)) return false; LookupRecord *lookupRecord = &StructAtOffset (coverage, coverage[0].static_size * count); - return context->check_array (lookupRecord, lookupRecord[0].static_size, lookupCount); + return c->check_array (lookupRecord, lookupRecord[0].static_size, lookupCount); } private: @@ -472,24 +472,24 @@ struct ContextFormat3 struct Context { protected: - inline bool apply (hb_apply_context_t *context, 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 (context, apply_func); - case 2: return u.format2.apply (context, apply_func); - case 3: return u.format3.apply (context, 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 (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (!u.format.sanitize (context)) return false; + if (!u.format.sanitize (c)) return false; switch (u.format) { - case 1: return u.format1.sanitize (context); - case 2: return u.format2.sanitize (context); - case 3: return u.format3.sanitize (context); + case 1: return u.format1.sanitize (c); + case 2: return u.format2.sanitize (c); + case 3: return u.format3.sanitize (c); default:return true; } } @@ -512,7 +512,7 @@ struct ChainContextLookupContext const void *match_data[3]; }; -static inline bool chain_context_lookup (hb_apply_context_t *context, +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) */ @@ -524,20 +524,20 @@ static inline bool chain_context_lookup (hb_apply_context_t *context, ChainContextLookupContext &lookup_context) { /* First guess */ - if (unlikely (context->buffer->out_pos < backtrackCount || - context->buffer->in_pos + inputCount + lookaheadCount > context->buffer->in_length || - inputCount + lookaheadCount > context->context_length)) + if (unlikely (c->buffer->out_pos < backtrackCount || + c->buffer->in_pos + inputCount + lookaheadCount > c->buffer->in_length || + inputCount + lookaheadCount > c->context_length)) return false; - hb_apply_context_t new_context = *context; - return match_backtrack (context, + hb_apply_context_t new_context = *c; + return match_backtrack (c, backtrackCount, backtrack, lookup_context.funcs.match, lookup_context.match_data[0]) - && match_input (context, + && match_input (c, inputCount, input, lookup_context.funcs.match, lookup_context.match_data[1], &new_context.context_length) - && match_lookahead (context, + && match_lookahead (c, lookaheadCount, lookahead, lookup_context.funcs.match, lookup_context.match_data[2], new_context.context_length) @@ -552,13 +552,13 @@ struct ChainRule friend struct ChainRuleSet; private: - inline bool apply (hb_apply_context_t *context, 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 (context, + return chain_context_lookup (c, backtrack.len, backtrack.array, input.len, input.array, lookahead.len, lookahead.array, @@ -568,15 +568,15 @@ struct ChainRule } public: - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (!backtrack.sanitize (context)) return false; + if (!backtrack.sanitize (c)) return false; HeadlessArrayOf &input = StructAfter > (backtrack); - if (!input.sanitize (context)) return false; + if (!input.sanitize (c)) return false; ArrayOf &lookahead = StructAfter > (input); - if (!lookahead.sanitize (context)) return false; + if (!lookahead.sanitize (c)) return false; ArrayOf &lookup = StructAfter > (lookahead); - return lookup.sanitize (context); + return lookup.sanitize (c); } private: @@ -599,22 +599,22 @@ struct ChainRule struct ChainRuleSet { - inline bool apply (hb_apply_context_t *context, 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 (context, lookup_context)) + if ((this+rule[i]).apply (c, lookup_context)) return true; } return false; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return rule.sanitize (context, this); + return rule.sanitize (c, this); } private: @@ -630,7 +630,7 @@ struct ChainContextFormat1 friend struct ChainContext; private: - inline bool apply (hb_apply_context_t *context, 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 ()); @@ -642,13 +642,13 @@ struct ChainContextFormat1 {match_glyph, apply_func}, {NULL, NULL, NULL} }; - return rule_set.apply (context, lookup_context); + return rule_set.apply (c, lookup_context); } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return coverage.sanitize (context, this) - && ruleSet.sanitize (context, this); + return coverage.sanitize (c, this) + && ruleSet.sanitize (c, this); } private: @@ -668,7 +668,7 @@ struct ChainContextFormat2 friend struct ChainContext; private: - inline bool apply (hb_apply_context_t *context, 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 ()); @@ -690,16 +690,16 @@ struct ChainContextFormat2 &input_class_def, &lookahead_class_def} }; - return rule_set.apply (context, lookup_context); + return rule_set.apply (c, lookup_context); } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return coverage.sanitize (context, this) - && backtrackClassDef.sanitize (context, this) - && inputClassDef.sanitize (context, this) - && lookaheadClassDef.sanitize (context, this) - && ruleSet.sanitize (context, this); + return coverage.sanitize (c, this) + && backtrackClassDef.sanitize (c, this) + && inputClassDef.sanitize (c, this) + && lookaheadClassDef.sanitize (c, this) + && ruleSet.sanitize (c, this); } private: @@ -732,7 +732,7 @@ struct ChainContextFormat3 private: - inline bool apply (hb_apply_context_t *context, 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); @@ -747,7 +747,7 @@ struct ChainContextFormat3 {match_coverage, apply_func}, {this, this, this} }; - return chain_context_lookup (context, + return chain_context_lookup (c, backtrack.len, (const USHORT *) backtrack.array, input.len, (const USHORT *) input.array + 1, lookahead.len, (const USHORT *) lookahead.array, @@ -756,15 +756,15 @@ struct ChainContextFormat3 return false; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (!backtrack.sanitize (context, this)) return false; + if (!backtrack.sanitize (c, this)) return false; OffsetArrayOf &input = StructAfter > (backtrack); - if (!input.sanitize (context, this)) return false; + if (!input.sanitize (c, this)) return false; OffsetArrayOf &lookahead = StructAfter > (input); - if (!lookahead.sanitize (context, this)) return false; + if (!lookahead.sanitize (c, this)) return false; ArrayOf &lookup = StructAfter > (lookahead); - return lookup.sanitize (context); + return lookup.sanitize (c); } private: @@ -791,24 +791,24 @@ struct ChainContextFormat3 struct ChainContext { protected: - inline bool apply (hb_apply_context_t *context, 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 (context, apply_func); - case 2: return u.format2.apply (context, apply_func); - case 3: return u.format3.apply (context, 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 (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (!u.format.sanitize (context)) return false; + if (!u.format.sanitize (c)) return false; switch (u.format) { - case 1: return u.format1.sanitize (context); - case 2: return u.format2.sanitize (context); - case 3: return u.format3.sanitize (context); + case 1: return u.format1.sanitize (c); + case 2: return u.format2.sanitize (c); + case 3: return u.format3.sanitize (c); default:return true; } } @@ -831,9 +831,9 @@ struct ExtensionFormat1 inline unsigned int get_type (void) const { return extensionLookupType; } inline unsigned int get_offset (void) const { return extensionOffset; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return context->check_struct (this); + return c->check_struct (this); } private: @@ -864,11 +864,11 @@ struct Extension } } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - if (!u.format.sanitize (context)) return false; + if (!u.format.sanitize (c)) return false; switch (u.format) { - case 1: return u.format1.sanitize (context); + case 1: return u.format1.sanitize (c); default:return true; } } @@ -921,12 +921,12 @@ struct GSUBGPOS inline const Lookup& get_lookup (unsigned int i) const { return (this+lookupList)[i]; } - inline bool sanitize (hb_sanitize_context_t *context) { + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); - return version.sanitize (context) && likely (version.major == 1) - && scriptList.sanitize (context, this) - && featureList.sanitize (context, this) - && lookupList.sanitize (context, this); + return version.sanitize (c) && likely (version.major == 1) + && scriptList.sanitize (c, this) + && featureList.sanitize (c, this) + && lookupList.sanitize (c, this); } protected: diff --git a/src/hb-ot-layout.cc b/src/hb-ot-layout.cc index 63186a3..2965384 100644 --- a/src/hb-ot-layout.cc +++ b/src/hb-ot-layout.cc @@ -320,10 +320,10 @@ hb_ot_layout_get_lig_carets (hb_font_t *font, unsigned int *caret_count /* IN/OUT */, int *caret_array /* OUT */) { - hb_ot_layout_context_t context; - context.font = font; - context.face = face; - return _get_gdef (face).get_lig_carets (&context, glyph, start_offset, caret_count, caret_array); + hb_ot_layout_context_t c; + c.font = font; + c.face = face; + return _get_gdef (face).get_lig_carets (&c, glyph, start_offset, caret_count, caret_array); } /* @@ -564,10 +564,10 @@ hb_ot_layout_substitute_lookup (hb_face_t *face, unsigned int lookup_index, hb_mask_t mask) { - hb_ot_layout_context_t context; - context.font = NULL; - context.face = face; - return _get_gsub (face).substitute_lookup (&context, buffer, lookup_index, mask); + hb_ot_layout_context_t c; + c.font = NULL; + c.face = face; + return _get_gsub (face).substitute_lookup (&c, buffer, lookup_index, mask); } @@ -588,10 +588,10 @@ hb_ot_layout_position_lookup (hb_font_t *font, unsigned int lookup_index, hb_mask_t mask) { - hb_ot_layout_context_t context; - context.font = font; - context.face = face; - return _get_gpos (face).position_lookup (&context, buffer, lookup_index, mask); + hb_ot_layout_context_t c; + c.font = font; + c.face = face; + return _get_gpos (face).position_lookup (&c, buffer, lookup_index, mask); } void -- 2.7.4