* 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)))
/*
#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)
#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)
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 {' ', ' ', ' ', ' '}
{
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>
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++)
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;
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];
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;
}
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 */
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)
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;
}
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,
*/
struct ContextLookupContext lookup_context = {
{match_class, apply_func},
- CHARP(&class_def)
+ DECONST_CHARP(&class_def)
};
return rule_set.apply (APPLY_ARG, lookup_context);
}
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),
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);
}
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,
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);
}
*/
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);
}
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,
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);
}
{
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) {