Remove ASSERT_SIZE in favor of the safer DEFINE_SIZE_STATIC

[framework/uifw/harfbuzz.git] / src / hb-ot-layout-gsubgpos-private.hh

diff --git a/src/hb-ot-layout-gsubgpos-private.hh b/src/hb-ot-layout-gsubgpos-private.hh
index 86d6405..86285d1 100644 (file)
--- 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 SANITIZE_SELF ();
+    return context->check_struct (this);
   }
 
   USHORT       sequenceIndex;          /* Index into current glyph
                                         * sequence--first glyph = 0 */
   USHORT       lookupListIndex;        /* Lookup to apply to that
                                         * position--zero--based */
+  public:
+  DEFINE_SIZE_STATIC (4);
 };
-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<LookupRecord> (input, input[0].get_size () * (inputCount ? inputCount - 1 : 0));
+    const LookupRecord *lookupRecord = &StructAtOffset<LookupRecord> (input, input[0].static_size * (inputCount ? inputCount - 1 : 0));
     return context_lookup (context,
                           inputCount, input,
                           lookupCount, lookupRecord,
@@ -287,11 +286,11 @@ struct Rule
   public:
   inline bool sanitize (hb_sanitize_context_t *context) {
     TRACE_SANITIZE ();
-    return SANITIZE (inputCount)
-       && SANITIZE (lookupCount)
+    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:
@@ -303,8 +302,9 @@ struct Rule
                                         * second glyph */
   LookupRecord lookupRecordX[VAR];     /* Array of LookupRecords--in
                                         * design order */
+  public:
+  DEFINE_SIZE_VAR2 (4, USHORT, LookupRecord);
 };
-ASSERT_SIZE_VAR2 (Rule, 4, USHORT, LookupRecord);
 
 struct RuleSet
 {
@@ -367,8 +367,9 @@ struct ContextFormat1
   OffsetArrayOf<RuleSet>
                ruleSet;                /* Array of RuleSet tables
                                         * ordered by Coverage Index */
+  public:
+  DEFINE_SIZE_STATIC (6);
 };
-ASSERT_SIZE (ContextFormat1, 6);
 
 
 struct ContextFormat2
@@ -414,8 +415,9 @@ struct ContextFormat2
   OffsetArrayOf<RuleSet>
                ruleSet;                /* Array of RuleSet tables
                                         * ordered by class */
+  public:
+  DEFINE_SIZE_STATIC (8);
 };
-ASSERT_SIZE (ContextFormat2, 8);
 
 
 struct ContextFormat3
@@ -430,7 +432,7 @@ struct ContextFormat3
     if (likely (index == NOT_COVERED))
       return false;
 
