src/hb-buffer.cc | 4 src/hb-dsalgs.hh | 362 ++++++++++++++++++++++++++++++++++++ src/hb-map-private.hh | 2 src/hb-open-type-private.hh | 4 src/hb-ot-cmap-table.hh | 2 src/hb-ot-hdmx-table.hh | 2 src/hb-ot-layout-gpos-table.hh | 4 src/hb-ot-layout-gsub-table.hh | 2 src/hb-ot-map.cc | 4 src/hb-ot-os2-unicode-ranges.hh | 1 src/hb-ot-post-table.hh | 1 src/hb-ot-shape.cc | 4 src/hb-private.hh | 393 +--------------------------------------- src/hb-set-private.hh | 6 src/hb-subset.cc | 2 15 files changed, 396 insertions(+), 397 deletions(-)
New commits: commit bddeb2b10ca2f4b4bee6f7eaaf5615875a67111d Author: Behdad Esfahbod <beh...@behdad.org> Date: Tue Jul 10 14:12:37 2018 +0200 Minor renamings of internal inline functions diff --git a/src/hb-buffer.cc b/src/hb-buffer.cc index 7b95aea4..d04e1e80 100644 --- a/src/hb-buffer.cc +++ b/src/hb-buffer.cc @@ -124,14 +124,14 @@ hb_buffer_t::enlarge (unsigned int size) hb_glyph_info_t *new_info = nullptr; bool separate_out = out_info != info; - if (unlikely (_hb_unsigned_int_mul_overflows (size, sizeof (info[0])))) + if (unlikely (hb_unsigned_mul_overflows (size, sizeof (info[0])))) goto done; while (size >= new_allocated) new_allocated += (new_allocated >> 1) + 32; static_assert ((sizeof (info[0]) == sizeof (pos[0])), ""); - if (unlikely (_hb_unsigned_int_mul_overflows (new_allocated, sizeof (info[0])))) + if (unlikely (hb_unsigned_mul_overflows (new_allocated, sizeof (info[0])))) goto done; new_pos = (hb_glyph_position_t *) realloc (pos, new_allocated * sizeof (pos[0])); diff --git a/src/hb-dsalgs.hh b/src/hb-dsalgs.hh index 0e44d7cc..ef48fb08 100644 --- a/src/hb-dsalgs.hh +++ b/src/hb-dsalgs.hh @@ -278,7 +278,7 @@ struct hb_vector_t } else { - bool overflows = (new_allocated < allocated) || _hb_unsigned_int_mul_overflows (new_allocated, sizeof (Type)); + bool overflows = (new_allocated < allocated) || hb_unsigned_mul_overflows (new_allocated, sizeof (Type)); if (likely (!overflows)) new_array = (Type *) realloc (arrayZ, new_allocated * sizeof (Type)); } diff --git a/src/hb-map-private.hh b/src/hb-map-private.hh index d3d4dded..c4f2fc7d 100644 --- a/src/hb-map-private.hh +++ b/src/hb-map-private.hh @@ -89,7 +89,7 @@ struct hb_map_t { if (unlikely (!successful)) return false; - unsigned int power = _hb_bit_storage (population * 2 + 8); + unsigned int power = hb_bit_storage (population * 2 + 8); unsigned int new_size = 1u << power; item_t *new_items = (item_t *) malloc ((size_t) new_size * sizeof (item_t)); if (unlikely (!new_items)) diff --git a/src/hb-open-type-private.hh b/src/hb-open-type-private.hh index 9a4835b8..59b8cc02 100644 --- a/src/hb-open-type-private.hh +++ b/src/hb-open-type-private.hh @@ -230,7 +230,7 @@ struct hb_sanitize_context_t : inline bool check_array (const void *base, unsigned int record_size, unsigned int len) const { const char *p = (const char *) base; - bool overflows = _hb_unsigned_int_mul_overflows (len, record_size); + bool overflows = hb_unsigned_mul_overflows (len, record_size); unsigned int array_size = record_size * len; bool ok = !overflows && this->check_range (base, array_size); @@ -1178,7 +1178,7 @@ struct BinSearchHeader { len.set (v); assert (len == v); - entrySelector.set (MAX (1u, _hb_bit_storage (v)) - 1); + entrySelector.set (MAX (1u, hb_bit_storage (v)) - 1); searchRange.set (16 * (1u << entrySelector)); rangeShift.set (v * 16 > searchRange ? 16 * v - searchRange diff --git a/src/hb-ot-cmap-table.hh b/src/hb-ot-cmap-table.hh index c1903f6e..0ea37209 100644 --- a/src/hb-ot-cmap-table.hh +++ b/src/hb-ot-cmap-table.hh @@ -89,7 +89,7 @@ struct CmapSubtableFormat4 this->length.set (get_sub_table_size (segments)); this->segCountX2.set (segments.len * 2); - this->entrySelector.set (MAX (1u, _hb_bit_storage (segments.len)) - 1); + this->entrySelector.set (MAX (1u, hb_bit_storage (segments.len)) - 1); this->searchRange.set (2 * (1u << this->entrySelector)); this->rangeShift.set (segments.len * 2 > this->searchRange ? 2 * segments.len - this->searchRange diff --git a/src/hb-ot-hdmx-table.hh b/src/hb-ot-hdmx-table.hh index d406e3e2..0951871c 100644 --- a/src/hb-ot-hdmx-table.hh +++ b/src/hb-ot-hdmx-table.hh @@ -199,7 +199,7 @@ struct hdmx { TRACE_SANITIZE (this); return_trace (c->check_struct (this) && version == 0 && - !_hb_unsigned_int_mul_overflows (num_records, size_device_record) && + !hb_unsigned_mul_overflows (num_records, size_device_record) && size_device_record >= DeviceRecord::min_size && c->check_range (this, get_size())); } diff --git a/src/hb-ot-layout-gpos-table.hh b/src/hb-ot-layout-gpos-table.hh index 182c8d90..b52c0144 100644 --- a/src/hb-ot-layout-gpos-table.hh +++ b/src/hb-ot-layout-gpos-table.hh @@ -99,7 +99,7 @@ struct ValueFormat : HBUINT16 #endif inline unsigned int get_len (void) const - { return _hb_popcount ((unsigned int) *this); } + { return hb_popcount ((unsigned int) *this); } inline unsigned int get_size (void) const { return get_len () * Value::static_size; } @@ -374,7 +374,7 @@ struct AnchorMatrix { TRACE_SANITIZE (this); if (!c->check_struct (this)) return_trace (false); - if (unlikely (_hb_unsigned_int_mul_overflows (rows, cols))) return_trace (false); + if (unlikely (hb_unsigned_mul_overflows (rows, cols))) return_trace (false); unsigned int count = rows * cols; if (!c->check_array (matrixZ, matrixZ[0].static_size, count)) return_trace (false); for (unsigned int i = 0; i < count; i++) diff --git a/src/hb-ot-layout-gsub-table.hh b/src/hb-ot-layout-gsub-table.hh index bd72fe6b..91b898b6 100644 --- a/src/hb-ot-layout-gsub-table.hh +++ b/src/hb-ot-layout-gsub-table.hh @@ -511,7 +511,7 @@ struct AlternateSubstFormat1 hb_mask_t lookup_mask = c->lookup_mask; /* Note: This breaks badly if two features enabled this lookup together. */ - unsigned int shift = _hb_ctz (lookup_mask); + unsigned int shift = hb_ctz (lookup_mask); unsigned int alt_index = ((lookup_mask & glyph_mask) >> shift); if (unlikely (alt_index > alt_set.len || alt_index == 0)) return_trace (false); diff --git a/src/hb-ot-map.cc b/src/hb-ot-map.cc index 46bf2db0..f26cac9b 100644 --- a/src/hb-ot-map.cc +++ b/src/hb-ot-map.cc @@ -145,7 +145,7 @@ hb_ot_map_builder_t::compile (hb_ot_map_t &m, { static_assert ((!(HB_GLYPH_FLAG_DEFINED & (HB_GLYPH_FLAG_DEFINED + 1))), ""); unsigned int global_bit_mask = HB_GLYPH_FLAG_DEFINED + 1; - unsigned int global_bit_shift = _hb_popcount (HB_GLYPH_FLAG_DEFINED); + unsigned int global_bit_shift = hb_popcount (HB_GLYPH_FLAG_DEFINED); m.global_mask = global_bit_mask; @@ -209,7 +209,7 @@ hb_ot_map_builder_t::compile (hb_ot_map_t &m, bits_needed = 0; else /* Limit to 8 bits per feature. */ - bits_needed = MIN(8u, _hb_bit_storage (info->max_value)); + bits_needed = MIN(8u, hb_bit_storage (info->max_value)); if (!info->max_value || next_bit + bits_needed > 8 * sizeof (hb_mask_t)) continue; /* Feature disabled, or not enough bits. */ diff --git a/src/hb-ot-shape.cc b/src/hb-ot-shape.cc index 36e0bf9c..1189b207 100644 --- a/src/hb-ot-shape.cc +++ b/src/hb-ot-shape.cc @@ -829,12 +829,12 @@ hb_ot_shape_internal (hb_ot_shape_context_t *c) { c->buffer->deallocate_var_all (); c->buffer->scratch_flags = HB_BUFFER_SCRATCH_FLAG_DEFAULT; - if (likely (!_hb_unsigned_int_mul_overflows (c->buffer->len, HB_BUFFER_MAX_LEN_FACTOR))) + if (likely (!hb_unsigned_mul_overflows (c->buffer->len, HB_BUFFER_MAX_LEN_FACTOR))) { c->buffer->max_len = MAX (c->buffer->len * HB_BUFFER_MAX_LEN_FACTOR, (unsigned) HB_BUFFER_MAX_LEN_MIN); } - if (likely (!_hb_unsigned_int_mul_overflows (c->buffer->len, HB_BUFFER_MAX_OPS_FACTOR))) + if (likely (!hb_unsigned_mul_overflows (c->buffer->len, HB_BUFFER_MAX_OPS_FACTOR))) { c->buffer->max_ops = MAX (c->buffer->len * HB_BUFFER_MAX_OPS_FACTOR, (unsigned) HB_BUFFER_MAX_OPS_MIN); diff --git a/src/hb-private.hh b/src/hb-private.hh index 65d4bae2..fa9a1aee 100644 --- a/src/hb-private.hh +++ b/src/hb-private.hh @@ -362,7 +362,7 @@ typedef const struct _hb_void_t *hb_void_t; /* Return the number of 1 bits in v. */ template <typename T> static inline HB_CONST_FUNC unsigned int -_hb_popcount (T v) +hb_popcount (T v) { #if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) && defined(__OPTIMIZE__) if (sizeof (T) <= sizeof (unsigned int)) @@ -387,13 +387,13 @@ _hb_popcount (T v) if (sizeof (T) == 8) { unsigned int shift = 32; - return _hb_popcount<uint32_t> ((uint32_t) v) + _hb_popcount ((uint32_t) (v >> shift)); + return hb_popcount<uint32_t> ((uint32_t) v) + hb_popcount ((uint32_t) (v >> shift)); } if (sizeof (T) == 16) { unsigned int shift = 64; - return _hb_popcount<uint64_t> ((uint64_t) v) + _hb_popcount ((uint64_t) (v >> shift)); + return hb_popcount<uint64_t> ((uint64_t) v) + hb_popcount ((uint64_t) (v >> shift)); } assert (0); @@ -403,7 +403,7 @@ _hb_popcount (T v) /* Returns the number of bits needed to store number */ template <typename T> static inline HB_CONST_FUNC unsigned int -_hb_bit_storage (T v) +hb_bit_storage (T v) { if (unlikely (!v)) return 0; @@ -466,8 +466,8 @@ _hb_bit_storage (T v) if (sizeof (T) == 16) { unsigned int shift = 64; - return (v >> shift) ? _hb_bit_storage<uint64_t> ((uint64_t) (v >> shift)) + shift : - _hb_bit_storage<uint64_t> ((uint64_t) v); + return (v >> shift) ? hb_bit_storage<uint64_t> ((uint64_t) (v >> shift)) + shift : + hb_bit_storage<uint64_t> ((uint64_t) v); } assert (0); @@ -477,7 +477,7 @@ _hb_bit_storage (T v) /* Returns the number of zero bits in the least significant side of v */ template <typename T> static inline HB_CONST_FUNC unsigned int -_hb_ctz (T v) +hb_ctz (T v) { if (unlikely (!v)) return 0; @@ -539,8 +539,8 @@ _hb_ctz (T v) if (sizeof (T) == 16) { unsigned int shift = 64; - return (uint64_t) v ? _hb_bit_storage<uint64_t> ((uint64_t) v) : - _hb_bit_storage<uint64_t> ((uint64_t) v >> shift) + shift; + return (uint64_t) v ? hb_bit_storage<uint64_t> ((uint64_t) v) : + hb_bit_storage<uint64_t> ((uint64_t) v >> shift) + shift; } assert (0); @@ -548,18 +548,19 @@ _hb_ctz (T v) } static inline bool -_hb_unsigned_int_mul_overflows (unsigned int count, unsigned int size) +hb_unsigned_mul_overflows (unsigned int count, unsigned int size) { return (size > 0) && (count >= ((unsigned int) -1) / size); } static inline unsigned int -_hb_ceil_to_4 (unsigned int v) +hb_ceil_to_4 (unsigned int v) { return ((v - 1) | 3) + 1; } -static inline bool _hb_ispow2 (unsigned int v) +static inline bool +hb_ispow2 (unsigned int v) { return 0 == (v & (v - 1)); } @@ -925,7 +926,7 @@ _hb_round (double x) static inline int _hb_memalign(void **memptr, size_t alignment, size_t size) { - if (unlikely (!_hb_ispow2 (alignment) || + if (unlikely (!hb_ispow2 (alignment) || !alignment || 0 != (alignment & (sizeof (void *) - 1)))) return EINVAL; diff --git a/src/hb-set-private.hh b/src/hb-set-private.hh index 6841189e..bdaf3f1a 100644 --- a/src/hb-set-private.hh +++ b/src/hb-set-private.hh @@ -94,7 +94,7 @@ struct hb_set_t { unsigned int pop = 0; for (unsigned int i = 0; i < len (); i++) - pop += _hb_popcount (v[i]); + pop += hb_popcount (v[i]); return pop; } @@ -161,8 +161,8 @@ struct hb_set_t static const unsigned int PAGE_BITS = 512; static_assert ((PAGE_BITS & ((PAGE_BITS) - 1)) == 0, ""); - static inline unsigned int elt_get_min (const elt_t &elt) { return _hb_ctz (elt); } - static inline unsigned int elt_get_max (const elt_t &elt) { return _hb_bit_storage (elt) - 1; } + static inline unsigned int elt_get_min (const elt_t &elt) { return hb_ctz (elt); } + static inline unsigned int elt_get_max (const elt_t &elt) { return hb_bit_storage (elt) - 1; } typedef hb_vector_size_t<elt_t, PAGE_BITS / 8> vector_t; diff --git a/src/hb-subset.cc b/src/hb-subset.cc index b97c7633..e8606341 100644 --- a/src/hb-subset.cc +++ b/src/hb-subset.cc @@ -154,7 +154,7 @@ _hb_subset_face_data_reference_blob (hb_subset_face_data_t *data) unsigned int face_length = table_count * 16 + 12; for (unsigned int i = 0; i < table_count; i++) - face_length += _hb_ceil_to_4 (hb_blob_get_length (data->tables.arrayZ[i].blob)); + face_length += hb_ceil_to_4 (hb_blob_get_length (data->tables.arrayZ[i].blob)); char *buf = (char *) malloc (face_length); if (unlikely (!buf)) commit d652ef299d123f28409e755ed2d2411295293f19 Author: Behdad Esfahbod <beh...@behdad.org> Date: Tue Jul 10 14:05:00 2018 +0200 Move hb_vector_t and hb_lockable_set_t to hb-dsalgs.hh diff --git a/src/hb-dsalgs.hh b/src/hb-dsalgs.hh index 68b1fd11..0e44d7cc 100644 --- a/src/hb-dsalgs.hh +++ b/src/hb-dsalgs.hh @@ -209,4 +209,315 @@ hb_codepoint_parse (const char *s, unsigned int len, int base, hb_codepoint_t *o } +#define HB_VECTOR_INIT {0, 0, false, nullptr} +template <typename Type, unsigned int StaticSize=8> +struct hb_vector_t +{ + unsigned int len; + unsigned int allocated; + bool successful; + Type *arrayZ; + Type static_array[StaticSize]; + + void init (void) + { + len = 0; + allocated = ARRAY_LENGTH (static_array); + successful = true; + arrayZ = static_array; + } + + inline Type& operator [] (unsigned int i) + { + if (unlikely (i >= len)) + return Crap (Type); + return arrayZ[i]; + } + inline const Type& operator [] (unsigned int i) const + { + if (unlikely (i >= len)) + return Null(Type); + return arrayZ[i]; + } + + inline Type *push (void) + { + if (unlikely (!resize (len + 1))) + return &Crap(Type); + return &arrayZ[len - 1]; + } + inline Type *push (const Type& v) + { + Type *p = push (); + *p = v; + return p; + } + + /* Allocate for size but don't adjust len. */ + inline bool alloc (unsigned int size) + { + if (unlikely (!successful)) + return false; + + if (likely (size <= allocated)) + return true; + + /* Reallocate */ + + unsigned int new_allocated = allocated; + while (size >= new_allocated) + new_allocated += (new_allocated >> 1) + 8; + + Type *new_array = nullptr; + + if (arrayZ == static_array) + { + new_array = (Type *) calloc (new_allocated, sizeof (Type)); + if (new_array) + memcpy (new_array, arrayZ, len * sizeof (Type)); + } + else + { + bool overflows = (new_allocated < allocated) || _hb_unsigned_int_mul_overflows (new_allocated, sizeof (Type)); + if (likely (!overflows)) + new_array = (Type *) realloc (arrayZ, new_allocated * sizeof (Type)); + } + + if (unlikely (!new_array)) + { + successful = false; + return false; + } + + arrayZ = new_array; + allocated = new_allocated; + + return true; + } + + inline bool resize (int size_) + { + unsigned int size = size_ < 0 ? 0u : (unsigned int) size_; + if (!alloc (size)) + return false; + + if (size > len) + memset (arrayZ + len, 0, (size - len) * sizeof (*arrayZ)); + + len = size; + return true; + } + + inline void pop (void) + { + if (!len) return; + len--; + } + + inline void remove (unsigned int i) + { + if (unlikely (i >= len)) + return; + memmove (static_cast<void *> (&arrayZ[i]), + static_cast<void *> (&arrayZ[i + 1]), + (len - i - 1) * sizeof (Type)); + len--; + } + + inline void shrink (int size_) + { + unsigned int size = size_ < 0 ? 0u : (unsigned int) size_; + if (size < len) + len = size; + } + + template <typename T> + inline Type *find (T v) { + for (unsigned int i = 0; i < len; i++) + if (arrayZ[i] == v) + return &arrayZ[i]; + return nullptr; + } + template <typename T> + inline const Type *find (T v) const { + for (unsigned int i = 0; i < len; i++) + if (arrayZ[i] == v) + return &arrayZ[i]; + return nullptr; + } + + inline void qsort (int (*cmp)(const void*, const void*)) + { + ::qsort (arrayZ, len, sizeof (Type), cmp); + } + + inline void qsort (void) + { + ::qsort (arrayZ, len, sizeof (Type), Type::cmp); + } + + inline void qsort (unsigned int start, unsigned int end) + { + ::qsort (arrayZ + start, end - start, sizeof (Type), Type::cmp); + } + + template <typename T> + inline Type *lsearch (const T &x) + { + for (unsigned int i = 0; i < len; i++) + if (0 == this->arrayZ[i].cmp (&x)) + return &arrayZ[i]; + return nullptr; + } + + template <typename T> + inline Type *bsearch (const T &x) + { + unsigned int i; + return bfind (x, &i) ? &arrayZ[i] : nullptr; + } + template <typename T> + inline const Type *bsearch (const T &x) const + { + unsigned int i; + return bfind (x, &i) ? &arrayZ[i] : nullptr; + } + template <typename T> + inline bool bfind (const 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->arrayZ[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->arrayZ[max].cmp (&x) > 0)) + max++; + *i = max; + return false; + } + + inline void fini (void) + { + if (arrayZ != static_array) + free (arrayZ); + arrayZ = nullptr; + allocated = len = 0; + } +}; + +template <typename Type> +struct hb_auto_t : Type +{ + hb_auto_t (void) { Type::init (); } + ~hb_auto_t (void) { Type::fini (); } + private: /* Hide */ + void init (void) {} + void fini (void) {} +}; +template <typename Type> +struct hb_auto_array_t : hb_auto_t <hb_vector_t <Type> > {}; + + +#define HB_LOCKABLE_SET_INIT {HB_VECTOR_INIT} +template <typename item_t, typename lock_t> +struct hb_lockable_set_t +{ + hb_vector_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) + { + l.lock (); + item_t *item = items.find (v); + if (item) { + if (replace) { + item_t old = *item; + *item = v; + l.unlock (); + old.fini (); + } + else { + item = nullptr; + l.unlock (); + } + } else { + item = items.push (v); + l.unlock (); + } + return item; + } + + template <typename T> + inline void remove (T v, lock_t &l) + { + l.lock (); + item_t *item = items.find (v); + if (item) { + item_t old = *item; + *item = items[items.len - 1]; + items.pop (); + l.unlock (); + old.fini (); + } else { + l.unlock (); + } + } + + template <typename T> + inline bool find (T v, item_t *i, lock_t &l) + { + l.lock (); + item_t *item = items.find (v); + if (item) + *i = *item; + l.unlock (); + return !!item; + } + + template <typename T> + inline item_t *find_or_insert (T v, lock_t &l) + { + l.lock (); + item_t *item = items.find (v); + if (!item) { + item = items.push (v); + } + l.unlock (); + return item; + } + + inline void fini (lock_t &l) + { + if (!items.len) { + /* No need for locking. */ + items.fini (); + return; + } + l.lock (); + while (items.len) { + item_t old = items[items.len - 1]; + items.pop (); + l.unlock (); + old.fini (); + l.lock (); + } + items.fini (); + l.unlock (); + } + +}; + + #endif /* HB_DSALGS_HH */ diff --git a/src/hb-private.hh b/src/hb-private.hh index 49ce6fef..65d4bae2 100644 --- a/src/hb-private.hh +++ b/src/hb-private.hh @@ -652,321 +652,6 @@ struct CrapOrNull<const Type> { #define CrapOrNull(Type) CrapOrNull<Type>::get () - -/* arrays and maps */ - - -#define HB_VECTOR_INIT {0, 0, false, nullptr} -template <typename Type, unsigned int StaticSize=8> -struct hb_vector_t -{ - unsigned int len; - unsigned int allocated; - bool successful; - Type *arrayZ; - Type static_array[StaticSize]; - - void init (void) - { - len = 0; - allocated = ARRAY_LENGTH (static_array); - successful = true; - arrayZ = static_array; - } - - inline Type& operator [] (unsigned int i) - { - if (unlikely (i >= len)) - return Crap (Type); - return arrayZ[i]; - } - inline const Type& operator [] (unsigned int i) const - { - if (unlikely (i >= len)) - return Null(Type); - return arrayZ[i]; - } - - inline Type *push (void) - { - if (unlikely (!resize (len + 1))) - return &Crap(Type); - return &arrayZ[len - 1]; - } - inline Type *push (const Type& v) - { - Type *p = push (); - *p = v; - return p; - } - - /* Allocate for size but don't adjust len. */ - inline bool alloc (unsigned int size) - { - if (unlikely (!successful)) - return false; - - if (likely (size <= allocated)) - return true; - - /* Reallocate */ - - unsigned int new_allocated = allocated; - while (size >= new_allocated) - new_allocated += (new_allocated >> 1) + 8; - - Type *new_array = nullptr; - - if (arrayZ == static_array) - { - new_array = (Type *) calloc (new_allocated, sizeof (Type)); - if (new_array) - memcpy (new_array, arrayZ, len * sizeof (Type)); - } - else - { - bool overflows = (new_allocated < allocated) || _hb_unsigned_int_mul_overflows (new_allocated, sizeof (Type)); - if (likely (!overflows)) - new_array = (Type *) realloc (arrayZ, new_allocated * sizeof (Type)); - } - - if (unlikely (!new_array)) - { - successful = false; - return false; - } - - arrayZ = new_array; - allocated = new_allocated; - - return true; - } - - inline bool resize (int size_) - { - unsigned int size = size_ < 0 ? 0u : (unsigned int) size_; - if (!alloc (size)) - return false; - - if (size > len) - memset (arrayZ + len, 0, (size - len) * sizeof (*arrayZ)); - - len = size; - return true; - } - - inline void pop (void) - { - if (!len) return; - len--; - } - - inline void remove (unsigned int i) - { - if (unlikely (i >= len)) - return; - memmove (static_cast<void *> (&arrayZ[i]), - static_cast<void *> (&arrayZ[i + 1]), - (len - i - 1) * sizeof (Type)); - len--; - } - - inline void shrink (int size_) - { - unsigned int size = size_ < 0 ? 0u : (unsigned int) size_; - if (size < len) - len = size; - } - - template <typename T> - inline Type *find (T v) { - for (unsigned int i = 0; i < len; i++) - if (arrayZ[i] == v) - return &arrayZ[i]; - return nullptr; - } - template <typename T> - inline const Type *find (T v) const { - for (unsigned int i = 0; i < len; i++) - if (arrayZ[i] == v) - return &arrayZ[i]; - return nullptr; - } - - inline void qsort (int (*cmp)(const void*, const void*)) - { - ::qsort (arrayZ, len, sizeof (Type), cmp); - } - - inline void qsort (void) - { - ::qsort (arrayZ, len, sizeof (Type), Type::cmp); - } - - inline void qsort (unsigned int start, unsigned int end) - { - ::qsort (arrayZ + start, end - start, sizeof (Type), Type::cmp); - } - - template <typename T> - inline Type *lsearch (const T &x) - { - for (unsigned int i = 0; i < len; i++) - if (0 == this->arrayZ[i].cmp (&x)) - return &arrayZ[i]; - return nullptr; - } - - template <typename T> - inline Type *bsearch (const T &x) - { - unsigned int i; - return bfind (x, &i) ? &arrayZ[i] : nullptr; - } - template <typename T> - inline const Type *bsearch (const T &x) const - { - unsigned int i; - return bfind (x, &i) ? &arrayZ[i] : nullptr; - } - template <typename T> - inline bool bfind (const 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->arrayZ[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->arrayZ[max].cmp (&x) > 0)) - max++; - *i = max; - return false; - } - - inline void fini (void) - { - if (arrayZ != static_array) - free (arrayZ); - arrayZ = nullptr; - allocated = len = 0; - } -}; - -template <typename Type> -struct hb_auto_t : Type -{ - hb_auto_t (void) { Type::init (); } - ~hb_auto_t (void) { Type::fini (); } - private: /* Hide */ - void init (void) {} - void fini (void) {} -}; -template <typename Type> -struct hb_auto_array_t : hb_auto_t <hb_vector_t <Type> > {}; - - -#define HB_LOCKABLE_SET_INIT {HB_VECTOR_INIT} -template <typename item_t, typename lock_t> -struct hb_lockable_set_t -{ - hb_vector_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) - { - l.lock (); - item_t *item = items.find (v); - if (item) { - if (replace) { - item_t old = *item; - *item = v; - l.unlock (); - old.fini (); - } - else { - item = nullptr; - l.unlock (); - } - } else { - item = items.push (v); - l.unlock (); - } - return item; - } - - template <typename T> - inline void remove (T v, lock_t &l) - { - l.lock (); - item_t *item = items.find (v); - if (item) { - item_t old = *item; - *item = items[items.len - 1]; - items.pop (); - l.unlock (); - old.fini (); - } else { - l.unlock (); - } - } - - template <typename T> - inline bool find (T v, item_t *i, lock_t &l) - { - l.lock (); - item_t *item = items.find (v); - if (item) - *i = *item; - l.unlock (); - return !!item; - } - - template <typename T> - inline item_t *find_or_insert (T v, lock_t &l) - { - l.lock (); - item_t *item = items.find (v); - if (!item) { - item = items.push (v); - } - l.unlock (); - return item; - } - - inline void fini (lock_t &l) - { - if (!items.len) { - /* No need for locking. */ - items.fini (); - return; - } - l.lock (); - while (items.len) { - item_t old = items[items.len - 1]; - items.pop (); - l.unlock (); - old.fini (); - l.lock (); - } - items.fini (); - l.unlock (); - } - -}; - - /* ASCII tag/character handling */ static inline bool ISALPHA (unsigned char c) commit 9e53b083295ad910a87e778ebd16cbe69ebe2130 Author: Behdad Esfahbod <beh...@behdad.org> Date: Tue Jul 10 14:03:58 2018 +0200 Move hb_stable_sort to hb-dsalgs.hh Also, include hb-dsalgs.hh from end of hb-pricate.hh diff --git a/src/hb-dsalgs.hh b/src/hb-dsalgs.hh index 95868719..68b1fd11 100644 --- a/src/hb-dsalgs.hh +++ b/src/hb-dsalgs.hh @@ -158,4 +158,55 @@ static inline void hb_sort_r(void *base, size_t nel, size_t width, sort_r_simple(base, nel, width, compar, arg); } + +template <typename T, typename T2> static inline void +hb_stable_sort (T *array, unsigned int len, int(*compar)(const T *, const T *), T2 *array2) +{ + for (unsigned int i = 1; i < len; i++) + { + unsigned int j = i; + while (j && compar (&array[j - 1], &array[i]) > 0) + j--; + if (i == j) + continue; + /* Move item i to occupy place for item j, shift what's in between. */ + { + T t = array[i]; + memmove (&array[j + 1], &array[j], (i - j) * sizeof (T)); + array[j] = t; + } + if (array2) + { + T2 t = array2[i]; + memmove (&array2[j + 1], &array2[j], (i - j) * sizeof (T2)); + array2[j] = t; + } + } +} + +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) +{ + /* Pain because we don't know whether s is nul-terminated. */ + char buf[64]; + len = MIN (ARRAY_LENGTH (buf) - 1, len); + strncpy (buf, s, len); + buf[len] = '\0'; + + char *end; + errno = 0; + unsigned long v = strtoul (buf, &end, base); + if (errno) return false; + if (*end) return false; + *out = v; + return true; +} + + #endif /* HB_DSALGS_HH */ diff --git a/src/hb-ot-os2-unicode-ranges.hh b/src/hb-ot-os2-unicode-ranges.hh index 9b32cfab..cb126078 100644 --- a/src/hb-ot-os2-unicode-ranges.hh +++ b/src/hb-ot-os2-unicode-ranges.hh @@ -28,7 +28,6 @@ #define HB_OT_OS2_UNICODE_RANGES_HH #include "hb-private.hh" -#include "hb-dsalgs.hh" namespace OT { diff --git a/src/hb-ot-post-table.hh b/src/hb-ot-post-table.hh index 5f42751d..d05fc091 100644 --- a/src/hb-ot-post-table.hh +++ b/src/hb-ot-post-table.hh @@ -28,7 +28,6 @@ #define HB_OT_POST_TABLE_HH #include "hb-open-type-private.hh" -#include "hb-dsalgs.hh" #include "hb-subset-plan.hh" #define HB_STRING_ARRAY_NAME format1_names diff --git a/src/hb-private.hh b/src/hb-private.hh index c4fae17b..49ce6fef 100644 --- a/src/hb-private.hh +++ b/src/hb-private.hh @@ -1059,55 +1059,6 @@ hb_in_ranges (T u, T lo1, T hi1, T lo2, T hi2, T lo3, T hi3) #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) -{ - for (unsigned int i = 1; i < len; i++) - { - unsigned int j = i; - while (j && compar (&array[j - 1], &array[i]) > 0) - j--; - if (i == j) - continue; - /* Move item i to occupy place for item j, shift what's in between. */ - { - T t = array[i]; - memmove (&array[j + 1], &array[j], (i - j) * sizeof (T)); - array[j] = t; - } - if (array2) - { - T2 t = array2[i]; - memmove (&array2[j + 1], &array2[j], (i - j) * sizeof (T2)); - array2[j] = t; - } - } -} - -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) -{ - /* Pain because we don't know whether s is nul-terminated. */ - char buf[64]; - len = MIN (ARRAY_LENGTH (buf) - 1, len); - strncpy (buf, s, len); - buf[len] = '\0'; - - char *end; - errno = 0; - unsigned long v = strtoul (buf, &end, base); - if (errno) return false; - if (*end) return false; - *out = v; - return true; -} - /* Vectorization */ @@ -1311,5 +1262,7 @@ _hb_memalign(void **memptr, size_t alignment, size_t size) #endif +#include "hb-dsalgs.hh" + #endif /* HB_PRIVATE_HH */ commit 39f11d8e72c6b2568f3b70847c6c9d1f374cd49c Author: Behdad Esfahbod <beh...@behdad.org> Date: Tue Jul 10 14:01:39 2018 +0200 Minor diff --git a/src/hb-private.hh b/src/hb-private.hh index 5131dded..c4fae17b 100644 --- a/src/hb-private.hh +++ b/src/hb-private.hh @@ -656,7 +656,7 @@ struct CrapOrNull<const Type> { /* arrays and maps */ -#define HB_PREALLOCED_ARRAY_INIT {0, 0, nullptr} +#define HB_VECTOR_INIT {0, 0, false, nullptr} template <typename Type, unsigned int StaticSize=8> struct hb_vector_t { @@ -875,7 +875,7 @@ template <typename Type> struct hb_auto_array_t : hb_auto_t <hb_vector_t <Type> > {}; -#define HB_LOCKABLE_SET_INIT {HB_PREALLOCED_ARRAY_INIT} +#define HB_LOCKABLE_SET_INIT {HB_VECTOR_INIT} template <typename item_t, typename lock_t> struct hb_lockable_set_t { _______________________________________________ HarfBuzz mailing list HarfBuzz@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/harfbuzz