< prev index next >
src/java.desktop/share/native/libfontmanager/harfbuzz/hb-private.hh
Print this page
*** 42,61 ****
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <assert.h>
-
- /* We only use these two for debug output. However, the debug code is
- * always seen by the compiler (and optimized out in non-debug builds.
- * If including these becomes a problem, we can start thinking about
- * someway around that. */
- #include <stdio.h>
#include <errno.h>
#include <stdarg.h>
/* Compile-time custom allocator support. */
#if defined(hb_malloc_impl) \
&& defined(hb_calloc_impl) \
&& defined(hb_realloc_impl) \
--- 42,59 ----
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <assert.h>
#include <errno.h>
+ #include <stdio.h>
#include <stdarg.h>
+ #define HB_PASTE1(a,b) a##b
+ #define HB_PASTE(a,b) HB_PASTE1(a,b)
+
/* Compile-time custom allocator support. */
#if defined(hb_malloc_impl) \
&& defined(hb_calloc_impl) \
&& defined(hb_realloc_impl) \
*** 72,85 ****
/* Compiler attributes */
! #if defined(__GNUC__) && (__GNUC__ > 2) && defined(__OPTIMIZE__)
! #define _HB_BOOLEAN_EXPR(expr) ((expr) ? 1 : 0)
! #define likely(expr) (__builtin_expect (_HB_BOOLEAN_EXPR(expr), 1))
! #define unlikely(expr) (__builtin_expect (_HB_BOOLEAN_EXPR(expr), 0))
#else
#define likely(expr) (expr)
#define unlikely(expr) (expr)
#endif
--- 70,98 ----
/* Compiler attributes */
! #if __cplusplus < 201103L
!
! #ifndef nullptr
! #define nullptr NULL
! #endif
!
! // Static assertions
! #ifndef static_assert
! #define static_assert(e, msg) \
! HB_UNUSED typedef int HB_PASTE(static_assertion_failed_at_line_, __LINE__) [(e) ? 1 : -1]
! #endif // static_assert
!
! #endif // __cplusplus < 201103L
!
! #define _GNU_SOURCE 1
!
! #if (defined(__GNUC__) || defined(__clang__)) && defined(__OPTIMIZE__)
! #define likely(expr) (__builtin_expect (!!(expr), 1))
! #define unlikely(expr) (__builtin_expect (!!(expr), 0))
#else
#define likely(expr) (expr)
#define unlikely(expr) (expr)
#endif
*** 166,190 ****
# define STRICT 1
# endif
# if defined(_WIN32_WCE)
/* Some things not defined on Windows CE. */
- # define strdup _strdup
# define vsnprintf _vsnprintf
! # define getenv(Name) NULL
# if _WIN32_WCE < 0x800
# define setlocale(Category, Locale) "C"
static int errno = 0; /* Use something better? */
# endif
# elif defined(WINAPI_FAMILY) && (WINAPI_FAMILY==WINAPI_FAMILY_PC_APP || WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP)
! # define getenv(Name) NULL
# endif
# if defined(_MSC_VER) && _MSC_VER < 1900
# define snprintf _snprintf
- # elif defined(_MSC_VER) && _MSC_VER >= 1900
- # /* Covers VC++ Error for strdup being a deprecated POSIX name and to instead use _strdup instead */
- # define strdup _strdup
# endif
#endif
#if HAVE_ATEXIT
/* atexit() is only safe to be called from shared libraries on certain
--- 179,199 ----
# define STRICT 1
# endif
# if defined(_WIN32_WCE)
/* Some things not defined on Windows CE. */
# define vsnprintf _vsnprintf
! # define getenv(Name) nullptr
# if _WIN32_WCE < 0x800
# define setlocale(Category, Locale) "C"
static int errno = 0; /* Use something better? */
# endif
# elif defined(WINAPI_FAMILY) && (WINAPI_FAMILY==WINAPI_FAMILY_PC_APP || WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP)
! # define getenv(Name) nullptr
# endif
# if defined(_MSC_VER) && _MSC_VER < 1900
# define snprintf _snprintf
# endif
#endif
#if HAVE_ATEXIT
/* atexit() is only safe to be called from shared libraries on certain
*** 212,226 ****
# endif
#endif
/* Basics */
-
- #ifndef NULL
- # define NULL ((void *) 0)
- #endif
-
#undef MIN
template <typename Type>
static inline Type MIN (const Type &a, const Type &b) { return a < b ? a : b; }
#undef MAX
--- 221,230 ----
*** 238,273 ****
#define ARRAY_LENGTH_CONST(__array) ((signed int) (sizeof (__array) / sizeof (__array[0])))
#define HB_STMT_START do
#define HB_STMT_END while (0)
! #define _ASSERT_STATIC1(_line, _cond) HB_UNUSED typedef int _static_assert_on_line_##_line##_failed[(_cond)?1:-1]
! #define _ASSERT_STATIC0(_line, _cond) _ASSERT_STATIC1 (_line, (_cond))
! #define ASSERT_STATIC(_cond) _ASSERT_STATIC0 (__LINE__, (_cond))
!
! template <unsigned int cond> class hb_assert_constant_t {};
#define ASSERT_STATIC_EXPR_ZERO(_cond) (0 * (unsigned int) sizeof (hb_assert_constant_t<_cond>))
- #define _PASTE1(a,b) a##b
- #define PASTE(a,b) _PASTE1(a,b)
-
/* Lets assert int types. Saves trouble down the road. */
! ASSERT_STATIC (sizeof (int8_t) == 1);
! ASSERT_STATIC (sizeof (uint8_t) == 1);
! ASSERT_STATIC (sizeof (int16_t) == 2);
! ASSERT_STATIC (sizeof (uint16_t) == 2);
! ASSERT_STATIC (sizeof (int32_t) == 4);
! ASSERT_STATIC (sizeof (uint32_t) == 4);
! ASSERT_STATIC (sizeof (int64_t) == 8);
! ASSERT_STATIC (sizeof (uint64_t) == 8);
!
! ASSERT_STATIC (sizeof (hb_codepoint_t) == 4);
! ASSERT_STATIC (sizeof (hb_position_t) == 4);
! ASSERT_STATIC (sizeof (hb_mask_t) == 4);
! ASSERT_STATIC (sizeof (hb_var_int_t) == 4);
/* We like our types POD */
#define _ASSERT_TYPE_POD1(_line, _type) union _type_##_type##_on_line_##_line##_is_not_POD { _type instance; }
--- 242,271 ----
#define ARRAY_LENGTH_CONST(__array) ((signed int) (sizeof (__array) / sizeof (__array[0])))
#define HB_STMT_START do
#define HB_STMT_END while (0)
! template <unsigned int cond> class hb_assert_constant_t;
! template <> class hb_assert_constant_t<1> {};
#define ASSERT_STATIC_EXPR_ZERO(_cond) (0 * (unsigned int) sizeof (hb_assert_constant_t<_cond>))
/* Lets assert int types. Saves trouble down the road. */
! static_assert ((sizeof (int8_t) == 1), "");
! static_assert ((sizeof (uint8_t) == 1), "");
! static_assert ((sizeof (int16_t) == 2), "");
! static_assert ((sizeof (uint16_t) == 2), "");
! static_assert ((sizeof (int32_t) == 4), "");
! static_assert ((sizeof (uint32_t) == 4), "");
! static_assert ((sizeof (int64_t) == 8), "");
! static_assert ((sizeof (uint64_t) == 8), "");
!
! static_assert ((sizeof (hb_codepoint_t) == 4), "");
! static_assert ((sizeof (hb_position_t) == 4), "");
! static_assert ((sizeof (hb_mask_t) == 4), "");
! static_assert ((sizeof (hb_var_int_t) == 4), "");
/* We like our types POD */
#define _ASSERT_TYPE_POD1(_line, _type) union _type_##_type##_on_line_##_line##_is_not_POD { _type instance; }
*** 298,308 ****
/* Misc */
/* Void! */
struct _hb_void_t {};
typedef const _hb_void_t *hb_void_t;
! #define HB_VOID ((const _hb_void_t *) NULL)
/* Return the number of 1 bits in mask. */
static inline HB_CONST_FUNC unsigned int
_hb_popcount32 (uint32_t mask)
{
--- 296,306 ----
/* Misc */
/* Void! */
struct _hb_void_t {};
typedef const _hb_void_t *hb_void_t;
! #define HB_VOID ((const _hb_void_t *) nullptr)
/* Return the number of 1 bits in mask. */
static inline HB_CONST_FUNC unsigned int
_hb_popcount32 (uint32_t mask)
{
*** 314,323 ****
--- 312,333 ----
y = (mask >> 1) &033333333333;
y = mask - y - ((y >>1) & 033333333333);
return (((y + (y >> 3)) & 030707070707) % 077);
#endif
}
+ static inline HB_CONST_FUNC unsigned int
+ _hb_popcount64 (uint64_t mask)
+ {
+ #if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+ if (sizeof (long) >= sizeof (mask))
+ return __builtin_popcountl (mask);
+ #endif
+ return _hb_popcount32 (mask & 0xFFFFFFFF) + _hb_popcount32 (mask >> 32);
+ }
+ template <typename T> static inline unsigned int _hb_popcount (T mask);
+ template <> inline unsigned int _hb_popcount<uint32_t> (uint32_t mask) { return _hb_popcount32 (mask); }
+ template <> inline unsigned int _hb_popcount<uint64_t> (uint64_t mask) { return _hb_popcount64 (mask); }
/* Returns the number of bits needed to store number */
static inline HB_CONST_FUNC unsigned int
_hb_bit_storage (unsigned int number)
{
*** 355,399 ****
{
return (size > 0) && (count >= ((unsigned int) -1) / size);
}
- /* Type of bsearch() / qsort() compare function */
- typedef int (*hb_compare_func_t) (const void *, const void *);
-
-
-
/* arrays and maps */
! #define HB_PREALLOCED_ARRAY_INIT {0, 0, NULL}
template <typename Type, unsigned int StaticSize=16>
struct hb_prealloced_array_t
{
unsigned int len;
unsigned int allocated;
Type *array;
Type static_array[StaticSize];
! void init (void) { memset (this, 0, sizeof (*this)); }
inline Type& operator [] (unsigned int i) { return array[i]; }
inline const Type& operator [] (unsigned int i) const { return array[i]; }
inline Type *push (void)
{
! if (!array) {
! array = static_array;
! allocated = ARRAY_LENGTH (static_array);
}
- if (likely (len < allocated))
- return &array[len++];
/* Need to reallocate */
! unsigned int new_allocated = allocated + (allocated >> 1) + 8;
! Type *new_array = NULL;
if (array == static_array) {
new_array = (Type *) calloc (new_allocated, sizeof (Type));
if (new_array)
memcpy (new_array, array, len * sizeof (Type));
--- 365,416 ----
{
return (size > 0) && (count >= ((unsigned int) -1) / size);
}
/* arrays and maps */
! #define HB_PREALLOCED_ARRAY_INIT {0, 0, nullptr}
template <typename Type, unsigned int StaticSize=16>
struct hb_prealloced_array_t
{
unsigned int len;
unsigned int allocated;
Type *array;
Type static_array[StaticSize];
! void init (void)
! {
! len = 0;
! allocated = ARRAY_LENGTH (static_array);
! array = static_array;
! }
inline Type& operator [] (unsigned int i) { return array[i]; }
inline const Type& operator [] (unsigned int i) const { return array[i]; }
inline Type *push (void)
{
! if (unlikely (!resize (len + 1)))
! return nullptr;
!
! return &array[len - 1];
}
+ inline bool resize (unsigned int size)
+ {
+ if (unlikely (size > allocated))
+ {
/* Need to reallocate */
!
! unsigned int new_allocated = allocated;
! while (size >= new_allocated)
! new_allocated += (new_allocated >> 1) + 8;
!
! Type *new_array = nullptr;
if (array == static_array) {
new_array = (Type *) calloc (new_allocated, sizeof (Type));
if (new_array)
memcpy (new_array, array, len * sizeof (Type));
*** 403,417 ****
new_array = (Type *) realloc (array, new_allocated * sizeof (Type));
}
}
if (unlikely (!new_array))
! return NULL;
array = new_array;
allocated = new_allocated;
! return &array[len++];
}
inline void pop (void)
{
len--;
--- 420,437 ----
new_array = (Type *) realloc (array, new_allocated * sizeof (Type));
}
}
if (unlikely (!new_array))
! return false;
array = new_array;
allocated = new_allocated;
! }
!
! len = size;
! return true;
}
inline void pop (void)
{
len--;
*** 436,481 ****
template <typename T>
inline Type *find (T v) {
for (unsigned int i = 0; i < len; i++)
if (array[i] == v)
return &array[i];
! return NULL;
}
template <typename T>
inline const Type *find (T v) const {
for (unsigned int i = 0; i < len; i++)
if (array[i] == v)
return &array[i];
! return NULL;
}
inline void qsort (void)
{
! ::qsort (array, len, sizeof (Type), (hb_compare_func_t) Type::cmp);
}
inline void qsort (unsigned int start, unsigned int end)
{
! ::qsort (array + start, end - start, sizeof (Type), (hb_compare_func_t) Type::cmp);
}
template <typename T>
! inline Type *bsearch (T *key)
{
! return (Type *) ::bsearch (key, array, len, sizeof (Type), (hb_compare_func_t) Type::cmp);
}
template <typename T>
! inline const Type *bsearch (T *key) const
{
! return (const Type *) ::bsearch (key, array, len, sizeof (Type), (hb_compare_func_t) Type::cmp);
}
inline void finish (void)
{
if (array != static_array)
free (array);
! array = NULL;
allocated = len = 0;
}
};
template <typename Type>
--- 456,526 ----
template <typename T>
inline Type *find (T v) {
for (unsigned int i = 0; i < len; i++)
if (array[i] == v)
return &array[i];
! return nullptr;
}
template <typename T>
inline const Type *find (T v) const {
for (unsigned int i = 0; i < len; i++)
if (array[i] == v)
return &array[i];
! return nullptr;
}
inline void qsort (void)
{
! ::qsort (array, len, sizeof (Type), Type::cmp);
}
inline void qsort (unsigned int start, unsigned int end)
{
! ::qsort (array + start, end - start, sizeof (Type), Type::cmp);
}
template <typename T>
! inline Type *bsearch (T *x)
{
! unsigned int i;
! return bfind (x, &i) ? &array[i] : nullptr;
}
template <typename T>
! inline const Type *bsearch (T *x) const
{
! unsigned int i;
! return bfind (x, &i) ? &array[i] : nullptr;
! }
! template <typename T>
! inline bool bfind (T *x, unsigned int *i) const
! {
! int min = 0, max = (int) this->len - 1;
! while (min <= max)
! {
! int mid = (min + max) / 2;
! int c = this->array[mid].cmp (x);
! if (c < 0)
! max = mid - 1;
! else if (c > 0)
! min = mid + 1;
! else
! {
! *i = mid;
! return true;
! }
! }
! if (max < 0 || (max < (int) this->len && this->array[max].cmp (x) > 0))
! max++;
! *i = max;
! return false;
}
inline void finish (void)
{
if (array != static_array)
free (array);
! array = nullptr;
allocated = len = 0;
}
};
template <typename Type>
*** 488,498 ****
#define HB_LOCKABLE_SET_INIT {HB_PREALLOCED_ARRAY_INIT}
template <typename item_t, typename lock_t>
struct hb_lockable_set_t
{
! hb_prealloced_array_t <item_t, 2> items;
inline void init (void) { items.init (); }
template <typename T>
inline item_t *replace_or_insert (T v, lock_t &l, bool replace)
--- 533,543 ----
#define HB_LOCKABLE_SET_INIT {HB_PREALLOCED_ARRAY_INIT}
template <typename item_t, typename lock_t>
struct hb_lockable_set_t
{
! hb_prealloced_array_t <item_t, 1> items;
inline void init (void) { items.init (); }
template <typename T>
inline item_t *replace_or_insert (T v, lock_t &l, bool replace)
*** 505,515 ****
*item = v;
l.unlock ();
old.finish ();
}
else {
! item = NULL;
l.unlock ();
}
} else {
item = items.push ();
if (likely (item))
--- 550,560 ----
*item = v;
l.unlock ();
old.finish ();
}
else {
! item = nullptr;
l.unlock ();
}
} else {
item = items.push ();
if (likely (item))
*** 593,877 ****
static inline unsigned char TOUPPER (unsigned char c)
{ return (c >= 'a' && c <= 'z') ? c - 'a' + 'A' : c; }
static inline unsigned char TOLOWER (unsigned char c)
{ return (c >= 'A' && c <= 'Z') ? c - 'A' + 'a' : c; }
- #define HB_TAG_CHAR4(s) (HB_TAG(((const char *) s)[0], \
- ((const char *) s)[1], \
- ((const char *) s)[2], \
- ((const char *) s)[3]))
-
-
- /* C++ helpers */
-
- /* Makes class uncopyable. Use in private: section. */
- #define NO_COPY(T) \
- T (const T &o); \
- T &operator = (const T &o)
-
-
- /* Debug */
-
/* HB_NDEBUG disables some sanity checks that are very safe to disable and
* should be disabled in production systems. If NDEBUG is defined, enable
* HB_NDEBUG; but if it's desirable that normal assert()s (which are very
* light-weight) to be enabled, then HB_DEBUG can be defined to disable
* the costlier checks. */
#ifdef NDEBUG
#define HB_NDEBUG
#endif
- #ifndef HB_DEBUG
- #define HB_DEBUG 0
- #endif
-
- static inline bool
- _hb_debug (unsigned int level,
- unsigned int max_level)
- {
- return level < max_level;
- }
-
- #define DEBUG_LEVEL_ENABLED(WHAT, LEVEL) (_hb_debug ((LEVEL), HB_DEBUG_##WHAT))
- #define DEBUG_ENABLED(WHAT) (DEBUG_LEVEL_ENABLED (WHAT, 0))
-
- static inline void
- _hb_print_func (const char *func)
- {
- if (func)
- {
- unsigned int func_len = strlen (func);
- /* Skip "static" */
- if (0 == strncmp (func, "static ", 7))
- func += 7;
- /* Skip "typename" */
- if (0 == strncmp (func, "typename ", 9))
- func += 9;
- /* Skip return type */
- const char *space = strchr (func, ' ');
- if (space)
- func = space + 1;
- /* Skip parameter list */
- const char *paren = strchr (func, '(');
- if (paren)
- func_len = paren - func;
- fprintf (stderr, "%.*s", func_len, func);
- }
- }
-
- template <int max_level> static inline void
- _hb_debug_msg_va (const char *what,
- const void *obj,
- const char *func,
- bool indented,
- unsigned int level,
- int level_dir,
- const char *message,
- va_list ap) HB_PRINTF_FUNC(7, 0);
- template <int max_level> static inline void
- _hb_debug_msg_va (const char *what,
- const void *obj,
- const char *func,
- bool indented,
- unsigned int level,
- int level_dir,
- const char *message,
- va_list ap)
- {
- if (!_hb_debug (level, max_level))
- return;
-
- fprintf (stderr, "%-10s", what ? what : "");
-
- if (obj)
- fprintf (stderr, "(%0*lx) ", (unsigned int) (2 * sizeof (void *)), (unsigned long) obj);
- else
- fprintf (stderr, " %*s ", (unsigned int) (2 * sizeof (void *)), "");
-
- if (indented) {
- #define VBAR "\342\224\202" /* U+2502 BOX DRAWINGS LIGHT VERTICAL */
- #define VRBAR "\342\224\234" /* U+251C BOX DRAWINGS LIGHT VERTICAL AND RIGHT */
- #define DLBAR "\342\225\256" /* U+256E BOX DRAWINGS LIGHT ARC DOWN AND LEFT */
- #define ULBAR "\342\225\257" /* U+256F BOX DRAWINGS LIGHT ARC UP AND LEFT */
- #define LBAR "\342\225\264" /* U+2574 BOX DRAWINGS LIGHT LEFT */
- static const char bars[] =
- VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR
- VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR
- VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR
- VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR
- VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR VBAR;
- fprintf (stderr, "%2u %s" VRBAR "%s",
- level,
- bars + sizeof (bars) - 1 - MIN ((unsigned int) sizeof (bars) - 1, (unsigned int) (sizeof (VBAR) - 1) * level),
- level_dir ? (level_dir > 0 ? DLBAR : ULBAR) : LBAR);
- } else
- fprintf (stderr, " " VRBAR LBAR);
-
- _hb_print_func (func);
-
- if (message)
- {
- fprintf (stderr, ": ");
- vfprintf (stderr, message, ap);
- }
-
- fprintf (stderr, "\n");
- }
- template <> inline void
- _hb_debug_msg_va<0> (const char *what HB_UNUSED,
- const void *obj HB_UNUSED,
- const char *func HB_UNUSED,
- bool indented HB_UNUSED,
- unsigned int level HB_UNUSED,
- int level_dir HB_UNUSED,
- const char *message HB_UNUSED,
- va_list ap HB_UNUSED) {}
-
- template <int max_level> static inline void
- _hb_debug_msg (const char *what,
- const void *obj,
- const char *func,
- bool indented,
- unsigned int level,
- int level_dir,
- const char *message,
- ...) HB_PRINTF_FUNC(7, 8);
- template <int max_level> static inline void
- _hb_debug_msg (const char *what,
- const void *obj,
- const char *func,
- bool indented,
- unsigned int level,
- int level_dir,
- const char *message,
- ...)
- {
- va_list ap;
- va_start (ap, message);
- _hb_debug_msg_va<max_level> (what, obj, func, indented, level, level_dir, message, ap);
- va_end (ap);
- }
- template <> inline void
- _hb_debug_msg<0> (const char *what HB_UNUSED,
- const void *obj HB_UNUSED,
- const char *func HB_UNUSED,
- bool indented HB_UNUSED,
- unsigned int level HB_UNUSED,
- int level_dir HB_UNUSED,
- const char *message HB_UNUSED,
- ...) HB_PRINTF_FUNC(7, 8);
- template <> inline void
- _hb_debug_msg<0> (const char *what HB_UNUSED,
- const void *obj HB_UNUSED,
- const char *func HB_UNUSED,
- bool indented HB_UNUSED,
- unsigned int level HB_UNUSED,
- int level_dir HB_UNUSED,
- const char *message HB_UNUSED,
- ...) {}
-
- #define DEBUG_MSG_LEVEL(WHAT, OBJ, LEVEL, LEVEL_DIR, ...) _hb_debug_msg<HB_DEBUG_##WHAT> (#WHAT, (OBJ), NULL, true, (LEVEL), (LEVEL_DIR), __VA_ARGS__)
- #define DEBUG_MSG(WHAT, OBJ, ...) _hb_debug_msg<HB_DEBUG_##WHAT> (#WHAT, (OBJ), NULL, false, 0, 0, __VA_ARGS__)
- #define DEBUG_MSG_FUNC(WHAT, OBJ, ...) _hb_debug_msg<HB_DEBUG_##WHAT> (#WHAT, (OBJ), HB_FUNC, false, 0, 0, __VA_ARGS__)
-
-
- /*
- * Printer
- */
-
- template <typename T>
- struct hb_printer_t {
- const char *print (const T&) { return "something"; }
- };
-
- template <>
- struct hb_printer_t<bool> {
- const char *print (bool v) { return v ? "true" : "false"; }
- };
-
- template <>
- struct hb_printer_t<hb_void_t> {
- const char *print (hb_void_t) { return ""; }
- };
-
-
- /*
- * Trace
- */
-
- template <typename T>
- static inline void _hb_warn_no_return (bool returned)
- {
- if (unlikely (!returned)) {
- fprintf (stderr, "OUCH, returned with no call to return_trace(). This is a bug, please report.\n");
- }
- }
- template <>
- /*static*/ inline void _hb_warn_no_return<hb_void_t> (bool returned HB_UNUSED)
- {}
-
- template <int max_level, typename ret_t>
- struct hb_auto_trace_t {
- explicit inline hb_auto_trace_t (unsigned int *plevel_,
- const char *what_,
- const void *obj_,
- const char *func,
- const char *message,
- ...) : plevel (plevel_), what (what_), obj (obj_), returned (false)
- {
- if (plevel) ++*plevel;
-
- va_list ap;
- va_start (ap, message);
- _hb_debug_msg_va<max_level> (what, obj, func, true, plevel ? *plevel : 0, +1, message, ap);
- va_end (ap);
- }
- inline ~hb_auto_trace_t (void)
- {
- _hb_warn_no_return<ret_t> (returned);
- if (!returned) {
- _hb_debug_msg<max_level> (what, obj, NULL, true, plevel ? *plevel : 1, -1, " ");
- }
- if (plevel) --*plevel;
- }
-
- inline ret_t ret (ret_t v, unsigned int line = 0)
- {
- if (unlikely (returned)) {
- fprintf (stderr, "OUCH, double calls to return_trace(). This is a bug, please report.\n");
- return v;
- }
-
- _hb_debug_msg<max_level> (what, obj, NULL, true, plevel ? *plevel : 1, -1,
- "return %s (line %d)",
- hb_printer_t<ret_t>().print (v), line);
- if (plevel) --*plevel;
- plevel = NULL;
- returned = true;
- return v;
- }
-
- private:
- unsigned int *plevel;
- const char *what;
- const void *obj;
- bool returned;
- };
- template <typename ret_t> /* Optimize when tracing is disabled */
- struct hb_auto_trace_t<0, ret_t> {
- explicit inline hb_auto_trace_t (unsigned int *plevel_ HB_UNUSED,
- const char *what HB_UNUSED,
- const void *obj HB_UNUSED,
- const char *func HB_UNUSED,
- const char *message HB_UNUSED,
- ...) {}
-
- inline ret_t ret (ret_t v, unsigned int line HB_UNUSED = 0) { return v; }
- };
-
- #define return_trace(RET) return trace.ret (RET, __LINE__)
/* Misc */
template <typename T> class hb_assert_unsigned_t;
template <> class hb_assert_unsigned_t<unsigned char> {};
--- 638,657 ----
*** 885,895 ****
/* The sizeof() is here to force template instantiation.
* I'm sure there are better ways to do this but can't think of
* one right now. Declaring a variable won't work as HB_UNUSED
* is unusable on some platforms and unused types are less likely
* to generate a warning than unused variables. */
! ASSERT_STATIC (sizeof (hb_assert_unsigned_t<T>) >= 0);
/* The casts below are important as if T is smaller than int,
* the subtract results will become a signed int! */
return (T)(u - lo) <= (T)(hi - lo);
}
--- 665,675 ----
/* The sizeof() is here to force template instantiation.
* I'm sure there are better ways to do this but can't think of
* one right now. Declaring a variable won't work as HB_UNUSED
* is unusable on some platforms and unused types are less likely
* to generate a warning than unused variables. */
! static_assert ((sizeof (hb_assert_unsigned_t<T>) >= 0), "");
/* The casts below are important as if T is smaller than int,
* the subtract results will become a signed int! */
return (T)(u - lo) <= (T)(hi - lo);
}
*** 930,944 ****
}
/* Useful for set-operations on small enums.
* For example, for testing "x ∈ {x1, x2, x3}" use:
! * (FLAG_SAFE(x) & (FLAG(x1) | FLAG(x2) | FLAG(x3)))
*/
! #define FLAG(x) (ASSERT_STATIC_EXPR_ZERO ((x) < 32) + (1U << (x)))
! #define FLAG_SAFE(x) (1U << (x))
! #define FLAG_UNSAFE(x) ((x) < 32 ? FLAG_SAFE(x) : 0)
#define FLAG_RANGE(x,y) (ASSERT_STATIC_EXPR_ZERO ((x) < (y)) + FLAG(y+1) - FLAG(x))
template <typename T, typename T2> static inline void
hb_stable_sort (T *array, unsigned int len, int(*compar)(const T *, const T *), T2 *array2)
--- 710,723 ----
}
/* Useful for set-operations on small enums.
* For example, for testing "x ∈ {x1, x2, x3}" use:
! * (FLAG_UNSAFE(x) & (FLAG(x1) | FLAG(x2) | FLAG(x3)))
*/
! #define FLAG(x) (ASSERT_STATIC_EXPR_ZERO ((unsigned int)(x) < 32) + (1U << (unsigned int)(x)))
! #define FLAG_UNSAFE(x) ((unsigned int)(x) < 32 ? (1U << (unsigned int)(x)) : 0)
#define FLAG_RANGE(x,y) (ASSERT_STATIC_EXPR_ZERO ((x) < (y)) + FLAG(y+1) - FLAG(x))
template <typename T, typename T2> static inline void
hb_stable_sort (T *array, unsigned int len, int(*compar)(const T *, const T *), T2 *array2)
*** 966,976 ****
}
template <typename T> static inline void
hb_stable_sort (T *array, unsigned int len, int(*compar)(const T *, const T *))
{
! hb_stable_sort (array, len, compar, (int *) NULL);
}
static inline hb_bool_t
hb_codepoint_parse (const char *s, unsigned int len, int base, hb_codepoint_t *out)
{
--- 745,755 ----
}
template <typename T> static inline void
hb_stable_sort (T *array, unsigned int len, int(*compar)(const T *, const T *))
{
! hb_stable_sort (array, len, compar, (int *) nullptr);
}
static inline hb_bool_t
hb_codepoint_parse (const char *s, unsigned int len, int base, hb_codepoint_t *out)
{
*** 988,997 ****
--- 767,843 ----
*out = v;
return true;
}
+ /* Vectorization */
+
+ struct HbOpOr
+ {
+ static const bool passthru_left = true;
+ static const bool passthru_right = true;
+ template <typename T> static void process (T &o, const T &a, const T &b) { o = a | b; }
+ };
+ struct HbOpAnd
+ {
+ static const bool passthru_left = false;
+ static const bool passthru_right = false;
+ template <typename T> static void process (T &o, const T &a, const T &b) { o = a & b; }
+ };
+ struct HbOpMinus
+ {
+ static const bool passthru_left = true;
+ static const bool passthru_right = false;
+ template <typename T> static void process (T &o, const T &a, const T &b) { o = a & ~b; }
+ };
+ struct HbOpXor
+ {
+ static const bool passthru_left = true;
+ static const bool passthru_right = true;
+ template <typename T> static void process (T &o, const T &a, const T &b) { o = a ^ b; }
+ };
+
+ /* Type behaving similar to vectorized vars defined using __attribute__((vector_size(...))). */
+ template <typename elt_t, unsigned int byte_size>
+ struct hb_vector_size_t
+ {
+ elt_t& operator [] (unsigned int i) { return v[i]; }
+ const elt_t& operator [] (unsigned int i) const { return v[i]; }
+
+ template <class Op>
+ inline hb_vector_size_t process (const hb_vector_size_t &o) const
+ {
+ hb_vector_size_t r;
+ for (unsigned int i = 0; i < ARRAY_LENGTH (v); i++)
+ Op::process (r.v[i], v[i], o.v[i]);
+ return r;
+ }
+ inline hb_vector_size_t operator | (const hb_vector_size_t &o) const
+ { return process<HbOpOr> (o); }
+ inline hb_vector_size_t operator & (const hb_vector_size_t &o) const
+ { return process<HbOpAnd> (o); }
+ inline hb_vector_size_t operator ^ (const hb_vector_size_t &o) const
+ { return process<HbOpXor> (o); }
+ inline hb_vector_size_t operator ~ () const
+ {
+ hb_vector_size_t r;
+ for (unsigned int i = 0; i < ARRAY_LENGTH (v); i++)
+ r.v[i] = ~v[i];
+ return r;
+ }
+
+ private:
+ static_assert (byte_size / sizeof (elt_t) * sizeof (elt_t) == byte_size, "");
+ elt_t v[byte_size / sizeof (elt_t)];
+ };
+
+ /* The `vector_size' attribute was introduced in gcc 3.1. */
+ #if defined( __GNUC__ ) && ( __GNUC__ >= 4 )
+ #define HAVE_VECTOR_SIZE 1
+ #endif
+
+
/* Global runtime options. */
struct hb_options_t
{
unsigned int initialized : 1;
*** 1000,1010 ****
union hb_options_union_t {
unsigned int i;
hb_options_t opts;
};
! ASSERT_STATIC (sizeof (int) == sizeof (hb_options_union_t));
HB_INTERNAL void
_hb_options_init (void);
extern HB_INTERNAL hb_options_union_t _hb_options;
--- 846,856 ----
union hb_options_union_t {
unsigned int i;
hb_options_t opts;
};
! static_assert ((sizeof (int) == sizeof (hb_options_union_t)), "");
HB_INTERNAL void
_hb_options_init (void);
extern HB_INTERNAL hb_options_union_t _hb_options;
*** 1019,1024 ****
--- 865,897 ----
}
/* Size signifying variable-sized array */
#define VAR 1
+
+ /* String type. */
+
+ struct hb_string_t
+ {
+ inline hb_string_t (void) : bytes (nullptr), len (0) {}
+ inline hb_string_t (const char *bytes_, unsigned int len_) : bytes (bytes_), len (len_) {}
+
+ inline int cmp (const hb_string_t &a) const
+ {
+ if (len != a.len)
+ return (int) a.len - (int) len;
+
+ return memcmp (a.bytes, bytes, len);
+ }
+ static inline int cmp (const void *pa, const void *pb)
+ {
+ hb_string_t *a = (hb_string_t *) pa;
+ hb_string_t *b = (hb_string_t *) pb;
+ return b->cmp (*a);
+ }
+
+ const char *bytes;
+ unsigned int len;
+ };
+
+
#endif /* HB_PRIVATE_HH */
< prev index next >