/* * Copyright (C) 2007,2008,2009 Red Hat, Inc. * * This is part of HarfBuzz, a text shaping library. * * Permission is hereby granted, without written agreement and without * license or royalty fees, to use, copy, modify, and distribute this * software and its documentation for any purpose, provided that the * above copyright notice and the following two paragraphs appear in * all copies of this software. * * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH * DAMAGE. * * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. * * Red Hat Author(s): Behdad Esfahbod */ #ifndef HB_PRIVATE_H #define HB_PRIVATE_H #if HAVE_CONFIG_H #include "config.h" #endif #include "hb-common.h" #include #include #include /* 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 #include /* Essentials */ #ifndef NULL # define NULL ((void *) 0) #endif #undef FALSE #define FALSE 0 #undef TRUE #define TRUE 1 /* Basics */ #undef MIN #define MIN(a,b) ((a) < (b) ? (a) : (b)) #undef MAX #define MAX(a,b) ((a) > (b) ? (a) : (b)) #ifndef HB_INTERNAL # define HB_INTERNAL extern #endif #undef ARRAY_LENGTH #define ARRAY_LENGTH(__array) ((signed int) (sizeof (__array) / sizeof (__array[0]))) #define HB_STMT_START do #define HB_STMT_END while (0) #define _ASSERT_STATIC1(_line, _cond) 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)) /* Misc */ #define ASSERT_SIZE(_type, _size) ASSERT_STATIC (sizeof (_type) == (_size)) /* Size signifying variable-sized array */ #define VAR 1 #define VAR0 (VAR+0) #define ASSERT_SIZE_VAR(_type, _size, _var_type) \ ASSERT_STATIC (sizeof (_type) == (_size) + VAR0 * sizeof (_var_type)) #define ASSERT_SIZE_VAR2(_type, _size, _var_type1, _var_type2) \ ASSERT_STATIC (sizeof (_type) == (_size) + VAR0 * sizeof (_var_type1) + VAR0 * sizeof (_var_type2)) #if defined(__GNUC__) && (__GNUC__ > 2) && defined(__OPTIMIZE__) #define _HB_BOOLEAN_EXPR(expr) \ __extension__ ({ \ int _hb_boolean_var_; \ if (expr) \ _hb_boolean_var_ = 1; \ else \ _hb_boolean_var_ = 0; \ _hb_boolean_var_; \ }) #define HB_LIKELY(expr) (__builtin_expect (_HB_BOOLEAN_EXPR(expr), 1)) #define HB_UNLIKELY(expr) (__builtin_expect (_HB_BOOLEAN_EXPR(expr), 0)) #else #define HB_LIKELY(expr) (expr) #define HB_UNLIKELY(expr) (expr) #endif #ifndef __GNUC__ #undef __attribute__ #define __attribute__(x) #endif #if __GNUC__ >= 3 #define HB_PURE_FUNC __attribute__((pure)) #define HB_CONST_FUNC __attribute__((const)) #else #define HB_PURE_FUNC #define HB_CONST_FUNC #endif #if __GNUC__ >= 4 #define HB_UNUSED __attribute__((unused)) #else #define HB_UNUSED #endif #if (defined(__WIN32__) && !defined(__WINE__)) || defined(_MSC_VER) #define snprintf _snprintf #endif #ifdef _MSC_VER #undef inline #define inline __inline #endif #ifdef __STRICT_ANSI__ #undef inline #define inline __inline__ #endif #if __GNUC__ >= 3 #define HB_FUNC __PRETTY_FUNCTION__ #elif defined(_MSC_VER) #define HB_FUNC __FUNCSIG__ #else #define HB_FUNC __func__ #endif /* Return the number of 1 bits in mask. * * GCC 3.4 supports a "population count" builtin, which on many targets is * implemented with a single instruction. There is a fallback definition * in libgcc in case a target does not have one, which should be just as * good as the open-coded solution below, (which is "HACKMEM 169"). */ static inline unsigned int _hb_popcount32 (uint32_t mask) { #if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) return __builtin_popcount (mask); #else register uint32_t y; y = (mask >> 1) &033333333333; y = mask - y - ((y >>1) & 033333333333); return (((y + (y >> 3)) & 030707070707) % 077); #endif } /* Multiplies a 16dot16 value by another value, then truncates the result */ #define _hb_16dot16_mul_round(A,B) (((int64_t) (A) * (B) + 0x8000) / 0x10000) /* We need external help for these */ #ifdef HAVE_GLIB #include typedef int hb_atomic_int_t; #define hb_atomic_int_fetch_and_add(AI, V) g_atomic_int_exchange_and_add (&(AI), V) #define hb_atomic_int_get(AI) g_atomic_int_get (&(AI)) #define hb_atomic_int_set(AI, V) g_atomic_int_set (&(AI), V) typedef GStaticMutex hb_mutex_t; #define HB_MUTEX_INIT G_STATIC_MUTEX_INIT #define hb_mutex_init(M) g_static_mutex_init (&M) #define hb_mutex_lock(M) g_static_mutex_lock (&M) #define hb_mutex_trylock(M) g_static_mutex_trylock (&M) #define hb_mutex_unlock(M) g_static_mutex_unlock (&M) #else #ifdef _MSC_VER #pragma message(__LOC__"Could not find any system to define platform macros, library will NOT be thread-safe") #else #warning "Could not find any system to define platform macros, library will NOT be thread-safe" #endif typedef int hb_atomic_int_t; #define hb_atomic_int_fetch_and_add(AI, V) ((AI) += (V), (AI) - (V)) #define hb_atomic_int_get(AI) (AI) #define hb_atomic_int_set(AI, V) HB_STMT_START { (AI) = (V); } HB_STMT_END typedef int hb_mutex_t; #define HB_MUTEX_INIT 0 #define hb_mutex_init(M) HB_STMT_START { (M) = 0; } HB_STMT_END #define hb_mutex_lock(M) HB_STMT_START { (M) = 1; } HB_STMT_END #define hb_mutex_trylock(M) ((M) = 1, 1) #define hb_mutex_unlock(M) HB_STMT_START { (M) = 0; } HB_STMT_END #endif /* Big-endian handling */ #define hb_be_uint16(v) ((uint16_t) ((((const uint8_t *)&(v))[0] << 8) + (((const uint8_t *)&(v))[1]))) #define hb_be_uint16_put(v,V) HB_STMT_START { v[0] = (V>>8); v[1] = (V); } HB_STMT_END #define hb_be_uint16_get(v) (uint16_t) ((v[0] << 8) + v[1]) #define hb_be_uint16_cmp(a,b) (a[0] == b[0] && a[1] == b[1]) #define hb_be_uint32_put(v,V) HB_STMT_START { v[0] = (V>>24); v[1] = (V>>16); v[2] = (V>>8); v[3] = (V); } HB_STMT_END #define hb_be_uint32_get(v) (uint32_t) ((v[0] << 24) + (v[1] << 16) + (v[2] << 8) + v[3]) #define hb_be_uint32_cmp(a,b) (a[0] == b[0] && a[1] == b[1] && a[2] == b[2] && a[3] == b[3]) /* Debug */ #ifndef HB_DEBUG #define HB_DEBUG 0 #endif static inline hb_bool_t /* always returns TRUE */ _hb_trace (const char *what, const char *function, const void *obj, unsigned int depth, unsigned int max_depth) { if (depth < max_depth) fprintf (stderr, "%s(%p) %-*d-> %s\n", what, obj, depth, depth, function); return TRUE; } #include "hb-object-private.h" #endif /* HB_PRIVATE_H */