typedef struct TableDirectory
{
inline bool sanitize (SANITIZE_ARG_DEF, const void *base) {
+ SANITIZE_DEBUG ();
return SANITIZE_SELF () && SANITIZE (tag) &&
SANITIZE_MEM (CONST_CHARP(base) + (unsigned long) offset, length);
}
public:
inline bool sanitize (SANITIZE_ARG_DEF, const void *base) {
+ SANITIZE_DEBUG ();
if (!(SANITIZE_SELF () && SANITIZE_MEM (tableDir, sizeof (tableDir[0]) * numTables))) return false;
unsigned int count = numTables;
for (unsigned int i = 0; i < count; i++)
}
bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!SANITIZE (version)) return false;
if (version.major < 1 || version.major > 2) return true;
/* XXX Maybe we shouldn't NEUTER these offsets, they may cause a full copy of
}
bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
switch (tag) {
default: return true;
case TrueTypeTag: case CFFTag: return SANITIZE_THIS (CAST (OffsetTable, *this, 0));
* Sanitize
*/
+#if HB_DEBUG
+#define SANITIZE_DEBUG_ARG_DEF , unsigned int sanitize_depth
+#define SANITIZE_DEBUG_ARG , sanitize_depth + 1
+#define SANITIZE_DEBUG_ARG_INIT , 0
+#define SANITIZE_DEBUG() \
+ HB_STMT_START { \
+ printf ("SANITIZE(%p) %-*d-> %s\n", \
+ (CONST_CHARP (this) == NullPool) ? 0 : this, \
+ sanitize_depth+1, sanitize_depth, \
+ __PRETTY_FUNCTION__); \
+ } HB_STMT_END
+#else
+#define SANITIZE_DEBUG_ARG_DEF
+#define SANITIZE_DEBUG_ARG
+#define SANITIZE_DEBUG_ARG_INIT
+#define SANITIZE_DEBUG() HB_STMT_START {} HB_STMT_END
+#endif
+
typedef struct _hb_sanitize_context_t hb_sanitize_context_t;
struct _hb_sanitize_context_t
{
}
#define SANITIZE_ARG_DEF \
- hb_sanitize_context_t *context
+ hb_sanitize_context_t *context SANITIZE_DEBUG_ARG_DEF
#define SANITIZE_ARG \
- context
+ context SANITIZE_DEBUG_ARG
+#define SANITIZE_ARG_INIT \
+ &context SANITIZE_DEBUG_ARG_INIT
#define SANITIZE(X) HB_LIKELY ((X).sanitize (SANITIZE_ARG))
#define SANITIZE2(X,Y) (SANITIZE (X) && SANITIZE (Y))
Type *t = &CAST (Type, context.start, 0);
- sane = t->sanitize (&context);
+ sane = t->sanitize (SANITIZE_ARG_INIT);
if (sane) {
if (context.edit_count) {
/* sanitize again to ensure not toe-stepping */
context.edit_count = 0;
- sane = t->sanitize (&context);
+ sane = t->sanitize (SANITIZE_ARG_INIT);
if (context.edit_count) {
sane = false;
}
inline NAME& operator = (TYPE i) { (TYPE&) v = BIG_ENDIAN (i); return *this; } \
inline operator TYPE(void) const { return BIG_ENDIAN ((TYPE&) v); } \
inline bool operator== (NAME o) const { return (TYPE&) v == (TYPE&) o.v; } \
- inline bool sanitize (SANITIZE_ARG_DEF) { return SANITIZE_SELF (); } \
+ inline bool sanitize (SANITIZE_ARG_DEF) { \
+ SANITIZE_DEBUG (); \
+ return SANITIZE_SELF (); \
+ } \
private: char v[BYTES]; \
}; \
ASSERT_SIZE (NAME, BYTES)
inline operator char* (void) { return CHARP(this); }
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
/* Note: Only accept ASCII-visible tags (mind DEL)
* This is one of the few times (only time?) we check
* for data integrity, as opposed o just boundary checks
inline operator uint32_t (void) const { return (major << 16) + minor; }
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_SELF ();
}
}
inline bool sanitize (SANITIZE_ARG_DEF, const void *base) {
+ SANITIZE_DEBUG ();
if (!SANITIZE_OBJ (*this)) return false;
unsigned int offset = *this;
if (HB_UNLIKELY (!offset)) return true;
return SANITIZE (CAST(Type, *DECONST_CHARP(base), offset)) || NEUTER (DECONST_CAST(OffsetType,*this,0), 0);
}
inline bool sanitize (SANITIZE_ARG_DEF, const void *base, const void *base2) {
+ SANITIZE_DEBUG ();
if (!SANITIZE_OBJ (*this)) return false;
unsigned int offset = *this;
if (HB_UNLIKELY (!offset)) return true;
return SANITIZE_BASE (CAST(Type, *DECONST_CHARP(base), offset), base2) || NEUTER (DECONST_CAST(OffsetType,*this,0), 0);
}
inline bool sanitize (SANITIZE_ARG_DEF, const void *base, unsigned int user_data) {
+ SANITIZE_DEBUG ();
if (!SANITIZE_OBJ (*this)) return false;
unsigned int offset = *this;
if (HB_UNLIKELY (!offset)) return true;
{ return sizeof (len) + len * sizeof (array[0]); }
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!SANITIZE_GET_SIZE()) return false;
/* Note; for non-recursive types, this is not much needed
unsigned int count = len;
return true;
}
inline bool sanitize (SANITIZE_ARG_DEF, const void *base) {
+ SANITIZE_DEBUG ();
if (!SANITIZE_GET_SIZE()) return false;
unsigned int count = len;
for (unsigned int i = 0; i < count; i++)
return true;
}
inline bool sanitize (SANITIZE_ARG_DEF, const void *base, const void *base2) {
+ SANITIZE_DEBUG ();
if (!SANITIZE_GET_SIZE()) return false;
unsigned int count = len;
for (unsigned int i = 0; i < count; i++)
return true;
}
inline bool sanitize (SANITIZE_ARG_DEF, const void *base, unsigned int user_data) {
+ SANITIZE_DEBUG ();
if (!SANITIZE_GET_SIZE()) return false;
unsigned int count = len;
for (unsigned int i = 0; i < count; i++)
{ return sizeof (len) + (len ? len - 1 : 0) * sizeof (array[0]); }
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!SANITIZE_GET_SIZE()) return false;
/* Note; for non-recursive types, this is not much needed
unsigned int count = len ? len - 1 : 0;
struct Record
{
inline bool sanitize (SANITIZE_ARG_DEF, const void *base) {
+ SANITIZE_DEBUG ();
return SANITIZE (tag) == 0 && SANITIZE_BASE (offset, base);
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return RecordArrayOf<Type>::sanitize (SANITIZE_ARG, CONST_CHARP(this));
}
};
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_SELF () && SANITIZE (featureIndex);
}
inline const LangSys& get_default_lang_sys (void) const { return this+defaultLangSys; }
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_THIS (defaultLangSys) && SANITIZE_THIS (langSys);
}
inline unsigned int get_lookup_count (void) const { return lookupIndex.len; }
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_SELF () && SANITIZE (lookupIndex);
}
struct LookupSubTable
{
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_SELF ();
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!(SANITIZE_SELF () && SANITIZE_THIS (subTable))) return false;
if (HB_UNLIKELY (lookupFlag & LookupFlag::UseMarkFilteringSet))
{
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return OffsetArrayOf<Type>::sanitize (SANITIZE_ARG, CONST_CHARP(this));
}
};
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE (glyphArray);
}
public:
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_SELF ();
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE (rangeRecord);
}
}
bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!SANITIZE (u.format)) return false;
switch (u.format) {
case 1: return u.format1->sanitize (SANITIZE_ARG);
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_SELF () && SANITIZE (classValue);
}
public:
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_SELF ();
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE (rangeRecord);
}
}
bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!SANITIZE (u.format)) return false;
switch (u.format) {
case 1: return u.format1->sanitize (SANITIZE_ARG);
}
bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_GET_SIZE ();
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_THIS2 (coverage, attachPoint);
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_SELF ();
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_SELF ();
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_SELF () && SANITIZE_THIS (deviceTable);
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!SANITIZE (u.format)) return false;
switch (u.format) {
case 1: return u.format1->sanitize (SANITIZE_ARG);
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE (carets);
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_THIS2 (coverage, ligGlyph);
}
{ return (this+coverage[set_index]).get_coverage (glyph_id) != NOT_COVERED; }
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_THIS (coverage);
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!SANITIZE (u.format)) return false;
switch (u.format) {
case 1: return u.format1->sanitize (SANITIZE_ARG);
{ return version >= 0x00010002 && (this+markGlyphSetsDef[0]).covers (set_index, glyph_id); }
bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!SANITIZE (version)) return false;
if (version.major != 1) return true;
return SANITIZE_THIS2 (glyphClassDef, attachList) &&
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_SELF ();
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_SELF ();
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_SELF () && SANITIZE_THIS2 (xDeviceTable, yDeviceTable);
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!SANITIZE (u.format)) return false;
switch (u.format) {
case 1: return u.format1->sanitize (SANITIZE_ARG);
friend struct MarkArray;
inline bool sanitize (SANITIZE_ARG_DEF, const void *base) {
+ SANITIZE_DEBUG ();
return SANITIZE_SELF () && SANITIZE_BASE (markAnchor, base);
}
inline const Anchor& get_anchor (unsigned int index) const { return this+markRecord[index].markAnchor; }
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_THIS (markRecord);
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_SELF () && SANITIZE_THIS (coverage) &&
SANITIZE_MEM (values, valueFormat.get_size ());
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_SELF () && SANITIZE_THIS (coverage) &&
SANITIZE_MEM (values, valueFormat.get_size () * valueCount);
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!SANITIZE (u.format)) return false;
switch (u.format) {
case 1: return u.format1->sanitize (SANITIZE_ARG);
friend struct PairPosFormat1;
inline bool sanitize (SANITIZE_ARG_DEF, unsigned int format_len) {
+ SANITIZE_DEBUG ();
if (!SANITIZE_SELF ()) return false;
unsigned int count = (1 + format_len) * len;
return SANITIZE_MEM (array, sizeof (array[0]) * count);
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_SELF () && SANITIZE_THIS (coverage) &&
pairSet.sanitize (SANITIZE_ARG, CONST_CHARP(this),
valueFormat1.get_len () + valueFormat2.get_len ());
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_SELF () && SANITIZE_THIS (coverage) &&
SANITIZE_THIS2 (classDef1, classDef2) &&
SANITIZE_MEM (values,
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!SANITIZE (u.format)) return false;
switch (u.format) {
case 1: return u.format1->sanitize (SANITIZE_ARG);
struct EntryExitRecord
{
inline bool sanitize (SANITIZE_ARG_DEF, const void *base) {
+ SANITIZE_DEBUG ();
return SANITIZE_BASE2 (entryAnchor, exitAnchor, base);
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_THIS2 (coverage, entryExitRecord);
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!SANITIZE (u.format)) return false;
switch (u.format) {
case 1: return u.format1->sanitize (SANITIZE_ARG);
friend struct MarkBasePosFormat1;
inline bool sanitize (SANITIZE_ARG_DEF, unsigned int cols) {
+ SANITIZE_DEBUG ();
if (!SANITIZE_SELF ()) return false;
unsigned int count = cols * len;
if (!SANITIZE_MEM (matrix, sizeof (matrix[0]) * count)) return false;
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_SELF () && SANITIZE_THIS2 (markCoverage, baseCoverage) &&
SANITIZE_THIS (markArray) && baseArray.sanitize (SANITIZE_ARG, CONST_CHARP(this), classCount);
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!SANITIZE (u.format)) return false;
switch (u.format) {
case 1: return u.format1->sanitize (SANITIZE_ARG);
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_SELF () &&
SANITIZE_THIS2 (markCoverage, ligatureCoverage) &&
SANITIZE_THIS2 (markArray, ligatureArray);
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!SANITIZE (u.format)) return false;
switch (u.format) {
case 1: return u.format1->sanitize (SANITIZE_ARG);
friend struct MarkMarkPosFormat1;
inline bool sanitize (SANITIZE_ARG_DEF, unsigned int cols) {
+ SANITIZE_DEBUG ();
if (!SANITIZE_SELF ()) return false;
unsigned int count = cols * len;
if (!SANITIZE_MEM (matrix, sizeof (matrix[0]) * count)) return false;
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_SELF () && SANITIZE_THIS2 (mark1Coverage, mark2Coverage) &&
SANITIZE_THIS (mark1Array) && mark2Array.sanitize (SANITIZE_ARG, CONST_CHARP(this), classCount);
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!SANITIZE (u.format)) return false;
switch (u.format) {
case 1: return u.format1->sanitize (SANITIZE_ARG);
}
bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!SANITIZE (u.format)) return false;
switch (u.format) {
case Single: return u.single->sanitize (SANITIZE_ARG);
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (Lookup::sanitize (SANITIZE_ARG)) return false;
OffsetArrayOf<PosLookupSubTable> &list = (OffsetArrayOf<PosLookupSubTable> &) subTable;
return SANITIZE_THIS (list);
{ return get_lookup (lookup_index).apply_string (context, buffer, mask); }
bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (GSUBGPOS::sanitize (SANITIZE_ARG)) return false;
OffsetTo<PosLookupList> &list = CAST(OffsetTo<PosLookupList>, lookupList, 0);
return SANITIZE_THIS (list);
inline bool ExtensionPos::sanitize (SANITIZE_ARG_DEF)
{
+ SANITIZE_DEBUG ();
return Extension::sanitize (SANITIZE_ARG) &&
(&(Extension::get_subtable ()) == &Null(LookupSubTable) ||
get_type () == PosLookupSubTable::Extension ||
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_THIS (coverage) && SANITIZE (deltaGlyphID);
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_THIS (coverage) && SANITIZE (substitute);
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!SANITIZE (u.format)) return false;
switch (u.format) {
case 1: return u.format1->sanitize (SANITIZE_ARG);
public:
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE (substitute);
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_THIS2 (coverage, sequence);
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!SANITIZE (u.format)) return false;
switch (u.format) {
case 1: return u.format1->sanitize (SANITIZE_ARG);
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_THIS2 (coverage, alternateSet);
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!SANITIZE (u.format)) return false;
switch (u.format) {
case 1: return u.format1->sanitize (SANITIZE_ARG);
public:
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE2 (ligGlyph, component);
}
public:
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_THIS (ligature);
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_THIS2 (coverage, ligatureSet);
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!SANITIZE (u.format)) return false;
switch (u.format) {
case 1: return u.format1->sanitize (SANITIZE_ARG);
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!SANITIZE_THIS2 (coverage, backtrack))
return false;
OffsetArrayOf<Coverage> &lookahead = CAST (OffsetArrayOf<Coverage>, backtrack, backtrack.get_size ());
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!SANITIZE (u.format)) return false;
switch (u.format) {
case 1: return u.format1->sanitize (SANITIZE_ARG);
}
bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!SANITIZE (u.format)) return false;
switch (u.format) {
case Single: return u.single->sanitize (SANITIZE_ARG);
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (Lookup::sanitize (SANITIZE_ARG)) return false;
OffsetArrayOf<SubstLookupSubTable> &list = (OffsetArrayOf<SubstLookupSubTable> &) subTable;
return SANITIZE_THIS (list);
bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (GSUBGPOS::sanitize (SANITIZE_ARG)) return false;
OffsetTo<SubstLookupList> &list = CAST(OffsetTo<SubstLookupList>, lookupList, 0);
return SANITIZE_THIS (list);
inline bool ExtensionSubst::sanitize (SANITIZE_ARG_DEF)
{
+ SANITIZE_DEBUG ();
return Extension::sanitize (SANITIZE_ARG) &&
(&(Extension::get_subtable ()) == &Null(LookupSubTable) ||
get_type () == SubstLookupSubTable::Extension ||
{
public:
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_SELF ();
}
public:
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!SANITIZE_SELF ()) return false;
return SANITIZE_MEM (input,
sizeof (input[0]) * inputCount +
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_THIS (rule);
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_THIS2 (coverage, ruleSet);
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_THIS3 (coverage, classDef, ruleSet);
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!SANITIZE_SELF ()) return false;
unsigned int count = glyphCount;
for (unsigned int i = 0; i < count; i++)
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!SANITIZE (u.format)) return false;
switch (u.format) {
case 1: return u.format1->sanitize (SANITIZE_ARG);
public:
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!SANITIZE (backtrack)) return false;
HeadlessArrayOf<USHORT> &input = CAST (HeadlessArrayOf<USHORT>, backtrack, backtrack.get_size ());
if (!SANITIZE (input)) return false;
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_THIS (rule);
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_THIS2 (coverage, ruleSet);
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_THIS2 (coverage, backtrackClassDef) &&
SANITIZE_THIS2 (inputClassDef, lookaheadClassDef) &&
SANITIZE_THIS (ruleSet);
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!SANITIZE_THIS (backtrack)) return false;
OffsetArrayOf<Coverage> &input = CAST (OffsetArrayOf<Coverage>, backtrack, backtrack.get_size ());
if (!SANITIZE_THIS (input)) return false;
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!SANITIZE (u.format)) return false;
switch (u.format) {
case 1: return u.format1->sanitize (SANITIZE_ARG);
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
return SANITIZE_SELF ();
}
}
inline bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!SANITIZE (u.format)) return false;
switch (u.format) {
case 1: return u.format1->sanitize (SANITIZE_ARG);
DEFINE_TAG_FIND_INTERFACE (Feature, feature); /* find_feature_index(), get_feature_by_tag(tag) */
bool sanitize (SANITIZE_ARG_DEF) {
+ SANITIZE_DEBUG ();
if (!SANITIZE (version)) return false;
if (version.major != 1) return true;
return SANITIZE_THIS3 (scriptList, featureList, lookupList);
#include "config.h"
#endif
+#define HB_DEBUG 1
+
#include <stdlib.h>
-#include <stdio.h> /* XXX */
#include <string.h>
#include <assert.h>
+#if HB_DEBUG
+#include <stdio.h> /* XXX */
+#endif
#include "hb-common.h"