1 /* 2 * Copyright 2007,2008,2009 Red Hat, Inc. 3 * Copyright 2011,2012 Google, Inc. 4 * 5 * This is part of HarfBuzz, a text shaping library. 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 26 * Google Author(s): Behdad Esfahbod 27 */ 28 29 #ifndef HB_PRIVATE_HH 30 #define HB_PRIVATE_HH 31 32 #ifdef HAVE_CONFIG_H 33 #include "config.h" 34 #endif 35 36 #include "hb.h" 37 #define HB_H_IN 38 #ifdef HAVE_OT 39 #include "hb-ot.h" 40 #define HB_OT_H_IN 41 #endif 42 43 #include <stdlib.h> 44 #include <stddef.h> 45 #include <string.h> 46 #include <assert.h> 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. */ 52 #include <stdio.h> 53 #include <errno.h> 54 #include <stdarg.h> 55 56 57 58 /* Essentials */ 59 60 #ifndef NULL 61 # define NULL ((void *) 0) 62 #endif 63 64 65 /* Void! */ 66 struct _hb_void_t {}; 67 typedef const _hb_void_t &hb_void_t; 68 #define HB_VOID (* (const _hb_void_t *) NULL) 69 70 71 /* Basics */ 72 73 74 #undef MIN 75 template <typename Type> 76 static inline Type MIN (const Type &a, const Type &b) { return a < b ? a : b; } 77 78 #undef MAX 79 template <typename Type> 80 static inline Type MAX (const Type &a, const Type &b) { return a > b ? a : b; } 81 82 static inline unsigned int DIV_CEIL (const unsigned int a, unsigned int b) 83 { return (a + (b - 1)) / b; } 84 85 86 #undef ARRAY_LENGTH 87 template <typename Type, unsigned int n> 88 static inline unsigned int ARRAY_LENGTH (const Type (&)[n]) { return n; } 89 /* A const version, but does not detect erratically being called on pointers. */ 90 #define ARRAY_LENGTH_CONST(__array) ((signed int) (sizeof (__array) / sizeof (__array[0]))) 91 92 #define HB_STMT_START do 93 #define HB_STMT_END while (0) 94 95 #define _ASSERT_STATIC1(_line, _cond) typedef int _static_assert_on_line_##_line##_failed[(_cond)?1:-1] 96 #define _ASSERT_STATIC0(_line, _cond) _ASSERT_STATIC1 (_line, (_cond)) 97 #define ASSERT_STATIC(_cond) _ASSERT_STATIC0 (__LINE__, (_cond)) 98 99 #define ASSERT_STATIC_EXPR(_cond)((void) sizeof (char[(_cond) ? 1 : -1])) 100 #define ASSERT_STATIC_EXPR_ZERO(_cond) (0 * sizeof (char[(_cond) ? 1 : -1])) 101 102 #define _PASTE1(a,b) a##b 103 #define PASTE(a,b) _PASTE1(a,b) 104 105 /* Lets assert int types. Saves trouble down the road. */ 106 107 ASSERT_STATIC (sizeof (int8_t) == 1); 108 ASSERT_STATIC (sizeof (uint8_t) == 1); 109 ASSERT_STATIC (sizeof (int16_t) == 2); 110 ASSERT_STATIC (sizeof (uint16_t) == 2); 111 ASSERT_STATIC (sizeof (int32_t) == 4); 112 ASSERT_STATIC (sizeof (uint32_t) == 4); 113 ASSERT_STATIC (sizeof (int64_t) == 8); 114 ASSERT_STATIC (sizeof (uint64_t) == 8); 115 116 ASSERT_STATIC (sizeof (hb_codepoint_t) == 4); 117 ASSERT_STATIC (sizeof (hb_position_t) == 4); 118 ASSERT_STATIC (sizeof (hb_mask_t) == 4); 119 ASSERT_STATIC (sizeof (hb_var_int_t) == 4); 120 121 122 /* We like our types POD */ 123 124 #define _ASSERT_TYPE_POD1(_line, _type) union _type_##_type##_on_line_##_line##_is_not_POD { _type instance; } 125 #define _ASSERT_TYPE_POD0(_line, _type) _ASSERT_TYPE_POD1 (_line, _type) 126 #define ASSERT_TYPE_POD(_type) _ASSERT_TYPE_POD0 (__LINE__, _type) 127 128 #ifdef __GNUC__ 129 # define _ASSERT_INSTANCE_POD1(_line, _instance) \ 130 HB_STMT_START { \ 131 typedef __typeof__(_instance) _type_##_line; \ 132 _ASSERT_TYPE_POD1 (_line, _type_##_line); \ 133 } HB_STMT_END 134 #else 135 # define _ASSERT_INSTANCE_POD1(_line, _instance) typedef int _assertion_on_line_##_line##_not_tested 136 #endif 137 # define _ASSERT_INSTANCE_POD0(_line, _instance) _ASSERT_INSTANCE_POD1 (_line, _instance) 138 # define ASSERT_INSTANCE_POD(_instance) _ASSERT_INSTANCE_POD0 (__LINE__, _instance) 139 140 /* Check _assertion in a method environment */ 141 #define _ASSERT_POD1(_line) \ 142 inline void _static_assertion_on_line_##_line (void) const \ 143 { _ASSERT_INSTANCE_POD1 (_line, *this); /* Make sure it's POD. */ } 144 # define _ASSERT_POD0(_line) _ASSERT_POD1 (_line) 145 # define ASSERT_POD() _ASSERT_POD0 (__LINE__) 146 147 148 149 /* Misc */ 150 151 152 #if defined(__GNUC__) && (__GNUC__ > 2) && defined(__OPTIMIZE__) 153 #define _HB_BOOLEAN_EXPR(expr) ((expr) ? 1 : 0) 154 #define likely(expr) (__builtin_expect (_HB_BOOLEAN_EXPR(expr), 1)) 155 #define unlikely(expr) (__builtin_expect (_HB_BOOLEAN_EXPR(expr), 0)) 156 #else 157 #define likely(expr) (expr) 158 #define unlikely(expr) (expr) 159 #endif 160 161 #ifndef __GNUC__ 162 #undef __attribute__ 163 #define __attribute__(x) 164 #endif 165 166 #if __GNUC__ >= 3 167 #define HB_PURE_FUNC __attribute__((pure)) 168 #define HB_CONST_FUNC __attribute__((const)) 169 #define HB_PRINTF_FUNC(format_idx, arg_idx) __attribute__((__format__ (__printf__, format_idx, arg_idx))) 170 #else 171 #define HB_PURE_FUNC 172 #define HB_CONST_FUNC 173 #define HB_PRINTF_FUNC(format_idx, arg_idx) 174 #endif 175 #if __GNUC__ >= 4 176 #define HB_UNUSED __attribute__((unused)) 177 #else 178 #define HB_UNUSED 179 #endif 180 181 #ifndef HB_INTERNAL 182 # ifndef __MINGW32__ 183 # define HB_INTERNAL __attribute__((__visibility__("hidden"))) 184 # else 185 # define HB_INTERNAL 186 # endif 187 #endif 188 189 190 #if (defined(__WIN32__) && !defined(__WINE__)) || defined(_MSC_VER) 191 #define snprintf _snprintf 192 #endif 193 194 #ifdef _MSC_VER 195 #undef inline 196 #define inline __inline 197 #endif 198 199 #ifdef __STRICT_ANSI__ 200 #undef inline 201 #define inline __inline__ 202 #endif 203 204 205 #if __GNUC__ >= 3 206 #define HB_FUNC __PRETTY_FUNCTION__ 207 #elif defined(_MSC_VER) 208 #define HB_FUNC __FUNCSIG__ 209 #else 210 #define HB_FUNC __func__ 211 #endif 212 213 214 /* Return the number of 1 bits in mask. */ 215 static inline HB_CONST_FUNC unsigned int 216 _hb_popcount32 (uint32_t mask) 217 { 218 #if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) 219 return __builtin_popcount (mask); 220 #else 221 /* "HACKMEM 169" */ 222 register uint32_t y; 223 y = (mask >> 1) &033333333333; 224 y = mask - y - ((y >>1) & 033333333333); 225 return (((y + (y >> 3)) & 030707070707) % 077); 226 #endif 227 } 228 229 /* Returns the number of bits needed to store number */ 230 static inline HB_CONST_FUNC unsigned int 231 _hb_bit_storage (unsigned int number) 232 { 233 #if defined(__GNUC__) && (__GNUC__ >= 4) && defined(__OPTIMIZE__) 234 return likely (number) ? (sizeof (unsigned int) * 8 - __builtin_clz (number)) : 0; 235 #else 236 register unsigned int n_bits = 0; 237 while (number) { 238 n_bits++; 239 number >>= 1; 240 } 241 return n_bits; 242 #endif 243 } 244 245 /* Returns the number of zero bits in the least significant side of number */ 246 static inline HB_CONST_FUNC unsigned int 247 _hb_ctz (unsigned int number) 248 { 249 #if defined(__GNUC__) && (__GNUC__ >= 4) && defined(__OPTIMIZE__) 250 return likely (number) ? __builtin_ctz (number) : 0; 251 #else 252 register unsigned int n_bits = 0; 253 if (unlikely (!number)) return 0; 254 while (!(number & 1)) { 255 n_bits++; 256 number >>= 1; 257 } 258 return n_bits; 259 #endif 260 } 261 262 static inline bool 263 _hb_unsigned_int_mul_overflows (unsigned int count, unsigned int size) 264 { 265 return (size > 0) && (count >= ((unsigned int) -1) / size); 266 } 267 268 269 /* Type of bsearch() / qsort() compare function */ 270 typedef int (*hb_compare_func_t) (const void *, const void *); 271 272 273 274 275 /* arrays and maps */ 276 277 278 #define HB_PREALLOCED_ARRAY_INIT {0} 279 template <typename Type, unsigned int StaticSize> 280 struct hb_prealloced_array_t 281 { 282 unsigned int len; 283 unsigned int allocated; 284 Type *array; 285 Type static_array[StaticSize]; 286 287 void init (void) { memset (this, 0, sizeof (*this)); } 288 289 inline Type& operator [] (unsigned int i) { return array[i]; } 290 inline const Type& operator [] (unsigned int i) const { return array[i]; } 291 292 inline Type *push (void) 293 { 294 if (!array) { 295 array = static_array; 296 allocated = ARRAY_LENGTH (static_array); 297 } 298 if (likely (len < allocated)) 299 return &array[len++]; 300 301 /* Need to reallocate */ 302 unsigned int new_allocated = allocated + (allocated >> 1) + 8; 303 Type *new_array = NULL; 304 305 if (array == static_array) { 306 new_array = (Type *) calloc (new_allocated, sizeof (Type)); 307 if (new_array) 308 memcpy (new_array, array, len * sizeof (Type)); 309 } else { 310 bool overflows = (new_allocated < allocated) || _hb_unsigned_int_mul_overflows (new_allocated, sizeof (Type)); 311 if (likely (!overflows)) { 312 new_array = (Type *) realloc (array, new_allocated * sizeof (Type)); 313 } 314 } 315 316 if (unlikely (!new_array)) 317 return NULL; 318 319 array = new_array; 320 allocated = new_allocated; 321 return &array[len++]; 322 } 323 324 inline void pop (void) 325 { 326 len--; 327 } 328 329 inline void remove (unsigned int i) 330 { 331 if (unlikely (i >= len)) 332 return; 333 memmove (static_cast<void *> (&array[i]), 334 static_cast<void *> (&array[i + 1]), 335 (len - i - 1) * sizeof (Type)); 336 len--; 337 } 338 339 inline void shrink (unsigned int l) 340 { 341 if (l < len) 342 len = l; 343 } 344 345 template <typename T> 346 inline Type *find (T v) { 347 for (unsigned int i = 0; i < len; i++) 348 if (array[i] == v) 349 return &array[i]; 350 return NULL; 351 } 352 template <typename T> 353 inline const Type *find (T v) const { 354 for (unsigned int i = 0; i < len; i++) 355 if (array[i] == v) 356 return &array[i]; 357 return NULL; 358 } 359 360 inline void sort (void) 361 { 362 qsort (array, len, sizeof (Type), (hb_compare_func_t) Type::cmp); 363 } 364 365 inline void sort (unsigned int start, unsigned int end) 366 { 367 qsort (array + start, end - start, sizeof (Type), (hb_compare_func_t) Type::cmp); 368 } 369 370 template <typename T> 371 inline Type *bsearch (T *key) 372 { 373 return (Type *) ::bsearch (key, array, len, sizeof (Type), (hb_compare_func_t) Type::cmp); 374 } 375 template <typename T> 376 inline const Type *bsearch (T *key) const 377 { 378 return (const Type *) ::bsearch (key, array, len, sizeof (Type), (hb_compare_func_t) Type::cmp); 379 } 380 381 inline void finish (void) 382 { 383 if (array != static_array) 384 free (array); 385 array = NULL; 386 allocated = len = 0; 387 } 388 }; 389 390 #define HB_AUTO_ARRAY_PREALLOCED 16 391 template <typename Type> 392 struct hb_auto_array_t : hb_prealloced_array_t <Type, HB_AUTO_ARRAY_PREALLOCED> 393 { 394 hb_auto_array_t (void) { hb_prealloced_array_t<Type, HB_AUTO_ARRAY_PREALLOCED>::init (); } 395 ~hb_auto_array_t (void) { hb_prealloced_array_t<Type, HB_AUTO_ARRAY_PREALLOCED>::finish (); } 396 }; 397 398 399 #define HB_LOCKABLE_SET_INIT {HB_PREALLOCED_ARRAY_INIT} 400 template <typename item_t, typename lock_t> 401 struct hb_lockable_set_t 402 { 403 hb_prealloced_array_t <item_t, 2> items; 404 405 inline void init (void) { items.init (); } 406 407 template <typename T> 408 inline item_t *replace_or_insert (T v, lock_t &l, bool replace) 409 { 410 l.lock (); 411 item_t *item = items.find (v); 412 if (item) { 413 if (replace) { 414 item_t old = *item; 415 *item = v; 416 l.unlock (); 417 old.finish (); 418 } 419 else { 420 item = NULL; 421 l.unlock (); 422 } 423 } else { 424 item = items.push (); 425 if (likely (item)) 426 *item = v; 427 l.unlock (); 428 } 429 return item; 430 } 431 432 template <typename T> 433 inline void remove (T v, lock_t &l) 434 { 435 l.lock (); 436 item_t *item = items.find (v); 437 if (item) { 438 item_t old = *item; 439 *item = items[items.len - 1]; 440 items.pop (); 441 l.unlock (); 442 old.finish (); 443 } else { 444 l.unlock (); 445 } 446 } 447 448 template <typename T> 449 inline bool find (T v, item_t *i, lock_t &l) 450 { 451 l.lock (); 452 item_t *item = items.find (v); 453 if (item) 454 *i = *item; 455 l.unlock (); 456 return !!item; 457 } 458 459 template <typename T> 460 inline item_t *find_or_insert (T v, lock_t &l) 461 { 462 l.lock (); 463 item_t *item = items.find (v); 464 if (!item) { 465 item = items.push (); 466 if (likely (item)) 467 *item = v; 468 } 469 l.unlock (); 470 return item; 471 } 472 473 inline void finish (lock_t &l) 474 { 475 if (!items.len) { 476 /* No need for locking. */ 477 items.finish (); 478 return; 479 } 480 l.lock (); 481 while (items.len) { 482 item_t old = items[items.len - 1]; 483 items.pop (); 484 l.unlock (); 485 old.finish (); 486 l.lock (); 487 } 488 items.finish (); 489 l.unlock (); 490 } 491 492 }; 493 494 495 496 497 /* Big-endian handling */ 498 499 static inline uint16_t hb_be_uint16 (const uint16_t v) 500 { 501 const uint8_t *V = (const uint8_t *) &v; 502 return (V[0] << 8) | V[1]; 503 } 504 505 static inline uint16_t hb_uint16_swap (const uint16_t v) 506 { 507 return (v >> 8) | (v << 8); 508 } 509 510 static inline uint32_t hb_uint32_swap (const uint32_t v) 511 { 512 return (hb_uint16_swap (v) << 16) | hb_uint16_swap (v >> 16); 513 } 514 515 /* Note, of the following macros, uint16_get is the one called many many times. 516 * If there is any optimizations to be done, it's in that macro. However, I 517 * already confirmed that on my T400 ThinkPad at least, using bswap_16(), which 518 * results in a single ror instruction, does NOT speed this up. In fact, it 519 * resulted in a minor slowdown. At any rate, note that v may not be correctly 520 * aligned, so I think the current implementation is optimal. 521 */ 522 523 #define hb_be_uint16_put(v,V) HB_STMT_START { v[0] = (V>>8); v[1] = (V); } HB_STMT_END 524 #define hb_be_uint16_get(v) (uint16_t) ((v[0] << 8) + v[1]) 525 #define hb_be_uint16_eq(a,b) (a[0] == b[0] && a[1] == b[1]) 526 527 #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 528 #define hb_be_uint32_get(v) (uint32_t) ((v[0] << 24) + (v[1] << 16) + (v[2] << 8) + v[3]) 529 #define hb_be_uint32_eq(a,b) (a[0] == b[0] && a[1] == b[1] && a[2] == b[2] && a[3] == b[3]) 530 531 #define hb_be_uint24_put(v,V) HB_STMT_START { v[0] = (V>>16); v[1] = (V>>8); v[2] = (V); } HB_STMT_END 532 #define hb_be_uint24_get(v) (uint32_t) ((v[0] << 16) + (v[1] << 8) + v[2]) 533 #define hb_be_uint24_eq(a,b) (a[0] == b[0] && a[1] == b[1] && a[2] == b[2]) 534 535 536 /* ASCII tag/character handling */ 537 538 static inline bool ISALPHA (unsigned char c) 539 { return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'); } 540 static inline bool ISALNUM (unsigned char c) 541 { return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9'); } 542 static inline bool ISSPACE (unsigned char c) 543 { return c == ' ' || c =='\f'|| c =='\n'|| c =='\r'|| c =='\t'|| c =='\v'; } 544 static inline unsigned char TOUPPER (unsigned char c) 545 { return (c >= 'a' && c <= 'z') ? c - 'a' + 'A' : c; } 546 static inline unsigned char TOLOWER (unsigned char c) 547 { return (c >= 'A' && c <= 'Z') ? c - 'A' + 'a' : c; } 548 549 #define HB_TAG_CHAR4(s) (HB_TAG(((const char *) s)[0], \ 550 ((const char *) s)[1], \ 551 ((const char *) s)[2], \ 552 ((const char *) s)[3])) 553 554 555 /* C++ helpers */ 556 557 /* Makes class uncopyable. Use in private: section. */ 558 #define NO_COPY(T) \ 559 T (const T &o); \ 560 T &operator = (const T &o) 561 562 563 /* Debug */ 564 565 566 #ifndef HB_DEBUG 567 #define HB_DEBUG 0 568 #endif 569 570 static inline bool 571 _hb_debug (unsigned int level, 572 unsigned int max_level) 573 { 574 return level < max_level; 575 } 576 577 #define DEBUG_LEVEL_ENABLED(WHAT, LEVEL) (_hb_debug ((LEVEL), HB_DEBUG_##WHAT)) 578 #define DEBUG_ENABLED(WHAT) (DEBUG_LEVEL_ENABLED (WHAT, 0)) 579 580 template <int max_level> static inline void 581 _hb_debug_msg_va (const char *what, 582 const void *obj, 583 const char *func, 584 bool indented, 585 unsigned int level, 586 int level_dir, 587 const char *message, 588 va_list ap) 589 { 590 if (!_hb_debug (level, max_level)) 591 return; 592 593 fprintf (stderr, "%-10s", what ? what : ""); 594 595 if (obj) 596 fprintf (stderr, "(%0*lx) ", (unsigned int) (2 * sizeof (void *)), (unsigned long) obj); 597 else 598 fprintf (stderr, " %*s ", (unsigned int) (2 * sizeof (void *)), ""); 599 600 if (indented) { 601 /* One may want to add ASCII version of these. See: 602 * https://bugs.freedesktop.org/show_bug.cgi?id=50970 */ 603 #define VBAR "\342\224\202" /* U+2502 BOX DRAWINGS LIGHT VERTICAL */ 604 #define VRBAR "\342\224\234" /* U+251C BOX DRAWINGS LIGHT VERTICAL AND RIGHT */ 605 #define DLBAR "\342\225\256" /* U+256E BOX DRAWINGS LIGHT ARC DOWN AND LEFT */ 606 #define ULBAR "\342\225\257" /* U+256F BOX DRAWINGS LIGHT ARC UP AND LEFT */ 607 #define LBAR "\342\225\264" /* U+2574 BOX DRAWINGS LIGHT LEFT */ 608 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; 609 fprintf (stderr, "%2u %s" VRBAR "%s", 610 level, 611 bars + sizeof (bars) - 1 - MIN ((unsigned int) sizeof (bars), (unsigned int) (sizeof (VBAR) - 1) * level), 612 level_dir ? (level_dir > 0 ? DLBAR : ULBAR) : LBAR); 613 } else 614 fprintf (stderr, " " VRBAR LBAR); 615 616 if (func) 617 { 618 unsigned int func_len = strlen (func); 619 #ifndef HB_DEBUG_VERBOSE 620 /* Skip "typename" */ 621 if (0 == strncmp (func, "typename ", 9)) 622 func += 9; 623 /* Skip return type */ 624 const char *space = strchr (func, ' '); 625 if (space) 626 func = space + 1; 627 /* Skip parameter list */ 628 const char *paren = strchr (func, '('); 629 if (paren) 630 func_len = paren - func; 631 #endif 632 fprintf (stderr, "%.*s: ", func_len, func); 633 } 634 635 if (message) 636 vfprintf (stderr, message, ap); 637 638 fprintf (stderr, "\n"); 639 } 640 template <> inline void 641 _hb_debug_msg_va<0> (const char *what HB_UNUSED, 642 const void *obj HB_UNUSED, 643 const char *func HB_UNUSED, 644 bool indented HB_UNUSED, 645 unsigned int level HB_UNUSED, 646 int level_dir HB_UNUSED, 647 const char *message HB_UNUSED, 648 va_list ap HB_UNUSED) {} 649 650 template <int max_level> static inline void 651 _hb_debug_msg (const char *what, 652 const void *obj, 653 const char *func, 654 bool indented, 655 unsigned int level, 656 int level_dir, 657 const char *message, 658 ...) HB_PRINTF_FUNC(7, 8); 659 template <int max_level> static inline void 660 _hb_debug_msg (const char *what, 661 const void *obj, 662 const char *func, 663 bool indented, 664 unsigned int level, 665 int level_dir, 666 const char *message, 667 ...) 668 { 669 va_list ap; 670 va_start (ap, message); 671 _hb_debug_msg_va<max_level> (what, obj, func, indented, level, level_dir, message, ap); 672 va_end (ap); 673 } 674 template <> inline void 675 _hb_debug_msg<0> (const char *what HB_UNUSED, 676 const void *obj HB_UNUSED, 677 const char *func HB_UNUSED, 678 bool indented HB_UNUSED, 679 unsigned int level HB_UNUSED, 680 int level_dir HB_UNUSED, 681 const char *message HB_UNUSED, 682 ...) HB_PRINTF_FUNC(7, 8); 683 template <> inline void 684 _hb_debug_msg<0> (const char *what HB_UNUSED, 685 const void *obj HB_UNUSED, 686 const char *func HB_UNUSED, 687 bool indented HB_UNUSED, 688 unsigned int level HB_UNUSED, 689 int level_dir HB_UNUSED, 690 const char *message HB_UNUSED, 691 ...) {} 692 693 #define DEBUG_MSG_LEVEL(WHAT, OBJ, LEVEL, LEVEL_DIR, ...) _hb_debug_msg<HB_DEBUG_##WHAT> (#WHAT, (OBJ), NULL, true, (LEVEL), (LEVEL_DIR), __VA_ARGS__) 694 #define DEBUG_MSG(WHAT, OBJ, ...) _hb_debug_msg<HB_DEBUG_##WHAT> (#WHAT, (OBJ), NULL, false, 0, 0, __VA_ARGS__) 695 #define DEBUG_MSG_FUNC(WHAT, OBJ, ...) _hb_debug_msg<HB_DEBUG_##WHAT> (#WHAT, (OBJ), HB_FUNC, false, 0, 0, __VA_ARGS__) 696 697 698 /* 699 * Printer 700 */ 701 702 template <typename T> 703 struct hb_printer_t {}; 704 705 template <> 706 struct hb_printer_t<bool> { 707 const char *print (bool v) { return v ? "true" : "false"; } 708 }; 709 710 template <> 711 struct hb_printer_t<hb_void_t> { 712 const char *print (hb_void_t) { return ""; } 713 }; 714 715 716 /* 717 * Trace 718 */ 719 720 template <typename T> 721 static inline void _hb_warn_no_return (bool returned) 722 { 723 if (unlikely (!returned)) { 724 fprintf (stderr, "OUCH, returned with no call to TRACE_RETURN. This is a bug, please report.\n"); 725 } 726 } 727 template <> 728 inline void _hb_warn_no_return<hb_void_t> (bool returned HB_UNUSED) 729 {} 730 731 template <int max_level, typename ret_t> 732 struct hb_auto_trace_t { 733 explicit inline hb_auto_trace_t (unsigned int *plevel_, 734 const char *what_, 735 const void *obj_, 736 const char *func, 737 const char *message, 738 ...) : plevel (plevel_), what (what_), obj (obj_), returned (false) 739 { 740 if (plevel) ++*plevel; 741 742 va_list ap; 743 va_start (ap, message); 744 _hb_debug_msg_va<max_level> (what, obj, func, true, plevel ? *plevel : 0, +1, message, ap); 745 va_end (ap); 746 } 747 inline ~hb_auto_trace_t (void) 748 { 749 _hb_warn_no_return<ret_t> (returned); 750 if (!returned) { 751 _hb_debug_msg<max_level> (what, obj, NULL, true, plevel ? *plevel : 1, -1, " "); 752 } 753 if (plevel) --*plevel; 754 } 755 756 inline ret_t ret (ret_t v, unsigned int line = 0) 757 { 758 if (unlikely (returned)) { 759 fprintf (stderr, "OUCH, double calls to TRACE_RETURN. This is a bug, please report.\n"); 760 return v; 761 } 762 763 _hb_debug_msg<max_level> (what, obj, NULL, true, plevel ? *plevel : 1, -1, 764 "return %s (line %d)", 765 hb_printer_t<ret_t>().print (v), line); 766 if (plevel) --*plevel; 767 plevel = NULL; 768 returned = true; 769 return v; 770 } 771 772 private: 773 unsigned int *plevel; 774 const char *what; 775 const void *obj; 776 bool returned; 777 }; 778 template <typename ret_t> /* Optimize when tracing is disabled */ 779 struct hb_auto_trace_t<0, ret_t> { 780 explicit inline hb_auto_trace_t (unsigned int *plevel_ HB_UNUSED, 781 const char *what HB_UNUSED, 782 const void *obj HB_UNUSED, 783 const char *func HB_UNUSED, 784 const char *message HB_UNUSED, 785 ...) {} 786 787 inline ret_t ret (ret_t v, unsigned int line HB_UNUSED = 0) { return v; } 788 }; 789 790 #define TRACE_RETURN(RET) trace.ret (RET, __LINE__) 791 792 /* Misc */ 793 794 795 /* Pre-mature optimization: 796 * Checks for lo <= u <= hi but with an optimization if lo and hi 797 * are only different in a contiguous set of lower-most bits. 798 */ 799 template <typename T> static inline bool 800 hb_in_range (T u, T lo, T hi) 801 { 802 if ( ((lo^hi) & lo) == 0 && 803 ((lo^hi) & hi) == (lo^hi) && 804 ((lo^hi) & ((lo^hi) + 1)) == 0 ) 805 return (u & ~(lo^hi)) == lo; 806 else 807 return lo <= u && u <= hi; 808 } 809 810 template <typename T> static inline bool 811 hb_in_ranges (T u, T lo1, T hi1, T lo2, T hi2, T lo3, T hi3) 812 { 813 return hb_in_range (u, lo1, hi1) || hb_in_range (u, lo2, hi2) || hb_in_range (u, lo3, hi3); 814 } 815 816 817 /* Useful for set-operations on small enums. 818 * For example, for testing "x {x1, x2, x3}" use: 819 * (FLAG(x) & (FLAG(x1) | FLAG(x2) | FLAG(x3))) 820 */ 821 #define FLAG(x) (1<<(x)) 822 #define FLAG_RANGE(x,y) (ASSERT_STATIC_EXPR_ZERO ((x) < (y)) + FLAG(y+1) - FLAG(x)) 823 824 825 template <typename T, typename T2> inline void 826 hb_bubble_sort (T *array, unsigned int len, int(*compar)(const T *, const T *), T2 *array2) 827 { 828 if (unlikely (!len)) 829 return; 830 831 unsigned int k = len - 1; 832 do { 833 unsigned int new_k = 0; 834 835 for (unsigned int j = 0; j < k; j++) 836 if (compar (&array[j], &array[j+1]) > 0) 837 { 838 { 839 T t; 840 t = array[j]; 841 array[j] = array[j + 1]; 842 array[j + 1] = t; 843 } 844 if (array2) 845 { 846 T2 t; 847 t = array2[j]; 848 array2[j] = array2[j + 1]; 849 array2[j + 1] = t; 850 } 851 852 new_k = j; 853 } 854 k = new_k; 855 } while (k); 856 } 857 858 template <typename T> inline void 859 hb_bubble_sort (T *array, unsigned int len, int(*compar)(const T *, const T *)) 860 { 861 hb_bubble_sort (array, len, compar, (int *) NULL); 862 } 863 864 static inline hb_bool_t 865 hb_codepoint_parse (const char *s, unsigned int len, int base, hb_codepoint_t *out) 866 { 867 /* Pain because we don't know whether s is nul-terminated. */ 868 char buf[64]; 869 len = MIN (ARRAY_LENGTH (buf) - 1, len); 870 strncpy (buf, s, len); 871 buf[len] = '\0'; 872 873 char *end; 874 errno = 0; 875 unsigned long v = strtoul (buf, &end, base); 876 if (errno) return false; 877 if (*end) return false; 878 *out = v; 879 return true; 880 } 881 882 883 /* Global runtime options. */ 884 885 struct hb_options_t 886 { 887 int initialized : 1; 888 int uniscribe_bug_compatible : 1; 889 }; 890 891 union hb_options_union_t { 892 int i; 893 hb_options_t opts; 894 }; 895 ASSERT_STATIC (sizeof (int) == sizeof (hb_options_union_t)); 896 897 HB_INTERNAL void 898 _hb_options_init (void); 899 900 extern HB_INTERNAL hb_options_union_t _hb_options; 901 902 static inline hb_options_t 903 hb_options (void) 904 { 905 if (unlikely (!_hb_options.i)) 906 _hb_options_init (); 907 908 return _hb_options.opts; 909 } 910 911 912 #endif /* HB_PRIVATE_HH */ 913
