From 39840474afd2cda9ff576c08aff9c87095496c27 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Wed, 5 May 2010 00:23:19 -0400 Subject: [PATCH] Remove SANITIZE_ARG_DEF and SANITIZE_ARG --- src/hb-open-file-private.hh | 16 ++--- src/hb-open-type-private.hh | 59 +++++++-------- src/hb-ot-layout-common-private.hh | 42 +++++------ src/hb-ot-layout-gdef-private.hh | 28 ++++---- src/hb-ot-layout-gpos-private.hh | 136 +++++++++++++++++------------------ src/hb-ot-layout-gsub-private.hh | 72 +++++++++---------- src/hb-ot-layout-gsubgpos-private.hh | 46 ++++++------ 7 files changed, 197 insertions(+), 202 deletions(-) diff --git a/src/hb-open-file-private.hh b/src/hb-open-file-private.hh index 547cef0..ed9369b 100644 --- a/src/hb-open-file-private.hh +++ b/src/hb-open-file-private.hh @@ -49,7 +49,7 @@ typedef struct TableDirectory { static inline unsigned int get_size () { return sizeof (TableDirectory); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_SELF (); } @@ -98,7 +98,7 @@ typedef struct OffsetTable } public: - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_SELF () && SANITIZE_ARRAY (tableDir, TableDirectory::get_size (), numTables); } @@ -124,7 +124,7 @@ 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 (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_WITH_BASE (this, table); } @@ -162,12 +162,12 @@ struct TTCHeader } } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); if (!SANITIZE (u.header.version)) return false; switch (u.header.version) { case 2: /* version 2 is compatible with version 1 */ - case 1: return u.version1->sanitize (SANITIZE_ARG); + case 1: return u.version1->sanitize (context); default:return true; } } @@ -224,15 +224,15 @@ struct OpenTypeFontFile } } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); if (!SANITIZE (u.tag)) return false; switch (u.tag) { case CFFTag: /* All the non-collection tags */ case TrueTag: case Typ1Tag: - case TrueTypeTag: return u.fontFace->sanitize (SANITIZE_ARG); - case TTCTag: return u.ttcHeader->sanitize (SANITIZE_ARG); + case TrueTypeTag: return u.fontFace->sanitize (context); + case TTCTag: return u.ttcHeader->sanitize (context); default: return true; } } diff --git a/src/hb-open-type-private.hh b/src/hb-open-type-private.hh index 2a0dccb..9254e44 100644 --- a/src/hb-open-type-private.hh +++ b/src/hb-open-type-private.hh @@ -153,11 +153,6 @@ struct hb_trace_t<0> { trace.log ("SANITIZE", HB_FUNC, this); -#define SANITIZE_ARG_DEF \ - hb_sanitize_context_t *context -#define SANITIZE_ARG \ - context - struct hb_sanitize_context_t { inline void init (hb_blob_t *blob) @@ -253,9 +248,9 @@ struct hb_sanitize_context_t }; -#define SANITIZE(X) likely ((X).sanitize (SANITIZE_ARG)) +#define SANITIZE(X) likely ((X).sanitize (context)) -#define SANITIZE_WITH_BASE(B,X) likely ((X).sanitize (SANITIZE_ARG, CharP(B))) +#define SANITIZE_WITH_BASE(B,X) likely ((X).sanitize (context, CharP(B))) #define SANITIZE_SELF() SANITIZE_MEM(this, sizeof (*this)) @@ -282,7 +277,7 @@ struct Sanitizer Type *t = CastP (const_cast (context->get_start ())); - sane = t->sanitize (SANITIZE_ARG); + sane = t->sanitize (context); if (sane) { if (context->get_edit_count ()) { if (HB_DEBUG_SANITIZE) @@ -291,7 +286,7 @@ struct Sanitizer /* sanitize again to ensure no toe-stepping */ context->reset_edit_count (); - sane = t->sanitize (SANITIZE_ARG); + sane = t->sanitize (context); if (context->get_edit_count ()) { if (HB_DEBUG_SANITIZE) fprintf (stderr, "Sanitizer %p requested %d edits in second round; FAILLING %s\n", @@ -373,7 +368,7 @@ 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 (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_SELF (); } @@ -435,7 +430,7 @@ struct FixedVersion { inline operator uint32_t (void) const { return (major << 16) + minor; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_SELF (); } @@ -462,27 +457,27 @@ struct GenericOffsetTo : OffsetType return StructAtOffset (*CharP(base), offset); } - inline bool sanitize (SANITIZE_ARG_DEF, void *base) { + inline bool sanitize (hb_sanitize_context_t *context, void *base) { TRACE_SANITIZE (); if (!SANITIZE_SELF ()) return false; unsigned int offset = *this; if (unlikely (!offset)) return true; Type &obj = StructAtOffset (*CharP(base), offset); - return likely (obj.sanitize (SANITIZE_ARG)) || neuter (SANITIZE_ARG); + return likely (obj.sanitize (context)) || neuter (context); } template - inline bool sanitize (SANITIZE_ARG_DEF, void *base, T user_data) { + inline bool sanitize (hb_sanitize_context_t *context, void *base, T user_data) { TRACE_SANITIZE (); if (!SANITIZE_SELF ()) return false; unsigned int offset = *this; if (unlikely (!offset)) return true; Type &obj = StructAtOffset (*CharP(base), offset); - return likely (obj.sanitize (SANITIZE_ARG, user_data)) || neuter (SANITIZE_ARG); + return likely (obj.sanitize (context, user_data)) || neuter (context); } private: /* Set the offset to Null */ - inline bool neuter (SANITIZE_ARG_DEF) { + inline bool neuter (hb_sanitize_context_t *context) { if (context->can_edit (CharP(this), this->get_size ())) { this->set (0); /* 0 is Null offset */ return true; @@ -530,9 +525,9 @@ struct GenericArrayOf inline unsigned int get_size () const { return len.get_size () + len * Type::get_size (); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); - if (!likely (sanitize_shallow (SANITIZE_ARG))) return false; + if (!likely (sanitize_shallow (context))) 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. @@ -547,28 +542,28 @@ struct GenericArrayOf return false; return true; } - inline bool sanitize (SANITIZE_ARG_DEF, void *base) { + inline bool sanitize (hb_sanitize_context_t *context, void *base) { TRACE_SANITIZE (); - if (!likely (sanitize_shallow (SANITIZE_ARG))) return false; + if (!likely (sanitize_shallow (context))) return false; unsigned int count = len; for (unsigned int i = 0; i < count; i++) - if (!array()[i].sanitize (SANITIZE_ARG, base)) + if (!array()[i].sanitize (context, base)) return false; return true; } template - inline bool sanitize (SANITIZE_ARG_DEF, void *base, T user_data) { + inline bool sanitize (hb_sanitize_context_t *context, void *base, T user_data) { TRACE_SANITIZE (); - if (!likely (sanitize_shallow (SANITIZE_ARG))) return false; + if (!likely (sanitize_shallow (context))) return false; unsigned int count = len; for (unsigned int i = 0; i < count; i++) - if (!array()[i].sanitize (SANITIZE_ARG, base, user_data)) + if (!array()[i].sanitize (context, base, user_data)) return false; return true; } private: - inline bool sanitize_shallow (SANITIZE_ARG_DEF) { + inline bool sanitize_shallow (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_SELF() && SANITIZE_ARRAY (this, Type::get_size (), len); } @@ -608,14 +603,14 @@ struct OffsetListOf : OffsetArrayOf return this+this->array()[i]; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); - return OffsetArrayOf::sanitize (SANITIZE_ARG, CharP(this)); + return OffsetArrayOf::sanitize (context, CharP(this)); } template - inline bool sanitize (SANITIZE_ARG_DEF, T user_data) { + inline bool sanitize (hb_sanitize_context_t *context, T user_data) { TRACE_SANITIZE (); - return OffsetArrayOf::sanitize (SANITIZE_ARG, CharP(this), user_data); + return OffsetArrayOf::sanitize (context, CharP(this), user_data); } }; @@ -636,13 +631,13 @@ struct HeadlessArrayOf inline unsigned int get_size () const { return len.get_size () + (len ? len - 1 : 0) * Type::get_size (); } - inline bool sanitize_shallow (SANITIZE_ARG_DEF) { + inline bool sanitize_shallow (hb_sanitize_context_t *context) { return SANITIZE_SELF() && SANITIZE_ARRAY (this, Type::get_size (), len); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); - if (!likely (sanitize_shallow (SANITIZE_ARG))) return false; + if (!likely (sanitize_shallow (context))) 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. diff --git a/src/hb-ot-layout-common-private.hh b/src/hb-ot-layout-common-private.hh index 2c1c988..d9b2da3 100644 --- a/src/hb-ot-layout-common-private.hh +++ b/src/hb-ot-layout-common-private.hh @@ -53,7 +53,7 @@ struct Record { static inline unsigned int get_size () { return sizeof (Record); } - inline bool sanitize (SANITIZE_ARG_DEF, void *base) { + inline bool sanitize (hb_sanitize_context_t *context, void *base) { TRACE_SANITIZE (); return SANITIZE_SELF () && SANITIZE_WITH_BASE (base, offset); @@ -110,9 +110,9 @@ struct RecordListOf : RecordArrayOf inline const Type& operator [] (unsigned int i) const { return this+RecordArrayOf::operator [](i).offset; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); - return RecordArrayOf::sanitize (SANITIZE_ARG, CharP(this)); + return RecordArrayOf::sanitize (context, CharP(this)); } }; @@ -164,7 +164,7 @@ struct LangSys return reqFeatureIndex;; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_SELF () && SANITIZE (featureIndex); } @@ -201,7 +201,7 @@ 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 (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_WITH_BASE (this, defaultLangSys) && SANITIZE_WITH_BASE (this, langSys); @@ -232,7 +232,7 @@ struct Feature unsigned int *lookup_tags /* OUT */) const { return lookupIndex.get_indexes (start_index, lookup_count, lookup_tags); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_SELF () && SANITIZE (lookupIndex); } @@ -282,10 +282,10 @@ struct Lookup return flag; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); /* Real sanitize of the subtables is done by GSUB/GPOS/... */ - if (!(SANITIZE_SELF () && likely (subTable.sanitize (SANITIZE_ARG)))) return false; + if (!(SANITIZE_SELF () && likely (subTable.sanitize (context)))) return false; if (unlikely (lookupFlag & LookupFlag::UseMarkFilteringSet)) { USHORT &markFilteringSet = StructAfter (subTable); @@ -331,7 +331,7 @@ struct CoverageFormat1 return NOT_COVERED; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE (glyphArray); } @@ -358,7 +358,7 @@ struct CoverageRangeRecord } public: - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_SELF (); } @@ -390,7 +390,7 @@ struct CoverageFormat2 return NOT_COVERED; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE (rangeRecord); } @@ -417,12 +417,12 @@ struct Coverage } } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); if (!SANITIZE (u.format)) return false; switch (u.format) { - case 1: return u.format1->sanitize (SANITIZE_ARG); - case 2: return u.format2->sanitize (SANITIZE_ARG); + case 1: return u.format1->sanitize (context); + case 2: return u.format2->sanitize (context); default:return true; } } @@ -452,7 +452,7 @@ struct ClassDefFormat1 return 0; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_SELF () && SANITIZE (classValue); } @@ -479,7 +479,7 @@ struct ClassRangeRecord } public: - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_SELF (); } @@ -510,7 +510,7 @@ struct ClassDefFormat2 return 0; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE (rangeRecord); } @@ -535,12 +535,12 @@ struct ClassDef } } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); if (!SANITIZE (u.format)) return false; switch (u.format) { - case 1: return u.format1->sanitize (SANITIZE_ARG); - case 2: return u.format2->sanitize (SANITIZE_ARG); + case 1: return u.format1->sanitize (context); + case 2: return u.format2->sanitize (context); default:return true; } } @@ -592,7 +592,7 @@ struct Device return USHORT::get_size () * (4 + ((endSize - startSize) >> (4 - f))); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_SELF() && SANITIZE_MEM (this, this->get_size ()); } diff --git a/src/hb-ot-layout-gdef-private.hh b/src/hb-ot-layout-gdef-private.hh index da49fac..65b2414 100644 --- a/src/hb-ot-layout-gdef-private.hh +++ b/src/hb-ot-layout-gdef-private.hh @@ -67,7 +67,7 @@ struct AttachList return points.len; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_WITH_BASE (this, coverage) && SANITIZE_WITH_BASE (this, attachPoint); @@ -98,7 +98,7 @@ struct CaretValueFormat1 return _hb_16dot16_mul_round (context->font->x_scale, coordinate); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_SELF (); } @@ -124,7 +124,7 @@ struct CaretValueFormat2 return 0; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_SELF (); } @@ -146,7 +146,7 @@ struct CaretValueFormat3 ((this+deviceTable).get_delta (context->font->x_ppem) << 16); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_SELF () && SANITIZE_WITH_BASE (this, deviceTable); @@ -174,13 +174,13 @@ struct CaretValue } } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); if (!SANITIZE (u.format)) return false; switch (u.format) { - case 1: return u.format1->sanitize (SANITIZE_ARG); - case 2: return u.format2->sanitize (SANITIZE_ARG); - case 3: return u.format3->sanitize (SANITIZE_ARG); + case 1: return u.format1->sanitize (context); + case 2: return u.format2->sanitize (context); + case 3: return u.format3->sanitize (context); default:return true; } } @@ -212,7 +212,7 @@ struct LigGlyph return carets.len; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_WITH_BASE (this, carets); } @@ -244,7 +244,7 @@ struct LigCaretList return lig_glyph.get_lig_carets (context, glyph_id, start_offset, caret_count, caret_array); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_WITH_BASE (this, coverage) && SANITIZE_WITH_BASE (this, ligGlyph); @@ -266,7 +266,7 @@ 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 (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_WITH_BASE (this, coverage); } @@ -289,11 +289,11 @@ struct MarkGlyphSets } } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); if (!SANITIZE (u.format)) return false; switch (u.format) { - case 1: return u.format1->sanitize (SANITIZE_ARG); + case 1: return u.format1->sanitize (context); default:return true; } } @@ -349,7 +349,7 @@ struct GDEF 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 (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE (version) && likely (version.major == 1) && SANITIZE_WITH_BASE (this, glyphClassDef) diff --git a/src/hb-ot-layout-gpos-private.hh b/src/hb-ot-layout-gpos-private.hh index 9837c04..8c75c9f 100644 --- a/src/hb-ot-layout-gpos-private.hh +++ b/src/hb-ot-layout-gpos-private.hh @@ -129,7 +129,7 @@ struct ValueFormat : USHORT } private: - inline bool sanitize_value_devices (SANITIZE_ARG_DEF, void *base, const Value *values) { + inline bool sanitize_value_devices (hb_sanitize_context_t *context, void *base, const Value *values) { unsigned int format = *this; if (format & xPlacement) values++; @@ -152,14 +152,14 @@ struct ValueFormat : USHORT return (format & devices) != 0; } - inline bool sanitize_value (SANITIZE_ARG_DEF, void *base, const Value *values) { + inline bool sanitize_value (hb_sanitize_context_t *context, void *base, const Value *values) { TRACE_SANITIZE (); return SANITIZE_MEM (values, get_size ()) && - (!has_device () || sanitize_value_devices (SANITIZE_ARG, base, values)); + (!has_device () || sanitize_value_devices (context, base, values)); } - inline bool sanitize_values (SANITIZE_ARG_DEF, void *base, const Value *values, unsigned int count) { + inline bool sanitize_values (hb_sanitize_context_t *context, void *base, const Value *values, unsigned int count) { TRACE_SANITIZE (); unsigned int len = get_len (); @@ -168,7 +168,7 @@ struct ValueFormat : USHORT if (!has_device ()) return true; for (unsigned int i = 0; i < count; i++) { - if (!sanitize_value_devices (SANITIZE_ARG, base, values)) + if (!sanitize_value_devices (context, base, values)) return false; values += len; } @@ -177,13 +177,13 @@ struct ValueFormat : USHORT } /* Just sanitize referenced Device tables. Doesn't check the values themselves. */ - inline bool sanitize_values_stride_unsafe (SANITIZE_ARG_DEF, void *base, const Value *values, unsigned int count, unsigned int stride) { + inline bool sanitize_values_stride_unsafe (hb_sanitize_context_t *context, void *base, const 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 (SANITIZE_ARG, base, values)) + if (!sanitize_value_devices (context, base, values)) return false; values += stride; } @@ -206,7 +206,7 @@ struct AnchorFormat1 *y = _hb_16dot16_mul_round (layout_context->font->y_scale, yCoordinate); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_SELF (); } @@ -237,7 +237,7 @@ struct AnchorFormat2 *y = y_ppem && ret ? cy : _hb_16dot16_mul_round (layout_context->font->y_scale, yCoordinate); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_SELF (); } @@ -268,7 +268,7 @@ struct AnchorFormat3 *y += (this+yDeviceTable).get_delta (layout_context->font->y_ppem) << 16; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_SELF () && SANITIZE_WITH_BASE (this, xDeviceTable) @@ -304,13 +304,13 @@ struct Anchor } } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); if (!SANITIZE (u.format)) return false; switch (u.format) { - case 1: return u.format1->sanitize (SANITIZE_ARG); - case 2: return u.format2->sanitize (SANITIZE_ARG); - case 3: return u.format3->sanitize (SANITIZE_ARG); + case 1: return u.format1->sanitize (context); + case 2: return u.format2->sanitize (context); + case 3: return u.format3->sanitize (context); default:return true; } } @@ -332,7 +332,7 @@ struct AnchorMatrix return this+matrix[row * cols + col]; } - inline bool sanitize (SANITIZE_ARG_DEF, unsigned int cols) { + inline bool sanitize (hb_sanitize_context_t *context, unsigned int cols) { TRACE_SANITIZE (); if (!SANITIZE_SELF ()) return false; if (unlikely (cols >= ((unsigned int) -1) / rows)) return false; @@ -358,7 +358,7 @@ struct MarkRecord static inline unsigned int get_size () { return sizeof (MarkRecord); } - inline bool sanitize (SANITIZE_ARG_DEF, void *base) { + inline bool sanitize (hb_sanitize_context_t *context, void *base) { TRACE_SANITIZE (); return SANITIZE_SELF () && SANITIZE_WITH_BASE (base, markAnchor); @@ -402,7 +402,7 @@ struct MarkArray return true; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_WITH_BASE (this, markRecord); } @@ -434,11 +434,11 @@ struct SinglePosFormat1 return true; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_SELF () && SANITIZE_WITH_BASE (this, coverage) - && valueFormat.sanitize_value (SANITIZE_ARG, CharP(this), values); + && valueFormat.sanitize_value (context, CharP(this), values); } private: @@ -477,11 +477,11 @@ struct SinglePosFormat2 return true; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_SELF () && SANITIZE_WITH_BASE (this, coverage) - && valueFormat.sanitize_values (SANITIZE_ARG, CharP(this), values, valueCount); + && valueFormat.sanitize_values (context, CharP(this), values, valueCount); } private: @@ -512,12 +512,12 @@ struct SinglePos } } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); if (!SANITIZE (u.format)) return false; switch (u.format) { - case 1: return u.format1->sanitize (SANITIZE_ARG); - case 2: return u.format2->sanitize (SANITIZE_ARG); + case 1: return u.format1->sanitize (context); + case 2: return u.format2->sanitize (context); default:return true; } } @@ -549,7 +549,7 @@ struct PairSet friend struct PairPosFormat1; /* Note: Doesn't sanitize the Device entries in the ValueRecord */ - inline bool sanitize (SANITIZE_ARG_DEF, unsigned int format_len) { + inline bool sanitize (hb_sanitize_context_t *context, unsigned int format_len) { TRACE_SANITIZE (); if (!SANITIZE_SELF ()) return false; unsigned int count = (1 + format_len) * len; @@ -612,7 +612,7 @@ struct PairPosFormat1 return false; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); unsigned int len1 = valueFormat1.get_len (); @@ -620,7 +620,7 @@ struct PairPosFormat1 if (!(SANITIZE_SELF () && SANITIZE_WITH_BASE (this, coverage) - && likely (pairSet.sanitize (SANITIZE_ARG, CharP(this), len1 + len2)))) return false; + && likely (pairSet.sanitize (context, CharP(this), len1 + len2)))) return false; if (!(valueFormat1.has_device () || valueFormat2.has_device ())) return true; @@ -632,8 +632,8 @@ struct PairPosFormat1 unsigned int count2 = pair_set.len; const PairValueRecord *record = pair_set.array; - if (!(valueFormat1.sanitize_values_stride_unsafe (SANITIZE_ARG, CharP(this), &record->values[0], count2, stride) && - valueFormat2.sanitize_values_stride_unsafe (SANITIZE_ARG, CharP(this), &record->values[len1], count2, stride))) + if (!(valueFormat1.sanitize_values_stride_unsafe (context, CharP(this), &record->values[0], count2, stride) && + valueFormat2.sanitize_values_stride_unsafe (context, CharP(this), &record->values[len1], count2, stride))) return false; } @@ -701,7 +701,7 @@ struct PairPosFormat2 return true; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); if (!(SANITIZE_SELF () && SANITIZE_WITH_BASE (this, coverage) @@ -714,8 +714,8 @@ struct PairPosFormat2 unsigned int record_size = valueFormat1.get_size () + valueFormat2.get_size (); unsigned int count = (unsigned int) class1Count * (unsigned int) class2Count; return SANITIZE_ARRAY (values, record_size, count) && - valueFormat1.sanitize_values_stride_unsafe (SANITIZE_ARG, CharP(this), &values[0], count, stride) && - valueFormat2.sanitize_values_stride_unsafe (SANITIZE_ARG, CharP(this), &values[len1], count, stride); + valueFormat1.sanitize_values_stride_unsafe (context, CharP(this), &values[0], count, stride) && + valueFormat2.sanitize_values_stride_unsafe (context, CharP(this), &values[len1], count, stride); } private: @@ -762,12 +762,12 @@ struct PairPos } } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); if (!SANITIZE (u.format)) return false; switch (u.format) { - case 1: return u.format1->sanitize (SANITIZE_ARG); - case 2: return u.format2->sanitize (SANITIZE_ARG); + case 1: return u.format1->sanitize (context); + case 2: return u.format2->sanitize (context); default:return true; } } @@ -785,7 +785,7 @@ struct EntryExitRecord { static inline unsigned int get_size () { return sizeof (EntryExitRecord); } - inline bool sanitize (SANITIZE_ARG_DEF, void *base) { + inline bool sanitize (hb_sanitize_context_t *context, void *base) { TRACE_SANITIZE (); return SANITIZE_WITH_BASE (base, entryAnchor) && SANITIZE_WITH_BASE (base, exitAnchor); @@ -982,7 +982,7 @@ struct CursivePosFormat1 return true; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_WITH_BASE (this, coverage) && SANITIZE_WITH_BASE (this, entryExitRecord); @@ -1013,11 +1013,11 @@ struct CursivePos } } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); if (!SANITIZE (u.format)) return false; switch (u.format) { - case 1: return u.format1->sanitize (SANITIZE_ARG); + case 1: return u.format1->sanitize (context); default:return true; } } @@ -1070,13 +1070,13 @@ struct MarkBasePosFormat1 return (this+markArray).apply (APPLY_ARG, mark_index, base_index, this+baseArray, classCount, j); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_SELF () && SANITIZE_WITH_BASE (this, markCoverage) && SANITIZE_WITH_BASE (this, baseCoverage) && SANITIZE_WITH_BASE (this, markArray) - && likely (baseArray.sanitize (SANITIZE_ARG, CharP(this), (unsigned int) classCount)); + && likely (baseArray.sanitize (context, CharP(this), (unsigned int) classCount)); } private: @@ -1111,11 +1111,11 @@ struct MarkBasePos } } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); if (!SANITIZE (u.format)) return false; switch (u.format) { - case 1: return u.format1->sanitize (SANITIZE_ARG); + case 1: return u.format1->sanitize (context); default:return true; } } @@ -1194,13 +1194,13 @@ struct MarkLigPosFormat1 return (this+markArray).apply (APPLY_ARG, mark_index, comp_index, lig_attach, classCount, j); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_SELF () && SANITIZE_WITH_BASE (this, markCoverage) && SANITIZE_WITH_BASE (this, ligatureCoverage) && SANITIZE_WITH_BASE (this, markArray) - && likely (ligatureArray.sanitize (SANITIZE_ARG, CharP(this), (unsigned int) classCount)); + && likely (ligatureArray.sanitize (context, CharP(this), (unsigned int) classCount)); } private: @@ -1236,11 +1236,11 @@ struct MarkLigPos } } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); if (!SANITIZE (u.format)) return false; switch (u.format) { - case 1: return u.format1->sanitize (SANITIZE_ARG); + case 1: return u.format1->sanitize (context); default:return true; } } @@ -1297,13 +1297,13 @@ struct MarkMarkPosFormat1 return (this+mark1Array).apply (APPLY_ARG, mark1_index, mark2_index, this+mark2Array, classCount, j); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_SELF () && SANITIZE_WITH_BASE (this, mark1Coverage) && SANITIZE_WITH_BASE (this, mark2Coverage) && SANITIZE_WITH_BASE (this, mark1Array) - && likely (mark2Array.sanitize (SANITIZE_ARG, CharP(this), (unsigned int) classCount)); + && likely (mark2Array.sanitize (context, CharP(this), (unsigned int) classCount)); } private: @@ -1340,11 +1340,11 @@ struct MarkMarkPos } } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); if (!SANITIZE (u.format)) return false; switch (u.format) { - case 1: return u.format1->sanitize (SANITIZE_ARG); + case 1: return u.format1->sanitize (context); default:return true; } } @@ -1398,7 +1398,7 @@ struct ExtensionPos : Extension inline bool apply (APPLY_ARG_DEF) const; - inline bool sanitize (SANITIZE_ARG_DEF); + inline bool sanitize (hb_sanitize_context_t *context); }; @@ -1441,19 +1441,19 @@ struct PosLookupSubTable } } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); if (!SANITIZE (u.format)) return false; switch (u.format) { - case Single: return u.single->sanitize (SANITIZE_ARG); - case Pair: return u.pair->sanitize (SANITIZE_ARG); - case Cursive: return u.cursive->sanitize (SANITIZE_ARG); - case MarkBase: return u.markBase->sanitize (SANITIZE_ARG); - case MarkLig: return u.markLig->sanitize (SANITIZE_ARG); - case MarkMark: return u.markMark->sanitize (SANITIZE_ARG); - case Context: return u.context->sanitize (SANITIZE_ARG); - case ChainContext: return u.chainContext->sanitize (SANITIZE_ARG); - case Extension: return u.extension->sanitize (SANITIZE_ARG); + 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); default:return true; } } @@ -1536,9 +1536,9 @@ struct PosLookup : Lookup return ret; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); - if (unlikely (!Lookup::sanitize (SANITIZE_ARG))) return false; + if (unlikely (!Lookup::sanitize (context))) return false; OffsetArrayOf &list = CastR > (subTable); return SANITIZE_WITH_BASE (this, list); } @@ -1564,9 +1564,9 @@ struct GPOS : GSUBGPOS hb_mask_t mask) const { return get_lookup (lookup_index).apply_string (layout_context, buffer, mask); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); - if (unlikely (!GSUBGPOS::sanitize (SANITIZE_ARG))) return false; + if (unlikely (!GSUBGPOS::sanitize (context))) return false; OffsetTo &list = CastR > (lookupList); return SANITIZE_WITH_BASE (this, list); } @@ -1582,10 +1582,10 @@ inline bool ExtensionPos::apply (APPLY_ARG_DEF) const return get_subtable ().apply (APPLY_ARG, get_type ()); } -inline bool ExtensionPos::sanitize (SANITIZE_ARG_DEF) +inline bool ExtensionPos::sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); - if (unlikely (!Extension::sanitize (SANITIZE_ARG))) return false; + if (unlikely (!Extension::sanitize (context))) return false; unsigned int offset = get_offset (); if (unlikely (!offset)) return true; return SANITIZE (StructAtOffset (*this, offset)); diff --git a/src/hb-ot-layout-gsub-private.hh b/src/hb-ot-layout-gsub-private.hh index 3632c1f..2dfe7c2 100644 --- a/src/hb-ot-layout-gsub-private.hh +++ b/src/hb-ot-layout-gsub-private.hh @@ -54,7 +54,7 @@ struct SingleSubstFormat1 return true; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_WITH_BASE (this, coverage) && SANITIZE (deltaGlyphID); @@ -97,7 +97,7 @@ struct SingleSubstFormat2 return true; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_WITH_BASE (this, coverage) && SANITIZE (substitute); @@ -130,12 +130,12 @@ struct SingleSubst } } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); if (!SANITIZE (u.format)) return false; switch (u.format) { - case 1: return u.format1->sanitize (SANITIZE_ARG); - case 2: return u.format2->sanitize (SANITIZE_ARG); + case 1: return u.format1->sanitize (context); + case 2: return u.format2->sanitize (context); default:return true; } } @@ -180,7 +180,7 @@ struct Sequence } public: - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE (substitute); } @@ -208,7 +208,7 @@ struct MultipleSubstFormat1 return (this+sequence[index]).apply (APPLY_ARG); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_WITH_BASE (this, coverage) && SANITIZE_WITH_BASE (this, sequence); @@ -240,11 +240,11 @@ struct MultipleSubst } } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); if (!SANITIZE (u.format)) return false; switch (u.format) { - case 1: return u.format1->sanitize (SANITIZE_ARG); + case 1: return u.format1->sanitize (context); default:return true; } } @@ -304,7 +304,7 @@ struct AlternateSubstFormat1 return true; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_WITH_BASE (this, coverage) && SANITIZE_WITH_BASE (this, alternateSet); @@ -336,11 +336,11 @@ struct AlternateSubst } } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); if (!SANITIZE (u.format)) return false; switch (u.format) { - case 1: return u.format1->sanitize (SANITIZE_ARG); + case 1: return u.format1->sanitize (context); default:return true; } } @@ -422,7 +422,7 @@ struct Ligature } public: - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE (ligGlyph) && SANITIZE (component); } @@ -456,7 +456,7 @@ struct LigatureSet } public: - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_WITH_BASE (this, ligature); } @@ -488,7 +488,7 @@ struct LigatureSubstFormat1 return lig_set.apply (APPLY_ARG, first_is_mark); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_WITH_BASE (this, coverage) && SANITIZE_WITH_BASE (this, ligatureSet); @@ -519,11 +519,11 @@ struct LigatureSubst } } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); if (!SANITIZE (u.format)) return false; switch (u.format) { - case 1: return u.format1->sanitize (SANITIZE_ARG); + case 1: return u.format1->sanitize (context); default:return true; } } @@ -579,7 +579,7 @@ struct ExtensionSubst : Extension inline bool apply (APPLY_ARG_DEF) const; - inline bool sanitize (SANITIZE_ARG_DEF); + inline bool sanitize (hb_sanitize_context_t *context); inline bool is_reverse (void) const; }; @@ -619,7 +619,7 @@ struct ReverseChainSingleSubstFormat1 return false; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); if (!(SANITIZE_WITH_BASE (this, coverage) && SANITIZE_WITH_BASE (this, backtrack))) @@ -664,11 +664,11 @@ struct ReverseChainSingleSubst } } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); if (!SANITIZE (u.format)) return false; switch (u.format) { - case 1: return u.format1->sanitize (SANITIZE_ARG); + case 1: return u.format1->sanitize (context); default:return true; } } @@ -717,18 +717,18 @@ struct SubstLookupSubTable } } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); if (!SANITIZE (u.format)) return false; switch (u.format) { - case Single: return u.single->sanitize (SANITIZE_ARG); - case Multiple: return u.multiple->sanitize (SANITIZE_ARG); - case Alternate: return u.alternate->sanitize (SANITIZE_ARG); - case Ligature: return u.ligature->sanitize (SANITIZE_ARG); - case Context: return u.context->sanitize (SANITIZE_ARG); - case ChainContext: return u.chainContext->sanitize (SANITIZE_ARG); - case Extension: return u.extension->sanitize (SANITIZE_ARG); - case ReverseChainSingle: return u.reverseChainContextSingle->sanitize (SANITIZE_ARG); + 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); default:return true; } } @@ -847,9 +847,9 @@ struct SubstLookup : Lookup return ret; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); - if (unlikely (!Lookup::sanitize (SANITIZE_ARG))) return false; + if (unlikely (!Lookup::sanitize (context))) return false; OffsetArrayOf &list = CastR > (subTable); return SANITIZE_WITH_BASE (this, list); } @@ -876,9 +876,9 @@ struct GSUB : GSUBGPOS { return get_lookup (lookup_index).apply_string (layout_context, buffer, mask); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); - if (unlikely (!GSUBGPOS::sanitize (SANITIZE_ARG))) return false; + if (unlikely (!GSUBGPOS::sanitize (context))) return false; OffsetTo &list = CastR > (lookupList); return SANITIZE_WITH_BASE (this, list); } @@ -894,10 +894,10 @@ inline bool ExtensionSubst::apply (APPLY_ARG_DEF) const return get_subtable ().apply (APPLY_ARG, get_type ()); } -inline bool ExtensionSubst::sanitize (SANITIZE_ARG_DEF) +inline bool ExtensionSubst::sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); - if (unlikely (!Extension::sanitize (SANITIZE_ARG))) return false; + if (unlikely (!Extension::sanitize (context))) return false; unsigned int offset = get_offset (); if (unlikely (!offset)) return true; return SANITIZE (StructAtOffset (*this, offset)); diff --git a/src/hb-ot-layout-gsubgpos-private.hh b/src/hb-ot-layout-gsubgpos-private.hh index c3a622b..71fe8a6 100644 --- a/src/hb-ot-layout-gsubgpos-private.hh +++ b/src/hb-ot-layout-gsubgpos-private.hh @@ -179,7 +179,7 @@ struct LookupRecord { static inline unsigned int get_size () { return sizeof (LookupRecord); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_SELF (); } @@ -289,7 +289,7 @@ struct Rule } public: - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); if (!(SANITIZE (inputCount) && SANITIZE (lookupCount))) return false; return SANITIZE_MEM (input, @@ -324,7 +324,7 @@ struct RuleSet return false; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_WITH_BASE (this, rule); } @@ -356,7 +356,7 @@ struct ContextFormat1 return rule_set.apply (APPLY_ARG, lookup_context); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_WITH_BASE (this, coverage) && SANITIZE_WITH_BASE (this, ruleSet); @@ -399,7 +399,7 @@ struct ContextFormat2 return rule_set.apply (APPLY_ARG, lookup_context); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_WITH_BASE (this, coverage) && SANITIZE_WITH_BASE (this, classDef) @@ -444,7 +444,7 @@ struct ContextFormat3 lookup_context); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); if (!SANITIZE_SELF ()) return false; unsigned int count = glyphCount; @@ -482,13 +482,13 @@ struct Context } } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); if (!SANITIZE (u.format)) return false; switch (u.format) { - case 1: return u.format1->sanitize (SANITIZE_ARG); - case 2: return u.format2->sanitize (SANITIZE_ARG); - case 3: return u.format3->sanitize (SANITIZE_ARG); + case 1: return u.format1->sanitize (context); + case 2: return u.format2->sanitize (context); + case 3: return u.format3->sanitize (context); default:return true; } } @@ -568,7 +568,7 @@ struct ChainRule } public: - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); if (!SANITIZE (backtrack)) return false; HeadlessArrayOf &input = StructAfter > (backtrack); @@ -611,7 +611,7 @@ struct ChainRuleSet return false; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_WITH_BASE (this, rule); } @@ -643,7 +643,7 @@ struct ChainContextFormat1 return rule_set.apply (APPLY_ARG, lookup_context); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_WITH_BASE (this, coverage) && SANITIZE_WITH_BASE (this, ruleSet); @@ -690,7 +690,7 @@ struct ChainContextFormat2 return rule_set.apply (APPLY_ARG, lookup_context); } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_WITH_BASE (this, coverage) && SANITIZE_WITH_BASE (this, backtrackClassDef) @@ -752,7 +752,7 @@ struct ChainContextFormat3 return false; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); if (!SANITIZE_WITH_BASE (this, backtrack)) return false; OffsetArrayOf &input = StructAfter > (backtrack); @@ -797,13 +797,13 @@ struct ChainContext } } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); if (!SANITIZE (u.format)) return false; switch (u.format) { - case 1: return u.format1->sanitize (SANITIZE_ARG); - case 2: return u.format2->sanitize (SANITIZE_ARG); - case 3: return u.format3->sanitize (SANITIZE_ARG); + case 1: return u.format1->sanitize (context); + case 2: return u.format2->sanitize (context); + case 3: return u.format3->sanitize (context); default:return true; } } @@ -826,7 +826,7 @@ struct ExtensionFormat1 inline unsigned int get_type (void) const { return extensionLookupType; } inline unsigned int get_offset (void) const { return extensionOffset; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE_SELF (); } @@ -858,11 +858,11 @@ struct Extension } } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); if (!SANITIZE (u.format)) return false; switch (u.format) { - case 1: return u.format1->sanitize (SANITIZE_ARG); + case 1: return u.format1->sanitize (context); default:return true; } } @@ -915,7 +915,7 @@ struct GSUBGPOS inline const Lookup& get_lookup (unsigned int i) const { return (this+lookupList)[i]; } - inline bool sanitize (SANITIZE_ARG_DEF) { + inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return SANITIZE (version) && likely (version.major == 1) && SANITIZE_WITH_BASE (this, scriptList) -- 2.7.4