walkero
/
harfbuzz
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

s/\<context\>/c/g

This commit is contained in:
Behdad Esfahbod 2010-05-13 14:18:49 -04:00
parent f679635893
commit d7cfb3b2d1
8 changed files with 679 additions and 679 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
src/hb-open-file-private.hh
View File

@ -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;
}
}

100
src/hb-open-type-private.hh
View File

@ -176,7 +176,7 @@ struct hb_trace_t<0> {
#define TRACE_SANITIZE() \
hb_trace_t<HB_DEBUG_SANITIZE> trace (&context->debug_depth, "SANITIZE", HB_FUNC, this); \
hb_trace_t<HB_DEBUG_SANITIZE> trace (&c->debug_depth, "SANITIZE", HB_FUNC, this); \
struct hb_sanitize_context_t
@ -278,7 +278,7 @@ template <typename Type>
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<Type> (const_cast<char *> (context->start));
Type *t = CastP<Type> (const_cast<char *> (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<Type> &o) const { return v == o.v; }
inline bool operator != (const IntType<Type> &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<Type, sizeof (Type)> 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<Type> (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<Type> (base, offset);
return likely (obj.sanitize (context)) || neuter (context);
return likely (obj.sanitize (c)) || neuter (c);
}
template <typename T>
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<Type> (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 <typename T>
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<Type>
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<Type>::sanitize (context, this);
return OffsetArrayOf<Type>::sanitize (c, this);
}
template <typename T>
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<Type>::sanitize (context, this, user_data);
return OffsetArrayOf<Type>::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;
}

84
src/hb-ot-layout-common-private.hh
View File

@ -51,10 +51,10 @@
template <typename Type>
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<Type>
inline const Type& operator [] (unsigned int i) const
{ return this+RecordArrayOf<Type>::operator [](i).offset; }
inline bool sanitize (hb_sanitize_context_t *context) {
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
return RecordArrayOf<Type>::sanitize (context, this);
return RecordArrayOf<Type>::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<USHORT> (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:

98
src/hb-ot-layout-gdef-private.hh
View File

@ -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<CaretValue> *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:

460
src/hb-ot-layout-gpos-private.hh
View File

File diff suppressed because it is too large Load Diff

306
src/hb-ot-layout-gsub-private.hh
View File

@ -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<SubstLookupSubTable> (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<Coverage> &lookahead = StructAfter<OffsetArrayOf<Coverage> > (backtrack);
const ArrayOf<GlyphID> &substitute = StructAfter<ArrayOf<GlyphID> > (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<Coverage> &lookahead = StructAfter<OffsetArrayOf<Coverage> > (backtrack);
if (!lookahead.sanitize (context, this))
if (!lookahead.sanitize (c, this))
return false;
ArrayOf<GlyphID> &substitute = StructAfter<ArrayOf<GlyphID> > (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<SubstLookupSubTable> &list = CastR<OffsetArrayOf<SubstLookupSubTable> > (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<SubstLookupList> &list = CastR<OffsetTo<SubstLookupList> > (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<SubstLookupSubTable> (this, offset).sanitize (context, get_type ());
return StructAtOffset<SubstLookupSubTable> (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);
}

258
src/hb-ot-layout-gsubgpos-private.hh
View File

@ -36,7 +36,7 @@
#endif
#define TRACE_APPLY() \
hb_trace_t<HB_DEBUG_APPLY> trace (&context->debug_depth, "APPLY", HB_FUNC, this); \
hb_trace_t<HB_DEBUG_APPLY> 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<LookupRecord> (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<LookupRecord> (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<USHORT> &input = StructAfter<HeadlessArrayOf<USHORT> > (backtrack);
const ArrayOf<USHORT> &lookahead = StructAfter<ArrayOf<USHORT> > (input);
const ArrayOf<LookupRecord> &lookup = StructAfter<ArrayOf<LookupRecord> > (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<USHORT> &input = StructAfter<HeadlessArrayOf<USHORT> > (backtrack);
if (!input.sanitize (context)) return false;
if (!input.sanitize (c)) return false;
ArrayOf<USHORT> &lookahead = StructAfter<ArrayOf<USHORT> > (input);
if (!lookahead.sanitize (context)) return false;
if (!lookahead.sanitize (c)) return false;
ArrayOf<LookupRecord> &lookup = StructAfter<ArrayOf<LookupRecord> > (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<Coverage> &input = StructAfter<OffsetArrayOf<Coverage> > (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<Coverage> &input = StructAfter<OffsetArrayOf<Coverage> > (backtrack);
if (!input.sanitize (context, this)) return false;
if (!input.sanitize (c, this)) return false;
OffsetArrayOf<Coverage> &lookahead = StructAfter<OffsetArrayOf<Coverage> > (input);
if (!lookahead.sanitize (context, this)) return false;
if (!lookahead.sanitize (c, this)) return false;
ArrayOf<LookupRecord> &lookup = StructAfter<ArrayOf<LookupRecord> > (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:

24
src/hb-ot-layout.cc
View File

@ -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