Behdad Esfahbod | 64aef3a | 2008-01-23 16:14:38 -0500 | [diff] [blame] | 1 | /* |
Behdad Esfahbod | 2409d5f | 2011-04-21 17:14:28 -0400 | [diff] [blame] | 2 | * Copyright © 2007,2008,2009 Red Hat, Inc. |
Behdad Esfahbod | 0ab8c86 | 2012-05-11 01:25:34 +0200 | [diff] [blame] | 3 | * Copyright © 2011,2012 Google, Inc. |
Behdad Esfahbod | 64aef3a | 2008-01-23 16:14:38 -0500 | [diff] [blame] | 4 | * |
Behdad Esfahbod | c755cb3 | 2010-04-22 00:11:43 -0400 | [diff] [blame] | 5 | * This is part of HarfBuzz, a text shaping library. |
Behdad Esfahbod | 64aef3a | 2008-01-23 16:14:38 -0500 | [diff] [blame] | 6 | * |
| 7 | * Permission is hereby granted, without written agreement and without |
| 8 | * license or royalty fees, to use, copy, modify, and distribute this |
| 9 | * software and its documentation for any purpose, provided that the |
| 10 | * above copyright notice and the following two paragraphs appear in |
| 11 | * all copies of this software. |
| 12 | * |
| 13 | * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR |
| 14 | * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES |
| 15 | * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN |
| 16 | * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH |
| 17 | * DAMAGE. |
| 18 | * |
| 19 | * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, |
| 20 | * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND |
| 21 | * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS |
| 22 | * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO |
| 23 | * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. |
| 24 | * |
| 25 | * Red Hat Author(s): Behdad Esfahbod |
Behdad Esfahbod | 2409d5f | 2011-04-21 17:14:28 -0400 | [diff] [blame] | 26 | * Google Author(s): Behdad Esfahbod |
Behdad Esfahbod | 64aef3a | 2008-01-23 16:14:38 -0500 | [diff] [blame] | 27 | */ |
| 28 | |
Behdad Esfahbod | c57d454 | 2011-04-20 18:50:27 -0400 | [diff] [blame] | 29 | #ifndef HB_PRIVATE_HH |
| 30 | #define HB_PRIVATE_HH |
Behdad Esfahbod | 5b3f770 | 2006-12-28 06:42:37 -0500 | [diff] [blame] | 31 | |
Behdad Esfahbod | 5ddd9cc | 2011-09-16 16:40:44 -0400 | [diff] [blame] | 32 | #ifdef HAVE_CONFIG_H |
Behdad Esfahbod | df66028 | 2009-08-01 20:46:02 -0400 | [diff] [blame] | 33 | #include "config.h" |
| 34 | #endif |
Behdad Esfahbod | 12360f7 | 2008-01-23 15:50:38 -0500 | [diff] [blame] | 35 | |
Behdad Esfahbod | d1c9eb4 | 2012-04-12 13:17:44 -0400 | [diff] [blame] | 36 | #include "hb.h" |
Behdad Esfahbod | d1c9eb4 | 2012-04-12 13:17:44 -0400 | [diff] [blame] | 37 | #define HB_H_IN |
Behdad Esfahbod | 3e32cd9 | 2012-04-23 13:20:52 -0400 | [diff] [blame] | 38 | #ifdef HAVE_OT |
| 39 | #include "hb-ot.h" |
Behdad Esfahbod | d1c9eb4 | 2012-04-12 13:17:44 -0400 | [diff] [blame] | 40 | #define HB_OT_H_IN |
Behdad Esfahbod | 3e32cd9 | 2012-04-23 13:20:52 -0400 | [diff] [blame] | 41 | #endif |
Behdad Esfahbod | b28815c | 2009-08-04 22:35:36 -0400 | [diff] [blame] | 42 | |
Behdad Esfahbod | c7d457a | 2009-05-21 12:46:29 -0400 | [diff] [blame] | 43 | #include <stdlib.h> |
Behdad Esfahbod | b65c060 | 2011-07-28 16:48:43 -0400 | [diff] [blame] | 44 | #include <stddef.h> |
Behdad Esfahbod | f0954d1 | 2009-07-30 15:33:57 -0400 | [diff] [blame] | 45 | #include <string.h> |
| 46 | #include <assert.h> |
Behdad Esfahbod | 1d52151 | 2010-04-28 13:18:41 -0400 | [diff] [blame] | 47 | |
| 48 | /* We only use these two for debug output. However, the debug code is |
| 49 | * always seen by the compiler (and optimized out in non-debug builds. |
| 50 | * If including these becomes a problem, we can start thinking about |
| 51 | * someway around that. */ |
Behdad Esfahbod | 7acb389 | 2009-08-05 15:20:34 -0400 | [diff] [blame] | 52 | #include <stdio.h> |
| 53 | #include <errno.h> |
Behdad Esfahbod | cc06c24 | 2011-07-25 20:25:44 -0400 | [diff] [blame] | 54 | #include <stdarg.h> |
Behdad Esfahbod | c7d457a | 2009-05-21 12:46:29 -0400 | [diff] [blame] | 55 | |
Behdad Esfahbod | acdba3f | 2010-07-23 15:11:18 -0400 | [diff] [blame] | 56 | |
Behdad Esfahbod | bc20045 | 2010-04-29 01:40:26 -0400 | [diff] [blame] | 57 | |
| 58 | /* Essentials */ |
| 59 | |
| 60 | #ifndef NULL |
| 61 | # define NULL ((void *) 0) |
| 62 | #endif |
| 63 | |
Behdad Esfahbod | a794ebf | 2009-08-06 12:32:35 -0400 | [diff] [blame] | 64 | |
Behdad Esfahbod | dabe698 | 2012-11-23 14:21:35 -0500 | [diff] [blame] | 65 | /* Void! */ |
Behdad Esfahbod | a1733db | 2012-11-23 16:40:04 -0500 | [diff] [blame] | 66 | struct _void_t; |
| 67 | typedef const _void_t &void_t; |
| 68 | #define VOID (* (const _void_t *) NULL) |
Behdad Esfahbod | dabe698 | 2012-11-23 14:21:35 -0500 | [diff] [blame] | 69 | |
| 70 | |
Behdad Esfahbod | c7d457a | 2009-05-21 12:46:29 -0400 | [diff] [blame] | 71 | /* Basics */ |
| 72 | |
Behdad Esfahbod | 153142d | 2011-04-27 01:49:03 -0400 | [diff] [blame] | 73 | |
Behdad Esfahbod | c7d457a | 2009-05-21 12:46:29 -0400 | [diff] [blame] | 74 | #undef MIN |
Behdad Esfahbod | 25326c2 | 2012-08-04 16:43:18 -0700 | [diff] [blame] | 75 | template <typename Type> |
| 76 | static inline Type MIN (const Type &a, const Type &b) { return a < b ? a : b; } |
Behdad Esfahbod | c7d457a | 2009-05-21 12:46:29 -0400 | [diff] [blame] | 77 | |
Behdad Esfahbod | 8a3511a | 2009-11-04 19:45:39 -0500 | [diff] [blame] | 78 | #undef MAX |
Behdad Esfahbod | 25326c2 | 2012-08-04 16:43:18 -0700 | [diff] [blame] | 79 | template <typename Type> |
| 80 | static inline Type MAX (const Type &a, const Type &b) { return a > b ? a : b; } |
Behdad Esfahbod | 153142d | 2011-04-27 01:49:03 -0400 | [diff] [blame] | 81 | |
Behdad Esfahbod | 8a3511a | 2009-11-04 19:45:39 -0500 | [diff] [blame] | 82 | |
Behdad Esfahbod | 4591753 | 2009-11-04 18:15:59 -0500 | [diff] [blame] | 83 | #undef ARRAY_LENGTH |
Behdad Esfahbod | 25326c2 | 2012-08-04 16:43:18 -0700 | [diff] [blame] | 84 | template <typename Type, unsigned int n> |
| 85 | static inline unsigned int ARRAY_LENGTH (const Type (&a)[n]) { return n; } |
Behdad Esfahbod | fabd311 | 2012-09-05 22:19:28 -0400 | [diff] [blame] | 86 | /* A const version, but does not detect erratically being called on pointers. */ |
| 87 | #define ARRAY_LENGTH_CONST(__array) ((signed int) (sizeof (__array) / sizeof (__array[0]))) |
Behdad Esfahbod | c7d457a | 2009-05-21 12:46:29 -0400 | [diff] [blame] | 88 | |
Behdad Esfahbod | 35a7383 | 2009-08-01 19:30:31 -0400 | [diff] [blame] | 89 | #define HB_STMT_START do |
| 90 | #define HB_STMT_END while (0) |
Behdad Esfahbod | 5b3f770 | 2006-12-28 06:42:37 -0500 | [diff] [blame] | 91 | |
Behdad Esfahbod | 73cb02d | 2012-06-06 11:29:25 -0400 | [diff] [blame] | 92 | #define _ASSERT_STATIC1(_line, _cond) typedef int _static_assert_on_line_##_line##_failed[(_cond)?1:-1] |
| 93 | #define _ASSERT_STATIC0(_line, _cond) _ASSERT_STATIC1 (_line, (_cond)) |
| 94 | #define ASSERT_STATIC(_cond) _ASSERT_STATIC0 (__LINE__, (_cond)) |
Behdad Esfahbod | 303fe62 | 2008-01-23 00:20:48 -0500 | [diff] [blame] | 95 | |
Behdad Esfahbod | 79e2b47 | 2012-06-06 11:27:17 -0400 | [diff] [blame] | 96 | #define ASSERT_STATIC_EXPR(_cond)((void) sizeof (char[(_cond) ? 1 : -1])) |
Behdad Esfahbod | 4ec30ae | 2011-06-28 14:13:38 -0400 | [diff] [blame] | 97 | #define ASSERT_STATIC_EXPR_ZERO(_cond) (0 * sizeof (char[(_cond) ? 1 : -1])) |
Behdad Esfahbod | dcb7026 | 2011-04-21 16:34:22 -0400 | [diff] [blame] | 98 | |
Behdad Esfahbod | 4be46ba | 2012-05-11 14:39:01 +0200 | [diff] [blame] | 99 | #define _PASTE1(a,b) a##b |
| 100 | #define PASTE(a,b) _PASTE1(a,b) |
Behdad Esfahbod | bc20045 | 2010-04-29 01:40:26 -0400 | [diff] [blame] | 101 | |
Behdad Esfahbod | 6fd5364 | 2011-04-11 11:47:14 -0400 | [diff] [blame] | 102 | /* Lets assert int types. Saves trouble down the road. */ |
| 103 | |
| 104 | ASSERT_STATIC (sizeof (int8_t) == 1); |
| 105 | ASSERT_STATIC (sizeof (uint8_t) == 1); |
| 106 | ASSERT_STATIC (sizeof (int16_t) == 2); |
| 107 | ASSERT_STATIC (sizeof (uint16_t) == 2); |
| 108 | ASSERT_STATIC (sizeof (int32_t) == 4); |
| 109 | ASSERT_STATIC (sizeof (uint32_t) == 4); |
| 110 | ASSERT_STATIC (sizeof (int64_t) == 8); |
| 111 | ASSERT_STATIC (sizeof (uint64_t) == 8); |
| 112 | |
Behdad Esfahbod | b13640d | 2011-04-11 12:29:31 -0400 | [diff] [blame] | 113 | ASSERT_STATIC (sizeof (hb_codepoint_t) == 4); |
| 114 | ASSERT_STATIC (sizeof (hb_position_t) == 4); |
| 115 | ASSERT_STATIC (sizeof (hb_mask_t) == 4); |
Behdad Esfahbod | ae9eeaf | 2011-04-11 11:49:08 -0400 | [diff] [blame] | 116 | ASSERT_STATIC (sizeof (hb_var_int_t) == 4); |
Behdad Esfahbod | 6fd5364 | 2011-04-11 11:47:14 -0400 | [diff] [blame] | 117 | |
Behdad Esfahbod | a00a63b | 2012-06-06 03:07:01 -0400 | [diff] [blame] | 118 | |
| 119 | /* We like our types POD */ |
| 120 | |
Behdad Esfahbod | 73cb02d | 2012-06-06 11:29:25 -0400 | [diff] [blame] | 121 | #define _ASSERT_TYPE_POD1(_line, _type) union _type_##_type##_on_line_##_line##_is_not_POD { _type instance; } |
| 122 | #define _ASSERT_TYPE_POD0(_line, _type) _ASSERT_TYPE_POD1 (_line, _type) |
| 123 | #define ASSERT_TYPE_POD(_type) _ASSERT_TYPE_POD0 (__LINE__, _type) |
Behdad Esfahbod | a00a63b | 2012-06-06 03:07:01 -0400 | [diff] [blame] | 124 | |
| 125 | #ifdef __GNUC__ |
Behdad Esfahbod | 79e2b47 | 2012-06-06 11:27:17 -0400 | [diff] [blame] | 126 | # define _ASSERT_INSTANCE_POD1(_line, _instance) \ |
| 127 | HB_STMT_START { \ |
| 128 | typedef __typeof__(_instance) _type_##_line; \ |
| 129 | _ASSERT_TYPE_POD1 (_line, _type_##_line); \ |
| 130 | } HB_STMT_END |
Behdad Esfahbod | a00a63b | 2012-06-06 03:07:01 -0400 | [diff] [blame] | 131 | #else |
Behdad Esfahbod | 73cb02d | 2012-06-06 11:29:25 -0400 | [diff] [blame] | 132 | # define _ASSERT_INSTANCE_POD1(_line, _instance) typedef int _assertion_on_line_##_line##_not_tested |
Behdad Esfahbod | a00a63b | 2012-06-06 03:07:01 -0400 | [diff] [blame] | 133 | #endif |
Behdad Esfahbod | 73cb02d | 2012-06-06 11:29:25 -0400 | [diff] [blame] | 134 | # define _ASSERT_INSTANCE_POD0(_line, _instance) _ASSERT_INSTANCE_POD1 (_line, _instance) |
| 135 | # define ASSERT_INSTANCE_POD(_instance) _ASSERT_INSTANCE_POD0 (__LINE__, _instance) |
Behdad Esfahbod | a00a63b | 2012-06-06 03:07:01 -0400 | [diff] [blame] | 136 | |
| 137 | /* Check _assertion in a method environment */ |
| 138 | #define _ASSERT_POD1(_line) \ |
Behdad Esfahbod | 73cb02d | 2012-06-06 11:29:25 -0400 | [diff] [blame] | 139 | inline void _static_assertion_on_line_##_line (void) const \ |
| 140 | { _ASSERT_INSTANCE_POD1 (_line, *this); /* Make sure it's POD. */ } |
| 141 | # define _ASSERT_POD0(_line) _ASSERT_POD1 (_line) |
| 142 | # define ASSERT_POD() _ASSERT_POD0 (__LINE__) |
Behdad Esfahbod | a00a63b | 2012-06-06 03:07:01 -0400 | [diff] [blame] | 143 | |
| 144 | |
| 145 | |
Behdad Esfahbod | bc20045 | 2010-04-29 01:40:26 -0400 | [diff] [blame] | 146 | /* Misc */ |
| 147 | |
Behdad Esfahbod | c7d457a | 2009-05-21 12:46:29 -0400 | [diff] [blame] | 148 | |
Behdad Esfahbod | df66028 | 2009-08-01 20:46:02 -0400 | [diff] [blame] | 149 | #if defined(__GNUC__) && (__GNUC__ > 2) && defined(__OPTIMIZE__) |
Behdad Esfahbod | 494d28a | 2010-05-10 23:50:07 -0400 | [diff] [blame] | 150 | #define _HB_BOOLEAN_EXPR(expr) ((expr) ? 1 : 0) |
Behdad Esfahbod | 64d3fc8 | 2010-05-03 22:51:19 -0400 | [diff] [blame] | 151 | #define likely(expr) (__builtin_expect (_HB_BOOLEAN_EXPR(expr), 1)) |
| 152 | #define unlikely(expr) (__builtin_expect (_HB_BOOLEAN_EXPR(expr), 0)) |
Behdad Esfahbod | df66028 | 2009-08-01 20:46:02 -0400 | [diff] [blame] | 153 | #else |
Behdad Esfahbod | 64d3fc8 | 2010-05-03 22:51:19 -0400 | [diff] [blame] | 154 | #define likely(expr) (expr) |
| 155 | #define unlikely(expr) (expr) |
Behdad Esfahbod | df66028 | 2009-08-01 20:46:02 -0400 | [diff] [blame] | 156 | #endif |
| 157 | |
| 158 | #ifndef __GNUC__ |
| 159 | #undef __attribute__ |
| 160 | #define __attribute__(x) |
| 161 | #endif |
| 162 | |
| 163 | #if __GNUC__ >= 3 |
Behdad Esfahbod | 33d13fd | 2010-04-29 13:56:44 -0400 | [diff] [blame] | 164 | #define HB_PURE_FUNC __attribute__((pure)) |
| 165 | #define HB_CONST_FUNC __attribute__((const)) |
Behdad Esfahbod | cc06c24 | 2011-07-25 20:25:44 -0400 | [diff] [blame] | 166 | #define HB_PRINTF_FUNC(format_idx, arg_idx) __attribute__((__format__ (__printf__, format_idx, arg_idx))) |
Behdad Esfahbod | df66028 | 2009-08-01 20:46:02 -0400 | [diff] [blame] | 167 | #else |
Behdad Esfahbod | 33d13fd | 2010-04-29 13:56:44 -0400 | [diff] [blame] | 168 | #define HB_PURE_FUNC |
| 169 | #define HB_CONST_FUNC |
Behdad Esfahbod | 44b4f50 | 2011-08-04 00:52:20 -0400 | [diff] [blame] | 170 | #define HB_PRINTF_FUNC(format_idx, arg_idx) |
Behdad Esfahbod | df66028 | 2009-08-01 20:46:02 -0400 | [diff] [blame] | 171 | #endif |
Behdad Esfahbod | bc7830e | 2010-02-17 15:14:57 -0500 | [diff] [blame] | 172 | #if __GNUC__ >= 4 |
Behdad Esfahbod | 33d13fd | 2010-04-29 13:56:44 -0400 | [diff] [blame] | 173 | #define HB_UNUSED __attribute__((unused)) |
Behdad Esfahbod | bc7830e | 2010-02-17 15:14:57 -0500 | [diff] [blame] | 174 | #else |
Behdad Esfahbod | 33d13fd | 2010-04-29 13:56:44 -0400 | [diff] [blame] | 175 | #define HB_UNUSED |
Behdad Esfahbod | bc7830e | 2010-02-17 15:14:57 -0500 | [diff] [blame] | 176 | #endif |
Behdad Esfahbod | df66028 | 2009-08-01 20:46:02 -0400 | [diff] [blame] | 177 | |
Behdad Esfahbod | eee8598 | 2010-05-12 23:22:55 -0400 | [diff] [blame] | 178 | #ifndef HB_INTERNAL |
Behdad Esfahbod | f60271c | 2011-08-02 09:56:30 -0400 | [diff] [blame] | 179 | # ifndef __MINGW32__ |
| 180 | # define HB_INTERNAL __attribute__((__visibility__("hidden"))) |
| 181 | # else |
| 182 | # define HB_INTERNAL |
| 183 | # endif |
Behdad Esfahbod | eee8598 | 2010-05-12 23:22:55 -0400 | [diff] [blame] | 184 | #endif |
| 185 | |
Behdad Esfahbod | df66028 | 2009-08-01 20:46:02 -0400 | [diff] [blame] | 186 | |
| 187 | #if (defined(__WIN32__) && !defined(__WINE__)) || defined(_MSC_VER) |
| 188 | #define snprintf _snprintf |
| 189 | #endif |
| 190 | |
| 191 | #ifdef _MSC_VER |
| 192 | #undef inline |
| 193 | #define inline __inline |
| 194 | #endif |
| 195 | |
| 196 | #ifdef __STRICT_ANSI__ |
| 197 | #undef inline |
| 198 | #define inline __inline__ |
| 199 | #endif |
| 200 | |
| 201 | |
Behdad Esfahbod | 7d3a126 | 2010-04-29 13:54:01 -0400 | [diff] [blame] | 202 | #if __GNUC__ >= 3 |
| 203 | #define HB_FUNC __PRETTY_FUNCTION__ |
| 204 | #elif defined(_MSC_VER) |
| 205 | #define HB_FUNC __FUNCSIG__ |
| 206 | #else |
| 207 | #define HB_FUNC __func__ |
| 208 | #endif |
| 209 | |
| 210 | |
Behdad Esfahbod | 9b60233 | 2010-05-20 15:31:12 +0100 | [diff] [blame] | 211 | /* Return the number of 1 bits in mask. */ |
Behdad Esfahbod | 97e7f8f | 2010-05-11 00:11:36 -0400 | [diff] [blame] | 212 | static inline HB_CONST_FUNC unsigned int |
Behdad Esfahbod | c7d457a | 2009-05-21 12:46:29 -0400 | [diff] [blame] | 213 | _hb_popcount32 (uint32_t mask) |
| 214 | { |
| 215 | #if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) |
Behdad Esfahbod | 9b60233 | 2010-05-20 15:31:12 +0100 | [diff] [blame] | 216 | return __builtin_popcount (mask); |
Behdad Esfahbod | c7d457a | 2009-05-21 12:46:29 -0400 | [diff] [blame] | 217 | #else |
Behdad Esfahbod | 9b60233 | 2010-05-20 15:31:12 +0100 | [diff] [blame] | 218 | /* "HACKMEM 169" */ |
| 219 | register uint32_t y; |
| 220 | y = (mask >> 1) &033333333333; |
| 221 | y = mask - y - ((y >>1) & 033333333333); |
| 222 | return (((y + (y >> 3)) & 030707070707) % 077); |
Behdad Esfahbod | c7d457a | 2009-05-21 12:46:29 -0400 | [diff] [blame] | 223 | #endif |
| 224 | } |
| 225 | |
Behdad Esfahbod | 9b60233 | 2010-05-20 15:31:12 +0100 | [diff] [blame] | 226 | /* Returns the number of bits needed to store number */ |
| 227 | static inline HB_CONST_FUNC unsigned int |
| 228 | _hb_bit_storage (unsigned int number) |
| 229 | { |
| 230 | #if defined(__GNUC__) && (__GNUC__ >= 4) && defined(__OPTIMIZE__) |
Behdad Esfahbod | f7acd8d | 2010-05-20 17:26:35 +0100 | [diff] [blame] | 231 | return likely (number) ? (sizeof (unsigned int) * 8 - __builtin_clz (number)) : 0; |
Behdad Esfahbod | 9b60233 | 2010-05-20 15:31:12 +0100 | [diff] [blame] | 232 | #else |
| 233 | register unsigned int n_bits = 0; |
| 234 | while (number) { |
| 235 | n_bits++; |
| 236 | number >>= 1; |
| 237 | } |
| 238 | return n_bits; |
| 239 | #endif |
| 240 | } |
Behdad Esfahbod | df66028 | 2009-08-01 20:46:02 -0400 | [diff] [blame] | 241 | |
Behdad Esfahbod | f7acd8d | 2010-05-20 17:26:35 +0100 | [diff] [blame] | 242 | /* Returns the number of zero bits in the least significant side of number */ |
| 243 | static inline HB_CONST_FUNC unsigned int |
| 244 | _hb_ctz (unsigned int number) |
| 245 | { |
| 246 | #if defined(__GNUC__) && (__GNUC__ >= 4) && defined(__OPTIMIZE__) |
| 247 | return likely (number) ? __builtin_ctz (number) : 0; |
| 248 | #else |
| 249 | register unsigned int n_bits = 0; |
| 250 | if (unlikely (!number)) return 0; |
| 251 | while (!(number & 1)) { |
| 252 | n_bits++; |
| 253 | number >>= 1; |
| 254 | } |
| 255 | return n_bits; |
| 256 | #endif |
| 257 | } |
| 258 | |
Behdad Esfahbod | 080a0eb | 2011-04-28 16:01:01 -0400 | [diff] [blame] | 259 | static inline bool |
| 260 | _hb_unsigned_int_mul_overflows (unsigned int count, unsigned int size) |
| 261 | { |
| 262 | return (size > 0) && (count >= ((unsigned int) -1) / size); |
| 263 | } |
| 264 | |
| 265 | |
Behdad Esfahbod | 8f08c32 | 2010-10-08 19:43:48 -0400 | [diff] [blame] | 266 | /* Type of bsearch() / qsort() compare function */ |
| 267 | typedef int (*hb_compare_func_t) (const void *, const void *); |
| 268 | |
| 269 | |
Behdad Esfahbod | a9f24c8 | 2011-04-21 17:18:22 -0400 | [diff] [blame] | 270 | |
Behdad Esfahbod | a9f24c8 | 2011-04-21 17:18:22 -0400 | [diff] [blame] | 271 | |
Behdad Esfahbod | 852e08e | 2011-04-27 21:45:51 -0400 | [diff] [blame] | 272 | /* arrays and maps */ |
Behdad Esfahbod | a9f24c8 | 2011-04-21 17:18:22 -0400 | [diff] [blame] | 273 | |
Behdad Esfahbod | a9f24c8 | 2011-04-21 17:18:22 -0400 | [diff] [blame] | 274 | |
Behdad Esfahbod | 0e253e9 | 2012-06-05 15:37:19 -0400 | [diff] [blame] | 275 | #define HB_PREALLOCED_ARRAY_INIT {0} |
Behdad Esfahbod | 852e08e | 2011-04-27 21:45:51 -0400 | [diff] [blame] | 276 | template <typename Type, unsigned int StaticSize> |
Behdad Esfahbod | 0e253e9 | 2012-06-05 15:37:19 -0400 | [diff] [blame] | 277 | struct hb_prealloced_array_t |
| 278 | { |
Behdad Esfahbod | 852e08e | 2011-04-27 21:45:51 -0400 | [diff] [blame] | 279 | unsigned int len; |
| 280 | unsigned int allocated; |
| 281 | Type *array; |
| 282 | Type static_array[StaticSize]; |
| 283 | |
Behdad Esfahbod | bf93b63 | 2012-06-05 14:17:32 -0400 | [diff] [blame] | 284 | void init (void) { memset (this, 0, sizeof (*this)); } |
Behdad Esfahbod | efde811 | 2011-08-23 00:04:57 +0200 | [diff] [blame] | 285 | |
Behdad Esfahbod | 265ac61 | 2011-05-05 14:38:16 -0400 | [diff] [blame] | 286 | inline Type& operator [] (unsigned int i) { return array[i]; } |
| 287 | inline const Type& operator [] (unsigned int i) const { return array[i]; } |
Behdad Esfahbod | 852e08e | 2011-04-27 21:45:51 -0400 | [diff] [blame] | 288 | |
| 289 | inline Type *push (void) |
| 290 | { |
| 291 | if (!array) { |
| 292 | array = static_array; |
| 293 | allocated = ARRAY_LENGTH (static_array); |
| 294 | } |
| 295 | if (likely (len < allocated)) |
| 296 | return &array[len++]; |
Behdad Esfahbod | 5a50303 | 2011-05-02 19:54:29 -0400 | [diff] [blame] | 297 | |
Behdad Esfahbod | 852e08e | 2011-04-27 21:45:51 -0400 | [diff] [blame] | 298 | /* Need to reallocate */ |
| 299 | unsigned int new_allocated = allocated + (allocated >> 1) + 8; |
Behdad Esfahbod | 5a50303 | 2011-05-02 19:54:29 -0400 | [diff] [blame] | 300 | Type *new_array = NULL; |
| 301 | |
Behdad Esfahbod | 852e08e | 2011-04-27 21:45:51 -0400 | [diff] [blame] | 302 | if (array == static_array) { |
| 303 | new_array = (Type *) calloc (new_allocated, sizeof (Type)); |
Behdad Esfahbod | 5a50303 | 2011-05-02 19:54:29 -0400 | [diff] [blame] | 304 | if (new_array) |
Behdad Esfahbod | 852e08e | 2011-04-27 21:45:51 -0400 | [diff] [blame] | 305 | memcpy (new_array, array, len * sizeof (Type)); |
Behdad Esfahbod | 852e08e | 2011-04-27 21:45:51 -0400 | [diff] [blame] | 306 | } else { |
Behdad Esfahbod | 080a0eb | 2011-04-28 16:01:01 -0400 | [diff] [blame] | 307 | bool overflows = (new_allocated < allocated) || _hb_unsigned_int_mul_overflows (new_allocated, sizeof (Type)); |
Behdad Esfahbod | 5a50303 | 2011-05-02 19:54:29 -0400 | [diff] [blame] | 308 | if (likely (!overflows)) { |
Behdad Esfahbod | 852e08e | 2011-04-27 21:45:51 -0400 | [diff] [blame] | 309 | new_array = (Type *) realloc (array, new_allocated * sizeof (Type)); |
Behdad Esfahbod | 852e08e | 2011-04-27 21:45:51 -0400 | [diff] [blame] | 310 | } |
| 311 | } |
Behdad Esfahbod | 5a50303 | 2011-05-02 19:54:29 -0400 | [diff] [blame] | 312 | |
| 313 | if (unlikely (!new_array)) |
Behdad Esfahbod | 852e08e | 2011-04-27 21:45:51 -0400 | [diff] [blame] | 314 | return NULL; |
Behdad Esfahbod | 5a50303 | 2011-05-02 19:54:29 -0400 | [diff] [blame] | 315 | |
| 316 | array = new_array; |
| 317 | allocated = new_allocated; |
| 318 | return &array[len++]; |
Behdad Esfahbod | 852e08e | 2011-04-27 21:45:51 -0400 | [diff] [blame] | 319 | } |
| 320 | |
| 321 | inline void pop (void) |
| 322 | { |
| 323 | len--; |
| 324 | /* TODO: shrink array if needed */ |
| 325 | } |
Behdad Esfahbod | 44b0a4d | 2011-05-05 13:42:19 -0400 | [diff] [blame] | 326 | |
| 327 | inline void shrink (unsigned int l) |
| 328 | { |
| 329 | if (l < len) |
| 330 | len = l; |
| 331 | /* TODO: shrink array if needed */ |
| 332 | } |
| 333 | |
Behdad Esfahbod | 6843569 | 2011-05-05 14:12:37 -0400 | [diff] [blame] | 334 | template <typename T> |
| 335 | inline Type *find (T v) { |
| 336 | for (unsigned int i = 0; i < len; i++) |
| 337 | if (array[i] == v) |
| 338 | return &array[i]; |
| 339 | return NULL; |
| 340 | } |
| 341 | template <typename T> |
| 342 | inline const Type *find (T v) const { |
| 343 | for (unsigned int i = 0; i < len; i++) |
| 344 | if (array[i] == v) |
| 345 | return &array[i]; |
| 346 | return NULL; |
| 347 | } |
| 348 | |
Behdad Esfahbod | 44b0a4d | 2011-05-05 13:42:19 -0400 | [diff] [blame] | 349 | inline void sort (void) |
| 350 | { |
| 351 | qsort (array, len, sizeof (Type), (hb_compare_func_t) Type::cmp); |
| 352 | } |
Behdad Esfahbod | 6843569 | 2011-05-05 14:12:37 -0400 | [diff] [blame] | 353 | |
Behdad Esfahbod | b70c96d | 2011-07-07 21:07:41 -0400 | [diff] [blame] | 354 | inline void sort (unsigned int start, unsigned int end) |
| 355 | { |
| 356 | qsort (array + start, end - start, sizeof (Type), (hb_compare_func_t) Type::cmp); |
| 357 | } |
| 358 | |
Behdad Esfahbod | 6843569 | 2011-05-05 14:12:37 -0400 | [diff] [blame] | 359 | template <typename T> |
| 360 | inline Type *bsearch (T *key) |
| 361 | { |
| 362 | return (Type *) ::bsearch (key, array, len, sizeof (Type), (hb_compare_func_t) Type::cmp); |
| 363 | } |
| 364 | template <typename T> |
| 365 | inline const Type *bsearch (T *key) const |
| 366 | { |
| 367 | return (const Type *) ::bsearch (key, array, len, sizeof (Type), (hb_compare_func_t) Type::cmp); |
| 368 | } |
Behdad Esfahbod | 6a7ac79 | 2011-05-11 14:19:18 -0400 | [diff] [blame] | 369 | |
| 370 | inline void finish (void) |
| 371 | { |
| 372 | if (array != static_array) |
| 373 | free (array); |
| 374 | array = NULL; |
| 375 | allocated = len = 0; |
| 376 | } |
Behdad Esfahbod | 852e08e | 2011-04-27 21:45:51 -0400 | [diff] [blame] | 377 | }; |
| 378 | |
Behdad Esfahbod | 852e08e | 2011-04-27 21:45:51 -0400 | [diff] [blame] | 379 | |
Behdad Esfahbod | 0e253e9 | 2012-06-05 15:37:19 -0400 | [diff] [blame] | 380 | #define HB_LOCKABLE_SET_INIT {HB_PREALLOCED_ARRAY_INIT} |
Behdad Esfahbod | 45bfa99 | 2011-05-10 19:12:49 -0400 | [diff] [blame] | 381 | template <typename item_t, typename lock_t> |
| 382 | struct hb_lockable_set_t |
Behdad Esfahbod | 852e08e | 2011-04-27 21:45:51 -0400 | [diff] [blame] | 383 | { |
Behdad Esfahbod | 0e253e9 | 2012-06-05 15:37:19 -0400 | [diff] [blame] | 384 | hb_prealloced_array_t <item_t, 2> items; |
Behdad Esfahbod | 852e08e | 2011-04-27 21:45:51 -0400 | [diff] [blame] | 385 | |
Behdad Esfahbod | bf93b63 | 2012-06-05 14:17:32 -0400 | [diff] [blame] | 386 | inline void init (void) { items.init (); } |
| 387 | |
Behdad Esfahbod | 478a425 | 2011-05-05 12:39:51 -0400 | [diff] [blame] | 388 | template <typename T> |
Behdad Esfahbod | 33ccc77 | 2011-08-09 00:43:24 +0200 | [diff] [blame] | 389 | inline item_t *replace_or_insert (T v, lock_t &l, bool replace) |
Behdad Esfahbod | 852e08e | 2011-04-27 21:45:51 -0400 | [diff] [blame] | 390 | { |
Behdad Esfahbod | 45bfa99 | 2011-05-10 19:12:49 -0400 | [diff] [blame] | 391 | l.lock (); |
Behdad Esfahbod | 6843569 | 2011-05-05 14:12:37 -0400 | [diff] [blame] | 392 | item_t *item = items.find (v); |
Behdad Esfahbod | 45bfa99 | 2011-05-10 19:12:49 -0400 | [diff] [blame] | 393 | if (item) { |
Behdad Esfahbod | 33ccc77 | 2011-08-09 00:43:24 +0200 | [diff] [blame] | 394 | if (replace) { |
| 395 | item_t old = *item; |
| 396 | *item = v; |
| 397 | l.unlock (); |
| 398 | old.finish (); |
| 399 | } |
| 400 | else { |
| 401 | item = NULL; |
| 402 | l.unlock (); |
| 403 | } |
Behdad Esfahbod | 45bfa99 | 2011-05-10 19:12:49 -0400 | [diff] [blame] | 404 | } else { |
Behdad Esfahbod | 852e08e | 2011-04-27 21:45:51 -0400 | [diff] [blame] | 405 | item = items.push (); |
Behdad Esfahbod | 45bfa99 | 2011-05-10 19:12:49 -0400 | [diff] [blame] | 406 | if (likely (item)) |
| 407 | *item = v; |
| 408 | l.unlock (); |
| 409 | } |
Behdad Esfahbod | b45f32e | 2011-05-05 15:00:43 -0400 | [diff] [blame] | 410 | return item; |
Behdad Esfahbod | 852e08e | 2011-04-27 21:45:51 -0400 | [diff] [blame] | 411 | } |
| 412 | |
Behdad Esfahbod | 811482b | 2011-05-05 13:21:04 -0400 | [diff] [blame] | 413 | template <typename T> |
Behdad Esfahbod | 45bfa99 | 2011-05-10 19:12:49 -0400 | [diff] [blame] | 414 | inline void remove (T v, lock_t &l) |
Behdad Esfahbod | 852e08e | 2011-04-27 21:45:51 -0400 | [diff] [blame] | 415 | { |
Behdad Esfahbod | 45bfa99 | 2011-05-10 19:12:49 -0400 | [diff] [blame] | 416 | l.lock (); |
Behdad Esfahbod | 6843569 | 2011-05-05 14:12:37 -0400 | [diff] [blame] | 417 | item_t *item = items.find (v); |
Behdad Esfahbod | 45bfa99 | 2011-05-10 19:12:49 -0400 | [diff] [blame] | 418 | if (item) { |
| 419 | item_t old = *item; |
| 420 | *item = items[items.len - 1]; |
| 421 | items.pop (); |
| 422 | l.unlock (); |
| 423 | old.finish (); |
| 424 | } else { |
| 425 | l.unlock (); |
| 426 | } |
Behdad Esfahbod | 852e08e | 2011-04-27 21:45:51 -0400 | [diff] [blame] | 427 | } |
| 428 | |
Behdad Esfahbod | 478a425 | 2011-05-05 12:39:51 -0400 | [diff] [blame] | 429 | template <typename T> |
Behdad Esfahbod | 45bfa99 | 2011-05-10 19:12:49 -0400 | [diff] [blame] | 430 | inline bool find (T v, item_t *i, lock_t &l) |
Behdad Esfahbod | 852e08e | 2011-04-27 21:45:51 -0400 | [diff] [blame] | 431 | { |
Behdad Esfahbod | 45bfa99 | 2011-05-10 19:12:49 -0400 | [diff] [blame] | 432 | l.lock (); |
| 433 | item_t *item = items.find (v); |
| 434 | if (item) |
| 435 | *i = *item; |
| 436 | l.unlock (); |
| 437 | return !!item; |
Behdad Esfahbod | 852e08e | 2011-04-27 21:45:51 -0400 | [diff] [blame] | 438 | } |
| 439 | |
Behdad Esfahbod | b45f32e | 2011-05-05 15:00:43 -0400 | [diff] [blame] | 440 | template <typename T> |
Behdad Esfahbod | 45bfa99 | 2011-05-10 19:12:49 -0400 | [diff] [blame] | 441 | inline item_t *find_or_insert (T v, lock_t &l) |
| 442 | { |
| 443 | l.lock (); |
| 444 | item_t *item = items.find (v); |
Behdad Esfahbod | b45f32e | 2011-05-05 15:00:43 -0400 | [diff] [blame] | 445 | if (!item) { |
| 446 | item = items.push (); |
| 447 | if (likely (item)) |
| 448 | *item = v; |
| 449 | } |
Behdad Esfahbod | 45bfa99 | 2011-05-10 19:12:49 -0400 | [diff] [blame] | 450 | l.unlock (); |
Behdad Esfahbod | b45f32e | 2011-05-05 15:00:43 -0400 | [diff] [blame] | 451 | return item; |
| 452 | } |
| 453 | |
Behdad Esfahbod | 45bfa99 | 2011-05-10 19:12:49 -0400 | [diff] [blame] | 454 | inline void finish (lock_t &l) |
| 455 | { |
Behdad Esfahbod | 3f4764b | 2012-07-30 10:06:42 -0400 | [diff] [blame] | 456 | if (!items.len) { |
| 457 | /* No need for locking. */ |
| 458 | items.finish (); |
| 459 | return; |
| 460 | } |
Behdad Esfahbod | 45bfa99 | 2011-05-10 19:12:49 -0400 | [diff] [blame] | 461 | l.lock (); |
| 462 | while (items.len) { |
| 463 | item_t old = items[items.len - 1]; |
| 464 | items.pop (); |
| 465 | l.unlock (); |
| 466 | old.finish (); |
| 467 | l.lock (); |
| 468 | } |
Behdad Esfahbod | 6a7ac79 | 2011-05-11 14:19:18 -0400 | [diff] [blame] | 469 | items.finish (); |
Behdad Esfahbod | 45bfa99 | 2011-05-10 19:12:49 -0400 | [diff] [blame] | 470 | l.unlock (); |
| 471 | } |
| 472 | |
| 473 | }; |
| 474 | |
Behdad Esfahbod | 852e08e | 2011-04-27 21:45:51 -0400 | [diff] [blame] | 475 | |
Behdad Esfahbod | a9f24c8 | 2011-04-21 17:18:22 -0400 | [diff] [blame] | 476 | |
| 477 | |
Behdad Esfahbod | f60f216 | 2010-04-21 02:12:45 -0400 | [diff] [blame] | 478 | /* Big-endian handling */ |
| 479 | |
Behdad Esfahbod | 153142d | 2011-04-27 01:49:03 -0400 | [diff] [blame] | 480 | static inline uint16_t hb_be_uint16 (const uint16_t v) |
| 481 | { |
| 482 | const uint8_t *V = (const uint8_t *) &v; |
Behdad Esfahbod | fcd6f53 | 2012-06-08 09:59:43 -0400 | [diff] [blame] | 483 | return (V[0] << 8) | V[1]; |
| 484 | } |
| 485 | |
| 486 | static inline uint16_t hb_uint16_swap (const uint16_t v) |
| 487 | { |
| 488 | return (v >> 8) | (v << 8); |
| 489 | } |
| 490 | |
| 491 | static inline uint32_t hb_uint32_swap (const uint32_t v) |
| 492 | { |
| 493 | return (hb_uint16_swap (v) << 16) | hb_uint16_swap (v >> 16); |
Behdad Esfahbod | 153142d | 2011-04-27 01:49:03 -0400 | [diff] [blame] | 494 | } |
Behdad Esfahbod | f60f216 | 2010-04-21 02:12:45 -0400 | [diff] [blame] | 495 | |
Behdad Esfahbod | e74616b | 2012-04-15 14:12:13 -0400 | [diff] [blame] | 496 | /* Note, of the following macros, uint16_get is the one called many many times. |
| 497 | * If there is any optimizations to be done, it's in that macro. However, I |
| 498 | * already confirmed that on my T400 ThinkPad at least, using bswap_16(), which |
| 499 | * results in a single ror instruction, does NOT speed this up. In fact, it |
| 500 | * resulted in a minor slowdown. At any rate, note that v may not be correctly |
| 501 | * aligned, so I think the current implementation is optimal. |
| 502 | */ |
| 503 | |
Behdad Esfahbod | e032ed9 | 2010-04-21 03:11:46 -0400 | [diff] [blame] | 504 | #define hb_be_uint16_put(v,V) HB_STMT_START { v[0] = (V>>8); v[1] = (V); } HB_STMT_END |
Behdad Esfahbod | 7a52f28 | 2010-04-21 02:14:44 -0400 | [diff] [blame] | 505 | #define hb_be_uint16_get(v) (uint16_t) ((v[0] << 8) + v[1]) |
Behdad Esfahbod | 153142d | 2011-04-27 01:49:03 -0400 | [diff] [blame] | 506 | #define hb_be_uint16_eq(a,b) (a[0] == b[0] && a[1] == b[1]) |
Behdad Esfahbod | f60f216 | 2010-04-21 02:12:45 -0400 | [diff] [blame] | 507 | |
Behdad Esfahbod | e032ed9 | 2010-04-21 03:11:46 -0400 | [diff] [blame] | 508 | #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 |
Behdad Esfahbod | 7a52f28 | 2010-04-21 02:14:44 -0400 | [diff] [blame] | 509 | #define hb_be_uint32_get(v) (uint32_t) ((v[0] << 24) + (v[1] << 16) + (v[2] << 8) + v[3]) |
Behdad Esfahbod | 153142d | 2011-04-27 01:49:03 -0400 | [diff] [blame] | 510 | #define hb_be_uint32_eq(a,b) (a[0] == b[0] && a[1] == b[1] && a[2] == b[2] && a[3] == b[3]) |
Behdad Esfahbod | f60f216 | 2010-04-21 02:12:45 -0400 | [diff] [blame] | 511 | |
| 512 | |
Behdad Esfahbod | 4188096 | 2011-04-11 14:58:28 -0400 | [diff] [blame] | 513 | /* ASCII tag/character handling */ |
Behdad Esfahbod | db5227c | 2011-04-11 13:16:08 -0400 | [diff] [blame] | 514 | |
Behdad Esfahbod | 153142d | 2011-04-27 01:49:03 -0400 | [diff] [blame] | 515 | static inline unsigned char ISALPHA (unsigned char c) |
| 516 | { return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'); } |
| 517 | static inline unsigned char ISALNUM (unsigned char c) |
| 518 | { return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9'); } |
| 519 | static inline unsigned char TOUPPER (unsigned char c) |
| 520 | { return (c >= 'a' && c <= 'z') ? c - 'a' + 'A' : c; } |
| 521 | static inline unsigned char TOLOWER (unsigned char c) |
| 522 | { return (c >= 'A' && c <= 'Z') ? c - 'A' + 'a' : c; } |
Behdad Esfahbod | db5227c | 2011-04-11 13:16:08 -0400 | [diff] [blame] | 523 | |
Behdad Esfahbod | 4188096 | 2011-04-11 14:58:28 -0400 | [diff] [blame] | 524 | #define HB_TAG_CHAR4(s) (HB_TAG(((const char *) s)[0], \ |
| 525 | ((const char *) s)[1], \ |
| 526 | ((const char *) s)[2], \ |
| 527 | ((const char *) s)[3])) |
| 528 | |
Behdad Esfahbod | db5227c | 2011-04-11 13:16:08 -0400 | [diff] [blame] | 529 | |
Behdad Esfahbod | 831886a | 2011-05-11 21:27:52 -0400 | [diff] [blame] | 530 | /* C++ helpers */ |
| 531 | |
| 532 | /* Makes class uncopyable. Use in private: section. */ |
| 533 | #define NO_COPY(T) \ |
| 534 | T (const T &o); \ |
Behdad Esfahbod | 970e092 | 2011-06-14 14:35:44 -0400 | [diff] [blame] | 535 | T &operator = (const T &o) |
Behdad Esfahbod | 831886a | 2011-05-11 21:27:52 -0400 | [diff] [blame] | 536 | |
| 537 | |
Behdad Esfahbod | bc20045 | 2010-04-29 01:40:26 -0400 | [diff] [blame] | 538 | /* Debug */ |
| 539 | |
Behdad Esfahbod | cc06c24 | 2011-07-25 20:25:44 -0400 | [diff] [blame] | 540 | |
Behdad Esfahbod | bc20045 | 2010-04-29 01:40:26 -0400 | [diff] [blame] | 541 | #ifndef HB_DEBUG |
| 542 | #define HB_DEBUG 0 |
| 543 | #endif |
| 544 | |
Behdad Esfahbod | cc06c24 | 2011-07-25 20:25:44 -0400 | [diff] [blame] | 545 | static inline bool |
| 546 | _hb_debug (unsigned int level, |
| 547 | unsigned int max_level) |
| 548 | { |
| 549 | return level < max_level; |
| 550 | } |
| 551 | |
| 552 | #define DEBUG_LEVEL(WHAT, LEVEL) (_hb_debug ((LEVEL), HB_DEBUG_##WHAT)) |
Behdad Esfahbod | 43ff203 | 2011-07-25 17:35:24 -0400 | [diff] [blame] | 553 | #define DEBUG(WHAT) (DEBUG_LEVEL (WHAT, 0)) |
| 554 | |
Behdad Esfahbod | 2d1dcb3 | 2012-10-07 17:13:46 -0400 | [diff] [blame] | 555 | template <int max_level> static inline void |
Behdad Esfahbod | 2081097 | 2012-05-10 23:06:58 +0200 | [diff] [blame] | 556 | _hb_debug_msg_va (const char *what, |
Behdad Esfahbod | 1e08830 | 2012-05-11 00:16:40 +0200 | [diff] [blame] | 557 | const void *obj, |
| 558 | const char *func, |
| 559 | bool indented, |
| 560 | unsigned int level, |
| 561 | int level_dir, |
| 562 | const char *message, |
| 563 | va_list ap) |
Behdad Esfahbod | 2081097 | 2012-05-10 23:06:58 +0200 | [diff] [blame] | 564 | { |
Behdad Esfahbod | 6eec6f4 | 2012-05-11 00:50:38 +0200 | [diff] [blame] | 565 | if (!_hb_debug (level, max_level)) |
Behdad Esfahbod | 829e814 | 2012-05-11 00:52:16 +0200 | [diff] [blame] | 566 | return; |
Behdad Esfahbod | 6eec6f4 | 2012-05-11 00:50:38 +0200 | [diff] [blame] | 567 | |
Behdad Esfahbod | 6eec6f4 | 2012-05-11 00:50:38 +0200 | [diff] [blame] | 568 | fprintf (stderr, "%-10s", what ? what : ""); |
| 569 | |
| 570 | if (obj) |
Behdad Esfahbod | 5ccfe8e | 2012-05-11 02:19:41 +0200 | [diff] [blame] | 571 | fprintf (stderr, "(%0*lx) ", (unsigned int) (2 * sizeof (void *)), (unsigned long) obj); |
Behdad Esfahbod | 6eec6f4 | 2012-05-11 00:50:38 +0200 | [diff] [blame] | 572 | else |
| 573 | fprintf (stderr, " %*s ", (unsigned int) (2 * sizeof (void *)), ""); |
| 574 | |
Behdad Esfahbod | d7bba01 | 2012-05-11 02:46:26 +0200 | [diff] [blame] | 575 | if (indented) { |
Behdad Esfahbod | 6932a41 | 2012-06-26 10:46:31 -0400 | [diff] [blame] | 576 | /* One may want to add ASCII version of these. See: |
| 577 | * https://bugs.freedesktop.org/show_bug.cgi?id=50970 */ |
| 578 | #define VBAR "\342\224\202" /* U+2502 BOX DRAWINGS LIGHT VERTICAL */ |
| 579 | #define VRBAR "\342\224\234" /* U+251C BOX DRAWINGS LIGHT VERTICAL AND RIGHT */ |
| 580 | #define DLBAR "\342\225\256" /* U+256E BOX DRAWINGS LIGHT ARC DOWN AND LEFT */ |
| 581 | #define ULBAR "\342\225\257" /* U+256F BOX DRAWINGS LIGHT ARC UP AND LEFT */ |
| 582 | #define LBAR "\342\225\264" /* U+2574 BOX DRAWINGS LIGHT LEFT */ |
| 583 | 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; |
| 584 | fprintf (stderr, "%2d %s" VRBAR "%s", |
Behdad Esfahbod | 6eec6f4 | 2012-05-11 00:50:38 +0200 | [diff] [blame] | 585 | level, |
Behdad Esfahbod | 6932a41 | 2012-06-26 10:46:31 -0400 | [diff] [blame] | 586 | bars + sizeof (bars) - 1 - MIN ((unsigned int) sizeof (bars), (unsigned int) (sizeof (VBAR) - 1) * level), |
| 587 | level_dir ? (level_dir > 0 ? DLBAR : ULBAR) : LBAR); |
Behdad Esfahbod | d7bba01 | 2012-05-11 02:46:26 +0200 | [diff] [blame] | 588 | } else |
Behdad Esfahbod | 6932a41 | 2012-06-26 10:46:31 -0400 | [diff] [blame] | 589 | fprintf (stderr, " " VRBAR LBAR); |
Behdad Esfahbod | 6eec6f4 | 2012-05-11 00:50:38 +0200 | [diff] [blame] | 590 | |
Behdad Esfahbod | adf7758 | 2012-11-23 17:32:00 -0500 | [diff] [blame^] | 591 | if (func) |
| 592 | { |
| 593 | /* Skip "typename" */ |
| 594 | if (0 == strncmp (func, "typename ", 9)) |
| 595 | func += 9; |
Behdad Esfahbod | fabd311 | 2012-09-05 22:19:28 -0400 | [diff] [blame] | 596 | /* Skip return type */ |
Behdad Esfahbod | d7bba01 | 2012-05-11 02:46:26 +0200 | [diff] [blame] | 597 | const char *space = strchr (func, ' '); |
Behdad Esfahbod | fabd311 | 2012-09-05 22:19:28 -0400 | [diff] [blame] | 598 | if (space) |
Behdad Esfahbod | d7bba01 | 2012-05-11 02:46:26 +0200 | [diff] [blame] | 599 | func = space + 1; |
Behdad Esfahbod | fabd311 | 2012-09-05 22:19:28 -0400 | [diff] [blame] | 600 | /* Skip parameter list */ |
| 601 | const char *paren = strchr (func, '('); |
| 602 | unsigned int func_len = paren ? paren - func : strlen (func); |
Behdad Esfahbod | d7bba01 | 2012-05-11 02:46:26 +0200 | [diff] [blame] | 603 | fprintf (stderr, "%.*s: ", func_len, func); |
Behdad Esfahbod | 85f73fa | 2012-05-11 02:40:42 +0200 | [diff] [blame] | 604 | } |
Behdad Esfahbod | 6eec6f4 | 2012-05-11 00:50:38 +0200 | [diff] [blame] | 605 | |
| 606 | if (message) |
| 607 | vfprintf (stderr, message, ap); |
| 608 | |
| 609 | fprintf (stderr, "\n"); |
Behdad Esfahbod | 2081097 | 2012-05-10 23:06:58 +0200 | [diff] [blame] | 610 | } |
Behdad Esfahbod | 829e814 | 2012-05-11 00:52:16 +0200 | [diff] [blame] | 611 | template <> inline void |
Behdad Esfahbod | 93345ed | 2012-05-13 16:01:08 +0200 | [diff] [blame] | 612 | _hb_debug_msg_va<0> (const char *what HB_UNUSED, |
| 613 | const void *obj HB_UNUSED, |
| 614 | const char *func HB_UNUSED, |
| 615 | bool indented HB_UNUSED, |
| 616 | unsigned int level HB_UNUSED, |
| 617 | int level_dir HB_UNUSED, |
| 618 | const char *message HB_UNUSED, |
| 619 | va_list ap HB_UNUSED) {} |
Behdad Esfahbod | 2081097 | 2012-05-10 23:06:58 +0200 | [diff] [blame] | 620 | |
Behdad Esfahbod | 2d1dcb3 | 2012-10-07 17:13:46 -0400 | [diff] [blame] | 621 | template <int max_level> static inline void |
Behdad Esfahbod | cc06c24 | 2011-07-25 20:25:44 -0400 | [diff] [blame] | 622 | _hb_debug_msg (const char *what, |
| 623 | const void *obj, |
| 624 | const char *func, |
| 625 | bool indented, |
Behdad Esfahbod | 1e08830 | 2012-05-11 00:16:40 +0200 | [diff] [blame] | 626 | unsigned int level, |
| 627 | int level_dir, |
Behdad Esfahbod | cc06c24 | 2011-07-25 20:25:44 -0400 | [diff] [blame] | 628 | const char *message, |
Behdad Esfahbod | 1e08830 | 2012-05-11 00:16:40 +0200 | [diff] [blame] | 629 | ...) HB_PRINTF_FUNC(7, 8); |
Behdad Esfahbod | 2d1dcb3 | 2012-10-07 17:13:46 -0400 | [diff] [blame] | 630 | template <int max_level> static inline void |
Behdad Esfahbod | cc06c24 | 2011-07-25 20:25:44 -0400 | [diff] [blame] | 631 | _hb_debug_msg (const char *what, |
| 632 | const void *obj, |
| 633 | const char *func, |
| 634 | bool indented, |
Behdad Esfahbod | 1e08830 | 2012-05-11 00:16:40 +0200 | [diff] [blame] | 635 | unsigned int level, |
| 636 | int level_dir, |
Behdad Esfahbod | cc06c24 | 2011-07-25 20:25:44 -0400 | [diff] [blame] | 637 | const char *message, |
| 638 | ...) |
Behdad Esfahbod | bc20045 | 2010-04-29 01:40:26 -0400 | [diff] [blame] | 639 | { |
Behdad Esfahbod | cc06c24 | 2011-07-25 20:25:44 -0400 | [diff] [blame] | 640 | va_list ap; |
| 641 | va_start (ap, message); |
Behdad Esfahbod | 829e814 | 2012-05-11 00:52:16 +0200 | [diff] [blame] | 642 | _hb_debug_msg_va<max_level> (what, obj, func, indented, level, level_dir, message, ap); |
Behdad Esfahbod | cc06c24 | 2011-07-25 20:25:44 -0400 | [diff] [blame] | 643 | va_end (ap); |
Behdad Esfahbod | bc20045 | 2010-04-29 01:40:26 -0400 | [diff] [blame] | 644 | } |
Behdad Esfahbod | 829e814 | 2012-05-11 00:52:16 +0200 | [diff] [blame] | 645 | template <> inline void |
Behdad Esfahbod | 93345ed | 2012-05-13 16:01:08 +0200 | [diff] [blame] | 646 | _hb_debug_msg<0> (const char *what HB_UNUSED, |
| 647 | const void *obj HB_UNUSED, |
| 648 | const char *func HB_UNUSED, |
| 649 | bool indented HB_UNUSED, |
| 650 | unsigned int level HB_UNUSED, |
| 651 | int level_dir HB_UNUSED, |
| 652 | const char *message HB_UNUSED, |
Behdad Esfahbod | 1e08830 | 2012-05-11 00:16:40 +0200 | [diff] [blame] | 653 | ...) HB_PRINTF_FUNC(7, 8); |
Behdad Esfahbod | 829e814 | 2012-05-11 00:52:16 +0200 | [diff] [blame] | 654 | template <> inline void |
Behdad Esfahbod | 93345ed | 2012-05-13 16:01:08 +0200 | [diff] [blame] | 655 | _hb_debug_msg<0> (const char *what HB_UNUSED, |
| 656 | const void *obj HB_UNUSED, |
| 657 | const char *func HB_UNUSED, |
| 658 | bool indented HB_UNUSED, |
| 659 | unsigned int level HB_UNUSED, |
| 660 | int level_dir HB_UNUSED, |
| 661 | const char *message HB_UNUSED, |
Behdad Esfahbod | 829e814 | 2012-05-11 00:52:16 +0200 | [diff] [blame] | 662 | ...) {} |
Behdad Esfahbod | cc06c24 | 2011-07-25 20:25:44 -0400 | [diff] [blame] | 663 | |
Behdad Esfahbod | 0594a24 | 2012-06-05 20:35:40 -0400 | [diff] [blame] | 664 | #define DEBUG_MSG_LEVEL(WHAT, OBJ, LEVEL, LEVEL_DIR, ...) _hb_debug_msg<HB_DEBUG_##WHAT> (#WHAT, (OBJ), NULL, true, (LEVEL), (LEVEL_DIR), __VA_ARGS__) |
| 665 | #define DEBUG_MSG(WHAT, OBJ, ...) _hb_debug_msg<HB_DEBUG_##WHAT> (#WHAT, (OBJ), NULL, false, 0, 0, __VA_ARGS__) |
| 666 | #define DEBUG_MSG_FUNC(WHAT, OBJ, ...) _hb_debug_msg<HB_DEBUG_##WHAT> (#WHAT, (OBJ), HB_FUNC, false, 0, 0, __VA_ARGS__) |
Behdad Esfahbod | cc06c24 | 2011-07-25 20:25:44 -0400 | [diff] [blame] | 667 | |
| 668 | |
| 669 | /* |
Behdad Esfahbod | dabe698 | 2012-11-23 14:21:35 -0500 | [diff] [blame] | 670 | * Printer |
| 671 | */ |
| 672 | |
| 673 | template <typename T> |
| 674 | struct hb_printer_t {}; |
| 675 | |
| 676 | template <> |
| 677 | struct hb_printer_t<bool> { |
| 678 | const char *print (bool v) { return v ? "true" : "false"; } |
| 679 | }; |
| 680 | |
| 681 | template <> |
| 682 | struct hb_printer_t<void_t> { |
| 683 | const char *print (void_t v) { return ""; } |
| 684 | }; |
| 685 | |
| 686 | |
| 687 | /* |
Behdad Esfahbod | cc06c24 | 2011-07-25 20:25:44 -0400 | [diff] [blame] | 688 | * Trace |
| 689 | */ |
| 690 | |
Behdad Esfahbod | 902cc8a | 2012-11-23 15:06:59 -0500 | [diff] [blame] | 691 | template <typename T> |
| 692 | static inline void _hb_warn_no_return (bool returned) |
| 693 | { |
| 694 | if (unlikely (!returned)) { |
| 695 | fprintf (stderr, "OUCH, returned with no call to TRACE_RETURN. This is a bug, please report.\n"); |
| 696 | } |
| 697 | } |
| 698 | template <> |
| 699 | inline void _hb_warn_no_return<void_t> (bool returned) |
| 700 | {} |
| 701 | |
| 702 | template <int max_level, typename ret_t> |
Behdad Esfahbod | cc06c24 | 2011-07-25 20:25:44 -0400 | [diff] [blame] | 703 | struct hb_auto_trace_t { |
| 704 | explicit inline hb_auto_trace_t (unsigned int *plevel_, |
Behdad Esfahbod | 9659523 | 2012-05-11 03:33:36 +0200 | [diff] [blame] | 705 | const char *what_, |
| 706 | const void *obj_, |
Behdad Esfahbod | cc06c24 | 2011-07-25 20:25:44 -0400 | [diff] [blame] | 707 | const char *func, |
Behdad Esfahbod | 2081097 | 2012-05-10 23:06:58 +0200 | [diff] [blame] | 708 | const char *message, |
Behdad Esfahbod | 9659523 | 2012-05-11 03:33:36 +0200 | [diff] [blame] | 709 | ...) : plevel (plevel_), what (what_), obj (obj_), returned (false) |
Behdad Esfahbod | cc06c24 | 2011-07-25 20:25:44 -0400 | [diff] [blame] | 710 | { |
Behdad Esfahbod | 1e08830 | 2012-05-11 00:16:40 +0200 | [diff] [blame] | 711 | if (plevel) ++*plevel; |
Behdad Esfahbod | 2081097 | 2012-05-10 23:06:58 +0200 | [diff] [blame] | 712 | |
| 713 | va_list ap; |
| 714 | va_start (ap, message); |
Behdad Esfahbod | 0594a24 | 2012-06-05 20:35:40 -0400 | [diff] [blame] | 715 | _hb_debug_msg_va<max_level> (what, obj, func, true, plevel ? *plevel : 0, +1, message, ap); |
Behdad Esfahbod | 2081097 | 2012-05-10 23:06:58 +0200 | [diff] [blame] | 716 | va_end (ap); |
Behdad Esfahbod | cc06c24 | 2011-07-25 20:25:44 -0400 | [diff] [blame] | 717 | } |
Behdad Esfahbod | 0ab8c86 | 2012-05-11 01:25:34 +0200 | [diff] [blame] | 718 | inline ~hb_auto_trace_t (void) |
Behdad Esfahbod | 1e08830 | 2012-05-11 00:16:40 +0200 | [diff] [blame] | 719 | { |
Behdad Esfahbod | 902cc8a | 2012-11-23 15:06:59 -0500 | [diff] [blame] | 720 | _hb_warn_no_return<ret_t> (returned); |
| 721 | if (!returned) { |
Behdad Esfahbod | 0594a24 | 2012-06-05 20:35:40 -0400 | [diff] [blame] | 722 | _hb_debug_msg<max_level> (what, obj, NULL, true, plevel ? *plevel : 1, -1, " "); |
Behdad Esfahbod | 0ab8c86 | 2012-05-11 01:25:34 +0200 | [diff] [blame] | 723 | } |
Behdad Esfahbod | 1e08830 | 2012-05-11 00:16:40 +0200 | [diff] [blame] | 724 | if (plevel) --*plevel; |
| 725 | } |
Behdad Esfahbod | cc06c24 | 2011-07-25 20:25:44 -0400 | [diff] [blame] | 726 | |
Behdad Esfahbod | 2c9d648 | 2012-11-23 16:49:19 -0500 | [diff] [blame] | 727 | inline ret_t ret (ret_t v, unsigned int line = 0) |
Behdad Esfahbod | 0ab8c86 | 2012-05-11 01:25:34 +0200 | [diff] [blame] | 728 | { |
| 729 | if (unlikely (returned)) { |
| 730 | fprintf (stderr, "OUCH, double calls to TRACE_RETURN. This is a bug, please report.\n"); |
| 731 | return v; |
| 732 | } |
| 733 | |
Behdad Esfahbod | 902cc8a | 2012-11-23 15:06:59 -0500 | [diff] [blame] | 734 | _hb_debug_msg<max_level> (what, obj, NULL, true, plevel ? *plevel : 1, -1, |
| 735 | "return %s (line %d)", |
| 736 | hb_printer_t<ret_t>().print (v), line); |
Behdad Esfahbod | 0ab8c86 | 2012-05-11 01:25:34 +0200 | [diff] [blame] | 737 | if (plevel) --*plevel; |
| 738 | plevel = NULL; |
| 739 | returned = true; |
| 740 | return v; |
| 741 | } |
| 742 | |
Behdad Esfahbod | cc06c24 | 2011-07-25 20:25:44 -0400 | [diff] [blame] | 743 | private: |
| 744 | unsigned int *plevel; |
Behdad Esfahbod | 9659523 | 2012-05-11 03:33:36 +0200 | [diff] [blame] | 745 | const char *what; |
| 746 | const void *obj; |
Behdad Esfahbod | c779d82 | 2012-11-23 14:07:24 -0500 | [diff] [blame] | 747 | bool returned; |
Behdad Esfahbod | cc06c24 | 2011-07-25 20:25:44 -0400 | [diff] [blame] | 748 | }; |
Behdad Esfahbod | 902cc8a | 2012-11-23 15:06:59 -0500 | [diff] [blame] | 749 | template <typename ret_t> /* Optimize when tracing is disabled */ |
| 750 | struct hb_auto_trace_t<0, ret_t> { |
Behdad Esfahbod | 93345ed | 2012-05-13 16:01:08 +0200 | [diff] [blame] | 751 | explicit inline hb_auto_trace_t (unsigned int *plevel_ HB_UNUSED, |
| 752 | const char *what HB_UNUSED, |
| 753 | const void *obj HB_UNUSED, |
| 754 | const char *func HB_UNUSED, |
| 755 | const char *message HB_UNUSED, |
Behdad Esfahbod | 2081097 | 2012-05-10 23:06:58 +0200 | [diff] [blame] | 756 | ...) {} |
Behdad Esfahbod | 0ab8c86 | 2012-05-11 01:25:34 +0200 | [diff] [blame] | 757 | |
Behdad Esfahbod | 2c9d648 | 2012-11-23 16:49:19 -0500 | [diff] [blame] | 758 | inline ret_t ret (ret_t v, unsigned int line = 0) { return v; } |
Behdad Esfahbod | cc06c24 | 2011-07-25 20:25:44 -0400 | [diff] [blame] | 759 | }; |
| 760 | |
Behdad Esfahbod | ae63cf2 | 2012-07-19 20:45:41 -0400 | [diff] [blame] | 761 | #define TRACE_RETURN(RET) trace.ret (RET, __LINE__) |
Behdad Esfahbod | cc06c24 | 2011-07-25 20:25:44 -0400 | [diff] [blame] | 762 | |
| 763 | /* Misc */ |
Behdad Esfahbod | bc20045 | 2010-04-29 01:40:26 -0400 | [diff] [blame] | 764 | |
Behdad Esfahbod | f60f216 | 2010-04-21 02:12:45 -0400 | [diff] [blame] | 765 | |
Behdad Esfahbod | 7b08b0a | 2011-07-20 23:59:07 -0400 | [diff] [blame] | 766 | /* Pre-mature optimization: |
| 767 | * Checks for lo <= u <= hi but with an optimization if lo and hi |
| 768 | * are only different in a contiguous set of lower-most bits. |
| 769 | */ |
Behdad Esfahbod | b5aeb95 | 2012-07-13 09:45:54 -0400 | [diff] [blame] | 770 | template <typename T> static inline bool |
Behdad Esfahbod | 8f0b64f | 2011-07-29 17:02:48 -0400 | [diff] [blame] | 771 | hb_in_range (T u, T lo, T hi) |
Behdad Esfahbod | 7b08b0a | 2011-07-20 23:59:07 -0400 | [diff] [blame] | 772 | { |
| 773 | if ( ((lo^hi) & lo) == 0 && |
| 774 | ((lo^hi) & hi) == (lo^hi) && |
| 775 | ((lo^hi) & ((lo^hi) + 1)) == 0 ) |
| 776 | return (u & ~(lo^hi)) == lo; |
| 777 | else |
| 778 | return lo <= u && u <= hi; |
| 779 | } |
| 780 | |
Behdad Esfahbod | 4a7f4f3 | 2012-07-23 13:15:33 -0400 | [diff] [blame] | 781 | template <typename T> static inline bool |
Behdad Esfahbod | 093cd58 | 2012-07-23 14:04:42 -0400 | [diff] [blame] | 782 | hb_in_ranges (T u, T lo1, T hi1, T lo2, T hi2, T lo3, T hi3) |
Behdad Esfahbod | 4a7f4f3 | 2012-07-23 13:15:33 -0400 | [diff] [blame] | 783 | { |
Behdad Esfahbod | 093cd58 | 2012-07-23 14:04:42 -0400 | [diff] [blame] | 784 | return hb_in_range (u, lo1, hi1) || hb_in_range (u, lo2, hi2) || hb_in_range (u, lo3, hi3); |
Behdad Esfahbod | 4a7f4f3 | 2012-07-23 13:15:33 -0400 | [diff] [blame] | 785 | } |
| 786 | |
Behdad Esfahbod | 8f0b64f | 2011-07-29 17:02:48 -0400 | [diff] [blame] | 787 | |
Behdad Esfahbod | 45d6f29 | 2011-07-30 14:44:30 -0400 | [diff] [blame] | 788 | /* Useful for set-operations on small enums. |
| 789 | * For example, for testing "x ∈ {x1, x2, x3}" use: |
| 790 | * (FLAG(x) & (FLAG(x1) | FLAG(x2) | FLAG(x3))) |
| 791 | */ |
Behdad Esfahbod | efb4ad7 | 2012-07-20 14:27:38 -0400 | [diff] [blame] | 792 | #define FLAG(x) (1<<(x)) |
Behdad Esfahbod | 2c372b8 | 2012-07-20 13:37:48 -0400 | [diff] [blame] | 793 | #define FLAG_RANGE(x,y) (ASSERT_STATIC_EXPR_ZERO ((x) < (y)) + FLAG(y+1) - FLAG(x)) |
Behdad Esfahbod | 7b08b0a | 2011-07-20 23:59:07 -0400 | [diff] [blame] | 794 | |
Behdad Esfahbod | 8f0b64f | 2011-07-29 17:02:48 -0400 | [diff] [blame] | 795 | |
Behdad Esfahbod | 39b1783 | 2012-07-17 17:09:29 -0400 | [diff] [blame] | 796 | template <typename T, typename T2> inline void |
| 797 | hb_bubble_sort (T *array, unsigned int len, int(*compar)(const T *, const T *), T2 *array2) |
Behdad Esfahbod | 45d6f29 | 2011-07-30 14:44:30 -0400 | [diff] [blame] | 798 | { |
| 799 | if (unlikely (!len)) |
| 800 | return; |
| 801 | |
| 802 | unsigned int k = len - 1; |
| 803 | do { |
| 804 | unsigned int new_k = 0; |
| 805 | |
| 806 | for (unsigned int j = 0; j < k; j++) |
Behdad Esfahbod | 39b1783 | 2012-07-17 17:09:29 -0400 | [diff] [blame] | 807 | if (compar (&array[j], &array[j+1]) > 0) |
| 808 | { |
| 809 | { |
| 810 | T t; |
| 811 | t = array[j]; |
| 812 | array[j] = array[j + 1]; |
| 813 | array[j + 1] = t; |
| 814 | } |
| 815 | if (array2) |
| 816 | { |
| 817 | T2 t; |
| 818 | t = array2[j]; |
| 819 | array2[j] = array2[j + 1]; |
| 820 | array2[j + 1] = t; |
| 821 | } |
Behdad Esfahbod | 45d6f29 | 2011-07-30 14:44:30 -0400 | [diff] [blame] | 822 | |
| 823 | new_k = j; |
| 824 | } |
| 825 | k = new_k; |
| 826 | } while (k); |
| 827 | } |
| 828 | |
Behdad Esfahbod | 39b1783 | 2012-07-17 17:09:29 -0400 | [diff] [blame] | 829 | template <typename T> inline void |
| 830 | hb_bubble_sort (T *array, unsigned int len, int(*compar)(const T *, const T *)) |
| 831 | { |
| 832 | hb_bubble_sort (array, len, compar, (int *) NULL); |
| 833 | } |
Behdad Esfahbod | 45d6f29 | 2011-07-30 14:44:30 -0400 | [diff] [blame] | 834 | |
Behdad Esfahbod | 6f3a300 | 2012-08-07 22:13:25 -0400 | [diff] [blame] | 835 | static inline hb_bool_t |
| 836 | hb_codepoint_parse (const char *s, unsigned int len, int base, hb_codepoint_t *out) |
| 837 | { |
| 838 | /* Pain because we don't know whether s is nul-terminated. */ |
| 839 | char buf[64]; |
| 840 | strncpy (buf, s, MIN (ARRAY_LENGTH (buf) - 1, len)); |
| 841 | buf[MIN (ARRAY_LENGTH (buf) - 1, len)] = '\0'; |
| 842 | |
| 843 | char *end; |
| 844 | errno = 0; |
| 845 | unsigned long v = strtoul (buf, &end, base); |
| 846 | if (errno) return false; |
| 847 | if (*end) return false; |
| 848 | *out = v; |
| 849 | return true; |
| 850 | } |
Behdad Esfahbod | 45d6f29 | 2011-07-30 14:44:30 -0400 | [diff] [blame] | 851 | |
Behdad Esfahbod | acdba3f | 2010-07-23 15:11:18 -0400 | [diff] [blame] | 852 | |
Behdad Esfahbod | c57d454 | 2011-04-20 18:50:27 -0400 | [diff] [blame] | 853 | #endif /* HB_PRIVATE_HH */ |