-    const LookupRecord *lookupRecord = &StructAtOffset<LookupRecord> (coverage, coverage[0].get_size () * glyphCount);
+    const LookupRecord *lookupRecord = &StructAtOffset<LookupRecord> (coverage, coverage[0].static_size * glyphCount);
     struct ContextLookupContext lookup_context = {
       {match_coverage, apply_func},
        CharP(this)
@@ -443,13 +445,13 @@ struct ContextFormat3
 
   inline bool sanitize (hb_sanitize_context_t *context) {
     TRACE_SANITIZE ();
-    if (!SANITIZE_SELF ()) return false;
+    if (!context->check_struct (this)) return false;
     unsigned int count = glyphCount;
-    if (!context->check_array (coverage, OffsetTo<Coverage>::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<LookupRecord> (coverage, OffsetTo<Coverage>::get_size () * count);
-    return context->check_array (lookupRecord, LookupRecord::get_size (), lookupCount);
+    LookupRecord *lookupRecord = &StructAtOffset<LookupRecord> (coverage, coverage[0].static_size * count);
+    return context->check_array (lookupRecord, lookupRecord[0].static_size, lookupCount);
   }
 
   private:
@@ -462,8 +464,9 @@ struct ContextFormat3
                                         * table in glyph sequence order */
   LookupRecord lookupRecordX[VAR];     /* Array of LookupRecords--in
                                         * design order */
+  public:
+  DEFINE_SIZE_VAR2 (6, OffsetTo<Coverage>, LookupRecord);
 };
-ASSERT_SIZE_VAR2 (ContextFormat3, 6, OffsetTo<Coverage>, LookupRecord);
 
 struct Context
 {
@@ -481,7 +484,7 @@ struct Context
 
   inline bool sanitize (hb_sanitize_context_t *context) {
     TRACE_SANITIZE ();
-    if (!SANITIZE (u.format)) return false;
+    if (!u.format.sanitize (context)) return false;
     switch (u.format) {
     case 1: return u.format1->sanitize (context);
     case 2: return u.format2->sanitize (context);
@@ -566,13 +569,13 @@ struct ChainRule
   public:
   inline bool sanitize (hb_sanitize_context_t *context) {
     TRACE_SANITIZE ();
-    if (!SANITIZE (backtrack)) return false;
+    if (!backtrack.sanitize (context)) return false;
     HeadlessArrayOf<USHORT> &input = StructAfter<HeadlessArrayOf<USHORT> > (backtrack);
-    if (!SANITIZE (input)) return false;
+    if (!input.sanitize (context)) return false;
     ArrayOf<USHORT> &lookahead = StructAfter<ArrayOf<USHORT> > (input);
-    if (!SANITIZE (lookahead)) return false;
+    if (!lookahead.sanitize (context)) return false;
     ArrayOf<LookupRecord> &lookup = StructAfter<ArrayOf<LookupRecord> > (lookahead);
-    return SANITIZE (lookup);
+    return lookup.sanitize (context);
   }
 
   private:
@@ -589,8 +592,9 @@ struct ChainRule
   ArrayOf<LookupRecord>
                lookupX;                /* Array of LookupRecords--in
                                         * design order) */
+  public:
+  DEFINE_SIZE_STATIC (8);
 };
-ASSERT_SIZE (ChainRule, 8);
 
 struct ChainRuleSet
 {
@@ -616,8 +620,9 @@ struct ChainRuleSet
   OffsetArrayOf<ChainRule>
                rule;                   /* Array of ChainRule tables
                                         * ordered by preference */
+  public:
+  DEFINE_SIZE_STATIC (2);
 };
-ASSERT_SIZE (ChainRuleSet, 2);
 
 struct ChainContextFormat1
 {
@@ -653,8 +658,9 @@ struct ChainContextFormat1
   OffsetArrayOf<ChainRuleSet>
                ruleSet;                /* Array of ChainRuleSet tables
                                         * ordered by Coverage Index */
+  public:
+  DEFINE_SIZE_STATIC (6);
 };
-ASSERT_SIZE (ChainContextFormat1, 6);
 
 struct ChainContextFormat2
 {
@@ -715,8 +721,9 @@ struct ChainContextFormat2
   OffsetArrayOf<ChainRuleSet>
                ruleSet;                /* Array of ChainRuleSet tables
                                         * ordered by class */
+  public:
+  DEFINE_SIZE_STATIC (12);
 };
-ASSERT_SIZE (ChainContextFormat2, 12);
 
 struct ChainContextFormat3
 {
@@ -756,7 +763,7 @@ struct ChainContextFormat3
     OffsetArrayOf<Coverage> &lookahead = StructAfter<OffsetArrayOf<Coverage> > (input);
     if (!lookahead.sanitize (context, this)) return false;
     ArrayOf<LookupRecord> &lookup = StructAfter<ArrayOf<LookupRecord> > (lookahead);
-    return SANITIZE (lookup);
+    return lookup.sanitize (context);
   }
 
   private:
@@ -776,8 +783,9 @@ struct ChainContextFormat3
   ArrayOf<LookupRecord>
                lookupX;                /* Array of LookupRecords--in
                                         * design order) */
+  public:
+  DEFINE_SIZE_STATIC (10);
 };
-ASSERT_SIZE (ChainContextFormat3, 10);
 
 struct ChainContext
 {
@@ -795,7 +803,7 @@ struct ChainContext
 
   inline bool sanitize (hb_sanitize_context_t *context) {
     TRACE_SANITIZE ();
-    if (!SANITIZE (u.format)) return false;
+    if (!u.format.sanitize (context)) return false;
     switch (u.format) {
     case 1: return u.format1->sanitize (context);
     case 2: return u.format2->sanitize (context);
@@ -824,7 +832,7 @@ struct ExtensionFormat1
 
   inline bool sanitize (hb_sanitize_context_t *context) {
     TRACE_SANITIZE ();
-    return SANITIZE_SELF ();
+    return context->check_struct (this);
   }
 
   private:
@@ -834,8 +842,9 @@ struct ExtensionFormat1
                                         * extension subtable). */
   ULONG                extensionOffset;        /* Offset to the extension subtable,
                                         * of lookup type subtable. */
+  public:
+  DEFINE_SIZE_STATIC (8);
 };
-ASSERT_SIZE (ExtensionFormat1, 8);
 
 struct Extension
 {
@@ -856,7 +865,7 @@ struct Extension
 
   inline bool sanitize (hb_sanitize_context_t *context) {
     TRACE_SANITIZE ();
-    if (!SANITIZE (u.format)) return false;
+    if (!u.format.sanitize (context)) return false;
     switch (u.format) {
     case 1: return u.format1->sanitize (context);
     default:return true;
@@ -913,7 +922,7 @@ struct GSUBGPOS
 
   inline bool sanitize (hb_sanitize_context_t *context) {
     TRACE_SANITIZE ();
-    return SANITIZE (version) && likely (version.major == 1)
+    return version.sanitize (context) && likely (version.major == 1)
        && scriptList.sanitize (context, this)
        && featureList.sanitize (context, this)
        && lookupList.sanitize (context, this);
@@ -928,8 +937,9 @@ struct GSUBGPOS
                featureList;    /* FeatureList table */
   OffsetTo<LookupList>
                lookupList;     /* LookupList table */
+  public:
+  DEFINE_SIZE_STATIC (10);
 };
-ASSERT_SIZE (GSUBGPOS, 10);
 
 
 #endif /* HB_OT_LAYOUT_GSUBGPOS_PRIVATE_HH */