#define DEFINE_SIZE_STATIC(size) \
DEFINE_INSTANCE_ASSERTION (sizeof (*this) == (size)); \
static const unsigned int static_size = (size); \
- static const unsigned int min_size = (size); \
- inline unsigned int get_size (void) const { return (size); }
+ static const unsigned int min_size = (size)
+
+/* Size signifying variable-sized array */
+#define VAR 1
#define DEFINE_SIZE_UNION(size, _member) \
DEFINE_INSTANCE_ASSERTION (this->u._member.static_size == (size)); \
#define Null(Type) Null<Type>()
-/*
- * Dispatch
- */
-
-template <typename Context, typename Return, unsigned int MaxDebugDepth>
-struct hb_dispatch_context_t
-{
- static const unsigned int max_debug_depth = MaxDebugDepth;
- typedef Return return_t;
- template <typename T, typename F>
- inline bool may_dispatch (const T *obj, const F *format) { return true; }
- static return_t no_dispatch_return_value (void) { return Context::default_return_value (); }
-};
-
/*
* Sanitize
/* This limits sanitizing time on really broken fonts. */
#ifndef HB_SANITIZE_MAX_EDITS
-#define HB_SANITIZE_MAX_EDITS 32
+#define HB_SANITIZE_MAX_EDITS 100
#endif
-struct hb_sanitize_context_t :
- hb_dispatch_context_t<hb_sanitize_context_t, bool, HB_DEBUG_SANITIZE>
+struct hb_sanitize_context_t
{
- inline hb_sanitize_context_t (void) :
- debug_depth (0),
- start (NULL), end (NULL),
- writable (false), edit_count (0),
- blob (NULL) {}
-
inline const char *get_name (void) { return "SANITIZE"; }
+ static const unsigned int max_debug_depth = HB_DEBUG_SANITIZE;
+ typedef bool return_t;
template <typename T, typename F>
inline bool may_dispatch (const T *obj, const F *format)
{ return format->sanitize (this); }
template <typename T>
inline return_t dispatch (const T &obj) { return obj.sanitize (this); }
static return_t default_return_value (void) { return true; }
- static return_t no_dispatch_return_value (void) { return false; }
bool stop_sublookup_iteration (const return_t r) const { return !r; }
inline void init (hb_blob_t *b)
struct Sanitizer
{
static hb_blob_t *sanitize (hb_blob_t *blob) {
- hb_sanitize_context_t c[1];
+ hb_sanitize_context_t c[1] = {{0, NULL, NULL, false, 0, NULL}};
bool sane;
/* TODO is_sane() stuff */
struct hb_serialize_context_t
{
- inline hb_serialize_context_t (void *start_, unsigned int size)
+ inline hb_serialize_context_t (void *start, unsigned int size)
{
- this->start = (char *) start_;
+ this->start = (char *) start;
this->end = this->start + size;
this->ran_out_of_room = false;
return reinterpret_cast<Type *> (&obj);
}
- inline void truncate (void *new_head)
+ inline void truncate (void *head)
{
- assert (this->start < new_head && new_head <= this->head);
- this->head = (char *) new_head;
+ assert (this->start < head && head <= this->head);
+ this->head = (char *) head;
}
unsigned int debug_depth;
template <typename Type, int Bytes> struct BEInt;
template <typename Type>
-struct BEInt<Type, 1>
-{
- public:
- inline void set (Type V)
- {
- v = V;
- }
- inline operator Type (void) const
- {
- return v;
- }
- private: uint8_t v;
-};
-template <typename Type>
struct BEInt<Type, 2>
{
public:
inline bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
- return_trace (likely (c->check_struct (this)));
+ return TRACE_RETURN (likely (c->check_struct (this)));
}
protected:
BEInt<Type, Size> v;
DEFINE_SIZE_STATIC (Size);
};
-typedef IntType<uint8_t , 1> BYTE; /* 8-bit unsigned integer. */
+typedef uint8_t BYTE; /* 8-bit unsigned integer. */
typedef IntType<uint16_t, 2> USHORT; /* 16-bit unsigned integer. */
typedef IntType<int16_t, 2> SHORT; /* 16-bit signed integer. */
typedef IntType<uint32_t, 4> ULONG; /* 32-bit unsigned integer. */
/* 16-bit unsigned integer (USHORT) that describes a quantity in FUnits. */
typedef USHORT UFWORD;
-/* 16-bit signed fixed number with the low 14 bits of fraction (2.14). */
-struct F2DOT14 : SHORT
-{
- //inline float to_float (void) const { return ???; }
- //inline void set_float (float f) { v.set (f * ???); }
- public:
- DEFINE_SIZE_STATIC (2);
-};
-
-/* 32-bit signed fixed-point number (16.16). */
-struct Fixed: LONG
-{
- //inline float to_float (void) const { return ???; }
- //inline void set_float (float f) { v.set (f * ???); }
- public:
- DEFINE_SIZE_STATIC (4);
-};
-
/* Date represented in number of seconds since 12:00 midnight, January 1,
* 1904. The value is represented as a signed 64-bit integer. */
struct LONGDATETIME
inline bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
- return_trace (likely (c->check_struct (this)));
+ return TRACE_RETURN (likely (c->check_struct (this)));
}
protected:
LONG major;
* Version Numbers
*/
-template <typename FixedType=USHORT>
struct FixedVersion
{
- inline uint32_t to_int (void) const { return (major << (sizeof(FixedType) * 8)) + minor; }
+ inline uint32_t to_int (void) const { return (major << 16) + minor; }
inline bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
- return_trace (c->check_struct (this));
+ return TRACE_RETURN (c->check_struct (this));
}
- FixedType major;
- FixedType minor;
+ USHORT major;
+ USHORT minor;
public:
- DEFINE_SIZE_STATIC (2 * sizeof(FixedType));
+ DEFINE_SIZE_STATIC (4);
};
inline bool sanitize (hb_sanitize_context_t *c, const void *base) const
{
TRACE_SANITIZE (this);
- if (unlikely (!c->check_struct (this))) return_trace (false);
+ if (unlikely (!c->check_struct (this))) return TRACE_RETURN (false);
unsigned int offset = *this;
- if (unlikely (!offset)) return_trace (true);
+ if (unlikely (!offset)) return TRACE_RETURN (true);
const Type &obj = StructAtOffset<Type> (base, offset);
- return_trace (likely (obj.sanitize (c)) || neuter (c));
+ return TRACE_RETURN (likely (obj.sanitize (c)) || neuter (c));
}
template <typename T>
inline bool sanitize (hb_sanitize_context_t *c, const void *base, T user_data) const
{
TRACE_SANITIZE (this);
- if (unlikely (!c->check_struct (this))) return_trace (false);
+ if (unlikely (!c->check_struct (this))) return TRACE_RETURN (false);
unsigned int offset = *this;
- if (unlikely (!offset)) return_trace (true);
+ if (unlikely (!offset)) return TRACE_RETURN (true);
const Type &obj = StructAtOffset<Type> (base, offset);
- return_trace (likely (obj.sanitize (c, user_data)) || neuter (c));
+ return TRACE_RETURN (likely (obj.sanitize (c, user_data)) || neuter (c));
}
/* Set the offset to Null */
unsigned int items_len)
{
TRACE_SERIALIZE (this);
- if (unlikely (!c->extend_min (*this))) return_trace (false);
+ if (unlikely (!c->extend_min (*this))) return TRACE_RETURN (false);
len.set (items_len); /* TODO(serialize) Overflow? */
- if (unlikely (!c->extend (*this))) return_trace (false);
- return_trace (true);
+ if (unlikely (!c->extend (*this))) return TRACE_RETURN (false);
+ return TRACE_RETURN (true);
}
inline bool serialize (hb_serialize_context_t *c,
unsigned int items_len)
{
TRACE_SERIALIZE (this);
- if (unlikely (!serialize (c, items_len))) return_trace (false);
+ if (unlikely (!serialize (c, items_len))) return TRACE_RETURN (false);
for (unsigned int i = 0; i < items_len; i++)
array[i] = items[i];
items.advance (items_len);
- return_trace (true);
+ return TRACE_RETURN (true);
}
inline bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
- if (unlikely (!sanitize_shallow (c))) return_trace (false);
+ if (unlikely (!sanitize_shallow (c))) return TRACE_RETURN (false);
/* Note: for structs that do not reference other structs,
* we do not need to call their sanitize() as we already did
*/
(void) (false && array[0].sanitize (c));
- return_trace (true);
+ return TRACE_RETURN (true);
}
inline bool sanitize (hb_sanitize_context_t *c, const void *base) const
{
TRACE_SANITIZE (this);
- if (unlikely (!sanitize_shallow (c))) return_trace (false);
+ if (unlikely (!sanitize_shallow (c))) return TRACE_RETURN (false);
unsigned int count = len;
for (unsigned int i = 0; i < count; i++)
if (unlikely (!array[i].sanitize (c, base)))
- return_trace (false);
- return_trace (true);
+ return TRACE_RETURN (false);
+ return TRACE_RETURN (true);
}
template <typename T>
inline bool sanitize (hb_sanitize_context_t *c, const void *base, T user_data) const
{
TRACE_SANITIZE (this);
- if (unlikely (!sanitize_shallow (c))) return_trace (false);
+ if (unlikely (!sanitize_shallow (c))) return TRACE_RETURN (false);
unsigned int count = len;
for (unsigned int i = 0; i < count; i++)
if (unlikely (!array[i].sanitize (c, base, user_data)))
- return_trace (false);
- return_trace (true);
+ return TRACE_RETURN (false);
+ return TRACE_RETURN (true);
}
template <typename SearchType>
inline bool sanitize_shallow (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
- return_trace (c->check_struct (this) && c->check_array (array, Type::static_size, len));
+ return TRACE_RETURN (c->check_struct (this) && c->check_array (this, Type::static_size, len));
}
public:
inline bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
- return_trace (OffsetArrayOf<Type>::sanitize (c, this));
+ return TRACE_RETURN (OffsetArrayOf<Type>::sanitize (c, this));
}
template <typename T>
inline bool sanitize (hb_sanitize_context_t *c, T user_data) const
{
TRACE_SANITIZE (this);
- return_trace (OffsetArrayOf<Type>::sanitize (c, this, user_data));
+ return TRACE_RETURN (OffsetArrayOf<Type>::sanitize (c, this, user_data));
}
};
unsigned int items_len)
{
TRACE_SERIALIZE (this);
- if (unlikely (!c->extend_min (*this))) return_trace (false);
+ if (unlikely (!c->extend_min (*this))) return TRACE_RETURN (false);
len.set (items_len); /* TODO(serialize) Overflow? */
- if (unlikely (!items_len)) return_trace (true);
- if (unlikely (!c->extend (*this))) return_trace (false);
+ if (unlikely (!items_len)) return TRACE_RETURN (true);
+ if (unlikely (!c->extend (*this))) return TRACE_RETURN (false);
for (unsigned int i = 0; i < items_len - 1; i++)
array[i] = items[i];
items.advance (items_len - 1);
- return_trace (true);
+ return TRACE_RETURN (true);
}
inline bool sanitize_shallow (hb_sanitize_context_t *c) const
inline bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
- if (unlikely (!sanitize_shallow (c))) return_trace (false);
+ if (unlikely (!sanitize_shallow (c))) return TRACE_RETURN (false);
/* Note: for structs that do not reference other structs,
* we do not need to call their sanitize() as we already did
*/
(void) (false && array[0].sanitize (c));
- return_trace (true);
+ return TRACE_RETURN (true);
}
LenType len;
projects / platform / upstream / harfbuzz.git / blobdiff