GNOME.org
 

[pango/harfbuzz-ng: 44/57] [HB] More cast cleanup

commit 7c897c7a2452ec740ac434561d2334c72c1ffdd8
Author: Behdad Esfahbod <behdad behdad org>
Date:   Tue Aug 4 11:38:50 2009 -0400

    [HB] More cast cleanup

 pango/opentype/hb-open-types-private.hh         |   23 +++++---
 pango/opentype/hb-ot-layout-common-private.hh   |    7 +--
 pango/opentype/hb-ot-layout-gsub-private.hh     |   27 ++++------
 pango/opentype/hb-ot-layout-gsubgpos-private.hh |   64 ++++++++--------------
 4 files changed, 50 insertions(+), 71 deletions(-)
---
diff --git a/pango/opentype/hb-open-types-private.hh b/pango/opentype/hb-open-types-private.hh
index 2ece79d..96e5eb1 100644
--- a/pango/opentype/hb-open-types-private.hh
+++ b/pango/opentype/hb-open-types-private.hh
@@ -42,8 +42,13 @@
  * Casts
  */
 
-#define CONST_CHARP(X) (reinterpret_cast<const char *>(X))
-#define CHARP(X) ((char *)reinterpret_cast<const char *>(X))
+#define CONST_CHARP(X)		(reinterpret_cast<const char *>(X))
+#define DECONST_CHARP(X)	((char *)reinterpret_cast<const char *>(X))
+#define CHARP(X)		(reinterpret_cast<char *>(X))
+
+#define CONST_CAST(T,X,Ofs)	(*(reinterpret_cast<const T *>(CONST_CHARP(&(X)) + Ofs)))
+#define DECONST_CAST(T,X,Ofs)	(*(reinterpret_cast<T *>((char *)CONST_CHARP(&(X)) + Ofs)))
+#define CAST(T,X,Ofs) 		(*(reinterpret_cast<T *>(CHARP(&(X)) + Ofs)))
 
 
 /*
@@ -65,7 +70,7 @@ struct _hb_sanitize_context_t
 #define SANITIZE(X) HB_LIKELY ((X).sanitize (SANITIZE_ARG))
 #define SANITIZE2(X,Y) SANITIZE (X) && SANITIZE (Y)
 
-#define SANITIZE_THIS(X) HB_LIKELY ((X).sanitize (SANITIZE_ARG, reinterpret_cast<const char *>(this)))
+#define SANITIZE_THIS(X) HB_LIKELY ((X).sanitize (SANITIZE_ARG, CONST_CHARP(this)))
 #define SANITIZE_THIS2(X,Y) SANITIZE_THIS (X) && SANITIZE_THIS (Y)
 #define SANITIZE_THIS3(X,Y,Z) SANITIZE_THIS (X) && SANITIZE_THIS (Y) && SANITIZE_THIS(Z)
 
@@ -73,7 +78,7 @@ struct _hb_sanitize_context_t
 #define SANITIZE_OBJ(X) SANITIZE_MEM(&(X), sizeof (X))
 #define SANITIZE_GET_SIZE() SANITIZE_MEM (this, this->get_size ())
 
-#define SANITIZE_MEM(B,L) HB_LIKELY (context->start <= reinterpret_cast<const char *>(B) && reinterpret_cast<const char *>(B) + (L) <= context->end) /* XXX overflow */
+#define SANITIZE_MEM(B,L) HB_LIKELY (context->start <= CONST_CHARP(B) && CONST_CHARP(B) + (L) <= context->end) /* XXX overflow */
 
 #define NEUTER(Var, Val) (false)
 
@@ -272,8 +277,8 @@ struct Tag : ULONG
   inline Tag (const char *c) { *(ULONG*)this = *(ULONG*)c; }
   inline bool operator== (const char *c) const { return *(ULONG*)this == *(ULONG*)c; }
   /* What the char* converters return is NOT nul-terminated.  Print using "%.4s" */
-  inline operator const char* (void) const { return reinterpret_cast<const char *>(this); }
-  inline operator char* (void) { return reinterpret_cast<char *>(this); }
+  inline operator const char* (void) const { return CONST_CHARP(this); }
+  inline operator char* (void) { return CHARP(this); }
 };
 ASSERT_SIZE (Tag, 4);
 #define _NULL_TAG_INIT  {' ', ' ', ' ', ' '}
