/*
- * Copyright (C) 2007,2008,2009 Red Hat, Inc.
+ * Copyright (C) 2007,2008,2009,2010 Red Hat, Inc.
*
* This is part of HarfBuzz, a text shaping library.
*
struct hb_apply_context_t
{
+ unsigned int debug_depth;
hb_ot_layout_context_t *layout;
hb_buffer_t *buffer;
unsigned int context_length;
unsigned int nesting_level_left;
unsigned int lookup_flag;
unsigned int property; /* propety of first glyph (TODO remove) */
- unsigned int debug_depth;
};
struct LookupRecord
{
- static inline unsigned int get_size () { return sizeof (LookupRecord); }
-
inline bool sanitize (hb_sanitize_context_t *context) {
TRACE_SANITIZE ();
- return SANITIZE_SELF ();
+ return context->check_struct (this);
}
USHORT sequenceIndex; /* Index into current glyph
* sequence--first glyph = 0 */
USHORT lookupListIndex; /* Lookup to apply to that
* position--zero--based */
+ public:
+ DEFINE_SIZE_STATIC (4);
};
-ASSERT_SIZE (LookupRecord, 4);
static inline bool apply_lookup (hb_apply_context_t *context,
unsigned int count, /* Including the first glyph */
const LookupRecord lookupRecord[],
ContextLookupContext &lookup_context)
{
- unsigned int new_context_length;
- if (!match_input (context,
- inputCount, input,
- lookup_context.funcs.match, lookup_context.match_data,
- &new_context_length)) return false;
- unsigned int old_context_length;
- old_context_length = context->context_length;
- context->context_length = new_context_length;
- bool ret = apply_lookup (context,
- inputCount,
- lookupCount, lookupRecord,
- lookup_context.funcs.apply);
- context->context_length = old_context_length;
- return ret;
+ hb_apply_context_t new_context = *context;
+ return match_input (context,
+ inputCount, input,
+ lookup_context.funcs.match, lookup_context.match_data,
+ &new_context.context_length)
+ && apply_lookup (&new_context,
+ inputCount,
+ lookupCount, lookupRecord,
+ lookup_context.funcs.apply);
}
struct Rule
inline bool apply (hb_apply_context_t *context, ContextLookupContext &lookup_context) const
{
TRACE_APPLY ();
- const LookupRecord *lookupRecord = &StructAtOffset<LookupRecord> (input, input[0].get_size () * (inputCount ? inputCount - 1 : 0));
+ const LookupRecord *lookupRecord = &StructAtOffset<LookupRecord> (input, input[0].static_size * (inputCount ? inputCount - 1 : 0));
return context_lookup (context,
inputCount, input,
lookupCount, lookupRecord,
public:
inline bool sanitize (hb_sanitize_context_t *context) {
TRACE_SANITIZE ();
- if (!(SANITIZE (inputCount) && SANITIZE (lookupCount))) return false;
- return SANITIZE_MEM (input,
- input[0].get_size () * inputCount +
- lookupRecordX[0].get_size () * lookupCount);
+ return inputCount.sanitize (context)
+ && lookupCount.sanitize (context)
+ && context->check_range (input,
+ input[0].static_size * inputCount
+ + lookupRecordX[0].static_size * lookupCount);
}
private:
* second glyph */
LookupRecord lookupRecordX[VAR]; /* Array of LookupRecords--in
* design order */
+ public:
+ DEFINE_SIZE_VAR2 (4, USHORT, LookupRecord);
};
-ASSERT_SIZE_VAR2 (Rule, 4, USHORT, LookupRecord);
struct RuleSet
{
inline bool sanitize (hb_sanitize_context_t *context) {
TRACE_SANITIZE ();
- return SANITIZE_WITH_BASE (this, rule);
+ return rule.sanitize (context, this);
}
private:
inline bool sanitize (hb_sanitize_context_t *context) {
TRACE_SANITIZE ();
- return SANITIZE_WITH_BASE (this, coverage)
- && SANITIZE_WITH_BASE (this, ruleSet);
+ return coverage.sanitize (context, this)
+ && ruleSet.sanitize (context, this);
}
private:
OffsetArrayOf<RuleSet>
ruleSet; /* Array of RuleSet tables
* ordered by Coverage Index */
+ public:
+ DEFINE_SIZE_STATIC (6);
};
-ASSERT_SIZE (ContextFormat1, 6);
struct ContextFormat2
inline bool sanitize (hb_sanitize_context_t *context) {
TRACE_SANITIZE ();
- return SANITIZE_WITH_BASE (this, coverage)
- && SANITIZE_WITH_BASE (this, classDef)
- && SANITIZE_WITH_BASE (this, ruleSet);
+ return coverage.sanitize (context, this)
+ && classDef.sanitize (context, this)
+ && ruleSet.sanitize (context, this);
}
private:
OffsetArrayOf<RuleSet>
ruleSet; /* Array of RuleSet tables
* ordered by class */
+ public:
+ DEFINE_SIZE_STATIC (8);
};
-ASSERT_SIZE (ContextFormat2, 8);
struct ContextFormat3
if (likely (index == NOT_COVERED))
return false;
- const LookupRecord *lookupRecord = &StructAtOffset<LookupRecord> (coverage, coverage[0].get_size () * glyphCount);
+ const LookupRecord *lookupRecord = &StructAtOffset<LookupRecord> (coverage, coverage[0].static_size * glyphCount);
struct ContextLookupContext lookup_context = {
{match_coverage, apply_func},
CharP(this)
inline bool sanitize (hb_sanitize_context_t *context) {
TRACE_SANITIZE ();
- if (!SANITIZE_SELF ()) return false;
+ if (!context->check_struct (this)) return false;
unsigned int count = glyphCount;
- if (!SANITIZE_ARRAY (coverage, OffsetTo<Coverage>::get_size (), glyphCount)) return false;
+ if (!context->check_array (coverage, coverage[0].static_size, count)) return false;
for (unsigned int i = 0; i < count; i++)
- if (!SANITIZE_WITH_BASE (this, coverage[i])) return false;
- LookupRecord *lookupRecord = &StructAtOffset<LookupRecord> (coverage, OffsetTo<Coverage>::get_size () * glyphCount);
- return SANITIZE_ARRAY (lookupRecord, LookupRecord::get_size (), lookupCount);
+ if (!coverage[i].sanitize (context, this)) return false;
+ LookupRecord *lookupRecord = &StructAtOffset<LookupRecord> (coverage, coverage[0].static_size * count);
+ return context->check_array (lookupRecord, lookupRecord[0].static_size, lookupCount);
}
private:
* table in glyph sequence order */
LookupRecord lookupRecordX[VAR]; /* Array of LookupRecords--in
* design order */
+ public:
+ DEFINE_SIZE_VAR2 (6, OffsetTo<Coverage>, LookupRecord);
};
-ASSERT_SIZE_VAR2 (ContextFormat3, 6, OffsetTo<Coverage>, LookupRecord);
struct Context
{
inline bool sanitize (hb_sanitize_context_t *context) {
TRACE_SANITIZE ();
- if (!SANITIZE (u.format)) return false;
+ if (!u.format.sanitize (context)) return false;
switch (u.format) {
case 1: return u.format1->sanitize (context);
case 2: return u.format2->sanitize (context);
inputCount + lookaheadCount > context->context_length))
return false;
- unsigned int offset;
- if (!(match_backtrack (context,
- backtrackCount, backtrack,
- lookup_context.funcs.match, lookup_context.match_data[0]) &&
- match_input (context,
- inputCount, input,
- lookup_context.funcs.match, lookup_context.match_data[1],
- &offset) &&
- match_lookahead (context,
- lookaheadCount, lookahead,
- lookup_context.funcs.match, lookup_context.match_data[2],
- offset))) return false;
-
- unsigned int old_context_length;
- old_context_length = context->context_length;
- context->context_length = offset;
- bool ret = apply_lookup (context,
- inputCount,
- lookupCount, lookupRecord,
- lookup_context.funcs.apply);
- context->context_length = old_context_length;
- return ret;
+ hb_apply_context_t new_context = *context;
+ return match_backtrack (context,
+ backtrackCount, backtrack,
+ lookup_context.funcs.match, lookup_context.match_data[0])
+ && match_input (context,
+ inputCount, input,
+ lookup_context.funcs.match, lookup_context.match_data[1],
+ &new_context.context_length)
+ && match_lookahead (context,
+ lookaheadCount, lookahead,
+ lookup_context.funcs.match, lookup_context.match_data[2],
+ new_context.context_length)
+ && apply_lookup (&new_context,
+ inputCount,
+ lookupCount, lookupRecord,
+ lookup_context.funcs.apply);
}
struct ChainRule
public:
inline bool sanitize (hb_sanitize_context_t *context) {
TRACE_SANITIZE ();
- if (!SANITIZE (backtrack)) return false;
+ if (!backtrack.sanitize (context)) return false;
HeadlessArrayOf<USHORT> &input = StructAfter<HeadlessArrayOf<USHORT> > (backtrack);
- if (!SANITIZE (input)) return false;
+ if (!input.sanitize (context)) return false;
ArrayOf<USHORT> &lookahead = StructAfter<ArrayOf<USHORT> > (input);
- if (!SANITIZE (lookahead)) return false;
+ if (!lookahead.sanitize (context)) return false;
ArrayOf<LookupRecord> &lookup = StructAfter<ArrayOf<LookupRecord> > (lookahead);
- return SANITIZE (lookup);
+ return lookup.sanitize (context);
}
private:
ArrayOf<LookupRecord>
lookupX; /* Array of LookupRecords--in
* design order) */
+ public:
+ DEFINE_SIZE_STATIC (8);
};
-ASSERT_SIZE (ChainRule, 8);
struct ChainRuleSet
{
inline bool sanitize (hb_sanitize_context_t *context) {
TRACE_SANITIZE ();
- return SANITIZE_WITH_BASE (this, rule);
+ return rule.sanitize (context, this);
}
private:
OffsetArrayOf<ChainRule>
rule; /* Array of ChainRule tables
* ordered by preference */
+ public:
+ DEFINE_SIZE_STATIC (2);
};
-ASSERT_SIZE (ChainRuleSet, 2);
struct ChainContextFormat1
{
inline bool sanitize (hb_sanitize_context_t *context) {
TRACE_SANITIZE ();
- return SANITIZE_WITH_BASE (this, coverage)
- && SANITIZE_WITH_BASE (this, ruleSet);
+ return coverage.sanitize (context, this)
+ && ruleSet.sanitize (context, this);
}
private:
OffsetArrayOf<ChainRuleSet>
ruleSet; /* Array of ChainRuleSet tables
* ordered by Coverage Index */
+ public:
+ DEFINE_SIZE_STATIC (6);
};
-ASSERT_SIZE (ChainContextFormat1, 6);
struct ChainContextFormat2
{
inline bool sanitize (hb_sanitize_context_t *context) {
TRACE_SANITIZE ();
- return SANITIZE_WITH_BASE (this, coverage)
- && SANITIZE_WITH_BASE (this, backtrackClassDef)
- && SANITIZE_WITH_BASE (this, inputClassDef)
- && SANITIZE_WITH_BASE (this, lookaheadClassDef)
- && SANITIZE_WITH_BASE (this, ruleSet);
+ return coverage.sanitize (context, this)
+ && backtrackClassDef.sanitize (context, this)
+ && inputClassDef.sanitize (context, this)
+ && lookaheadClassDef.sanitize (context, this)
+ && ruleSet.sanitize (context, this);
}
private:
OffsetArrayOf<ChainRuleSet>
ruleSet; /* Array of ChainRuleSet tables
* ordered by class */
+ public:
+ DEFINE_SIZE_STATIC (12);
};
-ASSERT_SIZE (ChainContextFormat2, 12);
struct ChainContextFormat3
{
inline bool sanitize (hb_sanitize_context_t *context) {
TRACE_SANITIZE ();
- if (!SANITIZE_WITH_BASE (this, backtrack)) return false;
+ if (!backtrack.sanitize (context, this)) return false;
OffsetArrayOf<Coverage> &input = StructAfter<OffsetArrayOf<Coverage> > (backtrack);
- if (!SANITIZE_WITH_BASE (this, input)) return false;
+ if (!input.sanitize (context, this)) return false;
OffsetArrayOf<Coverage> &lookahead = StructAfter<OffsetArrayOf<Coverage> > (input);
- if (!SANITIZE_WITH_BASE (this, lookahead)) return false;
+ if (!lookahead.sanitize (context, this)) return false;
ArrayOf<LookupRecord> &lookup = StructAfter<ArrayOf<LookupRecord> > (lookahead);
- return SANITIZE (lookup);
+ return lookup.sanitize (context);
}
private:
ArrayOf<LookupRecord>
lookupX; /* Array of LookupRecords--in
* design order) */
+ public:
+ DEFINE_SIZE_STATIC (10);
};
-ASSERT_SIZE (ChainContextFormat3, 10);
struct ChainContext
{
inline bool sanitize (hb_sanitize_context_t *context) {
TRACE_SANITIZE ();
- if (!SANITIZE (u.format)) return false;
+ if (!u.format.sanitize (context)) return false;
switch (u.format) {
case 1: return u.format1->sanitize (context);
case 2: return u.format2->sanitize (context);
inline bool sanitize (hb_sanitize_context_t *context) {
TRACE_SANITIZE ();
- return SANITIZE_SELF ();
+ return context->check_struct (this);
}
private:
* extension subtable). */
ULONG extensionOffset; /* Offset to the extension subtable,
* of lookup type subtable. */
+ public:
+ DEFINE_SIZE_STATIC (8);
};
-ASSERT_SIZE (ExtensionFormat1, 8);
struct Extension
{
inline bool sanitize (hb_sanitize_context_t *context) {
TRACE_SANITIZE ();
- if (!SANITIZE (u.format)) return false;
+ if (!u.format.sanitize (context)) return false;
switch (u.format) {
case 1: return u.format1->sanitize (context);
default:return true;
inline bool sanitize (hb_sanitize_context_t *context) {
TRACE_SANITIZE ();
- return SANITIZE (version) && likely (version.major == 1)
- && SANITIZE_WITH_BASE (this, scriptList)
- && SANITIZE_WITH_BASE (this, featureList)
- && SANITIZE_WITH_BASE (this, lookupList);
+ return version.sanitize (context) && likely (version.major == 1)
+ && scriptList.sanitize (context, this)
+ && featureList.sanitize (context, this)
+ && lookupList.sanitize (context, this);
}
protected:
featureList; /* FeatureList table */
OffsetTo<LookupList>
lookupList; /* LookupList table */
+ public:
+ DEFINE_SIZE_STATIC (10);
};
-ASSERT_SIZE (GSUBGPOS, 10);
#endif /* HB_OT_LAYOUT_GSUBGPOS_PRIVATE_HH */
projects / framework / uifw / harfbuzz.git / blobdiff