Michiharu Ariza
6 years ago
commit
161ece4c30
43 changed files with 1278 additions and 984 deletions
@ -0,0 +1,106 @@ |
||||
/*
|
||||
* Copyright © 2018 Google, Inc. |
||||
* |
||||
* This is part of HarfBuzz, a text shaping library. |
||||
* |
||||
* Permission is hereby granted, without written agreement and without |
||||
* license or royalty fees, to use, copy, modify, and distribute this |
||||
* software and its documentation for any purpose, provided that the |
||||
* above copyright notice and the following two paragraphs appear in |
||||
* all copies of this software. |
||||
* |
||||
* IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR |
||||
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES |
||||
* ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN |
||||
* IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH |
||||
* DAMAGE. |
||||
* |
||||
* THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, |
||||
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND |
||||
* FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS |
||||
* ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO |
||||
* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. |
||||
* |
||||
* Google Author(s): Behdad Esfahbod |
||||
*/ |
||||
|
||||
#ifndef HB_NULL_HH |
||||
#define HB_NULL_HH |
||||
|
||||
#include "hb-private.hh" |
||||
|
||||
|
||||
/*
|
||||
* Static pools |
||||
*/ |
||||
|
||||
/* Global nul-content Null pool. Enlarge as necessary. */ |
||||
|
||||
#define HB_NULL_POOL_SIZE 800 |
||||
|
||||
extern HB_INTERNAL |
||||
hb_vector_size_impl_t const _hb_NullPool[(HB_NULL_POOL_SIZE + sizeof (hb_vector_size_impl_t) - 1) / sizeof (hb_vector_size_impl_t)]; |
||||
|
||||
/* Generic nul-content Null objects. */ |
||||
template <typename Type> |
||||
static inline Type const & Null (void) { |
||||
static_assert (sizeof (Type) <= HB_NULL_POOL_SIZE, "Increase HB_NULL_POOL_SIZE."); |
||||
return *reinterpret_cast<Type const *> (_hb_NullPool); |
||||
} |
||||
#define Null(Type) Null<Type>() |
||||
|
||||
/* Specializaitons for arbitrary-content Null objects expressed in bytes. */ |
||||
#define DECLARE_NULL_NAMESPACE_BYTES(Namespace, Type) \ |
||||
} /* Close namespace. */ \
|
||||
extern HB_INTERNAL const unsigned char _hb_Null_##Namespace##_##Type[Namespace::Type::min_size]; \
|
||||
template <> \
|
||||
/*static*/ inline const Namespace::Type& Null<Namespace::Type> (void) { \
|
||||
return *reinterpret_cast<const Namespace::Type *> (_hb_Null_##Namespace##_##Type); \
|
||||
} \
|
||||
namespace Namespace { \
|
||||
static_assert (true, "Just so we take semicolon after.") |
||||
#define DEFINE_NULL_NAMESPACE_BYTES(Namespace, Type) \ |
||||
const unsigned char _hb_Null_##Namespace##_##Type[Namespace::Type::min_size] |
||||
|
||||
/* Specializaitons for arbitrary-content Null objects expressed as struct initializer. */ |
||||
#define DECLARE_NULL_INSTANCE(Type) \ |
||||
extern HB_INTERNAL const Type _hb_Null_##Type; \
|
||||
template <> \
|
||||
/*static*/ inline const Type& Null<Type> (void) { \
|
||||
return _hb_Null_##Type; \
|
||||
} \
|
||||
static_assert (true, "Just so we take semicolon after.") |
||||
#define DEFINE_NULL_INSTANCE(Type) \ |
||||
const Type _hb_Null_##Type |
||||
|
||||
/* Global writable pool. Enlarge as necessary. */ |
||||
|
||||
/* To be fully correct, CrapPool must be thread_local. However, we do not rely on CrapPool
|
||||
* for correct operation. It only exist to catch and divert program logic bugs instead of |
||||
* causing bad memory access. So, races there are not actually introducing incorrectness |
||||
* in the code. Has ~12kb binary size overhead to have it, also clang build fails with it. */ |
||||
extern HB_INTERNAL |
||||
/*thread_local*/ hb_vector_size_impl_t _hb_CrapPool[(HB_NULL_POOL_SIZE + sizeof (hb_vector_size_impl_t) - 1) / sizeof (hb_vector_size_impl_t)]; |
||||
|
||||
/* CRAP pool: Common Region for Access Protection. */ |
||||
template <typename Type> |
||||
static inline Type& Crap (void) { |
||||
static_assert (sizeof (Type) <= HB_NULL_POOL_SIZE, "Increase HB_NULL_POOL_SIZE."); |
||||
Type *obj = reinterpret_cast<Type *> (_hb_CrapPool); |
||||
*obj = Null(Type); |
||||
return *obj; |
||||
} |
||||
#define Crap(Type) Crap<Type>() |
||||
|
||||
template <typename Type> |
||||
struct CrapOrNull { |
||||
static inline Type & get (void) { return Crap(Type); } |
||||
}; |
||||
template <typename Type> |
||||
struct CrapOrNull<const Type> { |
||||
static inline Type const & get (void) { return Null(Type); } |
||||
}; |
||||
#define CrapOrNull(Type) CrapOrNull<Type>::get () |
||||
|
||||
|
||||
#endif /* HB_NULL_HH */ |
||||
@ -0,0 +1,238 @@ |
||||
/*
|
||||
* Copyright © 2017,2018 Google, Inc. |
||||
* |
||||
* This is part of HarfBuzz, a text shaping library. |
||||
* |
||||
* Permission is hereby granted, without written agreement and without |
||||
* license or royalty fees, to use, copy, modify, and distribute this |
||||
* software and its documentation for any purpose, provided that the |
||||
* above copyright notice and the following two paragraphs appear in |
||||
* all copies of this software. |
||||
* |
||||
* IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR |
||||
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES |
||||
* ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN |
||||
* IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH |
||||
* DAMAGE. |
||||
* |
||||
* THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, |
||||
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND |
||||
* FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS |
||||
* ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO |
||||
* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. |
||||
* |
||||
* Red Hat Author(s): Behdad Esfahbod |
||||
* Google Author(s): Behdad Esfahbod |
||||
*/ |
||||
|
||||
#ifndef HB_VECTOR_PRIVATE_HH |
||||
#define HB_VECTOR_PRIVATE_HH |
||||
|
||||
#include "hb-private.hh" |
||||
|
||||
|
||||
template <typename Type, unsigned int StaticSize=8> |
||||
struct hb_vector_t |
||||
{ |
||||
unsigned int len; |
||||
unsigned int allocated; /* == 0 means allocation failed. */ |
||||
Type *arrayZ; |
||||
Type static_array[StaticSize]; |
||||
|
||||
void init (void) |
||||
{ |
||||
len = 0; |
||||
allocated = ARRAY_LENGTH (static_array); |
||||
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 (!allocated)) |
||||
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_mul_overflows (new_allocated, sizeof (Type)); |
||||
if (likely (!overflows)) |
||||
new_array = (Type *) realloc (arrayZ, new_allocated * sizeof (Type)); |
||||
} |
||||
|
||||
if (unlikely (!new_array)) |
||||
{ |
||||
allocated = 0; |
||||
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; |
||||
} |
||||
}; |
||||
|
||||
|
||||
#endif /* HB_VECTOR_PRIVATE_HH */ |
||||
Loading…
Reference in new issue