fontconfig/src/fcserialize.c

288 lines
7.7 KiB
C

/*
* Copyright © 2006 Keith Packard
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that copyright
* notice and this permission notice appear in supporting documentation, and
* that the name of the copyright holders not be used in advertising or
* publicity pertaining to distribution of the software without specific,
* written prior permission. The copyright holders make no representations
* about the suitability of this software for any purpose. It is provided "as
* is" without express or implied warranty.
*
* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
#include "fcint.h"
intptr_t
FcAlignSize (intptr_t size)
{
intptr_t rem = size % sizeof (FcAlign);
if (rem)
size += sizeof (FcAlign) - rem;
return size;
}
/*
* Serialization helper object -- allocate space in the
* yet-to-be-created linear array for a serialized font set
*/
FcSerialize *
FcSerializeCreate (void)
{
FcSerialize *serialize;
serialize = malloc (sizeof (FcSerialize));
if (!serialize)
return NULL;
serialize->size = 0;
serialize->linear = NULL;
serialize->cs_freezer = NULL;
serialize->buckets = NULL;
serialize->buckets_count = 0;
serialize->buckets_used = 0;
serialize->buckets_used_max = 0;
return serialize;
}
void
FcSerializeDestroy (FcSerialize *serialize)
{
free (serialize->buckets);
if (serialize->cs_freezer)
FcCharSetFreezerDestroy (serialize->cs_freezer);
free (serialize);
}
static size_t
FcSerializeNextBucketIndex (const FcSerialize *serialize, size_t index)
{
if (index == 0)
index = serialize->buckets_count;
--index;
return index;
}
#if ((SIZEOF_VOID_P) * (CHAR_BIT)) == 32
/*
* Based on triple32
* https://github.com/skeeto/hash-prospector
*/
static uintptr_t
FcSerializeHashPtr (const void *object)
{
uintptr_t x = (uintptr_t)object;
x ^= x >> 17;
x *= 0xed5ad4bbU;
x ^= x >> 11;
x *= 0xac4c1b51U;
x ^= x >> 15;
x *= 0x31848babU;
x ^= x >> 14;
return x ? x : 1; /* 0 reserved to mark empty, x starts out 0 */
}
#elif ((SIZEOF_VOID_P) * (CHAR_BIT)) == 64
/*
* Based on splittable64/splitmix64 from Mix13
* https://zimbry.blogspot.com/2011/09/better-bit-mixing-improving-on.html
* https://prng.di.unimi.it/splitmix64.c
*/
static uintptr_t
FcSerializeHashPtr (const void *object)
{
uintptr_t x = (uintptr_t)object;
x ^= x >> 30;
x *= 0xbf58476d1ce4e5b9U;
x ^= x >> 27;
x *= 0x94d049bb133111ebU;
x ^= x >> 31;
return x ? x : 1; /* 0 reserved to mark empty, x starts out 0 */
}
#endif
static FcSerializeBucket*
FcSerializeFind (const FcSerialize *serialize, const void *object)
{
uintptr_t hash = FcSerializeHashPtr (object);
size_t buckets_count = serialize->buckets_count;
size_t index = hash & (buckets_count-1);
for (size_t n = 0; n < buckets_count; ++n) {
FcSerializeBucket* bucket = &serialize->buckets[index];
if (bucket->hash == 0) {
return NULL;
}
if (object == bucket->object) {
return bucket;
}
index = FcSerializeNextBucketIndex (serialize, index);
}
return NULL;
}
static FcSerializeBucket*
FcSerializeUncheckedSet (FcSerialize *serialize, FcSerializeBucket* insert) {
const void *object = insert->object;
size_t buckets_count = serialize->buckets_count;
size_t index = insert->hash & (buckets_count-1);
for (size_t n = 0; n < buckets_count; ++n) {
FcSerializeBucket* bucket = &serialize->buckets[index];
if (bucket->hash == 0) {
*bucket = *insert;
++serialize->buckets_used;
return bucket;
}
if (object == bucket->object) {
/* FcSerializeAlloc should not allow this to happen. */
assert (0);
*bucket = *insert;
return bucket;
}
index = FcSerializeNextBucketIndex (serialize, index);
}
assert (0);
return NULL;
}
static FcBool
FcSerializeResize (FcSerialize *serialize, size_t new_count)
{
size_t old_used = serialize->buckets_used;
size_t old_count = serialize->buckets_count;
FcSerializeBucket *old_buckets = serialize->buckets;
FcSerializeBucket *old_buckets_end = old_buckets + old_count;
FcSerializeBucket *new_buckets = malloc (new_count * sizeof (*old_buckets));
if (!new_buckets)
return FcFalse;
FcSerializeBucket *new_buckets_end = new_buckets + new_count;
for (FcSerializeBucket *b = new_buckets; b < new_buckets_end; ++b)
b->hash = 0;
serialize->buckets = new_buckets;
serialize->buckets_count = new_count;
serialize->buckets_used = 0;
for (FcSerializeBucket *b = old_buckets; b < old_buckets_end; ++b)
if (b->hash != 0 && !FcSerializeUncheckedSet (serialize, b))
{
serialize->buckets = old_buckets;
serialize->buckets_count = old_count;
serialize->buckets_used = old_used;
free (new_buckets);
return FcFalse;
}
free (old_buckets);
return FcTrue;
}
static FcSerializeBucket*
FcSerializeSet (FcSerialize *serialize, const void *object, intptr_t offset)
{
if (serialize->buckets_used >= serialize->buckets_used_max)
{
size_t capacity = serialize->buckets_count;
if (capacity == 0)
capacity = 4;
else if (capacity > SIZE_MAX / 2u)
return NULL;
else
capacity *= 2;
if (!FcSerializeResize (serialize, capacity))
return NULL;
serialize->buckets_used_max = capacity / 4u * 3u;
}
FcSerializeBucket bucket;
bucket.object = object;
bucket.offset = offset;
bucket.hash = FcSerializeHashPtr (object);
return FcSerializeUncheckedSet (serialize, &bucket);
}
/*
* Allocate space for an object in the serialized array. Keep track
* of where the object is placed and only allocate one copy of each object
*/
FcBool
FcSerializeAlloc (FcSerialize *serialize, const void *object, int size)
{
FcSerializeBucket *bucket = FcSerializeFind (serialize, object);
if (bucket)
return FcTrue;
if (!FcSerializeSet (serialize, object, serialize->size))
return FcFalse;
serialize->size += FcAlignSize (size);
return FcTrue;
}
/*
* Reserve space in the serialization array
*/
intptr_t
FcSerializeReserve (FcSerialize *serialize, int size)
{
intptr_t offset = serialize->size;
serialize->size += FcAlignSize (size);
return offset;
}
/*
* Given an object, return the offset in the serialized array where
* the serialized copy of the object is stored
*/
intptr_t
FcSerializeOffset (FcSerialize *serialize, const void *object)
{
FcSerializeBucket *bucket = FcSerializeFind (serialize, object);
return bucket ? bucket->offset : 0;
}
/*
* Given a cache and an object, return a pointer to where
* the serialized copy of the object is stored
*/
void *
FcSerializePtr (FcSerialize *serialize, const void *object)
{
intptr_t offset = FcSerializeOffset (serialize, object);
if (!offset)
return NULL;
return (void *) ((char *) serialize->linear + offset);
}
FcBool
FcStrSerializeAlloc (FcSerialize *serialize, const FcChar8 *str)
{
return FcSerializeAlloc (serialize, str, strlen ((const char *) str) + 1);
}
FcChar8 *
FcStrSerialize (FcSerialize *serialize, const FcChar8 *str)
{
FcChar8 *str_serialize = FcSerializePtr (serialize, str);
if (!str_serialize)
return NULL;
strcpy ((char *) str_serialize, (const char *) str);
return str_serialize;
}
#include "fcaliastail.h"
#undef __fcserialize__