/*
* fontconfig/src/fccharset.c
*
* Copyright © 2001 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 author(s) not be used in
* advertising or publicity pertaining to distribution of the software without
* specific, written prior permission. The authors make no
* representations about the suitability of this software for any purpose. It
* is provided "as is" without express or implied warranty.
*
* THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* EVENT SHALL THE AUTHOR(S) 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"
#include <stdlib.h>
/* #define CHECK */
FcCharSet *
FcCharSetCreate (void)
{
FcCharSet *fcs;
fcs = (FcCharSet *) malloc (sizeof (FcCharSet));
if (!fcs)
return 0;
FcRefInit (&fcs->ref, 1);
fcs->num = 0;
fcs->leaves_offset = 0;
fcs->numbers_offset = 0;
return fcs;
}
FcCharSet *
FcCharSetPromote (FcValuePromotionBuffer *vbuf)
{
FcCharSet *fcs = (FcCharSet *) vbuf;
FC_ASSERT_STATIC (sizeof (FcCharSet) <= sizeof (FcValuePromotionBuffer));
FcRefSetConst (&fcs->ref);
fcs->num = 0;
fcs->leaves_offset = 0;
fcs->numbers_offset = 0;
return fcs;
}
FcCharSet *
FcCharSetNew (void)
{
return FcCharSetCreate ();
}
void
FcCharSetDestroy (FcCharSet *fcs)
{
int i;
if (fcs)
{
if (FcRefIsConst (&fcs->ref))
{
FcCacheObjectDereference (fcs);
return;
}
if (FcRefDec (&fcs->ref) != 1)
return;
for (i = 0; i < fcs->num; i++)
free (FcCharSetLeaf (fcs, i));
if (fcs->num)
{
free (FcCharSetLeaves (fcs));
free (FcCharSetNumbers (fcs));
}
free (fcs);
}
}
/*
* Search for the leaf containing with the specified num.
* Return its index if it exists, otherwise return negative of
* the (position + 1) where it should be inserted
*/
static int
FcCharSetFindLeafForward (const FcCharSet *fcs, int start, FcChar16 num)
{
FcChar16 *numbers = FcCharSetNumbers(fcs);
FcChar16 page;
int low = start;
int high = fcs->num - 1;
if (!numbers)
return -1;
while (low <= high)
{
int mid = (low + high) >> 1;
page = numbers[mid];
if (page == num)
return mid;
if (page < num)
low = mid + 1;
else
high = mid - 1;
}
if (high < 0 || (high < fcs->num && numbers[high] < num))
high++;
return -(high + 1);
}
/*
* Locate the leaf containing the specified char, return
* its index if it exists, otherwise return negative of
* the (position + 1) where it should be inserted
*/
static int
FcCharSetFindLeafPos (const FcCharSet *fcs, FcChar32 ucs4)
{
return FcCharSetFindLeafForward (fcs, 0, ucs4 >> 8);
}
static FcCharLeaf *
FcCharSetFindLeaf (const FcCharSet *fcs, FcChar32 ucs4)
{
int pos = FcCharSetFindLeafPos (fcs, ucs4);
if (pos >= 0)
return FcCharSetLeaf(fcs, pos);
return 0;
}
#define FC_IS_ZERO_OR_POWER_OF_TWO(x) (!((x) & ((x)-1)))
static FcBool
FcCharSetPutLeaf (FcCharSet *fcs,
FcChar32 ucs4,
FcCharLeaf *leaf,
int pos)
{
intptr_t *leaves = FcCharSetLeaves (fcs);
FcChar16 *numbers = FcCharSetNumbers (fcs);
ucs4 >>= 8;
if (ucs4 >= 0x10000)
return FcFalse;
if (FC_IS_ZERO_OR_POWER_OF_TWO (fcs->num))
{
if (!fcs->num)
{
unsigned int alloced = 8;
leaves = malloc (alloced * sizeof (*leaves));
numbers = malloc (alloced * sizeof (*numbers));
if (!leaves || !numbers)
{
if (leaves)
free (leaves);
if (numbers)
free (numbers);
return FcFalse;
}
}
else
{
unsigned int alloced = fcs->num;
intptr_t *new_leaves, distance;
alloced *= 2;
new_leaves = realloc (leaves, alloced * sizeof (*leaves));
if (!new_leaves)
return FcFalse;
numbers = realloc (numbers, alloced * sizeof (*numbers));
if (!numbers)
{
/* Revert the reallocation of leaves */
leaves = realloc (new_leaves, (alloced / 2) * sizeof (*new_leaves));
/* unlikely to fail though */
if (!leaves)
return FcFalse;
fcs->leaves_offset = FcPtrToOffset (fcs, leaves);
return FcFalse;
}
distance = (intptr_t) new_leaves - (intptr_t) leaves;
if (new_leaves && distance)
{
int i;
for (i = 0; i < fcs->num; i++)
new_leaves[i] -= distance;
}
leaves = new_leaves;
}
fcs->leaves_offset = FcPtrToOffset (fcs, leaves);
fcs->numbers_offset = FcPtrToOffset (fcs, numbers);
}
memmove (leaves + pos + 1, leaves + pos,
(fcs->num - pos) * sizeof (*leaves));
memmove (numbers + pos + 1, numbers + pos,
(fcs->num - pos) * sizeof (*numbers));
numbers[pos] = (FcChar16) ucs4;
leaves[pos] = FcPtrToOffset (leaves, leaf);
fcs->num++;
return FcTrue;
}
/*
* Locate the leaf containing the specified char, creating it
* if desired
*/
FcCharLeaf *
FcCharSetFindLeafCreate (FcCharSet *fcs, FcChar32 ucs4)
{
int pos;
FcCharLeaf *leaf;
pos = FcCharSetFindLeafPos (fcs, ucs4);
if (pos >= 0)
return FcCharSetLeaf(fcs, pos);
leaf = calloc (1, sizeof (FcCharLeaf));
if (!leaf)
return 0;
pos = -pos - 1;
if (!FcCharSetPutLeaf (fcs, ucs4, leaf, pos))
{
free (leaf);
return 0;
}
return leaf;
}
static FcBool
FcCharSetInsertLeaf (FcCharSet *fcs, FcChar32 ucs4, FcCharLeaf *leaf)
{
int pos;
pos = FcCharSetFindLeafPos (fcs, ucs4);
if (pos >= 0)
{
free (FcCharSetLeaf (fcs, pos));
FcCharSetLeaves(fcs)[pos] = FcPtrToOffset (FcCharSetLeaves(fcs),
leaf);
return FcTrue;
}
pos = -pos - 1;
return FcCharSetPutLeaf (fcs, ucs4, leaf, pos);
}
FcBool
FcCharSetAddChar (FcCharSet *fcs, FcChar32 ucs4)
{
FcCharLeaf *leaf;
FcChar32 *b;
if (fcs == NULL || FcRefIsConst (&fcs->ref))
return FcFalse;
leaf = FcCharSetFindLeafCreate (fcs, ucs4);
if (!leaf)
return FcFalse;
b = &leaf->map[(ucs4 & 0xff) >> 5];
*b |= (1U << (ucs4 & 0x1f));
return FcTrue;
}
FcBool
FcCharSetDelChar (FcCharSet *fcs, FcChar32 ucs4)
{
FcCharLeaf *leaf;
FcChar32 *b;
if (fcs == NULL || FcRefIsConst (&fcs->ref))
return FcFalse;
leaf = FcCharSetFindLeaf (fcs, ucs4);
if (!leaf)
return FcTrue;
b = &leaf->map[(ucs4 & 0xff) >> 5];
*b &= ~(1U << (ucs4 & 0x1f));
/* We don't bother removing the leaf if it's empty */
return FcTrue;
}
/*
* An iterator for the leaves of a charset
*/
typedef struct _fcCharSetIter {
FcCharLeaf *leaf;
FcChar32 ucs4;
int pos;
} FcCharSetIter;
/*
* Set iter->leaf to the leaf containing iter->ucs4 or higher
*/
static void
FcCharSetIterSet (const FcCharSet *fcs, FcCharSetIter *iter)
{
int pos = FcCharSetFindLeafPos (fcs, iter->ucs4);
if (pos < 0)
{
pos = -pos - 1;
if (pos == fcs->num)
{
iter->ucs4 = ~0;
iter->leaf = 0;
return;
}
iter->ucs4 = (FcChar32) FcCharSetNumbers(fcs)[pos] << 8;
}
iter->leaf = FcCharSetLeaf(fcs, pos);
iter->pos = pos;
}
static void
FcCharSetIterNext (const FcCharSet *fcs, FcCharSetIter *iter)
{
int pos = iter->pos + 1;
if (pos >= fcs->num)
{
iter->ucs4 = ~0;
iter->leaf = 0;
}
else
{
iter->ucs4 = (FcChar32) FcCharSetNumbers(fcs)[pos] << 8;
iter->leaf = FcCharSetLeaf(fcs, pos);
iter->pos = pos;
}
}
static void
FcCharSetIterStart (const FcCharSet *fcs, FcCharSetIter *iter)
{
iter->ucs4 = 0;
iter->pos = 0;
FcCharSetIterSet (fcs, iter);
}
FcCharSet *
FcCharSetCopy (FcCharSet *src)
{
if (src)
{
if (!FcRefIsConst (&src->ref))
FcRefInc (&src->ref);
else
FcCacheObjectReference (src);
}
return src;
}
FcBool
FcCharSetEqual (const FcCharSet *a, const FcCharSet *b)
{
FcCharSetIter ai, bi;
int i;
if (a == b)
return FcTrue;
if (!a || !b)
return FcFalse;
for (FcCharSetIterStart (a, &ai), FcCharSetIterStart (b, &bi);
ai.leaf && bi.leaf;
FcCharSetIterNext (a, &ai), FcCharSetIterNext (b, &bi))
{
if (ai.ucs4 != bi.ucs4)
return FcFalse;
for (i = 0; i < 256/32; i++)
if (ai.leaf->map[i] != bi.leaf->map[i])
return FcFalse;
}
return ai.leaf == bi.leaf;
}
static FcBool
FcCharSetAddLeaf (FcCharSet *fcs,
FcChar32 ucs4,
FcCharLeaf *leaf)
{
FcCharLeaf *new = FcCharSetFindLeafCreate (fcs, ucs4);
if (!new)
return FcFalse;
*new = *leaf;
return FcTrue;
}
static FcCharSet *
FcCharSetOperate (const FcCharSet *a,
const FcCharSet *b,
FcBool (*overlap) (FcCharLeaf *result,
const FcCharLeaf *al,
const FcCharLeaf *bl),
FcBool aonly,
FcBool bonly)
{
FcCharSet *fcs;
FcCharSetIter ai, bi;
if (!a || !b)
goto bail0;
fcs = FcCharSetCreate ();
if (!fcs)
goto bail0;
FcCharSetIterStart (a, &ai);
FcCharSetIterStart (b, &bi);
while ((ai.leaf || (bonly && bi.leaf)) && (bi.leaf || (aonly && ai.leaf)))
{
if (ai.ucs4 < bi.ucs4)
{
if (aonly)
{
if (!FcCharSetAddLeaf (fcs, ai.ucs4, ai.leaf))
goto bail1;
FcCharSetIterNext (a, &ai);
}
else
{
ai.ucs4 = bi.ucs4;
FcCharSetIterSet (a, &ai);
}
}
else if (bi.ucs4 < ai.ucs4 )
{
if (bonly)
{
if (!FcCharSetAddLeaf (fcs, bi.ucs4, bi.leaf))
goto bail1;
FcCharSetIterNext (b, &bi);
}
else
{
bi.ucs4 = ai.ucs4;
FcCharSetIterSet (b, &bi);
}
}
else
{
FcCharLeaf leaf;
if ((*overlap) (&leaf, ai.leaf, bi.leaf))
{
if (!FcCharSetAddLeaf (fcs, ai.ucs4, &leaf))
goto bail1;
}
FcCharSetIterNext (a, &ai);
FcCharSetIterNext (b, &bi);
}
}
return fcs;
bail1:
FcCharSetDestroy (fcs);
bail0:
return 0;
}
static FcBool
FcCharSetIntersectLeaf (FcCharLeaf *result,
const FcCharLeaf *al,
const FcCharLeaf *bl)
{
int i;
FcBool nonempty = FcFalse;
for (i = 0; i < 256/32; i++)
if ((result->map[i] = al->map[i] & bl->map[i]))
nonempty = FcTrue;
return nonempty;
}
FcCharSet *
FcCharSetIntersect (const FcCharSet *a, const FcCharSet *b)
{
return FcCharSetOperate (a, b, FcCharSetIntersectLeaf, FcFalse, FcFalse);
}
static FcBool
FcCharSetUnionLeaf (FcCharLeaf *result,
const FcCharLeaf *al,
const FcCharLeaf *bl)
{
int i;
for (i = 0; i < 256/32; i++)
result->map[i] = al->map[i] | bl->map[i];
return FcTrue;
}
FcCharSet *
FcCharSetUnion (const FcCharSet *a, const FcCharSet *b)
{
return FcCharSetOperate (a, b, FcCharSetUnionLeaf, FcTrue, FcTrue);
}
FcBool
FcCharSetMerge (FcCharSet *a, const FcCharSet *b, FcBool *changed)
{
int ai = 0, bi = 0;
FcChar16 an, bn;
if (!a || !b)
return FcFalse;
if (FcRefIsConst (&a->ref)) {
if (changed)
*changed = FcFalse;
return FcFalse;
}
if (changed) {
*changed = !FcCharSetIsSubset(b, a);
if (!*changed)
return FcTrue;
}
while (bi < b->num)
{
an = ai < a->num ? FcCharSetNumbers(a)[ai] : ~0;
bn = FcCharSetNumbers(b)[bi];
if (an < bn)
{
ai = FcCharSetFindLeafForward (a, ai + 1, bn);
if (ai < 0)
ai = -ai - 1;
}
else
{
FcCharLeaf *bl = FcCharSetLeaf(b, bi);
if (bn < an)
{
if (!FcCharSetAddLeaf (a, bn << 8, bl))
return FcFalse;
}
else
{
FcCharLeaf *al = FcCharSetLeaf(a, ai);
FcCharSetUnionLeaf (al, al, bl);
}
ai++;
bi++;
}
}
return FcTrue;
}
static FcBool
FcCharSetSubtractLeaf (FcCharLeaf *result,
const FcCharLeaf *al,
const FcCharLeaf *bl)
{
int i;
FcBool nonempty = FcFalse;
for (i = 0; i < 256/32; i++)
if ((result->map[i] = al->map[i] & ~bl->map[i]))
nonempty = FcTrue;
return nonempty;
}
FcCharSet *
FcCharSetSubtract (const FcCharSet *a, const FcCharSet *b)
{
return FcCharSetOperate (a, b, FcCharSetSubtractLeaf, FcTrue, FcFalse);
}
FcBool
FcCharSetHasChar (const FcCharSet *fcs, FcChar32 ucs4)
{
FcCharLeaf *leaf;
if (!fcs)
return FcFalse;
leaf = FcCharSetFindLeaf (fcs, ucs4);
if (!leaf)
return FcFalse;
return (leaf->map[(ucs4 & 0xff) >> 5] & (1U << (ucs4 & 0x1f))) != 0;
}
static FcChar32
FcCharSetPopCount (FcChar32 c1)
{
#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
return __builtin_popcount (c1);
#else
/* hackmem 169 */
FcChar32 c2 = (c1 >> 1) & 033333333333;
c2 = c1 - c2 - ((c2 >> 1) & 033333333333);
return (((c2 + (c2 >> 3)) & 030707070707) % 077);
#endif
}
FcChar32
FcCharSetIntersectCount (const FcCharSet *a, const FcCharSet *b)
{
FcCharSetIter ai, bi;
FcChar32 count = 0;
if (a && b)
{
FcCharSetIterStart (a, &ai);
FcCharSetIterStart (b, &bi);
while (ai.leaf && bi.leaf)
{
if (ai.ucs4 == bi.ucs4)
{
FcChar32 *am = ai.leaf->map;
FcChar32 *bm = bi.leaf->map;
int i = 256/32;
while (i--)
count += FcCharSetPopCount (*am++ & *bm++);
FcCharSetIterNext (a, &ai);
}
else if (ai.ucs4 < bi.ucs4)
{
ai.ucs4 = bi.ucs4;
FcCharSetIterSet (a, &ai);
}
if (bi.ucs4 < ai.ucs4)
{
bi.ucs4 = ai.ucs4;
FcCharSetIterSet (b, &bi);
}
}
}
return count;
}
FcChar32
FcCharSetCount (const FcCharSet *a)
{
FcCharSetIter ai;
FcChar32 count = 0;
if (a)
{
for (FcCharSetIterStart (a, &ai); ai.leaf; FcCharSetIterNext (a, &ai))
{
int i = 256/32;
FcChar32 *am = ai.leaf->map;
while (i--)
count += FcCharSetPopCount (*am++);
}
}
return count;
}
FcChar32
FcCharSetSubtractCount (const FcCharSet *a, const FcCharSet *b)
{
FcCharSetIter ai, bi;
FcChar32 count = 0;
if (a && b)
{
FcCharSetIterStart (a, &ai);
FcCharSetIterStart (b, &bi);
while (ai.leaf)
{
if (ai.ucs4 <= bi.ucs4)
{
FcChar32 *am = ai.leaf->map;
int i = 256/32;
if (ai.ucs4 == bi.ucs4)
{
FcChar32 *bm = bi.leaf->map;
while (i--)
count += FcCharSetPopCount (*am++ & ~*bm++);
}
else
{
while (i--)
count += FcCharSetPopCount (*am++);
}
FcCharSetIterNext (a, &ai);
}
else if (bi.leaf)
{
bi.ucs4 = ai.ucs4;
FcCharSetIterSet (b, &bi);
}
}
}
return count;
}
/*
* return FcTrue iff a is a subset of b
*/
FcBool
FcCharSetIsSubset (const FcCharSet *a, const FcCharSet *b)
{
int ai, bi;
FcChar16 an, bn;
if (a == b)
return FcTrue;
if (!a || !b)
return FcFalse;
bi = 0;
ai = 0;
while (ai < a->num && bi < b->num)
{
an = FcCharSetNumbers(a)[ai];
bn = FcCharSetNumbers(b)[bi];
/*
* Check matching pages
*/
if (an == bn)
{
FcChar32 *am = FcCharSetLeaf(a, ai)->map;
FcChar32 *bm = FcCharSetLeaf(b, bi)->map;
if (am != bm)
{
int i = 256/32;
/*
* Does am have any bits not in bm?
*/
while (i--)
if (*am++ & ~*bm++)
return FcFalse;
}
ai++;
bi++;
}
/*
* Does a have any pages not in b?
*/
else if (an < bn)
return FcFalse;
else
{
bi = FcCharSetFindLeafForward (b, bi + 1, an);
if (bi < 0)
bi = -bi - 1;
}
}
/*
* did we look at every page?
*/
return ai >= a->num;
}
/*
* These two functions efficiently walk the entire charmap for
* other software (like pango) that want their own copy
*/
FcChar32
FcCharSetNextPage (const FcCharSet *a,
FcChar32 map[FC_CHARSET_MAP_SIZE],
FcChar32 *next)
{
FcCharSetIter ai;
FcChar32 page;
if (!a)
return FC_CHARSET_DONE;
ai.ucs4 = *next;
FcCharSetIterSet (a, &ai);
if (!ai.leaf)
return FC_CHARSET_DONE;
/*
* Save current information
*/
page = ai.ucs4;
memcpy (map, ai.leaf->map, sizeof (ai.leaf->map));
/*
* Step to next page
*/
FcCharSetIterNext (a, &ai);
*next = ai.ucs4;
return page;
}
FcChar32
FcCharSetFirstPage (const FcCharSet *a,
FcChar32 map[FC_CHARSET_MAP_SIZE],
FcChar32 *next)
{
*next = 0;
return FcCharSetNextPage (a, map, next);
}
/*
* old coverage API, rather hard to use correctly
*/
FcChar32
FcCharSetCoverage (const FcCharSet *a, FcChar32 page, FcChar32 *result)
{
FcCharSetIter ai;
ai.ucs4 = page;
FcCharSetIterSet (a, &ai);
if (!ai.leaf)
{
memset (result, '\0', 256 / 8);
page = 0;
}
else
{
memcpy (result, ai.leaf->map, sizeof (ai.leaf->map));
FcCharSetIterNext (a, &ai);
page = ai.ucs4;
}
return page;
}
static FcBool
FcNameParseRange (FcChar8 **string, FcChar32 *pfirst, FcChar32 *plast)
{
char *s = (char *) *string;
char *t;
long first, last;
while (isspace(*s))
s++;
t = s;
errno = 0;
first = last = strtol (s, &s, 16);
if (errno)
return FcFalse;
while (isspace(*s))
s++;
if (*s == '-')
{
s++;
errno = 0;
last = strtol (s, &s, 16);
if (errno)
return FcFalse;
}
if (s == t || first < 0 || last < 0 || last < first || last > 0x10ffff)
return FcFalse;
*string = (FcChar8 *) s;
*pfirst = first;
*plast = last;
return FcTrue;
}
FcCharSet *
FcNameParseCharSet (FcChar8 *string)
{
FcCharSet *c;
FcChar32 first, last;
c = FcCharSetCreate ();
if (!c)
goto bail0;
while (*string)
{
FcChar32 u;
if (!FcNameParseRange (&string, &first, &last))
goto bail1;
for (u = first; u < last + 1; u++)
FcCharSetAddChar (c, u);
}
return c;
bail1:
FcCharSetDestroy (c);
bail0:
return NULL;
}
static void
FcNameUnparseUnicode (FcStrBuf *buf, FcChar32 u)
{
FcChar8 buf_static[64];
snprintf ((char *) buf_static, sizeof (buf_static), "%x", u);
FcStrBufString (buf, buf_static);
}
FcBool
FcNameUnparseCharSet (FcStrBuf *buf, const FcCharSet *c)
{
FcCharSetIter ci;
FcChar32 first, last;
int i;
#ifdef CHECK
int len = buf->len;
#endif
first = last = 0x7FFFFFFF;
for (FcCharSetIterStart (c, &ci);
ci.leaf;
FcCharSetIterNext (c, &ci))
{
for (i = 0; i < 256/32; i++)
{
FcChar32 bits = ci.leaf->map[i];
FcChar32 u = ci.ucs4 + i * 32;
while (bits)
{
if (bits & 1)
{
if (u != last + 1)
{
if (last != first)
{
FcStrBufChar (buf, '-');
FcNameUnparseUnicode (buf, last);
}
if (last != 0x7FFFFFFF)
FcStrBufChar (buf, ' ');
/* Start new range. */
first = u;
FcNameUnparseUnicode (buf, u);
}
last = u;
}
bits >>= 1;
u++;
}
}
}
if (last != first)
{
FcStrBufChar (buf, '-');
FcNameUnparseUnicode (buf, last);
}
#ifdef CHECK
{
FcCharSet *check;
FcChar32 missing;
FcCharSetIter ci, checki;
/* null terminate for parser */
FcStrBufChar (buf, '\0');
/* step back over null for life after test */
buf->len--;
check = FcNameParseCharSet (buf->buf + len);
FcCharSetIterStart (c, &ci);
FcCharSetIterStart (check, &checki);
while (ci.leaf || checki.leaf)
{
if (ci.ucs4 < checki.ucs4)
{
printf ("Missing leaf node at 0x%x\n", ci.ucs4);
FcCharSetIterNext (c, &ci);
}
else if (checki.ucs4 < ci.ucs4)
{
printf ("Extra leaf node at 0x%x\n", checki.ucs4);
FcCharSetIterNext (check, &checki);
}
else
{
int i = 256/32;
FcChar32 *cm = ci.leaf->map;
FcChar32 *checkm = checki.leaf->map;
for (i = 0; i < 256; i += 32)
{
if (*cm != *checkm)
printf ("Mismatching sets at 0x%08x: 0x%08x != 0x%08x\n",
ci.ucs4 + i, *cm, *checkm);
cm++;
checkm++;
}
FcCharSetIterNext (c, &ci);
FcCharSetIterNext (check, &checki);
}
}
if ((missing = FcCharSetSubtractCount (c, check)))
printf ("%d missing in reparsed result\n", missing);
if ((missing = FcCharSetSubtractCount (check, c)))
printf ("%d extra in reparsed result\n", missing);
FcCharSetDestroy (check);
}
#endif
return FcTrue;
}
typedef struct _FcCharLeafEnt FcCharLeafEnt;
struct _FcCharLeafEnt {
FcCharLeafEnt *next;
FcChar32 hash;
FcCharLeaf leaf;
};
#define FC_CHAR_LEAF_BLOCK (4096 / sizeof (FcCharLeafEnt))
#define FC_CHAR_LEAF_HASH_SIZE 257
typedef struct _FcCharSetEnt FcCharSetEnt;
struct _FcCharSetEnt {
FcCharSetEnt *next;
FcChar32 hash;
FcCharSet set;
};
typedef struct _FcCharSetOrigEnt FcCharSetOrigEnt;
struct _FcCharSetOrigEnt {
FcCharSetOrigEnt *next;
const FcCharSet *orig;
const FcCharSet *frozen;
};
#define FC_CHAR_SET_HASH_SIZE 67
struct _FcCharSetFreezer {
FcCharLeafEnt *leaf_hash_table[FC_CHAR_LEAF_HASH_SIZE];
FcCharLeafEnt **leaf_blocks;
int leaf_block_count;
FcCharSetEnt *set_hash_table[FC_CHAR_SET_HASH_SIZE];
FcCharSetOrigEnt *orig_hash_table[FC_CHAR_SET_HASH_SIZE];
FcCharLeafEnt *current_block;
int leaf_remain;
int leaves_seen;
int charsets_seen;
int leaves_allocated;
int charsets_allocated;
};
static FcCharLeafEnt *
FcCharLeafEntCreate (FcCharSetFreezer *freezer)
{
if (!freezer->leaf_remain)
{
FcCharLeafEnt **newBlocks;
freezer->leaf_block_count++;
newBlocks = realloc (freezer->leaf_blocks, freezer->leaf_block_count * sizeof (FcCharLeafEnt *));
if (!newBlocks)
return 0;
freezer->leaf_blocks = newBlocks;
freezer->current_block = freezer->leaf_blocks[freezer->leaf_block_count-1] = malloc (FC_CHAR_LEAF_BLOCK * sizeof (FcCharLeafEnt));
if (!freezer->current_block)
return 0;
freezer->leaf_remain = FC_CHAR_LEAF_BLOCK;
}
freezer->leaf_remain--;
freezer->leaves_allocated++;
return freezer->current_block++;
}
static FcChar32
FcCharLeafHash (FcCharLeaf *leaf)
{
FcChar32 hash = 0;
int i;
for (i = 0; i < 256/32; i++)
hash = ((hash << 1) | (hash >> 31)) ^ leaf->map[i];
return hash;
}
static FcCharLeaf *
FcCharSetFreezeLeaf (FcCharSetFreezer *freezer, FcCharLeaf *leaf)
{
FcChar32 hash = FcCharLeafHash (leaf);
FcCharLeafEnt **bucket = &freezer->leaf_hash_table[hash % FC_CHAR_LEAF_HASH_SIZE];
FcCharLeafEnt *ent;
for (ent = *bucket; ent; ent = ent->next)
{
if (ent->hash == hash && !memcmp (&ent->leaf, leaf, sizeof (FcCharLeaf)))
return &ent->leaf;
}
ent = FcCharLeafEntCreate(freezer);
if (!ent)
return 0;
ent->leaf = *leaf;
ent->hash = hash;
ent->next = *bucket;
*bucket = ent;
return &ent->leaf;
}
static FcChar32
FcCharSetHash (FcCharSet *fcs)
{
FcChar32 hash = 0;
int i;
/* hash in leaves */
for (i = 0; i < fcs->num; i++)
hash = ((hash << 1) | (hash >> 31)) ^ FcCharLeafHash (FcCharSetLeaf(fcs,i));
/* hash in numbers */
for (i = 0; i < fcs->num; i++)
hash = ((hash << 1) | (hash >> 31)) ^ FcCharSetNumbers(fcs)[i];
return hash;
}
static FcBool
FcCharSetFreezeOrig (FcCharSetFreezer *freezer, const FcCharSet *orig, const FcCharSet *frozen)
{
FcCharSetOrigEnt **bucket = &freezer->orig_hash_table[((uintptr_t) orig) % FC_CHAR_SET_HASH_SIZE];
FcCharSetOrigEnt *ent;
ent = malloc (sizeof (FcCharSetOrigEnt));
if (!ent)
return FcFalse;
ent->orig = orig;
ent->frozen = frozen;
ent->next = *bucket;
*bucket = ent;
return FcTrue;
}
static FcCharSet *
FcCharSetFreezeBase (FcCharSetFreezer *freezer, FcCharSet *fcs)
{
FcChar32 hash = FcCharSetHash (fcs);
FcCharSetEnt **bucket = &freezer->set_hash_table[hash % FC_CHAR_SET_HASH_SIZE];
FcCharSetEnt *ent;
int size;
int i;
for (ent = *bucket; ent; ent = ent->next)
{
if (ent->hash == hash &&
ent->set.num == fcs->num &&
!memcmp (FcCharSetNumbers(&ent->set),
FcCharSetNumbers(fcs),
fcs->num * sizeof (FcChar16)))
{
FcBool ok = FcTrue;
int i;
for (i = 0; i < fcs->num; i++)
if (FcCharSetLeaf(&ent->set, i) != FcCharSetLeaf(fcs, i))
ok = FcFalse;
if (ok)
return &ent->set;
}
}
size = (sizeof (FcCharSetEnt) +
fcs->num * sizeof (FcCharLeaf *) +
fcs->num * sizeof (FcChar16));
ent = malloc (size);
if (!ent)
return 0;
freezer->charsets_allocated++;
FcRefSetConst (&ent->set.ref);
ent->set.num = fcs->num;
if (fcs->num)
{
intptr_t *ent_leaves;
ent->set.leaves_offset = sizeof (ent->set);
ent->set.numbers_offset = (ent->set.leaves_offset +
fcs->num * sizeof (intptr_t));
ent_leaves = FcCharSetLeaves (&ent->set);
for (i = 0; i < fcs->num; i++)
ent_leaves[i] = FcPtrToOffset (ent_leaves,
FcCharSetLeaf (fcs, i));
memcpy (FcCharSetNumbers (&ent->set),
FcCharSetNumbers (fcs),
fcs->num * sizeof (FcChar16));
}
else
{
ent->set.leaves_offset = 0;
ent->set.numbers_offset = 0;
}
ent->hash = hash;
ent->next = *bucket;
*bucket = ent;
return &ent->set;
}
static const FcCharSet *
FcCharSetFindFrozen (FcCharSetFreezer *freezer, const FcCharSet *orig)
{
FcCharSetOrigEnt **bucket = &freezer->orig_hash_table[((uintptr_t) orig) % FC_CHAR_SET_HASH_SIZE];
FcCharSetOrigEnt *ent;
for (ent = *bucket; ent; ent = ent->next)
if (ent->orig == orig)
return ent->frozen;
return NULL;
}
const FcCharSet *
FcCharSetFreeze (FcCharSetFreezer *freezer, const FcCharSet *fcs)
{
FcCharSet *b;
const FcCharSet *n = 0;
FcCharLeaf *l;
int i;
b = FcCharSetCreate ();
if (!b)
goto bail0;
for (i = 0; i < fcs->num; i++)
{
l = FcCharSetFreezeLeaf (freezer, FcCharSetLeaf(fcs, i));
if (!l)
goto bail1;
if (!FcCharSetInsertLeaf (b, FcCharSetNumbers(fcs)[i] << 8, l))
goto bail1;
}
n = FcCharSetFreezeBase (freezer, b);
if (!FcCharSetFreezeOrig (freezer, fcs, n))
{
n = NULL;
goto bail1;
}
freezer->charsets_seen++;
freezer->leaves_seen += fcs->num;
bail1:
if (b->num)
free (FcCharSetLeaves (b));
if (b->num)
free (FcCharSetNumbers (b));
free (b);
bail0:
return n;
}
FcCharSetFreezer *
FcCharSetFreezerCreate (void)
{
FcCharSetFreezer *freezer;
freezer = calloc (1, sizeof (FcCharSetFreezer));
return freezer;
}
void
FcCharSetFreezerDestroy (FcCharSetFreezer *freezer)
{
int i;
if (FcDebug() & FC_DBG_CACHE)
{
printf ("\ncharsets %d -> %d leaves %d -> %d\n",
freezer->charsets_seen, freezer->charsets_allocated,
freezer->leaves_seen, freezer->leaves_allocated);
}
for (i = 0; i < FC_CHAR_SET_HASH_SIZE; i++)
{
FcCharSetEnt *ent, *next;
for (ent = freezer->set_hash_table[i]; ent; ent = next)
{
next = ent->next;
free (ent);
}
}
for (i = 0; i < FC_CHAR_SET_HASH_SIZE; i++)
{
FcCharSetOrigEnt *ent, *next;
for (ent = freezer->orig_hash_table[i]; ent; ent = next)
{
next = ent->next;
free (ent);
}
}
for (i = 0; i < freezer->leaf_block_count; i++)
free (freezer->leaf_blocks[i]);
free (freezer->leaf_blocks);
free (freezer);
}
FcBool
FcCharSetSerializeAlloc (FcSerialize *serialize, const FcCharSet *cs)
{
intptr_t *leaves;
FcChar16 *numbers;
int i;
if (!FcRefIsConst (&cs->ref))
{
if (!serialize->cs_freezer)
{
serialize->cs_freezer = FcCharSetFreezerCreate ();
if (!serialize->cs_freezer)
return FcFalse;
}
if (FcCharSetFindFrozen (serialize->cs_freezer, cs))
return FcTrue;
cs = FcCharSetFreeze (serialize->cs_freezer, cs);
}
leaves = FcCharSetLeaves (cs);
numbers = FcCharSetNumbers (cs);
if (!FcSerializeAlloc (serialize, cs, sizeof (FcCharSet)))
return FcFalse;
if (!FcSerializeAlloc (serialize, leaves, cs->num * sizeof (intptr_t)))
return FcFalse;
if (!FcSerializeAlloc (serialize, numbers, cs->num * sizeof (FcChar16)))
return FcFalse;
for (i = 0; i < cs->num; i++)
if (!FcSerializeAlloc (serialize, FcCharSetLeaf(cs, i),
sizeof (FcCharLeaf)))
return FcFalse;
return FcTrue;
}
FcCharSet *
FcCharSetSerialize(FcSerialize *serialize, const FcCharSet *cs)
{
FcCharSet *cs_serialized;
intptr_t *leaves, *leaves_serialized;
FcChar16 *numbers, *numbers_serialized;
FcCharLeaf *leaf, *leaf_serialized;
int i;
if (!FcRefIsConst (&cs->ref) && serialize->cs_freezer)
{
cs = FcCharSetFindFrozen (serialize->cs_freezer, cs);
if (!cs)
return NULL;
}
cs_serialized = FcSerializePtr (serialize, cs);
if (!cs_serialized)
return NULL;
FcRefSetConst (&cs_serialized->ref);
cs_serialized->num = cs->num;
if (cs->num)
{
leaves = FcCharSetLeaves (cs);
leaves_serialized = FcSerializePtr (serialize, leaves);
if (!leaves_serialized)
return NULL;
cs_serialized->leaves_offset = FcPtrToOffset (cs_serialized,
leaves_serialized);
numbers = FcCharSetNumbers (cs);
numbers_serialized = FcSerializePtr (serialize, numbers);
if (!numbers)
return NULL;
cs_serialized->numbers_offset = FcPtrToOffset (cs_serialized,
numbers_serialized);
for (i = 0; i < cs->num; i++)
{
leaf = FcCharSetLeaf (cs, i);
leaf_serialized = FcSerializePtr (serialize, leaf);
if (!leaf_serialized)
return NULL;
*leaf_serialized = *leaf;
leaves_serialized[i] = FcPtrToOffset (leaves_serialized,
leaf_serialized);
numbers_serialized[i] = numbers[i];
}
}
else
{
cs_serialized->leaves_offset = 0;
cs_serialized->numbers_offset = 0;
}
return cs_serialized;
}
#define __fccharset__
#include "fcaliastail.h"
#undef __fccharset__