Don't use zero-sized arrays
It's not part of the standard and MSVC doesn't like it. It makes the code a lot less elegant than it used to be, but I think it should work now.
This commit is contained in:
Behdad Esfahbod
parent
6bec81aa3a
commit
d3480ba37f
@ -122,9 +122,9 @@ typedef struct OffsetTable
|
||||
USHORT searchRange; /* (Maximum power of 2 <= numTables) x 16 */
|
||||
USHORT entrySelector; /* Log2(maximum power of 2 <= numTables). */
|
||||
USHORT rangeShift; /* NumTables x 16-searchRange. */
|
||||
TableDirectory tableDir[]; /* TableDirectory entries. numTables items */
|
||||
TableDirectory tableDir[VAR]; /* TableDirectory entries. numTables items */
|
||||
} OpenTypeFontFace;
|
||||
ASSERT_SIZE (OffsetTable, 12);
|
||||
ASSERT_SIZE_VAR (OffsetTable, 12, TableDirectory);
|
||||
|
||||
/*
|
||||
* TrueType Collections
|
||||
|
||||
@ -50,6 +50,9 @@
|
||||
#define CONST_NEXT(T,X) (*(reinterpret_cast<const T *>(CONST_CHARP(&(X)) + (X).get_size ())))
|
||||
#define NEXT(T,X) (*(reinterpret_cast<T *>(CHARP(&(X)) + (X).get_size ())))
|
||||
|
||||
#define CONST_ARRAY_AFTER(T,X) ((reinterpret_cast<const T *>(CONST_CHARP(&(X)) + sizeof (X))))
|
||||
#define ARRAY_AFTER(T,X) ((reinterpret_cast<T *>(CHARP(&(X)) + sizeof (X))))
|
||||
|
||||
/*
|
||||
* Class features
|
||||
*/
|
||||
@ -58,7 +61,7 @@
|
||||
/* Null objects */
|
||||
|
||||
/* Global nul-content Null pool. Enlarge as necessary. */
|
||||
static const char NullPool[16] = "";
|
||||
static const char NullPool[32] = "";
|
||||
|
||||
/* Generic template for nul-content sizeof-sized Null objects. */
|
||||
template <typename Type>
|
||||
@ -505,13 +508,16 @@ struct LongOffsetTo : GenericOffsetTo<LongOffset, Type> {};
|
||||
template <typename LenType, typename Type>
|
||||
struct GenericArrayOf
|
||||
{
|
||||
const Type *const_array(void) const { return CONST_ARRAY_AFTER (Type, len); }
|
||||
Type *array(void) { return ARRAY_AFTER (Type, len); }
|
||||
|
||||
inline const Type& operator [] (unsigned int i) const
|
||||
{
|
||||
if (HB_UNLIKELY (i >= len)) return Null(Type);
|
||||
return array[i];
|
||||
return const_array()[i];
|
||||
}
|
||||
inline unsigned int get_size () const
|
||||
{ return sizeof (len) + len * sizeof (array[0]); }
|
||||
{ return sizeof (len) + len * sizeof (Type); }
|
||||
|
||||
inline bool sanitize (SANITIZE_ARG_DEF) {
|
||||
TRACE_SANITIZE ();
|
||||
@ -523,7 +529,7 @@ struct GenericArrayOf
|
||||
return true;
|
||||
unsigned int count = len;
|
||||
for (unsigned int i = 0; i < count; i++)
|
||||
if (!SANITIZE (array[i]))
|
||||
if (!SANITIZE (array()[i]))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
@ -532,7 +538,7 @@ struct GenericArrayOf
|
||||
if (!SANITIZE_GET_SIZE()) return false;
|
||||
unsigned int count = len;
|
||||
for (unsigned int i = 0; i < count; i++)
|
||||
if (!array[i].sanitize (SANITIZE_ARG, base))
|
||||
if (!array()[i].sanitize (SANITIZE_ARG, base))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
@ -541,7 +547,7 @@ struct GenericArrayOf
|
||||
if (!SANITIZE_GET_SIZE()) return false;
|
||||
unsigned int count = len;
|
||||
for (unsigned int i = 0; i < count; i++)
|
||||
if (!array[i].sanitize (SANITIZE_ARG, base, base2))
|
||||
if (!array()[i].sanitize (SANITIZE_ARG, base, base2))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
@ -550,13 +556,13 @@ struct GenericArrayOf
|
||||
if (!SANITIZE_GET_SIZE()) return false;
|
||||
unsigned int count = len;
|
||||
for (unsigned int i = 0; i < count; i++)
|
||||
if (!array[i].sanitize (SANITIZE_ARG, base, user_data))
|
||||
if (!array()[i].sanitize (SANITIZE_ARG, base, user_data))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
LenType len;
|
||||
Type array[];
|
||||
/*Type array[VAR];*/
|
||||
};
|
||||
|
||||
/* An array with a USHORT number of elements. */
|
||||
@ -586,7 +592,7 @@ struct OffsetListOf : OffsetArrayOf<Type>
|
||||
inline const Type& operator [] (unsigned int i) const
|
||||
{
|
||||
if (HB_UNLIKELY (i >= this->len)) return Null(Type);
|
||||
return this+this->array[i];
|
||||
return this+this->const_array()[i];
|
||||
}
|
||||
|
||||
inline bool sanitize (SANITIZE_ARG_DEF) {
|
||||
@ -605,13 +611,16 @@ struct OffsetListOf : OffsetArrayOf<Type>
|
||||
template <typename Type>
|
||||
struct HeadlessArrayOf
|
||||
{
|
||||
const Type *const_array(void) const { return CONST_ARRAY_AFTER (Type, len); }
|
||||
Type *array(void) { return ARRAY_AFTER (Type, len); }
|
||||
|
||||
inline const Type& operator [] (unsigned int i) const
|
||||
{
|
||||
if (HB_UNLIKELY (i >= len || !i)) return Null(Type);
|
||||
return array[i-1];
|
||||
return const_array()[i-1];
|
||||
}
|
||||
inline unsigned int get_size () const
|
||||
{ return sizeof (len) + (len ? len - 1 : 0) * sizeof (array[0]); }
|
||||
{ return sizeof (len) + (len ? len - 1 : 0) * sizeof (Type); }
|
||||
|
||||
inline bool sanitize (SANITIZE_ARG_DEF) {
|
||||
TRACE_SANITIZE ();
|
||||
@ -622,14 +631,15 @@ struct HeadlessArrayOf
|
||||
* do have a simple sanitize(). */
|
||||
return true;
|
||||
unsigned int count = len ? len - 1 : 0;
|
||||
Type *a = array();
|
||||
for (unsigned int i = 0; i < count; i++)
|
||||
if (!SANITIZE (array[i]))
|
||||
if (!SANITIZE (a[i]))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
USHORT len;
|
||||
Type array[];
|
||||
/*Type array[VAR];*/
|
||||
};
|
||||
|
||||
|
||||
|
||||
@ -67,14 +67,15 @@ struct RecordArrayOf : ArrayOf<Record<Type> > {
|
||||
inline const Tag& get_tag (unsigned int i) const
|
||||
{
|
||||
if (HB_UNLIKELY (i >= this->len)) return Null(Tag);
|
||||
return this->array[i].tag;
|
||||
return (*this)[i].tag;
|
||||
}
|
||||
inline bool get_tags (unsigned int *record_count /* IN/OUT */,
|
||||
hb_tag_t *record_tags /* OUT */) const
|
||||
{
|
||||
const Record<Type> *a = this->const_array();
|
||||
unsigned int count = MIN (this->len, *record_count);
|
||||
for (unsigned int i = 0; i < count; i++)
|
||||
record_tags[i] = this->array[i].tag;
|
||||
record_tags[i] = a[i].tag;
|
||||
|
||||
*record_count = this->len;
|
||||
return !!this->len;
|
||||
@ -83,10 +84,11 @@ struct RecordArrayOf : ArrayOf<Record<Type> > {
|
||||
{
|
||||
const Tag t = tag;
|
||||
// TODO bsearch
|
||||
const Record<Type> *a = this->const_array();
|
||||
unsigned int count = this->len;
|
||||
for (unsigned int i = 0; i < count; i++)
|
||||
{
|
||||
if (t == this->array[i].tag)
|
||||
if (t == a[i].tag)
|
||||
{
|
||||
if (index) *index = i;
|
||||
return true;
|
||||
@ -116,14 +118,15 @@ struct IndexArray : ArrayOf<USHORT>
|
||||
{
|
||||
if (HB_UNLIKELY (i >= this->len))
|
||||
return NO_INDEX;
|
||||
return this->array[i];
|
||||
return this->const_array()[i];
|
||||
}
|
||||
inline bool get_indexes (unsigned int *_count /* IN/OUT */,
|
||||
unsigned int *_indexes /* OUT */) const
|
||||
{
|
||||
unsigned int count = MIN (this->len, *_count);
|
||||
const USHORT *a = this->const_array();
|
||||
for (unsigned int i = 0; i < count; i++)
|
||||
_indexes[i] = this->array[i];
|
||||
_indexes[i] = a[i];
|
||||
|
||||
*_count = this->len;
|
||||
return !!this->len;
|
||||
@ -283,7 +286,7 @@ struct Lookup
|
||||
|
||||
inline bool sanitize (SANITIZE_ARG_DEF) {
|
||||
TRACE_SANITIZE ();
|
||||
if (!(SANITIZE_SELF () && SANITIZE_THIS (subTable))) return false;
|
||||
if (!(SANITIZE_SELF/*XXXXXXXXXXXXXX*/ () && SANITIZE_THIS (subTable))) return false;
|
||||
if (HB_UNLIKELY (lookupFlag & LookupFlag::UseMarkFilteringSet))
|
||||
{
|
||||
USHORT &markFilteringSet = NEXT (USHORT, subTable);
|
||||
@ -296,11 +299,11 @@ struct Lookup
|
||||
USHORT lookupFlag; /* Lookup qualifiers */
|
||||
OffsetArrayOf<LookupSubTable>
|
||||
subTable; /* Array of SubTables */
|
||||
USHORT markFilteringSetX[0]; /* Index (base 0) into GDEF mark glyph sets
|
||||
USHORT markFilteringSetX[VAR]; /* Index (base 0) into GDEF mark glyph sets
|
||||
* structure. This field is only present if bit
|
||||
* UseMarkFilteringSet of lookup flags is set. */
|
||||
};
|
||||
ASSERT_SIZE (Lookup, 6);
|
||||
ASSERT_SIZE_VAR (Lookup, 6, USHORT);
|
||||
|
||||
typedef OffsetListOf<Lookup> LookupList;
|
||||
ASSERT_SIZE (LookupList, 2);
|
||||
@ -425,11 +428,10 @@ struct Coverage
|
||||
private:
|
||||
union {
|
||||
USHORT format; /* Format identifier */
|
||||
CoverageFormat1 format1[];
|
||||
CoverageFormat2 format2[];
|
||||
CoverageFormat1 format1[VAR];
|
||||
CoverageFormat2 format2[VAR];
|
||||
} u;
|
||||
};
|
||||
ASSERT_SIZE (Coverage, 2);
|
||||
|
||||
|
||||
/*
|
||||
@ -541,11 +543,10 @@ struct ClassDef
|
||||
private:
|
||||
union {
|
||||
USHORT format; /* Format identifier */
|
||||
ClassDefFormat1 format1[];
|
||||
ClassDefFormat2 format2[];
|
||||
ClassDefFormat1 format1[VAR];
|
||||
ClassDefFormat2 format2[VAR];
|
||||
} u;
|
||||
};
|
||||
ASSERT_SIZE (ClassDef, 2);
|
||||
|
||||
|
||||
/*
|
||||
@ -595,9 +596,9 @@ struct Device
|
||||
USHORT startSize; /* Smallest size to correct--in ppem */
|
||||
USHORT endSize; /* Largest size to correct--in ppem */
|
||||
USHORT deltaFormat; /* Format of DeltaValue array data: 1, 2, or 3 */
|
||||
USHORT deltaValue[]; /* Array of compressed data */
|
||||
USHORT deltaValue[VAR]; /* Array of compressed data */
|
||||
};
|
||||
ASSERT_SIZE (Device, 6);
|
||||
ASSERT_SIZE_VAR (Device, 6, USHORT);
|
||||
|
||||
|
||||
#endif /* HB_OT_LAYOUT_COMMON_PRIVATE_HH */
|
||||
|
||||
@ -177,12 +177,11 @@ struct CaretValue
|
||||
private:
|
||||
union {
|
||||
USHORT format; /* Format identifier */
|
||||
CaretValueFormat1 format1[];
|
||||
CaretValueFormat2 format2[];
|
||||
CaretValueFormat3 format3[];
|
||||
CaretValueFormat1 format1[VAR];
|
||||
CaretValueFormat2 format2[VAR];
|
||||
CaretValueFormat3 format3[VAR];
|
||||
} u;
|
||||
};
|
||||
ASSERT_SIZE (CaretValue, 2);
|
||||
|
||||
struct LigGlyph
|
||||
{
|
||||
@ -286,10 +285,9 @@ struct MarkGlyphSets
|
||||
private:
|
||||
union {
|
||||
USHORT format; /* Format identifier */
|
||||
MarkGlyphSetsFormat1 format1[];
|
||||
MarkGlyphSetsFormat1 format1[VAR];
|
||||
} u;
|
||||
};
|
||||
ASSERT_SIZE (MarkGlyphSets, 2);
|
||||
|
||||
|
||||
/*
|
||||
@ -364,12 +362,12 @@ struct GDEF
|
||||
* mark attachment type--from beginning
|
||||
* of GDEF header (may be Null) */
|
||||
OffsetTo<MarkGlyphSets>
|
||||
markGlyphSetsDef[0]; /* Offset to the table of mark set
|
||||
markGlyphSetsDef[VAR]; /* Offset to the table of mark set
|
||||
* definitions--from beginning of GDEF
|
||||
* header (may be NULL). Introduced
|
||||
* in version 00010002. */
|
||||
};
|
||||
ASSERT_SIZE (GDEF, 12);
|
||||
ASSERT_SIZE_VAR (GDEF, 12, OffsetTo<MarkGlyphSets>);
|
||||
|
||||
|
||||
#endif /* HB_OT_LAYOUT_GDEF_PRIVATE_HH */
|
||||
|
||||
@ -35,8 +35,8 @@
|
||||
|
||||
typedef SHORT Value;
|
||||
|
||||
typedef Value ValueRecord[0];
|
||||
ASSERT_SIZE (ValueRecord, 0);
|
||||
typedef Value ValueRecord[VAR];
|
||||
ASSERT_SIZE_VAR (Value, 0, ValueRecord);
|
||||
|
||||
struct ValueFormat : USHORT
|
||||
{
|
||||
@ -259,12 +259,11 @@ struct Anchor
|
||||
private:
|
||||
union {
|
||||
USHORT format; /* Format identifier */
|
||||
AnchorFormat1 format1[];
|
||||
AnchorFormat2 format2[];
|
||||
AnchorFormat3 format3[];
|
||||
AnchorFormat1 format1[VAR];
|
||||
AnchorFormat2 format2[VAR];
|
||||
AnchorFormat3 format3[VAR];
|
||||
} u;
|
||||
};
|
||||
ASSERT_SIZE (Anchor, 2);
|
||||
|
||||
|
||||
struct AnchorMatrix
|
||||
@ -287,10 +286,10 @@ struct AnchorMatrix
|
||||
USHORT rows; /* Number of rows */
|
||||
private:
|
||||
OffsetTo<Anchor>
|
||||
matrix[]; /* Matrix of offsets to Anchor tables--
|
||||
matrix[VAR]; /* Matrix of offsets to Anchor tables--
|
||||
* from beginning of AnchorMatrix table */
|
||||
};
|
||||
ASSERT_SIZE (AnchorMatrix, 2);
|
||||
ASSERT_SIZE_VAR (AnchorMatrix, 2, OffsetTo<Anchor>);
|
||||
|
||||
|
||||
struct MarkRecord
|
||||
@ -389,7 +388,7 @@ struct SinglePosFormat1
|
||||
* value(s)--applied to all glyphs in
|
||||
* the Coverage table */
|
||||
};
|
||||
ASSERT_SIZE (SinglePosFormat1, 6);
|
||||
ASSERT_SIZE_VAR (SinglePosFormat1, 6, ValueRecord);
|
||||
|
||||
struct SinglePosFormat2
|
||||
{
|
||||
@ -431,7 +430,7 @@ struct SinglePosFormat2
|
||||
ValueRecord values; /* Array of ValueRecords--positioning
|
||||
* values applied to glyphs */
|
||||
};
|
||||
ASSERT_SIZE (SinglePosFormat2, 8);
|
||||
ASSERT_SIZE_VAR (SinglePosFormat2, 8, ValueRecord);
|
||||
|
||||
struct SinglePos
|
||||
{
|
||||
@ -461,11 +460,10 @@ struct SinglePos
|
||||
private:
|
||||
union {
|
||||
USHORT format; /* Format identifier */
|
||||
SinglePosFormat1 format1[];
|
||||
SinglePosFormat2 format2[];
|
||||
SinglePosFormat1 format1[VAR];
|
||||
SinglePosFormat2 format2[VAR];
|
||||
} u;
|
||||
};
|
||||
ASSERT_SIZE (SinglePos, 2);
|
||||
|
||||
|
||||
struct PairValueRecord
|
||||
@ -479,7 +477,7 @@ struct PairValueRecord
|
||||
ValueRecord values; /* Positioning data for the first glyph
|
||||
* followed by for second glyph */
|
||||
};
|
||||
ASSERT_SIZE (PairValueRecord, 2);
|
||||
ASSERT_SIZE_VAR (PairValueRecord, 2, ValueRecord);
|
||||
|
||||
struct PairSet
|
||||
{
|
||||
@ -495,10 +493,10 @@ struct PairSet
|
||||
private:
|
||||
USHORT len; /* Number of PairValueRecords */
|
||||
PairValueRecord
|
||||
array[]; /* Array of PairValueRecords--ordered
|
||||
array[VAR]; /* Array of PairValueRecords--ordered
|
||||
* by GlyphID of the second glyph */
|
||||
};
|
||||
ASSERT_SIZE (PairSet, 2);
|
||||
ASSERT_SIZE_VAR (PairSet, 2, PairValueRecord);
|
||||
|
||||
struct PairPosFormat1
|
||||
{
|
||||
@ -654,7 +652,7 @@ struct PairPosFormat2
|
||||
* class1-major, class2-minor,
|
||||
* Each entry has value1 and value2 */
|
||||
};
|
||||
ASSERT_SIZE (PairPosFormat2, 16);
|
||||
ASSERT_SIZE_VAR (PairPosFormat2, 16, ValueRecord);
|
||||
|
||||
struct PairPos
|
||||
{
|
||||
@ -684,11 +682,10 @@ struct PairPos
|
||||
private:
|
||||
union {
|
||||
USHORT format; /* Format identifier */
|
||||
PairPosFormat1 format1[];
|
||||
PairPosFormat2 format2[];
|
||||
PairPosFormat1 format1[VAR];
|
||||
PairPosFormat2 format2[VAR];
|
||||
} u;
|
||||
};
|
||||
ASSERT_SIZE (PairPos, 2);
|
||||
|
||||
|
||||
struct EntryExitRecord
|
||||
@ -931,17 +928,15 @@ struct CursivePos
|
||||
private:
|
||||
union {
|
||||
USHORT format; /* Format identifier */
|
||||
CursivePosFormat1 format1[];
|
||||
CursivePosFormat1 format1[VAR];
|
||||
} u;
|
||||
};
|
||||
ASSERT_SIZE (CursivePos, 2);
|
||||
|
||||
|
||||
typedef AnchorMatrix BaseArray; /* base-major--
|
||||
* in order of BaseCoverage Index--,
|
||||
* mark-minor--
|
||||
* ordered by class--zero-based. */
|
||||
ASSERT_SIZE (BaseArray, 2);
|
||||
|
||||
struct MarkBasePosFormat1
|
||||
{
|
||||
@ -1027,23 +1022,20 @@ struct MarkBasePos
|
||||
private:
|
||||
union {
|
||||
USHORT format; /* Format identifier */
|
||||
MarkBasePosFormat1 format1[];
|
||||
MarkBasePosFormat1 format1[VAR];
|
||||
} u;
|
||||
};
|
||||
ASSERT_SIZE (MarkBasePos, 2);
|
||||
|
||||
|
||||
typedef AnchorMatrix LigatureAttach; /* component-major--
|
||||
* in order of writing direction--,
|
||||
* mark-minor--
|
||||
* ordered by class--zero-based. */
|
||||
ASSERT_SIZE (LigatureAttach, 2);
|
||||
|
||||
typedef OffsetListOf<LigatureAttach> LigatureArray;
|
||||
/* Array of LigatureAttach
|
||||
* tables ordered by
|
||||
* LigatureCoverage Index */
|
||||
ASSERT_SIZE (LigatureArray, 2);
|
||||
|
||||
struct MarkLigPosFormat1
|
||||
{
|
||||
@ -1152,17 +1144,15 @@ struct MarkLigPos
|
||||
private:
|
||||
union {
|
||||
USHORT format; /* Format identifier */
|
||||
MarkLigPosFormat1 format1[];
|
||||
MarkLigPosFormat1 format1[VAR];
|
||||
} u;
|
||||
};
|
||||
ASSERT_SIZE (MarkLigPos, 2);
|
||||
|
||||
|
||||
typedef AnchorMatrix Mark2Array; /* mark2-major--
|
||||
* in order of Mark2Coverage Index--,
|
||||
* mark1-minor--
|
||||
* ordered by class--zero-based. */
|
||||
ASSERT_SIZE (Mark2Array, 2);
|
||||
|
||||
struct MarkMarkPosFormat1
|
||||
{
|
||||
@ -1253,10 +1243,9 @@ struct MarkMarkPos
|
||||
private:
|
||||
union {
|
||||
USHORT format; /* Format identifier */
|
||||
MarkMarkPosFormat1 format1[];
|
||||
MarkMarkPosFormat1 format1[VAR];
|
||||
} u;
|
||||
};
|
||||
ASSERT_SIZE (MarkMarkPos, 2);
|
||||
|
||||
|
||||
static inline bool position_lookup (APPLY_ARG_DEF, unsigned int lookup_index);
|
||||
@ -1272,7 +1261,6 @@ struct ContextPos : Context
|
||||
return Context::apply (APPLY_ARG, position_lookup);
|
||||
}
|
||||
};
|
||||
ASSERT_SIZE (ContextPos, 2);
|
||||
|
||||
struct ChainContextPos : ChainContext
|
||||
{
|
||||
@ -1285,7 +1273,6 @@ struct ChainContextPos : ChainContext
|
||||
return ChainContext::apply (APPLY_ARG, position_lookup);
|
||||
}
|
||||
};
|
||||
ASSERT_SIZE (ChainContextPos, 2);
|
||||
|
||||
|
||||
struct ExtensionPos : Extension
|
||||
@ -1300,7 +1287,6 @@ struct ExtensionPos : Extension
|
||||
|
||||
inline bool sanitize (SANITIZE_ARG_DEF);
|
||||
};
|
||||
ASSERT_SIZE (ExtensionPos, 2);
|
||||
|
||||
|
||||
|
||||
@ -1362,18 +1348,17 @@ struct PosLookupSubTable
|
||||
private:
|
||||
union {
|
||||
USHORT format;
|
||||
SinglePos single[];
|
||||
PairPos pair[];
|
||||
CursivePos cursive[];
|
||||
MarkBasePos markBase[];
|
||||
MarkLigPos markLig[];
|
||||
MarkMarkPos markMark[];
|
||||
ContextPos context[];
|
||||
ChainContextPos chainContext[];
|
||||
ExtensionPos extension[];
|
||||
SinglePos single[VAR];
|
||||
PairPos pair[VAR];
|
||||
CursivePos cursive[VAR];
|
||||
MarkBasePos markBase[VAR];
|
||||
MarkLigPos markLig[VAR];
|
||||
MarkMarkPos markMark[VAR];
|
||||
ContextPos context[VAR];
|
||||
ChainContextPos chainContext[VAR];
|
||||
ExtensionPos extension[VAR];
|
||||
} u;
|
||||
};
|
||||
ASSERT_SIZE (PosLookupSubTable, 2);
|
||||
|
||||
|
||||
struct PosLookup : Lookup
|
||||
@ -1462,7 +1447,6 @@ struct PosLookup : Lookup
|
||||
return SANITIZE_THIS (list);
|
||||
}
|
||||
};
|
||||
ASSERT_SIZE (PosLookup, 6);
|
||||
|
||||
typedef OffsetListOf<PosLookup> PosLookupList;
|
||||
ASSERT_SIZE (PosLookupList, 2);
|
||||
|
||||
@ -141,11 +141,10 @@ struct SingleSubst
|
||||
private:
|
||||
union {
|
||||
USHORT format; /* Format identifier */
|
||||
SingleSubstFormat1 format1[];
|
||||
SingleSubstFormat2 format2[];
|
||||
SingleSubstFormat1 format1[VAR];
|
||||
SingleSubstFormat2 format2[VAR];
|
||||
} u;
|
||||
};
|
||||
ASSERT_SIZE (SingleSubst, 2);
|
||||
|
||||
|
||||
struct Sequence
|
||||
@ -160,7 +159,7 @@ struct Sequence
|
||||
return false;
|
||||
|
||||
_hb_buffer_add_output_glyphs (buffer, 1,
|
||||
substitute.len, (const uint16_t *) substitute.array,
|
||||
substitute.len, (const uint16_t *) substitute.const_array(),
|
||||
0xFFFF, 0xFFFF);
|
||||
|
||||
/* This is a guess only ... */
|
||||
@ -249,10 +248,9 @@ struct MultipleSubst
|
||||
private:
|
||||
union {
|
||||
USHORT format; /* Format identifier */
|
||||
MultipleSubstFormat1 format1[];
|
||||
MultipleSubstFormat1 format1[VAR];
|
||||
} u;
|
||||
};
|
||||
ASSERT_SIZE (MultipleSubst, 2);
|
||||
|
||||
|
||||
typedef ArrayOf<GlyphID> AlternateSet; /* Array of alternate GlyphIDs--in
|
||||
@ -345,10 +343,9 @@ struct AlternateSubst
|
||||
private:
|
||||
union {
|
||||
USHORT format; /* Format identifier */
|
||||
AlternateSubstFormat1 format1[];
|
||||
AlternateSubstFormat1 format1[VAR];
|
||||
} u;
|
||||
};
|
||||
ASSERT_SIZE (AlternateSubst, 2);
|
||||
|
||||
|
||||
struct Ligature
|
||||
@ -531,10 +528,9 @@ struct LigatureSubst
|
||||
private:
|
||||
union {
|
||||
USHORT format; /* Format identifier */
|
||||
LigatureSubstFormat1 format1[];
|
||||
LigatureSubstFormat1 format1[VAR];
|
||||
} u;
|
||||
};
|
||||
ASSERT_SIZE (LigatureSubst, 2);
|
||||
|
||||
|
||||
|
||||
@ -551,7 +547,6 @@ struct ContextSubst : Context
|
||||
return Context::apply (APPLY_ARG, substitute_lookup);
|
||||
}
|
||||
};
|
||||
ASSERT_SIZE (ContextSubst, 2);
|
||||
|
||||
struct ChainContextSubst : ChainContext
|
||||
{
|
||||
@ -564,7 +559,6 @@ struct ChainContextSubst : ChainContext
|
||||
return ChainContext::apply (APPLY_ARG, substitute_lookup);
|
||||
}
|
||||
};
|
||||
ASSERT_SIZE (ChainContextSubst, 2);
|
||||
|
||||
|
||||
struct ExtensionSubst : Extension
|
||||
@ -579,7 +573,6 @@ struct ExtensionSubst : Extension
|
||||
|
||||
inline bool sanitize (SANITIZE_ARG_DEF);
|
||||
};
|
||||
ASSERT_SIZE (ExtensionSubst, 2);
|
||||
|
||||
|
||||
struct ReverseChainSingleSubstFormat1
|
||||
@ -601,10 +594,10 @@ struct ReverseChainSingleSubstFormat1
|
||||
const ArrayOf<GlyphID> &substitute = CONST_NEXT (ArrayOf<GlyphID>, lookahead);
|
||||
|
||||
if (match_backtrack (APPLY_ARG,
|
||||
backtrack.len, (USHORT *) backtrack.array,
|
||||
backtrack.len, (USHORT *) backtrack.const_array(),
|
||||
match_coverage, DECONST_CHARP(this)) &&
|
||||
match_lookahead (APPLY_ARG,
|
||||
lookahead.len, (USHORT *) lookahead.array,
|
||||
lookahead.len, (USHORT *) lookahead.const_array(),
|
||||
match_coverage, DECONST_CHARP(this),
|
||||
1))
|
||||
{
|
||||
@ -672,10 +665,9 @@ struct ReverseChainSingleSubst
|
||||
private:
|
||||
union {
|
||||
USHORT format; /* Format identifier */
|
||||
ReverseChainSingleSubstFormat1 format1[];
|
||||
ReverseChainSingleSubstFormat1 format1[VAR];
|
||||
} u;
|
||||
};
|
||||
ASSERT_SIZE (ReverseChainSingleSubst, 2);
|
||||
|
||||
|
||||
|
||||
@ -733,17 +725,16 @@ struct SubstLookupSubTable
|
||||
private:
|
||||
union {
|
||||
USHORT format;
|
||||
SingleSubst single[];
|
||||
MultipleSubst multiple[];
|
||||
AlternateSubst alternate[];
|
||||
LigatureSubst ligature[];
|
||||
ContextSubst context[];
|
||||
ChainContextSubst chainContext[];
|
||||
ExtensionSubst extension[];
|
||||
ReverseChainSingleSubst reverseChainContextSingle[];
|
||||
SingleSubst single[VAR];
|
||||
MultipleSubst multiple[VAR];
|
||||
AlternateSubst alternate[VAR];
|
||||
LigatureSubst ligature[VAR];
|
||||
ContextSubst context[VAR];
|
||||
ChainContextSubst chainContext[VAR];
|
||||
ExtensionSubst extension[VAR];
|
||||
ReverseChainSingleSubst reverseChainContextSingle[VAR];
|
||||
} u;
|
||||
};
|
||||
ASSERT_SIZE (SubstLookupSubTable, 2);
|
||||
|
||||
|
||||
struct SubstLookup : Lookup
|
||||
@ -846,7 +837,6 @@ struct SubstLookup : Lookup
|
||||
return SANITIZE_THIS (list);
|
||||
}
|
||||
};
|
||||
ASSERT_SIZE (SubstLookup, 6);
|
||||
|
||||
typedef OffsetListOf<SubstLookup> SubstLookupList;
|
||||
ASSERT_SIZE (SubstLookupList, 2);
|
||||
|
||||
@ -307,7 +307,7 @@ struct Rule
|
||||
public:
|
||||
inline bool sanitize (SANITIZE_ARG_DEF) {
|
||||
TRACE_SANITIZE ();
|
||||
if (!SANITIZE_SELF ()) return false;
|
||||
if (!(SANITIZE (inputCount) && SANITIZE (lookupCount))) return false;
|
||||
return SANITIZE_MEM (input,
|
||||
sizeof (input[0]) * inputCount +
|
||||
sizeof (lookupRecordX[0]) * lookupCount);
|
||||
@ -318,12 +318,12 @@ struct Rule
|
||||
* glyph sequence--includes the first
|
||||
* glyph */
|
||||
USHORT lookupCount; /* Number of LookupRecords */
|
||||
USHORT input[]; /* Array of match inputs--start with
|
||||
USHORT input[VAR]; /* Array of match inputs--start with
|
||||
* second glyph */
|
||||
LookupRecord lookupRecordX[]; /* Array of LookupRecords--in
|
||||
LookupRecord lookupRecordX[VAR]; /* Array of LookupRecords--in
|
||||
* design order */
|
||||
};
|
||||
ASSERT_SIZE (Rule, 4);
|
||||
ASSERT_SIZE_VAR2 (Rule, 4, USHORT, LookupRecord);
|
||||
|
||||
struct RuleSet
|
||||
{
|
||||
@ -473,12 +473,12 @@ struct ContextFormat3
|
||||
* sequence */
|
||||
USHORT lookupCount; /* Number of LookupRecords */
|
||||
OffsetTo<Coverage>
|
||||
coverage[]; /* Array of offsets to Coverage
|
||||
coverage[VAR]; /* Array of offsets to Coverage
|
||||
* table in glyph sequence order */
|
||||
LookupRecord lookupRecordX[]; /* Array of LookupRecords--in
|
||||
LookupRecord lookupRecordX[VAR]; /* Array of LookupRecords--in
|
||||
* design order */
|
||||
};
|
||||
ASSERT_SIZE (ContextFormat3, 6);
|
||||
ASSERT_SIZE_VAR2 (ContextFormat3, 6, OffsetTo<Coverage>, LookupRecord);
|
||||
|
||||
struct Context
|
||||
{
|
||||
@ -508,12 +508,11 @@ struct Context
|
||||
private:
|
||||
union {
|
||||
USHORT format; /* Format identifier */
|
||||
ContextFormat1 format1[];
|
||||
ContextFormat2 format2[];
|
||||
ContextFormat3 format3[];
|
||||
ContextFormat1 format1[VAR];
|
||||
ContextFormat2 format2[VAR];
|
||||
ContextFormat3 format3[VAR];
|
||||
} u;
|
||||
};
|
||||
ASSERT_SIZE (Context, 2);
|
||||
|
||||
|
||||
/* Chaining Contextual lookups */
|
||||
@ -572,10 +571,10 @@ struct ChainRule
|
||||
const ArrayOf<USHORT> &lookahead = CONST_NEXT (ArrayOf<USHORT>, input);
|
||||
const ArrayOf<LookupRecord> &lookup = CONST_NEXT (ArrayOf<LookupRecord>, lookahead);
|
||||
return chain_context_lookup (APPLY_ARG,
|
||||
backtrack.len, backtrack.array,
|
||||
input.len, input.array,
|
||||
lookahead.len, lookahead.array,
|
||||
lookup.len, lookup.array,
|
||||
backtrack.len, backtrack.const_array(),
|
||||
input.len, input.const_array(),
|
||||
lookahead.len, lookahead.const_array(),
|
||||
lookup.len, lookup.const_array(),
|
||||
lookup_context);
|
||||
return false;
|
||||
}
|
||||
@ -754,10 +753,10 @@ struct ChainContextFormat3
|
||||
{DECONST_CHARP(this), DECONST_CHARP(this), DECONST_CHARP(this)}
|
||||
};
|
||||
return chain_context_lookup (APPLY_ARG,
|
||||
backtrack.len, (USHORT *) backtrack.array,
|
||||
input.len, (USHORT *) input.array + 1,
|
||||
lookahead.len, (USHORT *) lookahead.array,
|
||||
lookup.len, lookup.array,
|
||||
backtrack.len, (const USHORT *) backtrack.const_array(),
|
||||
input.len, (const USHORT *) input.const_array() + 1,
|
||||
lookahead.len, (const USHORT *) lookahead.const_array(),
|
||||
lookup.len, lookup.const_array(),
|
||||
lookup_context);
|
||||
return false;
|
||||
}
|
||||
@ -821,12 +820,11 @@ struct ChainContext
|
||||
private:
|
||||
union {
|
||||
USHORT format; /* Format identifier */
|
||||
ChainContextFormat1 format1[];
|
||||
ChainContextFormat2 format2[];
|
||||
ChainContextFormat3 format3[];
|
||||
ChainContextFormat1 format1[VAR];
|
||||
ChainContextFormat2 format2[VAR];
|
||||
ChainContextFormat3 format3[VAR];
|
||||
} u;
|
||||
};
|
||||
ASSERT_SIZE (ChainContext, 2);
|
||||
|
||||
|
||||
struct ExtensionFormat1
|
||||
@ -889,10 +887,9 @@ struct Extension
|
||||
private:
|
||||
union {
|
||||
USHORT format; /* Format identifier */
|
||||
ExtensionFormat1 format1[];
|
||||
ExtensionFormat1 format1[VAR];
|
||||
} u;
|
||||
};
|
||||
ASSERT_SIZE (Extension, 2);
|
||||
|
||||
|
||||
/*
|
||||
|
||||
@ -139,6 +139,11 @@ typedef int hb_mutex_t;
|
||||
|
||||
#define ASSERT_SIZE(_type, _size) ASSERT_STATIC (sizeof (_type) == (_size))
|
||||
|
||||
#define VAR 1 /* Size signifying variable-sized array */
|
||||
#define ASSERT_SIZE_VAR(_type, _size, _var_type) \
|
||||
ASSERT_STATIC (sizeof (_type) == (_size) + VAR * sizeof (_var_type))
|
||||
#define ASSERT_SIZE_VAR2(_type, _size, _var_type1, _var_type2) \
|
||||
ASSERT_STATIC (sizeof (_type) == (_size) + VAR * sizeof (_var_type1) + VAR * sizeof (_var_type2))
|
||||
|
||||
#if defined(__GNUC__) && (__GNUC__ > 2) && defined(__OPTIMIZE__)
|
||||
#define _HB_BOOLEAN_EXPR(expr) \
|
||||
|
||||
Loading…
Reference in New Issue
Block a user