From e45d3f86f9a5f3d29ca35a282de7f98e702878f9 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 6 May 2010 19:33:31 -0400 Subject: [PATCH] Start cleaning up get_size() So we know when the size is static and when dynamic. --- src/hb-open-file-private.hh | 7 +++--- src/hb-open-type-private.hh | 42 +++++++++++++++++++++++++----------- src/hb-ot-layout-common-private.hh | 14 ++++++------ src/hb-ot-layout-gpos-private.hh | 17 ++++++--------- src/hb-ot-layout-gsubgpos-private.hh | 19 ++++++++-------- 5 files changed, 55 insertions(+), 44 deletions(-) diff --git a/src/hb-open-file-private.hh b/src/hb-open-file-private.hh index cf75df9..c531c29 100644 --- a/src/hb-open-file-private.hh +++ b/src/hb-open-file-private.hh @@ -47,20 +47,19 @@ struct TTCHeader; typedef struct TableDirectory { - static inline unsigned int get_size () { return sizeof (TableDirectory); } - inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return context->check_struct (this); } + DEFINE_SIZE_STATIC (16); + Tag tag; /* 4-byte identifier. */ CheckSum checkSum; /* CheckSum for this table. */ ULONG offset; /* Offset from beginning of TrueType font * file. */ ULONG length; /* Length of this table. */ } OpenTypeTable; -ASSERT_SIZE (TableDirectory, 16); typedef struct OffsetTable { @@ -101,7 +100,7 @@ typedef struct OffsetTable inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return context->check_struct (this) - && context->check_array (tableDir, TableDirectory::get_size (), numTables); + && context->check_array (tableDir, TableDirectory::static_size, numTables); } private: diff --git a/src/hb-open-type-private.hh b/src/hb-open-type-private.hh index 82242e9..b0daf41 100644 --- a/src/hb-open-type-private.hh +++ b/src/hb-open-type-private.hh @@ -86,6 +86,29 @@ inline Type& StructAfter(TObject &X) /* + * Size checking + */ + +#define DEFINE_SIZE_STATIC(size) \ + inline void _size_assertion (void) const \ + { ASSERT_STATIC (sizeof (*this) == (size)); } \ + static inline unsigned int get_size (void) { return (size); } \ + static const unsigned int static_size = (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)); } \ + static const unsigned int min_size = (size) + +#define DEFINE_SIZE_VAR2(_type, size, _var_type1, _var_type2) \ + inline void _size_assertion (void) const \ + { ASSERT_STATIC (sizeof (*this) == (size) + VAR0 * sizeof (_var_type1) + VAR0 * sizeof (_var_type2)); } \ + static const unsigned int min_size = (size) + + + +/* * Null objects */ @@ -348,7 +371,6 @@ class BEInt template struct IntType { - static inline unsigned int get_size () { return sizeof (Type); } inline void set (Type i) { v = i; } inline operator Type(void) const { return v; } inline bool operator == (const IntType &o) const { return v == o.v; } @@ -357,6 +379,7 @@ struct IntType TRACE_SANITIZE (); return context->check_struct (this); } + DEFINE_SIZE_STATIC (sizeof (Type)); private: BEInt v; }; @@ -365,11 +388,6 @@ typedef IntType SHORT; /* 16-bit signed integer. */ typedef IntType ULONG; /* 32-bit unsigned integer. */ typedef IntType LONG; /* 32-bit signed integer. */ -ASSERT_SIZE (USHORT, 2); -ASSERT_SIZE (SHORT, 2); -ASSERT_SIZE (ULONG, 4); -ASSERT_SIZE (LONG, 4); - /* Array of four uint8s (length = 32 bits) used to identify a script, language * system, feature, or baseline */ struct Tag : ULONG @@ -397,7 +415,7 @@ struct CheckSum : ULONG static uint32_t CalcTableChecksum (ULONG *Table, uint32_t Length) { uint32_t Sum = 0L; - ULONG *EndPtr = Table+((Length+3) & ~3) / ULONG::get_size (); + ULONG *EndPtr = Table+((Length+3) & ~3) / ULONG::static_size; while (Table < EndPtr) Sum += *Table++; @@ -463,7 +481,7 @@ struct GenericOffsetTo : OffsetType private: /* Set the offset to Null */ inline bool neuter (hb_sanitize_context_t *context) { - if (context->can_edit (CharP(this), this->get_size ())) { + if (context->can_edit (CharP(this), this->static_size)) { this->set (0); /* 0 is Null offset */ return true; } @@ -508,7 +526,7 @@ struct GenericArrayOf return array()[i]; } inline unsigned int get_size () const - { return len.get_size () + len * Type::get_size (); } + { return len.static_size + len * Type::static_size; } inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); @@ -551,7 +569,7 @@ struct GenericArrayOf inline bool sanitize_shallow (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return context->check_struct (this) - && context->check_array (this, Type::get_size (), len); + && context->check_array (this, Type::static_size, len); } public: @@ -615,11 +633,11 @@ struct HeadlessArrayOf return array()[i-1]; } inline unsigned int get_size () const - { return len.get_size () + (len ? len - 1 : 0) * Type::get_size (); } + { 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::get_size (), len); + && context->check_array (this, Type::static_size, len); } inline bool sanitize (hb_sanitize_context_t *context) { diff --git a/src/hb-ot-layout-common-private.hh b/src/hb-ot-layout-common-private.hh index 09a6930..97002cb 100644 --- a/src/hb-ot-layout-common-private.hh +++ b/src/hb-ot-layout-common-private.hh @@ -51,14 +51,14 @@ template struct Record { - static inline unsigned int get_size () { return sizeof (Record); } - inline bool sanitize (hb_sanitize_context_t *context, void *base) { TRACE_SANITIZE (); return context->check_struct (this) && offset.sanitize (context, base); } + DEFINE_SIZE_STATIC (6); + Tag tag; /* 4-byte Tag identifier */ OffsetTo offset; /* Offset from beginning of object holding @@ -350,8 +350,6 @@ struct CoverageRangeRecord { friend struct CoverageFormat2; - static inline unsigned int get_size () { return sizeof (CoverageRangeRecord); } - private: inline unsigned int get_coverage (hb_codepoint_t glyph_id) const { @@ -366,13 +364,14 @@ struct CoverageRangeRecord return context->check_struct (this); } + DEFINE_SIZE_STATIC (6); + private: GlyphID start; /* First GlyphID in the range */ GlyphID end; /* Last GlyphID in the range */ USHORT startCoverageIndex; /* Coverage Index of first GlyphID in * range */ }; -ASSERT_SIZE (CoverageRangeRecord, 6); DEFINE_NULL_DATA (CoverageRangeRecord, 6, "\000\001"); struct CoverageFormat2 @@ -472,8 +471,6 @@ struct ClassRangeRecord { friend struct ClassDefFormat2; - static inline unsigned int get_size () { return sizeof (ClassRangeRecord); } - private: inline hb_ot_layout_class_t get_class (hb_codepoint_t glyph_id) const { @@ -488,12 +485,13 @@ struct ClassRangeRecord return context->check_struct (this); } + DEFINE_SIZE_STATIC (6); + private: GlyphID start; /* First GlyphID in the range */ GlyphID end; /* Last GlyphID in the range */ USHORT classValue; /* Applied to all glyphs in the range */ }; -ASSERT_SIZE (ClassRangeRecord, 6); DEFINE_NULL_DATA (ClassRangeRecord, 6, "\000\001"); struct ClassDefFormat2 diff --git a/src/hb-ot-layout-gpos-private.hh b/src/hb-ot-layout-gpos-private.hh index 60ee17e..ab72731 100644 --- a/src/hb-ot-layout-gpos-private.hh +++ b/src/hb-ot-layout-gpos-private.hh @@ -90,7 +90,7 @@ struct ValueFormat : USHORT inline unsigned int get_len () const { return _hb_popcount32 ((unsigned int) *this); } inline unsigned int get_size () const - { return get_len () * Value::get_size (); } + { return get_len () * Value::static_size; } void apply_value (hb_ot_layout_context_t *layout, const char *base, @@ -349,7 +349,7 @@ struct AnchorMatrix if (!context->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].get_size (), count)) return false; + if (!context->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; return true; @@ -368,21 +368,19 @@ struct MarkRecord { friend struct MarkArray; - static inline unsigned int get_size () { return sizeof (MarkRecord); } - inline bool sanitize (hb_sanitize_context_t *context, void *base) { TRACE_SANITIZE (); return context->check_struct (this) && markAnchor.sanitize (context, base); } + DEFINE_SIZE_STATIC (4); private: USHORT klass; /* Class defined for this mark */ OffsetTo markAnchor; /* Offset to Anchor table--from * beginning of MarkArray table */ }; -ASSERT_SIZE (MarkRecord, 4); struct MarkArray { @@ -565,7 +563,7 @@ struct PairSet TRACE_SANITIZE (); if (!context->check_struct (this)) return false; unsigned int count = (1 + format_len) * len; - return context->check_array (array, USHORT::get_size (), count); + return context->check_array (array, USHORT::static_size, count); } private: @@ -602,7 +600,7 @@ struct PairPosFormat1 unsigned int len1 = valueFormat1.get_len (); unsigned int len2 = valueFormat2.get_len (); - unsigned int record_size = USHORT::get_size () * (1 + len1 + len2); + unsigned int record_size = USHORT::static_size * (1 + len1 + len2); const PairSet &pair_set = this+pairSet[index]; unsigned int count = pair_set.len; @@ -795,14 +793,14 @@ struct PairPos struct EntryExitRecord { - static inline unsigned int get_size () { return sizeof (EntryExitRecord); } - inline bool sanitize (hb_sanitize_context_t *context, void *base) { TRACE_SANITIZE (); return entryAnchor.sanitize (context, base) && exitAnchor.sanitize (context, base); } + DEFINE_SIZE_STATIC (4); + OffsetTo entryAnchor; /* Offset to EntryAnchor table--from * beginning of CursivePos @@ -812,7 +810,6 @@ struct EntryExitRecord * beginning of CursivePos * subtable--may be NULL */ }; -ASSERT_SIZE (EntryExitRecord, 4); struct CursivePosFormat1 { diff --git a/src/hb-ot-layout-gsubgpos-private.hh b/src/hb-ot-layout-gsubgpos-private.hh index 7777b9c..f389b19 100644 --- a/src/hb-ot-layout-gsubgpos-private.hh +++ b/src/hb-ot-layout-gsubgpos-private.hh @@ -172,19 +172,18 @@ static inline bool match_lookahead (hb_apply_context_t *context, struct LookupRecord { - static inline unsigned int get_size () { return sizeof (LookupRecord); } - inline bool sanitize (hb_sanitize_context_t *context) { TRACE_SANITIZE (); return context->check_struct (this); } + DEFINE_SIZE_STATIC (4); + USHORT sequenceIndex; /* Index into current glyph * sequence--first glyph = 0 */ USHORT lookupListIndex; /* Lookup to apply to that * position--zero--based */ }; -ASSERT_SIZE (LookupRecord, 4); static inline bool apply_lookup (hb_apply_context_t *context, unsigned int count, /* Including the first glyph */ @@ -277,7 +276,7 @@ struct Rule inline bool apply (hb_apply_context_t *context, ContextLookupContext &lookup_context) const { TRACE_APPLY (); - const LookupRecord *lookupRecord = &StructAtOffset (input, input[0].get_size () * (inputCount ? inputCount - 1 : 0)); + const LookupRecord *lookupRecord = &StructAtOffset (input, input[0].static_size * (inputCount ? inputCount - 1 : 0)); return context_lookup (context, inputCount, input, lookupCount, lookupRecord, @@ -290,8 +289,8 @@ struct Rule return inputCount.sanitize (context) && lookupCount.sanitize (context) && context->check_range (input, - input[0].get_size () * inputCount - + lookupRecordX[0].get_size () * lookupCount); + input[0].static_size * inputCount + + lookupRecordX[0].static_size * lookupCount); } private: @@ -430,7 +429,7 @@ struct ContextFormat3 if (likely (index == NOT_COVERED)) return false; - const LookupRecord *lookupRecord = &StructAtOffset (coverage, coverage[0].get_size () * glyphCount); + const LookupRecord *lookupRecord = &StructAtOffset (coverage, coverage[0].static_size * glyphCount); struct ContextLookupContext lookup_context = { {match_coverage, apply_func}, CharP(this) @@ -445,11 +444,11 @@ struct ContextFormat3 TRACE_SANITIZE (); if (!context->check_struct (this)) return false; unsigned int count = glyphCount; - if (!context->check_array (coverage, OffsetTo::get_size (), count)) return false; + if (!context->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; - LookupRecord *lookupRecord = &StructAtOffset (coverage, OffsetTo::get_size () * count); - return context->check_array (lookupRecord, LookupRecord::get_size (), lookupCount); + LookupRecord *lookupRecord = &StructAtOffset (coverage, coverage[0].static_size * count); + return context->check_array (lookupRecord, lookupRecord[0].static_size, lookupCount); } private: -- 2.7.4