LongOffsetLongArrayOf<OffsetTable>
table; /* Array of offsets to the OffsetTable for each font
* from the beginning of the file */
+ public:
+ DEFINE_SIZE_STATIC (12);
};
-ASSERT_SIZE (TTCHeaderVersion1, 12);
struct TTCHeader
{
static const unsigned int static_size = (size); \
static const unsigned int min_size = (size)
+/* Size signifying variable-sized array */
+#define VAR 1
+#define VAR0 (VAR+0)
+
+#define DEFINE_SIZE_VAR0(size) \
+ inline void _size_assertion (void) const \
+ { ASSERT_STATIC (sizeof (*this) == (size)); } \
+ static const unsigned int min_size = (size)
+
#define DEFINE_SIZE_VAR(size, _var_type) \
inline void _size_assertion (void) const \
{ ASSERT_STATIC (sizeof (*this) == (size) + VAR0 * sizeof (_var_type)); } \
/* What the char* converters return is NOT nul-terminated. Print using "%.4s" */
inline operator const char* (void) const { return CharP(this); }
inline operator char* (void) { return CharP(this); }
+ public:
+ DEFINE_SIZE_STATIC (4);
};
-ASSERT_SIZE (Tag, 4);
DEFINE_NULL_DATA (Tag, " ");
/* Glyph index number, same as uint16 (length = 16 bits) */
Sum += *Table++;
return Sum;
}
+ public:
+ DEFINE_SIZE_STATIC (4);
};
-ASSERT_SIZE (CheckSum, 4);
/*
USHORT major;
USHORT minor;
+ public:
+ DEFINE_SIZE_STATIC (4);
};
-ASSERT_SIZE (FixedVersion, 4);
public:
LenType len;
/*Type array[VAR];*/
+ public:
+ DEFINE_SIZE_VAR0 (sizeof (LenType));
};
/* An array with a USHORT number of elements. */
RecordArrayOf<LangSys>
langSys; /* Array of LangSysRecords--listed
* alphabetically by LangSysTag */
+ public:
+ DEFINE_SIZE_STATIC (4);
};
-ASSERT_SIZE (Script, 4);
typedef RecordListOf<Script> ScriptList;
-ASSERT_SIZE (ScriptList, 2);
struct Feature
* to the beginning of the Feature Table; = Null
* if not required */
IndexArray lookupIndex; /* Array of LookupList indices */
+ public:
+ DEFINE_SIZE_STATIC (4);
};
-ASSERT_SIZE (Feature, 4);
typedef RecordListOf<Feature> FeatureList;
-ASSERT_SIZE (FeatureList, 2);
struct LookupFlag : USHORT
Reserved = 0x00E0u,
MarkAttachmentType = 0xFF00u
};
+ public:
+ DEFINE_SIZE_STATIC (2);
};
-ASSERT_SIZE (LookupFlag, 2);
struct Lookup
{
};
typedef OffsetListOf<Lookup> LookupList;
-ASSERT_SIZE (LookupList, 2);
/*
USHORT coverageFormat; /* Format identifier--format = 1 */
ArrayOf<GlyphID>
glyphArray; /* Array of GlyphIDs--in numerical order */
+ public:
+ DEFINE_SIZE_STATIC (4);
};
-ASSERT_SIZE (CoverageFormat1, 4);
struct CoverageRangeRecord
{
rangeRecord; /* Array of glyph ranges--ordered by
* Start GlyphID. rangeCount entries
* long */
+ public:
+ DEFINE_SIZE_STATIC (4);
};
-ASSERT_SIZE (CoverageFormat2, 4);
struct Coverage
{
GlyphID startGlyph; /* First GlyphID of the classValueArray */
ArrayOf<USHORT>
classValue; /* Array of Class Values--one per GlyphID */
+ public:
+ DEFINE_SIZE_STATIC (6);
};
-ASSERT_SIZE (ClassDefFormat1, 6);
struct ClassRangeRecord
{
ArrayOf<ClassRangeRecord>
rangeRecord; /* Array of glyph ranges--ordered by
* Start GlyphID */
+ public:
+ DEFINE_SIZE_STATIC (4);
};
-ASSERT_SIZE (ClassDefFormat2, 4);
struct ClassDef
{
typedef ArrayOf<USHORT> AttachPoint; /* Array of contour point indices--in
* increasing numerical order */
-ASSERT_SIZE (AttachPoint, 2);
struct AttachList
{
OffsetArrayOf<AttachPoint>
attachPoint; /* Array of AttachPoint tables
* in Coverage Index order */
+ public:
+ DEFINE_SIZE_STATIC (4);
};
-ASSERT_SIZE (AttachList, 4);
/*
* Ligature Caret Table
private:
USHORT caretValueFormat; /* Format identifier--format = 1 */
SHORT coordinate; /* X or Y value, in design units */
+ public:
+ DEFINE_SIZE_STATIC (4);
};
-ASSERT_SIZE (CaretValueFormat1, 4);
struct CaretValueFormat2
{
private:
USHORT caretValueFormat; /* Format identifier--format = 2 */
USHORT caretValuePoint; /* Contour point index on glyph */
+ public:
+ DEFINE_SIZE_STATIC (4);
};
-ASSERT_SIZE (CaretValueFormat2, 4);
struct CaretValueFormat3
{
deviceTable; /* Offset to Device table for X or Y
* value--from beginning of CaretValue
* table */
+ public:
+ DEFINE_SIZE_STATIC (6);
};
-ASSERT_SIZE (CaretValueFormat3, 6);
struct CaretValue
{
carets; /* Offset array of CaretValue tables
* --from beginning of LigGlyph table
* --in increasing coordinate order */
+ public:
+ DEFINE_SIZE_STATIC (2);
};
-ASSERT_SIZE (LigGlyph, 2);
struct LigCaretList
{
OffsetArrayOf<LigGlyph>
ligGlyph; /* Array of LigGlyph tables
* in Coverage Index order */
+ public:
+ DEFINE_SIZE_STATIC (4);
};
-ASSERT_SIZE (LigCaretList, 4);
struct MarkGlyphSetsFormat1
LongOffsetArrayOf<Coverage>
coverage; /* Array of long offsets to mark set
* coverage tables */
+ public:
+ DEFINE_SIZE_STATIC (4);
};
-ASSERT_SIZE (MarkGlyphSetsFormat1, 4);
struct MarkGlyphSets
{
return true;
}
};
-ASSERT_SIZE (ValueFormat, 2);
struct AnchorFormat1
USHORT format; /* Format identifier--format = 1 */
SHORT xCoordinate; /* Horizontal value--in design units */
SHORT yCoordinate; /* Vertical value--in design units */
+ public:
+ DEFINE_SIZE_STATIC (6);
};
-ASSERT_SIZE (AnchorFormat1, 6);
struct AnchorFormat2
{
SHORT xCoordinate; /* Horizontal value--in design units */
SHORT yCoordinate; /* Vertical value--in design units */
USHORT anchorPoint; /* Index to glyph contour point */
+ public:
+ DEFINE_SIZE_STATIC (8);
};
-ASSERT_SIZE (AnchorFormat2, 8);
struct AnchorFormat3
{
yDeviceTable; /* Offset to Device table for Y
* coordinate-- from beginning of
* Anchor table (may be NULL) */
+ public:
+ DEFINE_SIZE_STATIC (10);
};
-ASSERT_SIZE (AnchorFormat3, 10);
struct Anchor
{
private:
ArrayOf<MarkRecord>
markRecord; /* Array of MarkRecords--in Coverage order */
+ public:
+ DEFINE_SIZE_STATIC (2);
};
-ASSERT_SIZE (MarkArray, 2);
/* Lookups */
OffsetArrayOf<PairSet>
pairSet; /* Array of PairSet tables
* ordered by Coverage Index */
+ public:
+ DEFINE_SIZE_STATIC (10);
};
-ASSERT_SIZE (PairPosFormat1, 10);
struct PairPosFormat2
{
ArrayOf<EntryExitRecord>
entryExitRecord; /* Array of EntryExit records--in
* Coverage Index order */
+ public:
+ DEFINE_SIZE_STATIC (6);
};
-ASSERT_SIZE (CursivePosFormat1, 6);
struct CursivePos
{
j--;
} while (_hb_ot_layout_skip_mark (context->layout->face, IN_INFO (j), LookupFlag::IgnoreMarks, &property));
-#if 0
- /* The following assertion is too strong. */
- if (!(property & HB_OT_LAYOUT_GLYPH_CLASS_BASE_GLYPH))
+ /* The following assertion is too strong, so we've disabled it. */
+ if (false && !(property & HB_OT_LAYOUT_GLYPH_CLASS_BASE_GLYPH))
return false;
-#endif
unsigned int base_index = (this+baseCoverage) (IN_GLYPH (j));
if (base_index == NOT_COVERED)
OffsetTo<BaseArray>
baseArray; /* Offset to BaseArray table--from
* beginning of MarkBasePos subtable */
+ public:
+ DEFINE_SIZE_STATIC (12);
};
-ASSERT_SIZE (MarkBasePosFormat1, 12);
struct MarkBasePos
{
j--;
} while (_hb_ot_layout_skip_mark (context->layout->face, IN_INFO (j), LookupFlag::IgnoreMarks, &property));
-#if 0
- /* The following assertion is too strong. */
- if (!(property & HB_OT_LAYOUT_GLYPH_CLASS_LIGATURE))
+ /* The following assertion is too strong, so we've disabled it. */
+ if (false && !(property & HB_OT_LAYOUT_GLYPH_CLASS_LIGATURE))
return false;
-#endif
unsigned int lig_index = (this+ligatureCoverage) (IN_GLYPH (j));
if (lig_index == NOT_COVERED)
OffsetTo<LigatureArray>
ligatureArray; /* Offset to LigatureArray table--from
* beginning of MarkLigPos subtable */
+ public:
+ DEFINE_SIZE_STATIC (12);
};
-ASSERT_SIZE (MarkLigPosFormat1, 12);
struct MarkLigPos
{
OffsetTo<Mark2Array>
mark2Array; /* Offset to Mark2Array table--from
* beginning of MarkMarkPos subtable */
+ public:
+ DEFINE_SIZE_STATIC (12);
};
-ASSERT_SIZE (MarkMarkPosFormat1, 12);
struct MarkMarkPos
{
};
typedef OffsetListOf<PosLookup> PosLookupList;
-ASSERT_SIZE (PosLookupList, 2);
/*
* GPOS
OffsetTo<PosLookupList> &list = CastR<OffsetTo<PosLookupList> > (lookupList);
return list.sanitize (context, this);
}
+ public:
+ DEFINE_SIZE_STATIC (10);
};
-ASSERT_SIZE (GPOS, 10);
/* Out-of-class implementation for methods recursing */
* beginning of Substitution table */
SHORT deltaGlyphID; /* Add to original GlyphID to get
* substitute GlyphID */
+ public:
+ DEFINE_SIZE_STATIC (6);
};
-ASSERT_SIZE (SingleSubstFormat1, 6);
struct SingleSubstFormat2
{
ArrayOf<GlyphID>
substitute; /* Array of substitute
* GlyphIDs--ordered by Coverage Index */
+ public:
+ DEFINE_SIZE_STATIC (6);
};
-ASSERT_SIZE (SingleSubstFormat2, 6);
struct SingleSubst
{
private:
ArrayOf<GlyphID>
substitute; /* String of GlyphIDs to substitute */
+ public:
+ DEFINE_SIZE_STATIC (2);
};
-ASSERT_SIZE (Sequence, 2);
struct MultipleSubstFormat1
{
OffsetArrayOf<Sequence>
sequence; /* Array of Sequence tables
* ordered by Coverage Index */
+ public:
+ DEFINE_SIZE_STATIC (6);
};
-ASSERT_SIZE (MultipleSubstFormat1, 6);
struct MultipleSubst
{
typedef ArrayOf<GlyphID> AlternateSet; /* Array of alternate GlyphIDs--in
* arbitrary order */
-ASSERT_SIZE (AlternateSet, 2);
struct AlternateSubstFormat1
{
OffsetArrayOf<AlternateSet>
alternateSet; /* Array of AlternateSet tables
* ordered by Coverage Index */
+ public:
+ DEFINE_SIZE_STATIC (6);
};
-ASSERT_SIZE (AlternateSubstFormat1, 6);
struct AlternateSubst
{
component; /* Array of component GlyphIDs--start
* with the second component--ordered
* in writing direction */
+ public:
+ DEFINE_SIZE_STATIC (4);
};
-ASSERT_SIZE (Ligature, 4);
struct LigatureSet
{
OffsetArrayOf<Ligature>
ligature; /* Array LigatureSet tables
* ordered by preference */
+ public:
+ DEFINE_SIZE_STATIC (2);
};
-ASSERT_SIZE (LigatureSet, 2);
struct LigatureSubstFormat1
{
OffsetArrayOf<LigatureSet>
ligatureSet; /* Array LigatureSet tables
* ordered by Coverage Index */
+ public:
+ DEFINE_SIZE_STATIC (6);
};
-ASSERT_SIZE (LigatureSubstFormat1, 6);
struct LigatureSubst
{
ArrayOf<GlyphID>
substituteX; /* Array of substitute
* GlyphIDs--ordered by Coverage Index */
+ public:
+ DEFINE_SIZE_STATIC (10);
};
-ASSERT_SIZE (ReverseChainSingleSubstFormat1, 10);
struct ReverseChainSingleSubst
{
};
typedef OffsetListOf<SubstLookup> SubstLookupList;
-ASSERT_SIZE (SubstLookupList, 2);
/*
* GSUB
OffsetTo<SubstLookupList> &list = CastR<OffsetTo<SubstLookupList> > (lookupList);
return list.sanitize (context, this);
}
+ public:
+ DEFINE_SIZE_STATIC (10);
};
-ASSERT_SIZE (GSUB, 10);
/* Out-of-class implementation for methods recursing */
OffsetArrayOf<RuleSet>
ruleSet; /* Array of RuleSet tables
* ordered by Coverage Index */
+ public:
+ DEFINE_SIZE_STATIC (6);
};
-ASSERT_SIZE (ContextFormat1, 6);
struct ContextFormat2
OffsetArrayOf<RuleSet>
ruleSet; /* Array of RuleSet tables
* ordered by class */
+ public:
+ DEFINE_SIZE_STATIC (8);
};
-ASSERT_SIZE (ContextFormat2, 8);
struct ContextFormat3
ArrayOf<LookupRecord>
lookupX; /* Array of LookupRecords--in
* design order) */
+ public:
+ DEFINE_SIZE_STATIC (8);
};
-ASSERT_SIZE (ChainRule, 8);
struct ChainRuleSet
{
OffsetArrayOf<ChainRule>
rule; /* Array of ChainRule tables
* ordered by preference */
+ public:
+ DEFINE_SIZE_STATIC (2);
};
-ASSERT_SIZE (ChainRuleSet, 2);
struct ChainContextFormat1
{
OffsetArrayOf<ChainRuleSet>
ruleSet; /* Array of ChainRuleSet tables
* ordered by Coverage Index */
+ public:
+ DEFINE_SIZE_STATIC (6);
};
-ASSERT_SIZE (ChainContextFormat1, 6);
struct ChainContextFormat2
{
OffsetArrayOf<ChainRuleSet>
ruleSet; /* Array of ChainRuleSet tables
* ordered by class */
+ public:
+ DEFINE_SIZE_STATIC (12);
};
-ASSERT_SIZE (ChainContextFormat2, 12);
struct ChainContextFormat3
{
ArrayOf<LookupRecord>
lookupX; /* Array of LookupRecords--in
* design order) */
+ public:
+ DEFINE_SIZE_STATIC (10);
};
-ASSERT_SIZE (ChainContextFormat3, 10);
struct ChainContext
{
* extension subtable). */
ULONG extensionOffset; /* Offset to the extension subtable,
* of lookup type subtable. */
+ public:
+ DEFINE_SIZE_STATIC (8);
};
-ASSERT_SIZE (ExtensionFormat1, 8);
struct Extension
{
featureList; /* FeatureList table */
OffsetTo<LookupList>
lookupList; /* LookupList table */
+ public:
+ DEFINE_SIZE_STATIC (10);
};
-ASSERT_SIZE (GSUBGPOS, 10);
#endif /* HB_OT_LAYOUT_GSUBGPOS_PRIVATE_HH */
/* Misc */
-#define ASSERT_SIZE(_type, _size) ASSERT_STATIC (sizeof (_type) == (_size))
-
#if defined(__GNUC__) && (__GNUC__ > 2) && defined(__OPTIMIZE__)
#define _HB_BOOLEAN_EXPR(expr) \
projects / profile / ivi / org.tizen.video-player.git / commitdiff