@@ -337,14 +342,14 @@ struct GenericOffsetTo : OffsetType
   {
     unsigned int offset = *this;
     if (HB_UNLIKELY (!offset)) return Null(Type);
-    return *reinterpret_cast<const Type*>(reinterpret_cast<const char *>(base) + offset);
+    return CONST_CAST(Type, base, offset);
   }
 
   inline bool sanitize (SANITIZE_ARG_DEF, const void *base) {
     if (!SANITIZE_OBJ (*this)) return false;
     unsigned int offset = *this;
     if (HB_UNLIKELY (!offset)) return true;
-    return SANITIZE (*reinterpret_cast<Type*>((char *)(reinterpret_cast<const char *>(base) + offset))) || NEUTER (*this, 0);
+    return SANITIZE (CAST(Type, base, offset)) || NEUTER (*this, 0);
   }
 };
 template <typename Base, typename OffsetType, typename Type>
@@ -379,7 +384,7 @@ struct GenericArrayOf
         return false;
     */
   }
-  inline bool sanitize (SANITIZE_ARG_DEF, const char *base) {
+  inline bool sanitize (SANITIZE_ARG_DEF, const void *base) {
     if (!(SANITIZE (len) && SANITIZE_GET_SIZE())) return false;
     unsigned int count = len;
     for (unsigned int i = 0; i < count; i++)
diff --git a/pango/opentype/hb-ot-layout-common-private.hh b/pango/opentype/hb-ot-layout-common-private.hh
index 9b0d032..6720b60 100644
--- a/pango/opentype/hb-ot-layout-common-private.hh
+++ b/pango/opentype/hb-ot-layout-common-private.hh
@@ -46,7 +46,7 @@
 template <typename Type>
 struct Record
 {
-  inline bool sanitize (SANITIZE_ARG_DEF, const char *base) {
+  inline bool sanitize (SANITIZE_ARG_DEF, const void *base) {
     /* Note: Only accept ASCII-visible tags (mind DEL)
      * This is one of the few times (only time?) we check
      * for data integrity, as opposed o just boundary checks
@@ -210,8 +210,7 @@ struct Lookup
     unsigned int flag = lookupFlag;
     if (HB_UNLIKELY (flag & LookupFlag::UseMarkFilteringSet))
     {
-      const USHORT &markFilteringSet = *(const USHORT*)
-					(CONST_CHARP(&subTable) + subTable.get_size ());
+      const USHORT &markFilteringSet = CONST_CAST (USHORT, subTable, subTable.get_size ());
       flag += (markFilteringSet << 16);
     }
     return flag;
@@ -221,7 +220,7 @@ struct Lookup
     if (!(SANITIZE_SELF () && SANITIZE_THIS (subTable))) return false;
     if (HB_UNLIKELY (lookupFlag & LookupFlag::UseMarkFilteringSet))
     {
-      USHORT &markFilteringSet = *(USHORT*) (CHARP(&subTable) + subTable.get_size ());
+      USHORT &markFilteringSet = CAST (USHORT, subTable, subTable.get_size ());
       if (!SANITIZE (markFilteringSet)) return false;
     }
     return true;
diff --git a/pango/opentype/hb-ot-layout-gsub-private.hh b/pango/opentype/hb-ot-layout-gsub-private.hh
index e29128f..c3fca5b 100644
--- a/pango/opentype/hb-ot-layout-gsub-private.hh
+++ b/pango/opentype/hb-ot-layout-gsub-private.hh
@@ -543,9 +543,7 @@ struct ExtensionSubst : Extension
 
   private:
   inline const struct SubstLookupSubTable& get_subtable (void) const
-  { return (const struct SubstLookupSubTable&) Extension::get_subtable (); }
-  inline struct SubstLookupSubTable& get_subtable (void)
-  { return (struct SubstLookupSubTable&) Extension::get_subtable (); }
+  { return CONST_CAST (SubstLookupSubTable, Extension::get_subtable (), 0); }
 
   inline bool apply (APPLY_ARG_DEF) const;
 
@@ -568,17 +566,15 @@ struct ReverseChainSingleSubstFormat1
     if (HB_LIKELY (index == NOT_COVERED))
       return false;
 
-    const OffsetArrayOf<Coverage> &lookahead = *(const OffsetArrayOf<Coverage>*)
-					        (CONST_CHARP(&backtrack) + backtrack.get_size ());
-    const ArrayOf<GlyphID> &substitute = *(const ArrayOf<GlyphID>*)
-					  (CONST_CHARP(&lookahead) + lookahead.get_size ());
+    const OffsetArrayOf<Coverage> &lookahead = CONST_CAST (OffsetArrayOf<Coverage>, backtrack, backtrack.get_size ());
+    const ArrayOf<GlyphID> &substitute = CONST_CAST (ArrayOf<GlyphID>, lookahead, lookahead.get_size ());
 
     if (match_backtrack (APPLY_ARG,
 			 backtrack.len, (USHORT *) backtrack.array,
-			 match_coverage, CHARP(this)) &&
+			 match_coverage, DECONST_CHARP(this)) &&
         match_lookahead (APPLY_ARG,
 			 lookahead.len, (USHORT *) lookahead.array,
-			 match_coverage, CHARP(this),
+			 match_coverage, DECONST_CHARP(this),
 			 1))
     {
       IN_CURGLYPH () = substitute[index];
@@ -592,12 +588,10 @@ struct ReverseChainSingleSubstFormat1
   inline bool sanitize (SANITIZE_ARG_DEF) {
     if (!SANITIZE_THIS2 (coverage, backtrack))
       return false;
-    OffsetArrayOf<Coverage> &lookahead = *(OffsetArrayOf<Coverage>*)
-					  (CONST_CHARP(&backtrack) + backtrack.get_size ());
+    OffsetArrayOf<Coverage> &lookahead = CAST (OffsetArrayOf<Coverage>, backtrack, backtrack.get_size ());
     if (!SANITIZE_THIS (lookahead))
       return false;
-    ArrayOf<GlyphID> &substitute = *(ArrayOf<GlyphID>*)
-				    (CONST_CHARP(&lookahead) + lookahead.get_size ());
+    ArrayOf<GlyphID> &substitute = CAST (ArrayOf<GlyphID>, lookahead, lookahead.get_size ());
     if (!SANITIZE (substitute))
       return false;
   }
@@ -720,9 +714,7 @@ ASSERT_SIZE (SubstLookupSubTable, 2);
 struct SubstLookup : Lookup
 {
   inline const SubstLookupSubTable& get_subtable (unsigned int i) const
-  { return (const SubstLookupSubTable&) Lookup::get_subtable (i); }
-  inline SubstLookupSubTable& get_subtable (unsigned int i)
-  { return (SubstLookupSubTable&) Lookup::get_subtable (i); }
+  { return CONST_CAST (SubstLookupSubTable, Lookup::get_subtable (i), 0); }
 
   /* Like get_type(), but looks through extension lookups.
    * Never returns Extension */
@@ -871,7 +863,8 @@ inline bool ExtensionSubst::apply (APPLY_ARG_DEF) const
 
 inline bool ExtensionSubst::sanitize (SANITIZE_ARG_DEF)
 {
-  return Extension::sanitize (SANITIZE_ARG) && get_subtable ().sanitize (SANITIZE_ARG);
+  return Extension::sanitize (SANITIZE_ARG) &&
+	 DECONST_CAST (SubstLookupSubTable, get_subtable (), 0).sanitize (SANITIZE_ARG);
 }
 
 static inline bool substitute_lookup (APPLY_ARG_DEF, unsigned int lookup_index)
diff --git a/pango/opentype/hb-ot-layout-gsubgpos-private.hh b/pango/opentype/hb-ot-layout-gsubgpos-private.hh
index 4324c93..ec305e3 100644
--- a/pango/opentype/hb-ot-layout-gsubgpos-private.hh
+++ b/pango/opentype/hb-ot-layout-gsubgpos-private.hh
@@ -64,7 +64,7 @@ static inline bool match_glyph (hb_codepoint_t glyph_id, const USHORT &value, ch
 
 static inline bool match_class (hb_codepoint_t glyph_id, const USHORT &value, char *data)
 {
-  const ClassDef &class_def = *(const ClassDef *)data;
+  const ClassDef &class_def = *reinterpret_cast<const ClassDef *>(data);
   return class_def.get_class (glyph_id) == value;
 }
 
@@ -256,9 +256,7 @@ struct Rule
   private:
   inline bool apply (APPLY_ARG_DEF, ContextLookupContext &lookup_context) const
   {
-    const LookupRecord *lookupRecord = (const LookupRecord *)
-				       (CONST_CHARP(input) +
-					sizeof (input[0]) * (inputCount ? inputCount - 1 : 0));
+    const LookupRecord *lookupRecord = &CONST_CAST (LookupRecord, input, sizeof (input[0]) * (inputCount ? inputCount - 1 : 0));
     return context_lookup (APPLY_ARG,
 			   inputCount, input,
 			   lookupCount, lookupRecord,
@@ -364,7 +362,7 @@ struct ContextFormat2
      */
     struct ContextLookupContext lookup_context = {
      {match_class, apply_func},
-      CHARP(&class_def)
+      DECONST_CHARP(&class_def)
     };
     return rule_set.apply (APPLY_ARG, lookup_context);
   }
@@ -399,12 +397,10 @@ struct ContextFormat3
     if (HB_LIKELY (index == NOT_COVERED))
       return false;
 
-    const LookupRecord *lookupRecord = (const LookupRecord *)
-				       (CONST_CHARP(coverage) +
-					sizeof (coverage[0]) * glyphCount);
+    const LookupRecord *lookupRecord = &CONST_CAST(LookupRecord, coverage, sizeof (coverage[0]) * glyphCount);
     struct ContextLookupContext lookup_context = {
       {match_coverage, apply_func},
-      CHARP(this)
+      DECONST_CHARP(this)
     };
     return context_lookup (APPLY_ARG,
 			   glyphCount, (const USHORT *) (coverage + 1),
@@ -417,9 +413,7 @@ struct ContextFormat3
     unsigned int count = glyphCount;
     for (unsigned int i = 0; i < count; i++)
       if (!SANITIZE_THIS (coverage[i])) return false;
-    LookupRecord *lookupRecord = (LookupRecord *)
-				 (CHARP(coverage) +
-				  sizeof (coverage[0]) * glyphCount);
+    LookupRecord *lookupRecord = &CAST(LookupRecord, coverage, sizeof (coverage[0]) * glyphCount);
     return SANITIZE_MEM (lookupRecord, sizeof (lookupRecord[0]) * lookupCount);
   }
 
@@ -521,12 +515,9 @@ struct ChainRule
   private:
   inline bool apply (APPLY_ARG_DEF, ChainContextLookupContext &lookup_context) const
   {
-    const HeadlessArrayOf<USHORT> &input = *(const HeadlessArrayOf<USHORT>*)
-					    (CONST_CHARP(&backtrack) + backtrack.get_size ());
-    const ArrayOf<USHORT> &lookahead = *(const ArrayOf<USHORT>*)
-				        (CONST_CHARP(&input) + input.get_size ());
-    const ArrayOf<LookupRecord> &lookup = *(const ArrayOf<LookupRecord>*)
-					   (CONST_CHARP(&lookahead) + lookahead.get_size ());
+    const HeadlessArrayOf<USHORT> &input = CONST_CAST (HeadlessArrayOf<USHORT>, backtrack, backtrack.get_size ());
+    const ArrayOf<USHORT> &lookahead = CONST_CAST (ArrayOf<USHORT>, input, input.get_size ());
+    const ArrayOf<LookupRecord> &lookup = CONST_CAST (ArrayOf<LookupRecord>, lookahead, lookahead.get_size ());
     return chain_context_lookup (APPLY_ARG,
 				 backtrack.len, backtrack.array,
 				 input.len, input.array + 1,
@@ -539,14 +530,11 @@ struct ChainRule
   public:
   inline bool sanitize (SANITIZE_ARG_DEF) {
     if (!SANITIZE (backtrack)) return false;
-    HeadlessArrayOf<USHORT> &input = *(HeadlessArrayOf<USHORT>*)
-				      (CHARP(&backtrack) + backtrack.get_size ());
+    HeadlessArrayOf<USHORT> &input = CAST (HeadlessArrayOf<USHORT>, backtrack, backtrack.get_size ());
     if (!SANITIZE (input)) return false;
-    ArrayOf<USHORT> &lookahead = *(ArrayOf<USHORT>*)
-				  (CHARP(&input) + input.get_size ());
+    ArrayOf<USHORT> &lookahead = CAST (ArrayOf<USHORT>, input, input.get_size ());
     if (!SANITIZE (lookahead)) return false;
-    ArrayOf<LookupRecord> &lookup = *(ArrayOf<LookupRecord>*)
-				     (CHARP(&lookahead) + lookahead.get_size ());
+    ArrayOf<LookupRecord> &lookup = CAST (ArrayOf<LookupRecord>, lookahead, lookahead.get_size ());
     return SANITIZE (lookup);
   }
 
@@ -648,9 +636,9 @@ struct ChainContextFormat2
      */
     struct ChainContextLookupContext lookup_context = {
      {match_class, apply_func},
-     {CHARP(&backtrack_class_def),
-      CHARP(&input_class_def),
-      CHARP(&lookahead_class_def)}
+     {DECONST_CHARP(&backtrack_class_def),
+      DECONST_CHARP(&input_class_def),
+      DECONST_CHARP(&lookahead_class_def)}
     };
     return rule_set.apply (APPLY_ARG, lookup_context);
   }
@@ -692,20 +680,17 @@ struct ChainContextFormat3
 
   inline bool apply (APPLY_ARG_DEF, apply_lookup_func_t apply_func) const
   {
-    const OffsetArrayOf<Coverage> &input = *(const OffsetArrayOf<Coverage>*)
-					    (CONST_CHARP(&backtrack) + backtrack.get_size ());
+    const OffsetArrayOf<Coverage> &input = CONST_CAST (OffsetArrayOf<Coverage>, backtrack, backtrack.get_size ());
 
     unsigned int index = (this+input[0]) (IN_CURGLYPH ());
     if (HB_LIKELY (index == NOT_COVERED))
       return false;
 
-    const OffsetArrayOf<Coverage> &lookahead = *(const OffsetArrayOf<Coverage>*)
-					        (CONST_CHARP(&input) + input.get_size ());
-    const ArrayOf<LookupRecord> &lookup = *(const ArrayOf<LookupRecord>*)
-					   (CONST_CHARP(&lookahead) + lookahead.get_size ());
+    const OffsetArrayOf<Coverage> &lookahead = CONST_CAST (OffsetArrayOf<Coverage>, input, input.get_size ());
+    const ArrayOf<LookupRecord> &lookup = CONST_CAST (ArrayOf<LookupRecord>, lookahead, lookahead.get_size ());
     struct ChainContextLookupContext lookup_context = {
       {match_coverage, apply_func},
-      {CHARP(this), CHARP(this), CHARP(this)}
+      {DECONST_CHARP(this), DECONST_CHARP(this), DECONST_CHARP(this)}
     };
     return chain_context_lookup (APPLY_ARG,
 				 backtrack.len, (USHORT *) backtrack.array,
@@ -718,14 +703,11 @@ struct ChainContextFormat3
 
   inline bool sanitize (SANITIZE_ARG_DEF) {
     if (!SANITIZE_THIS (backtrack)) return false;
-    OffsetArrayOf<Coverage> &input = *(OffsetArrayOf<Coverage>*)
-				      (CHARP(&backtrack) + backtrack.get_size ());
+    OffsetArrayOf<Coverage> &input = CAST (OffsetArrayOf<Coverage>, backtrack, backtrack.get_size ());
     if (!SANITIZE_THIS (input)) return false;
-    OffsetArrayOf<Coverage> &lookahead = *(OffsetArrayOf<Coverage>*)
-					  (CHARP(&input) + input.get_size ());
+    OffsetArrayOf<Coverage> &lookahead = CAST (OffsetArrayOf<Coverage>, input, input.get_size ());
     if (!SANITIZE_THIS (lookahead)) return false;
-    ArrayOf<LookupRecord> &lookup = *(ArrayOf<LookupRecord>*)
-				     (CHARP(&lookahead) + lookahead.get_size ());
+    ArrayOf<LookupRecord> &lookup = CAST (ArrayOf<LookupRecord>, lookahead, lookahead.get_size ());
     return SANITIZE (lookup);
   }
 
@@ -794,7 +776,7 @@ struct ExtensionFormat1
   {
     unsigned int offset = get_offset ();
     if (HB_UNLIKELY (!offset)) return Null(LookupSubTable);
-    return *(LookupSubTable*)(CHARP(this) + offset);
+    return CONST_CAST (LookupSubTable, *this, offset);
   }
 
   inline bool sanitize (SANITIZE_ARG_DEF) {
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]