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. */
}
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:
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:
}
}
- 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;
}
}
}
}
- 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;
}
}
#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
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 */
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)
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;
{
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;
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;
}
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.
* 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:
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);
}
};
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.
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;
}
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 */
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);
}
};
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
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:
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() */
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;
}
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:
}
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:
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:
}
}
- 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;
}
}
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 */
}
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:
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 */
}
}
- 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;
}
}
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:
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:
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:
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:
{
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:
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;
}
}
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 */,
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:
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 */,
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:
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:
}
}
- 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;
}
}
{ 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:
#undef BUFFER
-#define BUFFER context->buffer
+#define BUFFER c->buffer
#define HB_OT_LAYOUT_GPOS_NO_LAST ((unsigned int) -1)
}
private:
- inline bool sanitize_value_devices (hb_sanitize_context_t *context, void *base, Value *values) {
+ inline bool sanitize_value_devices (hb_sanitize_context_t *c, void *base, Value *values) {
unsigned int format = *this;
if (format & xPlacement) values++;
if (format & xAdvance) values++;
if (format & yAdvance) values++;
- if ((format & xPlaDevice) && !get_device (values++).sanitize (context, base)) return false;
- if ((format & yPlaDevice) && !get_device (values++).sanitize (context, base)) return false;
- if ((format & xAdvDevice) && !get_device (values++).sanitize (context, base)) return false;
- if ((format & yAdvDevice) && !get_device (values++).sanitize (context, base)) return false;
+ if ((format & xPlaDevice) && !get_device (values++).sanitize (c, base)) return false;
+ if ((format & yPlaDevice) && !get_device (values++).sanitize (c, base)) return false;
+ if ((format & xAdvDevice) && !get_device (values++).sanitize (c, base)) return false;
+ if ((format & yAdvDevice) && !get_device (values++).sanitize (c, base)) return false;
return true;
}
return (format & devices) != 0;
}
- inline bool sanitize_value (hb_sanitize_context_t *context, void *base, Value *values) {
+ inline bool sanitize_value (hb_sanitize_context_t *c, void *base, Value *values) {
TRACE_SANITIZE ();
- return context->check_range (values, get_size ())
- && (!has_device () || sanitize_value_devices (context, base, values));
+ return c->check_range (values, get_size ())
+ && (!has_device () || sanitize_value_devices (c, base, values));
}
- inline bool sanitize_values (hb_sanitize_context_t *context, void *base, Value *values, unsigned int count) {
+ inline bool sanitize_values (hb_sanitize_context_t *c, void *base, Value *values, unsigned int count) {
TRACE_SANITIZE ();
unsigned int len = get_len ();
- if (!context->check_array (values, get_size (), count)) return false;
+ if (!c->check_array (values, get_size (), count)) return false;
if (!has_device ()) return true;
for (unsigned int i = 0; i < count; i++) {
- if (!sanitize_value_devices (context, base, values))
+ if (!sanitize_value_devices (c, base, values))
return false;
values += len;
}
}
/* Just sanitize referenced Device tables. Doesn't check the values themselves. */
- inline bool sanitize_values_stride_unsafe (hb_sanitize_context_t *context, void *base, Value *values, unsigned int count, unsigned int stride) {
+ inline bool sanitize_values_stride_unsafe (hb_sanitize_context_t *c, void *base, Value *values, unsigned int count, unsigned int stride) {
TRACE_SANITIZE ();
if (!has_device ()) return true;
for (unsigned int i = 0; i < count; i++) {
- if (!sanitize_value_devices (context, base, values))
+ if (!sanitize_value_devices (c, base, values))
return false;
values += stride;
}
*y = _hb_16dot16_mul_round (layout->font->y_scale, yCoordinate);
}
- inline bool sanitize (hb_sanitize_context_t *context) {
+ inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
- return context->check_struct (this);
+ return c->check_struct (this);
}
private:
*y = y_ppem && ret ? cy : _hb_16dot16_mul_round (layout->font->y_scale, yCoordinate);
}
- inline bool sanitize (hb_sanitize_context_t *context) {
+ inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
- return context->check_struct (this);
+ return c->check_struct (this);
}
private:
*y += (this+yDeviceTable).get_delta (layout->font->y_ppem) << 16;
}
- inline bool sanitize (hb_sanitize_context_t *context) {
+ inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
- return context->check_struct (this)
- && xDeviceTable.sanitize (context, this)
- && yDeviceTable.sanitize (context, this);
+ return c->check_struct (this)
+ && xDeviceTable.sanitize (c, this)
+ && yDeviceTable.sanitize (c, this);
}
private:
}
}
- 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;
}
}
return this+matrix[row * cols + col];
}
- inline bool sanitize (hb_sanitize_context_t *context, unsigned int cols) {
+ inline bool sanitize (hb_sanitize_context_t *c, unsigned int cols) {
TRACE_SANITIZE ();
- if (!context->check_struct (this)) return false;
+ if (!c->check_struct (this)) return false;
if (unlikely (cols >= ((unsigned int) -1) / rows)) return false;
unsigned int count = rows * cols;
- if (!context->check_array (matrix, matrix[0].static_size, count)) return false;
+ if (!c->check_array (matrix, matrix[0].static_size, count)) return false;
for (unsigned int i = 0; i < count; i++)
- if (!matrix[i].sanitize (context, this)) return false;
+ if (!matrix[i].sanitize (c, this)) return false;
return true;
}
{
friend struct MarkArray;
- inline bool sanitize (hb_sanitize_context_t *context, void *base) {
+ inline bool sanitize (hb_sanitize_context_t *c, void *base) {
TRACE_SANITIZE ();
- return context->check_struct (this)
- && markAnchor.sanitize (context, base);
+ return c->check_struct (this)
+ && markAnchor.sanitize (c, base);
}
private:
struct MarkArray : ArrayOf<MarkRecord> /* Array of MarkRecords--in Coverage order */
{
- inline bool apply (hb_apply_context_t *context,
+ inline bool apply (hb_apply_context_t *c,
unsigned int mark_index, unsigned int glyph_index,
const AnchorMatrix &anchors, unsigned int class_count,
unsigned int glyph_pos) const
hb_position_t mark_x, mark_y, base_x, base_y;
- mark_anchor.get_anchor (context->layout, IN_CURGLYPH (), &mark_x, &mark_y);
- glyph_anchor.get_anchor (context->layout, IN_GLYPH (glyph_pos), &base_x, &base_y);
+ mark_anchor.get_anchor (c->layout, IN_CURGLYPH (), &mark_x, &mark_y);
+ glyph_anchor.get_anchor (c->layout, IN_GLYPH (glyph_pos), &base_x, &base_y);
- hb_internal_glyph_position_t *o = POSITION (context->buffer->in_pos);
+ hb_internal_glyph_position_t *o = POSITION (c->buffer->in_pos);
o->x_advance = 0;
o->y_advance = 0;
o->x_offset = base_x - mark_x;
o->y_offset = base_y - mark_y;
- o->back = context->buffer->in_pos - glyph_pos;
+ o->back = c->buffer->in_pos - glyph_pos;
- context->buffer->in_pos++;
+ c->buffer->in_pos++;
return true;
}
- inline bool sanitize (hb_sanitize_context_t *context) {
+ inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
- return ArrayOf<MarkRecord>::sanitize (context, this);
+ return ArrayOf<MarkRecord>::sanitize (c, this);
}
};
friend struct SinglePos;
private:
- inline bool apply (hb_apply_context_t *context) const
+ inline bool apply (hb_apply_context_t *c) const
{
TRACE_APPLY ();
unsigned int index = (this+coverage) (IN_CURGLYPH ());
if (likely (index == NOT_COVERED))
return false;
- valueFormat.apply_value (context->layout, this, values, CURPOSITION ());
+ valueFormat.apply_value (c->layout, this, values, CURPOSITION ());
- context->buffer->in_pos++;
+ c->buffer->in_pos++;
return true;
}
- inline bool sanitize (hb_sanitize_context_t *context) {
+ inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
- return context->check_struct (this)
- && coverage.sanitize (context, this)
- && valueFormat.sanitize_value (context, this, values);
+ return c->check_struct (this)
+ && coverage.sanitize (c, this)
+ && valueFormat.sanitize_value (c, this, values);
}
private:
friend struct SinglePos;
private:
- inline bool apply (hb_apply_context_t *context) const
+ inline bool apply (hb_apply_context_t *c) const
{
TRACE_APPLY ();
unsigned int index = (this+coverage) (IN_CURGLYPH ());
if (likely (index >= valueCount))
return false;
- valueFormat.apply_value (context->layout, this,
+ valueFormat.apply_value (c->layout, this,
&values[index * valueFormat.get_len ()],
CURPOSITION ());
- context->buffer->in_pos++;
+ c->buffer->in_pos++;
return true;
}
- inline bool sanitize (hb_sanitize_context_t *context) {
+ inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
- return context->check_struct (this)
- && coverage.sanitize (context, this)
- && valueFormat.sanitize_values (context, this, values, valueCount);
+ return c->check_struct (this)
+ && coverage.sanitize (c, this)
+ && valueFormat.sanitize_values (c, this, values, valueCount);
}
private:
friend struct PosLookupSubTable;
private:
- inline bool apply (hb_apply_context_t *context) const
+ inline bool apply (hb_apply_context_t *c) const
{
TRACE_APPLY ();
switch (u.format) {
- case 1: return u.format1.apply (context);
- case 2: return u.format2.apply (context);
+ case 1: return u.format1.apply (c);
+ case 2: return u.format2.apply (c);
default:return false;
}
}
- inline bool sanitize (hb_sanitize_context_t *context) {
+ inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
- if (!u.format.sanitize (context)) return false;
+ if (!u.format.sanitize (c)) return false;
switch (u.format) {
- case 1: return u.format1.sanitize (context);
- case 2: return u.format2.sanitize (context);
+ case 1: return u.format1.sanitize (c);
+ case 2: return u.format2.sanitize (c);
default:return true;
}
}
{
friend struct PairPosFormat1;
- inline bool apply (hb_apply_context_t *context,
+ inline bool apply (hb_apply_context_t *c,
const ValueFormat *valueFormats,
unsigned int pos) const
{
{
if (IN_GLYPH (pos) == record->secondGlyph)
{
- valueFormats[0].apply_value (context->layout, this, &record->values[0], CURPOSITION ());
- valueFormats[1].apply_value (context->layout, this, &record->values[len1], POSITION (pos));
+ valueFormats[0].apply_value (c->layout, this, &record->values[0], CURPOSITION ());
+ valueFormats[1].apply_value (c->layout, this, &record->values[len1], POSITION (pos));
if (len2)
pos++;
- context->buffer->in_pos = pos;
+ c->buffer->in_pos = pos;
return true;
}
record = &StructAtOffset<PairValueRecord> (record, record_size);
unsigned int stride; /* 1 + len1 + len2 */
};
- inline bool sanitize (hb_sanitize_context_t *context, const sanitize_closure_t *closure) {
+ inline bool sanitize (hb_sanitize_context_t *c, const sanitize_closure_t *closure) {
TRACE_SANITIZE ();
- if (!(context->check_struct (this)
- && context->check_array (array, USHORT::static_size * closure->stride, len))) return false;
+ if (!(c->check_struct (this)
+ && c->check_array (array, USHORT::static_size * closure->stride, len))) return false;
unsigned int count = len;
PairValueRecord *record = CastP<PairValueRecord> (array);
- return closure->valueFormats[0].sanitize_values_stride_unsafe (context, closure->base, &record->values[0], count, closure->stride)
- && closure->valueFormats[1].sanitize_values_stride_unsafe (context, closure->base, &record->values[closure->len1], count, closure->stride);
+ return closure->valueFormats[0].sanitize_values_stride_unsafe (c, closure->base, &record->values[0], count, closure->stride)
+ && closure->valueFormats[1].sanitize_values_stride_unsafe (c, closure->base, &record->values[closure->len1], count, closure->stride);
}
private:
friend struct PairPos;
private:
- inline bool apply (hb_apply_context_t *context) const
+ inline bool apply (hb_apply_context_t *c) const
{
TRACE_APPLY ();
- unsigned int end = MIN (context->buffer->in_length, context->buffer->in_pos + context->context_length);
- if (unlikely (context->buffer->in_pos + 2 > end))
+ unsigned int end = MIN (c->buffer->in_length, c->buffer->in_pos + c->context_length);
+ if (unlikely (c->buffer->in_pos + 2 > end))
return false;
unsigned int index = (this+coverage) (IN_CURGLYPH ());
if (likely (index == NOT_COVERED))
return false;
- unsigned int j = context->buffer->in_pos + 1;
- while (_hb_ot_layout_skip_mark (context->layout->face, IN_INFO (j), context->lookup_flag, NULL))
+ unsigned int j = c->buffer->in_pos + 1;
+ while (_hb_ot_layout_skip_mark (c->layout->face, IN_INFO (j), c->lookup_flag, NULL))
{
if (unlikely (j == end))
return false;
j++;
}
- return (this+pairSet[index]).apply (context, &valueFormat1, j);
+ return (this+pairSet[index]).apply (c, &valueFormat1, j);
}
- inline bool sanitize (hb_sanitize_context_t *context) {
+ inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
unsigned int len1 = valueFormat1.get_len ();
1 + len1 + len2
};
- return context->check_struct (this)
- && coverage.sanitize (context, this)
- && pairSet.sanitize (context, this, &closure);
+ return c->check_struct (this)
+ && coverage.sanitize (c, this)
+ && pairSet.sanitize (c, this, &closure);
}
private:
friend struct PairPos;
private:
- inline bool apply (hb_apply_context_t *context) const
+ inline bool apply (hb_apply_context_t *c) const
{
TRACE_APPLY ();
- unsigned int end = MIN (context->buffer->in_length, context->buffer->in_pos + context->context_length);
- if (unlikely (context->buffer->in_pos + 2 > end))
+ unsigned int end = MIN (c->buffer->in_length, c->buffer->in_pos + c->context_length);
+ if (unlikely (c->buffer->in_pos + 2 > end))
return false;
unsigned int index = (this+coverage) (IN_CURGLYPH ());
if (likely (index == NOT_COVERED))
return false;
- unsigned int j = context->buffer->in_pos + 1;
- while (_hb_ot_layout_skip_mark (context->layout->face, IN_INFO (j), context->lookup_flag, NULL))
+ unsigned int j = c->buffer->in_pos + 1;
+ while (_hb_ot_layout_skip_mark (c->layout->face, IN_INFO (j), c->lookup_flag, NULL))
{
if (unlikely (j == end))
return false;
return false;
const Value *v = &values[record_len * (klass1 * class2Count + klass2)];
- valueFormat1.apply_value (context->layout, this, v, CURPOSITION ());
- valueFormat2.apply_value (context->layout, this, v + len1, POSITION (j));
+ valueFormat1.apply_value (c->layout, this, v, CURPOSITION ());
+ valueFormat2.apply_value (c->layout, this, v + len1, POSITION (j));
if (len2)
j++;
- context->buffer->in_pos = j;
+ c->buffer->in_pos = j;
return true;
}
- inline bool sanitize (hb_sanitize_context_t *context) {
+ inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
- if (!(context->check_struct (this)
- && coverage.sanitize (context, this)
- && classDef1.sanitize (context, this)
- && classDef2.sanitize (context, this))) return false;
+ if (!(c->check_struct (this)
+ && coverage.sanitize (c, this)
+ && classDef1.sanitize (c, this)
+ && classDef2.sanitize (c, this))) return false;
unsigned int len1 = valueFormat1.get_len ();
unsigned int len2 = valueFormat2.get_len ();
unsigned int stride = len1 + len2;
unsigned int record_size = valueFormat1.get_size () + valueFormat2.get_size ();
unsigned int count = (unsigned int) class1Count * (unsigned int) class2Count;
- return context->check_array (values, record_size, count) &&
- valueFormat1.sanitize_values_stride_unsafe (context, this, &values[0], count, stride) &&
- valueFormat2.sanitize_values_stride_unsafe (context, this, &values[len1], count, stride);
+ return c->check_array (values, record_size, count) &&
+ valueFormat1.sanitize_values_stride_unsafe (c, this, &values[0], count, stride) &&
+ valueFormat2.sanitize_values_stride_unsafe (c, this, &values[len1], count, stride);
}
private:
friend struct PosLookupSubTable;
private:
- inline bool apply (hb_apply_context_t *context) const
+ inline bool apply (hb_apply_context_t *c) const
{
TRACE_APPLY ();
switch (u.format) {
- case 1: return u.format1.apply (context);
- case 2: return u.format2.apply (context);
+ case 1: return u.format1.apply (c);
+ case 2: return u.format2.apply (c);
default:return false;
}
}
- inline bool sanitize (hb_sanitize_context_t *context) {
+ inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
- if (!u.format.sanitize (context)) return false;
+ if (!u.format.sanitize (c)) return false;
switch (u.format) {
- case 1: return u.format1.sanitize (context);
- case 2: return u.format2.sanitize (context);
+ case 1: return u.format1.sanitize (c);
+ case 2: return u.format2.sanitize (c);
default:return true;
}
}
{
friend struct CursivePosFormat1;
- inline bool sanitize (hb_sanitize_context_t *context, void *base) {
+ inline bool sanitize (hb_sanitize_context_t *c, void *base) {
TRACE_SANITIZE ();
- return entryAnchor.sanitize (context, base)
- && exitAnchor.sanitize (context, base);
+ return entryAnchor.sanitize (c, base)
+ && exitAnchor.sanitize (c, base);
}
private:
friend struct CursivePos;
private:
- inline bool apply (hb_apply_context_t *context) const
+ inline bool apply (hb_apply_context_t *c) const
{
TRACE_APPLY ();
/* Now comes the messiest part of the whole OpenType
Since horizontal advance widths or vertical advance heights
can be used alone but not together, no ambiguity occurs. */
- struct hb_ot_layout_context_t::info_t::gpos_t *gpi = &context->layout->info.gpos;
+ struct hb_ot_layout_context_t::info_t::gpos_t *gpi = &c->layout->info.gpos;
hb_codepoint_t last_pos = gpi->last;
gpi->last = HB_OT_LAYOUT_GPOS_NO_LAST;
/* We don't handle mark glyphs here. */
- if (context->property == HB_OT_LAYOUT_GLYPH_CLASS_MARK)
+ if (c->property == HB_OT_LAYOUT_GLYPH_CLASS_MARK)
return false;
unsigned int index = (this+coverage) (IN_CURGLYPH ());
goto end;
hb_position_t entry_x, entry_y;
- (this+record.entryAnchor).get_anchor (context->layout, IN_CURGLYPH (), &entry_x, &entry_y);
+ (this+record.entryAnchor).get_anchor (c->layout, IN_CURGLYPH (), &entry_x, &entry_y);
/* TODO vertical */
- if (context->buffer->direction == HB_DIRECTION_RTL)
+ if (c->buffer->direction == HB_DIRECTION_RTL)
{
/* advance is absolute, not relative */
- POSITION (context->buffer->in_pos)->x_advance = entry_x - gpi->anchor_x;
+ POSITION (c->buffer->in_pos)->x_advance = entry_x - gpi->anchor_x;
}
else
{
POSITION (last_pos)->x_advance = gpi->anchor_x - entry_x;
}
- if (context->lookup_flag & LookupFlag::RightToLeft)
+ if (c->lookup_flag & LookupFlag::RightToLeft)
{
- POSITION (last_pos)->cursive_chain = last_pos - context->buffer->in_pos;
+ POSITION (last_pos)->cursive_chain = last_pos - c->buffer->in_pos;
POSITION (last_pos)->y_offset = entry_y - gpi->anchor_y;
}
else
{
- POSITION (context->buffer->in_pos)->cursive_chain = context->buffer->in_pos - last_pos;
- POSITION (context->buffer->in_pos)->y_offset = gpi->anchor_y - entry_y;
+ POSITION (c->buffer->in_pos)->cursive_chain = c->buffer->in_pos - last_pos;
+ POSITION (c->buffer->in_pos)->y_offset = gpi->anchor_y - entry_y;
}
end:
if (record.exitAnchor)
{
- gpi->last = context->buffer->in_pos;
- (this+record.exitAnchor).get_anchor (context->layout, IN_CURGLYPH (), &gpi->anchor_x, &gpi->anchor_y);
+ gpi->last = c->buffer->in_pos;
+ (this+record.exitAnchor).get_anchor (c->layout, IN_CURGLYPH (), &gpi->anchor_x, &gpi->anchor_y);
}
- context->buffer->in_pos++;
+ c->buffer->in_pos++;
return true;
}
- inline bool sanitize (hb_sanitize_context_t *context) {
+ inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
- return coverage.sanitize (context, this)
- && entryExitRecord.sanitize (context, this);
+ return coverage.sanitize (c, this)
+ && entryExitRecord.sanitize (c, this);
}
private:
friend struct PosLookupSubTable;
private:
- inline bool apply (hb_apply_context_t *context) const
+ inline bool apply (hb_apply_context_t *c) const
{
TRACE_APPLY ();
switch (u.format) {
- case 1: return u.format1.apply (context);
+ case 1: return u.format1.apply (c);
default:return false;
}
}
- inline bool sanitize (hb_sanitize_context_t *context) {
+ inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
- if (!u.format.sanitize (context)) return false;
+ if (!u.format.sanitize (c)) return false;
switch (u.format) {
- case 1: return u.format1.sanitize (context);
+ case 1: return u.format1.sanitize (c);
default:return true;
}
}
friend struct MarkBasePos;
private:
- inline bool apply (hb_apply_context_t *context) const
+ inline bool apply (hb_apply_context_t *c) const
{
TRACE_APPLY ();
unsigned int mark_index = (this+markCoverage) (IN_CURGLYPH ());
/* now we search backwards for a non-mark glyph */
unsigned int property;
- unsigned int j = context->buffer->in_pos;
+ unsigned int j = c->buffer->in_pos;
do
{
if (unlikely (!j))
return false;
j--;
- } while (_hb_ot_layout_skip_mark (context->layout->face, IN_INFO (j), LookupFlag::IgnoreMarks, &property));
+ } while (_hb_ot_layout_skip_mark (c->layout->face, IN_INFO (j), LookupFlag::IgnoreMarks, &property));
/* The following assertion is too strong, so we've disabled it. */
if (false && !(property & HB_OT_LAYOUT_GLYPH_CLASS_BASE_GLYPH))
if (base_index == NOT_COVERED)
return false;
- return (this+markArray).apply (context, mark_index, base_index, this+baseArray, classCount, j);
+ return (this+markArray).apply (c, mark_index, base_index, this+baseArray, classCount, j);
}
- inline bool sanitize (hb_sanitize_context_t *context) {
+ inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
- return context->check_struct (this)
- && markCoverage.sanitize (context, this)
- && baseCoverage.sanitize (context, this)
- && markArray.sanitize (context, this)
- && baseArray.sanitize (context, this, (unsigned int) classCount);
+ return c->check_struct (this)
+ && markCoverage.sanitize (c, this)
+ && baseCoverage.sanitize (c, this)
+ && markArray.sanitize (c, this)
+ && baseArray.sanitize (c, this, (unsigned int) classCount);
}
private:
friend struct PosLookupSubTable;
private:
- inline bool apply (hb_apply_context_t *context) const
+ inline bool apply (hb_apply_context_t *c) const
{
TRACE_APPLY ();
switch (u.format) {
- case 1: return u.format1.apply (context);
+ case 1: return u.format1.apply (c);
default:return false;
}
}
- inline bool sanitize (hb_sanitize_context_t *context) {
+ inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
- if (!u.format.sanitize (context)) return false;
+ if (!u.format.sanitize (c)) return false;
switch (u.format) {
- case 1: return u.format1.sanitize (context);
+ case 1: return u.format1.sanitize (c);
default:return true;
}
}
friend struct MarkLigPos;
private:
- inline bool apply (hb_apply_context_t *context) const
+ inline bool apply (hb_apply_context_t *c) const
{
TRACE_APPLY ();
unsigned int mark_index = (this+markCoverage) (IN_CURGLYPH ());
/* now we search backwards for a non-mark glyph */
unsigned int property;
- unsigned int j = context->buffer->in_pos;
+ unsigned int j = c->buffer->in_pos;
do
{
if (unlikely (!j))
return false;
j--;
- } while (_hb_ot_layout_skip_mark (context->layout->face, IN_INFO (j), LookupFlag::IgnoreMarks, &property));
+ } while (_hb_ot_layout_skip_mark (c->layout->face, IN_INFO (j), LookupFlag::IgnoreMarks, &property));
/* The following assertion is too strong, so we've disabled it. */
if (false && !(property & HB_OT_LAYOUT_GLYPH_CLASS_LIGATURE))
* is identical to the ligature ID of the found ligature. If yes, we
* can directly use the component index. If not, we attach the mark
* glyph to the last component of the ligature. */
- if (IN_LIGID (j) && IN_LIGID (j) == IN_LIGID (context->buffer->in_pos) && IN_COMPONENT (context->buffer->in_pos))
+ if (IN_LIGID (j) && IN_LIGID (j) == IN_LIGID (c->buffer->in_pos) && IN_COMPONENT (c->buffer->in_pos))
{
- comp_index = IN_COMPONENT (context->buffer->in_pos) - 1;
+ comp_index = IN_COMPONENT (c->buffer->in_pos) - 1;
if (comp_index >= comp_count)
comp_index = comp_count - 1;
}
else
comp_index = comp_count - 1;
- return (this+markArray).apply (context, mark_index, comp_index, lig_attach, classCount, j);
+ return (this+markArray).apply (c, mark_index, comp_index, lig_attach, classCount, j);
}
- inline bool sanitize (hb_sanitize_context_t *context) {
+ inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
- return context->check_struct (this)
- && markCoverage.sanitize (context, this)
- && ligatureCoverage.sanitize (context, this)
- && markArray.sanitize (context, this)
- && ligatureArray.sanitize (context, this, (unsigned int) classCount);
+ return c->check_struct (this)
+ && markCoverage.sanitize (c, this)
+ && ligatureCoverage.sanitize (c, this)
+ && markArray.sanitize (c, this)
+ && ligatureArray.sanitize (c, this, (unsigned int) classCount);
}
private:
friend struct PosLookupSubTable;
private:
- inline bool apply (hb_apply_context_t *context) const
+ inline bool apply (hb_apply_context_t *c) const
{
TRACE_APPLY ();
switch (u.format) {
- case 1: return u.format1.apply (context);
+ case 1: return u.format1.apply (c);
default:return false;
}
}
- inline bool sanitize (hb_sanitize_context_t *context) {
+ inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
- if (!u.format.sanitize (context)) return false;
+ if (!u.format.sanitize (c)) return false;
switch (u.format) {
- case 1: return u.format1.sanitize (context);
+ case 1: return u.format1.sanitize (c);
default:return true;
}
}
friend struct MarkMarkPos;
private:
- inline bool apply (hb_apply_context_t *context) const
+ inline bool apply (hb_apply_context_t *c) const
{
TRACE_APPLY ();
unsigned int mark1_index = (this+mark1Coverage) (IN_CURGLYPH ());
/* now we search backwards for a suitable mark glyph until a non-mark glyph */
unsigned int property;
- unsigned int j = context->buffer->in_pos;
+ unsigned int j = c->buffer->in_pos;
do
{
if (unlikely (!j))
return false;
j--;
- } while (_hb_ot_layout_skip_mark (context->layout->face, IN_INFO (j), context->lookup_flag, &property));
+ } while (_hb_ot_layout_skip_mark (c->layout->face, IN_INFO (j), c->lookup_flag, &property));
if (!(property & HB_OT_LAYOUT_GLYPH_CLASS_MARK))
return false;
/* Two marks match only if they belong to the same base, or same component
* of the same ligature. That is, the component numbers must match, and
* if those are non-zero, the ligid number should also match. */
- if ((IN_COMPONENT (j) != IN_COMPONENT (context->buffer->in_pos)) ||
- (IN_COMPONENT (j) && IN_LIGID (j) != IN_LIGID (context->buffer->in_pos)))
+ if ((IN_COMPONENT (j) != IN_COMPONENT (c->buffer->in_pos)) ||
+ (IN_COMPONENT (j) && IN_LIGID (j) != IN_LIGID (c->buffer->in_pos)))
return false;
unsigned int mark2_index = (this+mark2Coverage) (IN_GLYPH (j));
if (mark2_index == NOT_COVERED)
return false;
- return (this+mark1Array).apply (context, mark1_index, mark2_index, this+mark2Array, classCount, j);
+ return (this+mark1Array).apply (c, mark1_index, mark2_index, this+mark2Array, classCount, j);
}
- inline bool sanitize (hb_sanitize_context_t *context) {
+ inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
- return context->check_struct (this)
- && mark1Coverage.sanitize (context, this)
- && mark2Coverage.sanitize (context, this)
- && mark1Array.sanitize (context, this)
- && mark2Array.sanitize (context, this, (unsigned int) classCount);
+ return c->check_struct (this)
+ && mark1Coverage.sanitize (c, this)
+ && mark2Coverage.sanitize (c, this)
+ && mark1Array.sanitize (c, this)
+ && mark2Array.sanitize (c, this, (unsigned int) classCount);
}
private:
friend struct PosLookupSubTable;
private:
- inline bool apply (hb_apply_context_t *context) const
+ inline bool apply (hb_apply_context_t *c) const
{
TRACE_APPLY ();
switch (u.format) {
- case 1: return u.format1.apply (context);
+ case 1: return u.format1.apply (c);
default:return false;
}
}
- inline bool sanitize (hb_sanitize_context_t *context) {
+ inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
- if (!u.format.sanitize (context)) return false;
+ if (!u.format.sanitize (c)) return false;
switch (u.format) {
- case 1: return u.format1.sanitize (context);
+ case 1: return u.format1.sanitize (c);
default:return true;
}
}
};
-static inline bool position_lookup (hb_apply_context_t *context, unsigned int lookup_index);
+static inline bool position_lookup (hb_apply_context_t *c, unsigned int lookup_index);
struct ContextPos : Context
{
friend struct PosLookupSubTable;
private:
- inline bool apply (hb_apply_context_t *context) const
+ inline bool apply (hb_apply_context_t *c) const
{
TRACE_APPLY ();
- return Context::apply (context, position_lookup);
+ return Context::apply (c, position_lookup);
}
};
friend struct PosLookupSubTable;
private:
- inline bool apply (hb_apply_context_t *context) const
+ inline bool apply (hb_apply_context_t *c) const
{
TRACE_APPLY ();
- return ChainContext::apply (context, position_lookup);
+ return ChainContext::apply (c, position_lookup);
}
};
return StructAtOffset<PosLookupSubTable> (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);
};
Extension = 9
};
- inline bool apply (hb_apply_context_t *context, unsigned int lookup_type) const
+ inline bool apply (hb_apply_context_t *c, unsigned int lookup_type) const
{
TRACE_APPLY ();
switch (lookup_type) {
- case Single: return u.single.apply (context);
- case Pair: return u.pair.apply (context);
- case Cursive: return u.cursive.apply (context);
- case MarkBase: return u.markBase.apply (context);
- case MarkLig: return u.markLig.apply (context);
- case MarkMark: return u.markMark.apply (context);
- case Context: return u.context.apply (context);
- case ChainContext: return u.chainContext.apply (context);
- case Extension: return u.extension.apply (context);
+ case Single: return u.single.apply (c);
+ case Pair: return u.pair.apply (c);
+ case Cursive: return u.cursive.apply (c);
+ case MarkBase: return u.markBase.apply (c);
+ case MarkLig: return u.markLig.apply (c);
+ case MarkMark: return u.markMark.apply (c);
+ case Context: return u.c.apply (c);
+ case ChainContext: return u.chainContext.apply (c);
+ case Extension: return u.extension.apply (c);
default:return false;
}
}
- inline bool sanitize (hb_sanitize_context_t *context, unsigned int lookup_type) {
+ inline bool sanitize (hb_sanitize_context_t *c, unsigned int lookup_type) {
TRACE_SANITIZE ();
switch (lookup_type) {
- case Single: return u.single.sanitize (context);
- case Pair: return u.pair.sanitize (context);
- case Cursive: return u.cursive.sanitize (context);
- case MarkBase: return u.markBase.sanitize (context);
- case MarkLig: return u.markLig.sanitize (context);
- case MarkMark: return u.markMark.sanitize (context);
- case Context: return u.context.sanitize (context);
- case ChainContext: return u.chainContext.sanitize (context);
- case Extension: return u.extension.sanitize (context);
+ case Single: return u.single.sanitize (c);
+ case Pair: return u.pair.sanitize (c);
+ case Cursive: return u.cursive.sanitize (c);
+ case MarkBase: return u.markBase.sanitize (c);
+ case MarkLig: return u.markLig.sanitize (c);
+ case MarkMark: return u.markMark.sanitize (c);
+ case Context: return u.c.sanitize (c);
+ case ChainContext: return u.chainContext.sanitize (c);
+ case Extension: return u.extension.sanitize (c);
default:return true;
}
}
MarkBasePos markBase;
MarkLigPos markLig;
MarkMarkPos markMark;
- ContextPos context;
+ ContextPos c;
ChainContextPos chainContext;
ExtensionPos extension;
} u;
unsigned int nesting_level_left) const
{
unsigned int lookup_type = get_type ();
- hb_apply_context_t context[1] = {{0}};
+ hb_apply_context_t c[1] = {{0}};
- context->layout = layout;
- context->buffer = buffer;
- context->context_length = context_length;
- context->nesting_level_left = nesting_level_left;
- context->lookup_flag = get_flag ();
+ c->layout = layout;
+ c->buffer = buffer;
+ c->context_length = context_length;
+ c->nesting_level_left = nesting_level_left;
+ c->lookup_flag = get_flag ();
- if (!_hb_ot_layout_check_glyph_property (context->layout->face, IN_CURINFO (), context->lookup_flag, &context->property))
+ if (!_hb_ot_layout_check_glyph_property (c->layout->face, IN_CURINFO (), c->lookup_flag, &c->property))
return false;
for (unsigned int i = 0; i < get_subtable_count (); i++)
- if (get_subtable (i).apply (context, lookup_type))
+ if (get_subtable (i).apply (c, lookup_type))
return true;
return false;
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<PosLookupSubTable> &list = CastR<OffsetArrayOf<PosLookupSubTable> > (subTable);
- return list.sanitize (context, this, get_type ());
+ return list.sanitize (c, this, get_type ());
}
};
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<PosLookupList> &list = CastR<OffsetTo<PosLookupList> > (lookupList);
- return list.sanitize (context, this);
+ return list.sanitize (c, this);
}
public:
DEFINE_SIZE_STATIC (10);
/* Out-of-class implementation for methods recursing */
-inline bool ExtensionPos::apply (hb_apply_context_t *context) const
+inline bool ExtensionPos::apply (hb_apply_context_t *c) const
{
TRACE_APPLY ();
- return get_subtable ().apply (context, get_type ());
+ return get_subtable ().apply (c, get_type ());
}
-inline bool ExtensionPos::sanitize (hb_sanitize_context_t *context)
+inline bool ExtensionPos::sanitize (hb_sanitize_context_t *c)
{
TRACE_SANITIZE ();
- if (unlikely (!Extension::sanitize (context))) return false;
+ if (unlikely (!Extension::sanitize (c))) return false;
unsigned int offset = get_offset ();
if (unlikely (!offset)) return true;
- return StructAtOffset<PosLookupSubTable> (this, offset).sanitize (context, get_type ());
+ return StructAtOffset<PosLookupSubTable> (this, offset).sanitize (c, get_type ());
}
-static inline bool position_lookup (hb_apply_context_t *context, unsigned int lookup_index)
+static inline bool position_lookup (hb_apply_context_t *c, unsigned int lookup_index)
{
- const GPOS &gpos = *(context->layout->face->ot_layout.gpos);
+ const GPOS &gpos = *(c->layout->face->ot_layout.gpos);
const PosLookup &l = gpos.get_lookup (lookup_index);
- if (unlikely (context->nesting_level_left == 0))
+ if (unlikely (c->nesting_level_left == 0))
return false;
- if (unlikely (context->context_length < 1))
+ if (unlikely (c->context_length < 1))
return false;
- return l.apply_once (context->layout, context->buffer, context->context_length, context->nesting_level_left - 1);
+ return l.apply_once (c->layout, c->buffer, c->context_length, c->nesting_level_left - 1);
}
#undef BUFFER
-#define BUFFER context->buffer
+#define BUFFER c->buffer
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 ();
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:
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 ();
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:
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;
}
}
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:
private:
- inline bool apply (hb_apply_context_t *context) const
+ inline bool apply (hb_apply_context_t *c) const
{
TRACE_APPLY ();
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:
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;
}
}
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 ();
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);
*/
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:
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;
}
}
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;
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
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)++;
}
}
}
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:
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;
}
}
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:
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:
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;
}
}
-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);
}
};
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);
}
};
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;
};
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 ());
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:
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;
}
}
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;
}
}
MultipleSubst multiple;
AlternateSubst alternate;
LigatureSubst ligature;
- ContextSubst context;
+ ContextSubst c;
ChainContextSubst chainContext;
ExtensionSubst extension;
ReverseChainSingleSubst reverseChainContextSingle;
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))
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;
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 ());
}
};
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);
/* 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
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);
}
#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
#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
{
}
-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,
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;
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;
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,
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;
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
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:
*/
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)
{
not_applied:
/* No lookup applied for this index */
- context->buffer->next_glyph ();
+ c->buffer->next_glyph ();
i++;
}
}
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)
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);
}
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:
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 ());
{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:
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 ());
{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:
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 ());
{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:
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;
}
}
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) */
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)
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,
}
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:
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:
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 ());
{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:
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 ());
&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:
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);
{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,
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:
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;
}
}
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:
}
}
- 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;
}
}
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:
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);
}
/*
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);
}
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
projects / apps / home / video-player.git / commitdiff