#include <stdlib.h>
#include "fcint.h"
FcCharSet *
FcCharSetCreate (void)
{
FcCharSet *fcs;
fcs = (FcCharSet *) malloc (sizeof (FcCharSet));
if (!fcs)
return 0;
FcMemAlloc (FC_MEM_CHARSET, sizeof (FcCharSet));
fcs->ref = 1;
fcs->num = 0;
fcs->leaves = 0;
fcs->numbers = 0;
return fcs;
}
FcCharSet *
FcCharSetNew (void);
FcCharSet *
FcCharSetNew (void)
{
return FcCharSetCreate ();
}
void
FcCharSetDestroy (FcCharSet *fcs)
{
int i;
if (fcs->ref == FC_REF_CONSTANT)
return;
if (--fcs->ref > 0)
return;
for (i = 0; i < fcs->num; i++)
{
FcMemFree (FC_MEM_CHARLEAF, sizeof (FcCharLeaf));
free (fcs->leaves[i]);
}
if (fcs->leaves)
{
FcMemFree (FC_MEM_CHARSET, fcs->num * sizeof (FcCharLeaf *));
free (fcs->leaves);
}
if (fcs->numbers)
{
FcMemFree (FC_MEM_CHARSET, fcs->num * sizeof (FcChar16));
free (fcs->numbers);
}
FcMemFree (FC_MEM_CHARSET, sizeof (FcCharSet));
free (fcs);
}
static int
FcCharSetFindLeafPos (const FcCharSet *fcs, FcChar32 ucs4)
{
FcChar16 *numbers = fcs->numbers;
FcChar16 page;
int low = 0;
int high = fcs->num - 1;
if (!numbers)
return -1;
ucs4 >>= 8;
while (low <= high)
{
int mid = (low + high) >> 1;
page = numbers[mid];
if (page == ucs4)
return mid;
if (page < ucs4)
low = mid + 1;
else
high = mid - 1;
}
if (high < 0 || (high < fcs->num && numbers[high] < ucs4))
high++;
return -(high + 1);
}
static FcCharLeaf *
FcCharSetFindLeaf (const FcCharSet *fcs, FcChar32 ucs4)
{
int pos = FcCharSetFindLeafPos (fcs, ucs4);
if (pos >= 0)
return fcs->leaves[pos];
return 0;
}
static FcBool
FcCharSetPutLeaf (FcCharSet *fcs,
FcChar32 ucs4,
FcCharLeaf *leaf,
int pos)
{
FcCharLeaf **leaves;
FcChar16 *numbers;
ucs4 >>= 8;
if (ucs4 >= 0x10000)
return FcFalse;
if (!fcs->leaves)
leaves = malloc (sizeof (FcCharLeaf *));
else
leaves = realloc (fcs->leaves, (fcs->num + 1) * sizeof (FcCharLeaf *));
if (!leaves)
return FcFalse;
if (fcs->num)
FcMemFree (FC_MEM_CHARSET, fcs->num * sizeof (FcCharLeaf *));
FcMemAlloc (FC_MEM_CHARSET, (fcs->num + 1) * sizeof (FcCharLeaf *));
fcs->leaves = leaves;
if (!fcs->numbers)
numbers = malloc (sizeof (FcChar16));
else
numbers = realloc (fcs->numbers, (fcs->num + 1) * sizeof (FcChar16));
if (!numbers)
return FcFalse;
if (fcs->num)
FcMemFree (FC_MEM_CHARSET, fcs->num * sizeof (FcChar16));
FcMemAlloc (FC_MEM_CHARSET, (fcs->num + 1) * sizeof (FcChar16));
fcs->numbers = numbers;
memmove (fcs->leaves + pos + 1, fcs->leaves + pos,
(fcs->num - pos) * sizeof (FcCharLeaf *));
memmove (fcs->numbers + pos + 1, fcs->numbers + pos,
(fcs->num - pos) * sizeof (FcChar16));
fcs->numbers[pos] = (FcChar16) ucs4;
fcs->leaves[pos] = leaf;
fcs->num++;
return FcTrue;
}
static FcCharLeaf *
FcCharSetFindLeafCreate (FcCharSet *fcs, FcChar32 ucs4)
{
int pos;
FcCharLeaf *leaf;
pos = FcCharSetFindLeafPos (fcs, ucs4);
if (pos >= 0)
return fcs->leaves[pos];
leaf = calloc (1, sizeof (FcCharLeaf));
if (!leaf)
return 0;
pos = -pos - 1;
if (!FcCharSetPutLeaf (fcs, ucs4, leaf, pos))
{
free (leaf);
return 0;
}
FcMemAlloc (FC_MEM_CHARLEAF, sizeof (FcCharLeaf));
return leaf;
}
static FcBool
FcCharSetInsertLeaf (FcCharSet *fcs, FcChar32 ucs4, FcCharLeaf *leaf)
{
int pos;
pos = FcCharSetFindLeafPos (fcs, ucs4);
if (pos >= 0)
{
FcMemFree (FC_MEM_CHARLEAF, sizeof (FcCharLeaf));
free (fcs->leaves[pos]);
fcs->leaves[pos] = leaf;
return FcTrue;
}
pos = -pos - 1;
return FcCharSetPutLeaf (fcs, ucs4, leaf, pos);
}
FcBool
FcCharSetAddChar (FcCharSet *fcs, FcChar32 ucs4)
{
FcCharLeaf *leaf;
FcChar32 *b;
if (fcs->ref == FC_REF_CONSTANT)
return FcFalse;
leaf = FcCharSetFindLeafCreate (fcs, ucs4);
if (!leaf)
return FcFalse;
b = &leaf->map[(ucs4 & 0xff) >> 5];
*b |= (1 << (ucs4 & 0x1f));
return FcTrue;
}
typedef struct _fcCharSetIter {
FcCharLeaf *leaf;
FcChar32 ucs4;
int pos;
} FcCharSetIter;
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) fcs->numbers[pos] << 8;
}
iter->leaf = fcs->leaves[pos];
iter->pos = pos;
#ifdef CHATTY
printf ("set %08x: %08x\n", iter->ucs4, (FcChar32) iter->leaf);
#endif
}
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) fcs->numbers[pos] << 8;
iter->leaf = fcs->leaves[pos];
iter->pos = pos;
}
}
#ifdef CHATTY
static void
FcCharSetDump (const FcCharSet *fcs)
{
int pos;
printf ("fcs %08x:\n", (FcChar32) fcs);
for (pos = 0; pos < fcs->num; pos++)
{
FcCharLeaf *leaf = fcs->leaves[pos];
FcChar32 ucs4 = (FcChar32) fcs->numbers[pos] << 8;
printf (" %08x: %08x\n", ucs4, (FcChar32) leaf);
}
}
#endif
static void
FcCharSetIterStart (const FcCharSet *fcs, FcCharSetIter *iter)
{
#ifdef CHATTY
FcCharSetDump (fcs);
#endif
iter->ucs4 = 0;
FcCharSetIterSet (fcs, iter);
}
FcCharSet *
FcCharSetCopy (FcCharSet *src)
{
if (src->ref != FC_REF_CONSTANT)
src->ref++;
return src;
}
FcBool
FcCharSetEqual (const FcCharSet *a, const FcCharSet *b)
{
FcCharSetIter ai, bi;
int i;
if (a == b)
return FcTrue;
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;
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);
}
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 = FcCharSetFindLeaf (fcs, ucs4);
if (!leaf)
return FcFalse;
return (leaf->map[(ucs4 & 0xff) >> 5] & (1 << (ucs4 & 0x1f))) != 0;
}
static FcChar32
FcCharSetPopCount (FcChar32 c1)
{
FcChar32 c2 = (c1 >> 1) & 033333333333;
c2 = c1 - c2 - ((c2 >> 1) & 033333333333);
return (((c2 + (c2 >> 3)) & 030707070707) % 077);
}
FcChar32
FcCharSetIntersectCount (const FcCharSet *a, const FcCharSet *b)
{
FcCharSetIter ai, bi;
FcChar32 count = 0;
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;
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;
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;
}
FcBool
FcCharSetIsSubset (const FcCharSet *a, const FcCharSet *b)
{
int ai, bi;
FcChar16 an, bn;
if (a == b) return FcTrue;
bi = 0;
ai = 0;
while (ai < a->num && bi < b->num)
{
an = a->numbers[ai];
bn = b->numbers[bi];
if (an == bn)
{
FcChar32 *am = a->leaves[ai]->map;
FcChar32 *bm = b->leaves[bi]->map;
if (am != bm)
{
int i = 256/32;
while (i--)
if (*am++ & ~*bm++)
return FcFalse;
}
ai++;
bi++;
}
else if (an < bn)
return FcFalse;
else
{
int low = bi + 1;
int high = b->num - 1;
while (low <= high)
{
int mid = (low + high) >> 1;
bn = b->numbers[mid];
if (bn == an)
{
high = mid;
break;
}
if (bn < an)
low = mid + 1;
else
high = mid - 1;
}
bi = high;
while (bi < b->num && b->numbers[bi] < an)
bi++;
}
}
return FcTrue;
}
FcChar32
FcCharSetNextPage (const FcCharSet *a,
FcChar32 map[FC_CHARSET_MAP_SIZE],
FcChar32 *next)
{
FcCharSetIter ai;
FcChar32 page;
ai.ucs4 = *next;
FcCharSetIterSet (a, &ai);
if (!ai.leaf)
return FC_CHARSET_DONE;
page = ai.ucs4;
memcpy (map, ai.leaf->map, sizeof (ai.leaf->map));
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);
}
FcChar32
FcCharSetCoverage (const FcCharSet *a, FcChar32 page, FcChar32 *result);
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 const unsigned char charToValue[256] = {
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0x00, 0xff, 0x01, 0x02, 0x03, 0x04, 0xff,
0x05, 0x06, 0x07, 0x08, 0xff, 0xff, 0x09, 0x0a,
0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12,
0x13, 0x14, 0xff, 0x15, 0x16, 0xff, 0x17, 0x18,
0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
0x31, 0x32, 0x33, 0x34, 0xff, 0x35, 0x36, 0xff,
0xff, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d,
0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45,
0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d,
0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
};
static const FcChar8 valueToChar[0x55] = {
'!', '#', '$', '%', '&', '(', ')', '*',
'+', '.', '/', '0', '1', '2', '3', '4',
'5', '6', '7', '8', '9', ';', '<', '>',
'?', '@', 'A', 'B', 'C', 'D', 'E', 'F',
'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
'W', 'X', 'Y', 'Z', '[', ']', '^', 'a',
'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q',
'r', 's', 't', 'u', 'v', 'w', 'x', 'y',
'z', '{', '|', '}', '~',
};
static FcChar8 *
FcCharSetParseValue (FcChar8 *string, FcChar32 *value)
{
int i;
FcChar32 v;
FcChar32 c;
if (*string == ' ')
{
v = 0;
string++;
}
else
{
v = 0;
for (i = 0; i < 5; i++)
{
if (!(c = (FcChar32) (unsigned char) *string++))
return 0;
c = charToValue[c];
if (c == 0xff)
return 0;
v = v * 85 + c;
}
}
*value = v;
return string;
}
static FcBool
FcCharSetUnparseValue (FcStrBuf *buf, FcChar32 value)
{
int i;
if (value == 0)
{
return FcStrBufChar (buf, ' ');
}
else
{
FcChar8 string[6];
FcChar8 *s = string + 5;
string[5] = '\0';
for (i = 0; i < 5; i++)
{
*--s = valueToChar[value % 85];
value /= 85;
}
for (i = 0; i < 5; i++)
if (!FcStrBufChar (buf, *s++))
return FcFalse;
}
return FcTrue;
}
typedef struct _FcCharLeafEnt FcCharLeafEnt;
struct _FcCharLeafEnt {
FcCharLeafEnt *next;
FcChar32 hash;
FcCharLeaf leaf;
};
#define FC_CHAR_LEAF_BLOCK (4096 / sizeof (FcCharLeafEnt))
static FcCharLeafEnt *
FcCharLeafEntCreate (void)
{
static FcCharLeafEnt *block;
static int remain;
if (!remain)
{
block = malloc (FC_CHAR_LEAF_BLOCK * sizeof (FcCharLeafEnt));
if (!block)
return 0;
FcMemAlloc (FC_MEM_CHARLEAF, FC_CHAR_LEAF_BLOCK * sizeof (FcCharLeafEnt));
remain = FC_CHAR_LEAF_BLOCK;
}
remain--;
return block++;
}
#define FC_CHAR_LEAF_HASH_SIZE 257
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 int FcCharLeafTotal;
static int FcCharLeafUsed;
static FcCharLeaf *
FcCharSetFreezeLeaf (FcCharLeaf *leaf)
{
static FcCharLeafEnt *hashTable[FC_CHAR_LEAF_HASH_SIZE];
FcChar32 hash = FcCharLeafHash (leaf);
FcCharLeafEnt **bucket = &hashTable[hash % FC_CHAR_LEAF_HASH_SIZE];
FcCharLeafEnt *ent;
FcCharLeafTotal++;
for (ent = *bucket; ent; ent = ent->next)
{
if (ent->hash == hash && !memcmp (&ent->leaf, leaf, sizeof (FcCharLeaf)))
return &ent->leaf;
}
ent = FcCharLeafEntCreate();
if (!ent)
return 0;
FcCharLeafUsed++;
ent->leaf = *leaf;
ent->hash = hash;
ent->next = *bucket;
*bucket = ent;
return &ent->leaf;
}
typedef struct _FcCharSetEnt FcCharSetEnt;
struct _FcCharSetEnt {
FcCharSetEnt *next;
FcChar32 hash;
FcCharSet set;
};
#define FC_CHAR_SET_HASH_SIZE 67
static FcChar32
FcCharSetHash (FcCharSet *fcs)
{
FcChar32 hash = 0;
FcChar32 *p;
int i;
p = (FcChar32 *) fcs->leaves;
for (i = 0; i < fcs->num * sizeof (FcCharLeaf *) / sizeof (FcChar32); i++)
hash = ((hash << 1) | (hash >> 31)) ^ *p++;
for (i = 0; i < fcs->num; i++)
hash = ((hash << 1) | (hash >> 31)) ^ fcs->numbers[i];
return hash;
}
static int FcCharSetTotal;
static int FcCharSetUsed;
static int FcCharSetTotalEnts, FcCharSetUsedEnts;
static FcCharSet *
FcCharSetFreezeBase (FcCharSet *fcs)
{
static FcCharSetEnt *hashTable[FC_CHAR_SET_HASH_SIZE];
FcChar32 hash = FcCharSetHash (fcs);
FcCharSetEnt **bucket = &hashTable[hash % FC_CHAR_SET_HASH_SIZE];
FcCharSetEnt *ent;
int size;
FcCharSetTotal++;
FcCharSetTotalEnts += fcs->num;
for (ent = *bucket; ent; ent = ent->next)
{
if (ent->hash == hash &&
ent->set.num == fcs->num &&
!memcmp (ent->set.leaves, fcs->leaves,
fcs->num * sizeof (FcCharLeaf *)) &&
!memcmp (ent->set.numbers, fcs->numbers,
fcs->num * sizeof (FcChar16)))
{
return &ent->set;
}
}
size = (sizeof (FcCharSetEnt) +
fcs->num * sizeof (FcCharLeaf *) +
fcs->num * sizeof (FcChar16));
ent = malloc (size);
if (!ent)
return 0;
FcMemAlloc (FC_MEM_CHARSET, size);
FcCharSetUsed++;
FcCharSetUsedEnts += fcs->num;
ent->set.ref = FC_REF_CONSTANT;
ent->set.num = fcs->num;
if (fcs->num)
{
ent->set.leaves = (FcCharLeaf **) (ent + 1);
ent->set.numbers = (FcChar16 *) (ent->set.leaves + fcs->num);
memcpy (ent->set.leaves, fcs->leaves, fcs->num * sizeof (FcCharLeaf *));
memcpy (ent->set.numbers, fcs->numbers, fcs->num * sizeof (FcChar16));
}
else
{
ent->set.leaves = 0;
ent->set.numbers = 0;
}
ent->hash = hash;
ent->next = *bucket;
*bucket = ent;
return &ent->set;
}
FcCharSet *
FcCharSetFreeze (FcCharSet *fcs)
{
FcCharSet *b;
FcCharSet *n = 0;
FcCharLeaf *l;
int i;
b = FcCharSetCreate ();
if (!b)
goto bail0;
for (i = 0; i < fcs->num; i++)
{
l = FcCharSetFreezeLeaf (fcs->leaves[i]);
if (!l)
goto bail1;
if (!FcCharSetInsertLeaf (b, fcs->numbers[i] << 8, l))
goto bail1;
}
n = FcCharSetFreezeBase (b);
bail1:
if (b->leaves)
{
FcMemFree (FC_MEM_CHARSET, b->num * sizeof (FcCharLeaf *));
free (b->leaves);
}
if (b->numbers)
{
FcMemFree (FC_MEM_CHARSET, b->num * sizeof (FcChar16));
free (b->numbers);
}
FcMemFree (FC_MEM_CHARSET, sizeof (FcCharSet));
free (b);
bail0:
return n;
}
FcCharSet *
FcNameParseCharSet (FcChar8 *string)
{
FcCharSet *c, *n = 0;
FcChar32 ucs4;
FcCharLeaf *leaf;
FcCharLeaf temp;
FcChar32 bits;
int i;
c = FcCharSetCreate ();
if (!c)
goto bail0;
while (*string)
{
string = FcCharSetParseValue (string, &ucs4);
if (!string)
goto bail1;
bits = 0;
for (i = 0; i < 256/32; i++)
{
string = FcCharSetParseValue (string, &temp.map[i]);
if (!string)
goto bail1;
bits |= temp.map[i];
}
if (bits)
{
leaf = FcCharSetFreezeLeaf (&temp);
if (!leaf)
goto bail1;
if (!FcCharSetInsertLeaf (c, ucs4, leaf))
goto bail1;
}
}
#ifdef CHATTY
printf (" %8s %8s %8s %8s\n", "total", "totalmem", "new", "newmem");
printf ("Leaves: %8d %8d %8d %8d\n",
FcCharLeafTotal, sizeof (FcCharLeaf) * FcCharLeafTotal,
FcCharLeafUsed, sizeof (FcCharLeaf) * FcCharLeafUsed);
printf ("Charsets: %8d %8d %8d %8d\n",
FcCharSetTotal, sizeof (FcCharSet) * FcCharSetTotal,
FcCharSetUsed, sizeof (FcCharSet) * FcCharSetUsed);
printf ("Tables: %8d %8d %8d %8d\n",
FcCharSetTotalEnts, FcCharSetTotalEnts * (sizeof (FcCharLeaf *) + sizeof (FcChar16)),
FcCharSetUsedEnts, FcCharSetUsedEnts * (sizeof (FcCharLeaf *) + sizeof (FcChar16)));
printf ("Total: %8s %8d %8s %8d\n",
"",
sizeof (FcCharLeaf) * FcCharLeafTotal +
sizeof (FcCharSet) * FcCharSetTotal +
FcCharSetTotalEnts * (sizeof (FcCharLeaf *) + sizeof (FcChar16)),
"",
sizeof (FcCharLeaf) * FcCharLeafUsed +
sizeof (FcCharSet) * FcCharSetUsed +
FcCharSetUsedEnts * (sizeof (FcCharLeaf *) + sizeof (FcChar16)));
#endif
n = FcCharSetFreezeBase (c);
bail1:
if (c->leaves)
{
FcMemFree (FC_MEM_CHARSET, c->num * sizeof (FcCharLeaf *));
free (c->leaves);
}
if (c->numbers)
{
FcMemFree (FC_MEM_CHARSET, c->num * sizeof (FcChar16));
free (c->numbers);
}
FcMemFree (FC_MEM_CHARSET, sizeof (FcCharSet));
free (c);
bail0:
return n;
}
FcBool
FcNameUnparseCharSet (FcStrBuf *buf, const FcCharSet *c)
{
FcCharSetIter ci;
int i;
#ifdef CHECK
int len = buf->len;
#endif
for (FcCharSetIterStart (c, &ci);
ci.leaf;
FcCharSetIterNext (c, &ci))
{
if (!FcCharSetUnparseValue (buf, ci.ucs4))
return FcFalse;
for (i = 0; i < 256/32; i++)
if (!FcCharSetUnparseValue (buf, ci.leaf->map[i]))
return FcFalse;
}
#ifdef CHECK
{
FcCharSet *check;
FcChar32 missing;
FcCharSetIter ci, checki;
FcStrBufChar (buf, '\0');
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;
}
#if FREETYPE_MAJOR > 2
# define HAS_NEXT_CHAR
#else
# if FREETYPE_MAJOR == 2
# if FREETYPE_MINOR > 0
# define HAS_NEXT_CHAR
# else
# if FREETYPE_MINOR == 0
# if FREETYPE_PATCH >= 9
# define HAS_NEXT_CHAR
# endif
# endif
# endif
# endif
#endif
#ifndef HAS_NEXT_CHAR
#define FT_Get_First_Char(face, gi) ((*(gi) = 1), 1)
#define FT_Get_Next_Char(face, ucs4, gi) ((ucs4) >= 0xffffff ? \
(*(gi) = 0), 0 : \
(*(gi) = 1), (ucs4) + 1)
#warning "No FT_Get_Next_Char"
#endif
typedef struct _FcCharEnt {
FcChar16 bmp;
unsigned char encode;
} FcCharEnt;
struct _FcCharMap {
const FcCharEnt *ent;
int nent;
};
typedef struct _FcFontDecode {
FT_Encoding encoding;
const FcCharMap *map;
FcChar32 max;
} FcFontDecode;
static const FcCharEnt AppleRomanEnt[] = {
{ 0x0020, 0x20 },
{ 0x0021, 0x21 },
{ 0x0022, 0x22 },
{ 0x0023, 0x23 },
{ 0x0024, 0x24 },
{ 0x0025, 0x25 },
{ 0x0026, 0x26 },
{ 0x0027, 0x27 },
{ 0x0028, 0x28 },
{ 0x0029, 0x29 },
{ 0x002A, 0x2A },
{ 0x002B, 0x2B },
{ 0x002C, 0x2C },
{ 0x002D, 0x2D },
{ 0x002E, 0x2E },
{ 0x002F, 0x2F },
{ 0x0030, 0x30 },
{ 0x0031, 0x31 },
{ 0x0032, 0x32 },
{ 0x0033, 0x33 },
{ 0x0034, 0x34 },
{ 0x0035, 0x35 },
{ 0x0036, 0x36 },
{ 0x0037, 0x37 },
{ 0x0038, 0x38 },
{ 0x0039, 0x39 },
{ 0x003A, 0x3A },
{ 0x003B, 0x3B },
{ 0x003C, 0x3C },
{ 0x003D, 0x3D },
{ 0x003E, 0x3E },
{ 0x003F, 0x3F },
{ 0x0040, 0x40 },
{ 0x0041, 0x41 },
{ 0x0042, 0x42 },
{ 0x0043, 0x43 },
{ 0x0044, 0x44 },
{ 0x0045, 0x45 },
{ 0x0046, 0x46 },
{ 0x0047, 0x47 },
{ 0x0048, 0x48 },
{ 0x0049, 0x49 },
{ 0x004A, 0x4A },
{ 0x004B, 0x4B },
{ 0x004C, 0x4C },
{ 0x004D, 0x4D },
{ 0x004E, 0x4E },
{ 0x004F, 0x4F },
{ 0x0050, 0x50 },
{ 0x0051, 0x51 },
{ 0x0052, 0x52 },
{ 0x0053, 0x53 },
{ 0x0054, 0x54 },
{ 0x0055, 0x55 },
{ 0x0056, 0x56 },
{ 0x0057, 0x57 },
{ 0x0058, 0x58 },
{ 0x0059, 0x59 },
{ 0x005A, 0x5A },
{ 0x005B, 0x5B },
{ 0x005C, 0x5C },
{ 0x005D, 0x5D },
{ 0x005E, 0x5E },
{ 0x005F, 0x5F },
{ 0x0060, 0x60 },
{ 0x0061, 0x61 },
{ 0x0062, 0x62 },
{ 0x0063, 0x63 },
{ 0x0064, 0x64 },
{ 0x0065, 0x65 },
{ 0x0066, 0x66 },
{ 0x0067, 0x67 },
{ 0x0068, 0x68 },
{ 0x0069, 0x69 },
{ 0x006A, 0x6A },
{ 0x006B, 0x6B },
{ 0x006C, 0x6C },
{ 0x006D, 0x6D },
{ 0x006E, 0x6E },
{ 0x006F, 0x6F },
{ 0x0070, 0x70 },
{ 0x0071, 0x71 },
{ 0x0072, 0x72 },
{ 0x0073, 0x73 },
{ 0x0074, 0x74 },
{ 0x0075, 0x75 },
{ 0x0076, 0x76 },
{ 0x0077, 0x77 },
{ 0x0078, 0x78 },
{ 0x0079, 0x79 },
{ 0x007A, 0x7A },
{ 0x007B, 0x7B },
{ 0x007C, 0x7C },
{ 0x007D, 0x7D },
{ 0x007E, 0x7E },
{ 0x00A0, 0xCA },
{ 0x00A1, 0xC1 },
{ 0x00A2, 0xA2 },
{ 0x00A3, 0xA3 },
{ 0x00A5, 0xB4 },
{ 0x00A7, 0xA4 },
{ 0x00A8, 0xAC },
{ 0x00A9, 0xA9 },
{ 0x00AA, 0xBB },
{ 0x00AB, 0xC7 },
{ 0x00AC, 0xC2 },
{ 0x00AE, 0xA8 },
{ 0x00AF, 0xF8 },
{ 0x00B0, 0xA1 },
{ 0x00B1, 0xB1 },
{ 0x00B4, 0xAB },
{ 0x00B5, 0xB5 },
{ 0x00B6, 0xA6 },
{ 0x00B7, 0xE1 },
{ 0x00B8, 0xFC },
{ 0x00BA, 0xBC },
{ 0x00BB, 0xC8 },
{ 0x00BF, 0xC0 },
{ 0x00C0, 0xCB },
{ 0x00C1, 0xE7 },
{ 0x00C2, 0xE5 },
{ 0x00C3, 0xCC },
{ 0x00C4, 0x80 },
{ 0x00C5, 0x81 },
{ 0x00C6, 0xAE },
{ 0x00C7, 0x82 },
{ 0x00C8, 0xE9 },
{ 0x00C9, 0x83 },
{ 0x00CA, 0xE6 },
{ 0x00CB, 0xE8 },
{ 0x00CC, 0xED },
{ 0x00CD, 0xEA },
{ 0x00CE, 0xEB },
{ 0x00CF, 0xEC },
{ 0x00D1, 0x84 },
{ 0x00D2, 0xF1 },
{ 0x00D3, 0xEE },
{ 0x00D4, 0xEF },
{ 0x00D5, 0xCD },
{ 0x00D6, 0x85 },
{ 0x00D8, 0xAF },
{ 0x00D9, 0xF4 },
{ 0x00DA, 0xF2 },
{ 0x00DB, 0xF3 },
{ 0x00DC, 0x86 },
{ 0x00DF, 0xA7 },
{ 0x00E0, 0x88 },
{ 0x00E1, 0x87 },
{ 0x00E2, 0x89 },
{ 0x00E3, 0x8B },
{ 0x00E4, 0x8A },
{ 0x00E5, 0x8C },
{ 0x00E6, 0xBE },
{ 0x00E7, 0x8D },
{ 0x00E8, 0x8F },
{ 0x00E9, 0x8E },
{ 0x00EA, 0x90 },
{ 0x00EB, 0x91 },
{ 0x00EC, 0x93 },
{ 0x00ED, 0x92 },
{ 0x00EE, 0x94 },
{ 0x00EF, 0x95 },
{ 0x00F1, 0x96 },
{ 0x00F2, 0x98 },
{ 0x00F3, 0x97 },
{ 0x00F4, 0x99 },
{ 0x00F5, 0x9B },
{ 0x00F6, 0x9A },
{ 0x00F7, 0xD6 },
{ 0x00F8, 0xBF },
{ 0x00F9, 0x9D },
{ 0x00FA, 0x9C },
{ 0x00FB, 0x9E },
{ 0x00FC, 0x9F },
{ 0x00FF, 0xD8 },
{ 0x0131, 0xF5 },
{ 0x0152, 0xCE },
{ 0x0153, 0xCF },
{ 0x0178, 0xD9 },
{ 0x0192, 0xC4 },
{ 0x02C6, 0xF6 },
{ 0x02C7, 0xFF },
{ 0x02D8, 0xF9 },
{ 0x02D9, 0xFA },
{ 0x02DA, 0xFB },
{ 0x02DB, 0xFE },
{ 0x02DC, 0xF7 },
{ 0x02DD, 0xFD },
{ 0x03A9, 0xBD },
{ 0x03C0, 0xB9 },
{ 0x2013, 0xD0 },
{ 0x2014, 0xD1 },
{ 0x2018, 0xD4 },
{ 0x2019, 0xD5 },
{ 0x201A, 0xE2 },
{ 0x201C, 0xD2 },
{ 0x201D, 0xD3 },
{ 0x201E, 0xE3 },
{ 0x2020, 0xA0 },
{ 0x2021, 0xE0 },
{ 0x2022, 0xA5 },
{ 0x2026, 0xC9 },
{ 0x2030, 0xE4 },
{ 0x2039, 0xDC },
{ 0x203A, 0xDD },
{ 0x2044, 0xDA },
{ 0x20AC, 0xDB },
{ 0x2122, 0xAA },
{ 0x2202, 0xB6 },
{ 0x2206, 0xC6 },
{ 0x220F, 0xB8 },
{ 0x2211, 0xB7 },
{ 0x221A, 0xC3 },
{ 0x221E, 0xB0 },
{ 0x222B, 0xBA },
{ 0x2248, 0xC5 },
{ 0x2260, 0xAD },
{ 0x2264, 0xB2 },
{ 0x2265, 0xB3 },
{ 0x25CA, 0xD7 },
{ 0xF8FF, 0xF0 },
{ 0xFB01, 0xDE },
{ 0xFB02, 0xDF },
};
static const FcCharMap AppleRoman = {
AppleRomanEnt,
sizeof (AppleRomanEnt) / sizeof (AppleRomanEnt[0])
};
static const FcCharEnt AdobeSymbolEnt[] = {
{ 0x0020, 0x20 },
{ 0x0021, 0x21 },
{ 0x0023, 0x23 },
{ 0x0025, 0x25 },
{ 0x0026, 0x26 },
{ 0x0028, 0x28 },
{ 0x0029, 0x29 },
{ 0x002B, 0x2B },
{ 0x002C, 0x2C },
{ 0x002E, 0x2E },
{ 0x002F, 0x2F },
{ 0x0030, 0x30 },
{ 0x0031, 0x31 },
{ 0x0032, 0x32 },
{ 0x0033, 0x33 },
{ 0x0034, 0x34 },
{ 0x0035, 0x35 },
{ 0x0036, 0x36 },
{ 0x0037, 0x37 },
{ 0x0038, 0x38 },
{ 0x0039, 0x39 },
{ 0x003A, 0x3A },
{ 0x003B, 0x3B },
{ 0x003C, 0x3C },
{ 0x003D, 0x3D },
{ 0x003E, 0x3E },
{ 0x003F, 0x3F },
{ 0x005B, 0x5B },
{ 0x005D, 0x5D },
{ 0x005F, 0x5F },
{ 0x007B, 0x7B },
{ 0x007C, 0x7C },
{ 0x007D, 0x7D },
{ 0x00A0, 0x20 },
{ 0x00AC, 0xD8 },
{ 0x00B0, 0xB0 },
{ 0x00B1, 0xB1 },
{ 0x00B5, 0x6D },
{ 0x00D7, 0xB4 },
{ 0x00F7, 0xB8 },
{ 0x0192, 0xA6 },
{ 0x0391, 0x41 },
{ 0x0392, 0x42 },
{ 0x0393, 0x47 },
{ 0x0394, 0x44 },
{ 0x0395, 0x45 },
{ 0x0396, 0x5A },
{ 0x0397, 0x48 },
{ 0x0398, 0x51 },
{ 0x0399, 0x49 },
{ 0x039A, 0x4B },
{ 0x039B, 0x4C },
{ 0x039C, 0x4D },
{ 0x039D, 0x4E },
{ 0x039E, 0x58 },
{ 0x039F, 0x4F },
{ 0x03A0, 0x50 },
{ 0x03A1, 0x52 },
{ 0x03A3, 0x53 },
{ 0x03A4, 0x54 },
{ 0x03A5, 0x55 },
{ 0x03A6, 0x46 },
{ 0x03A7, 0x43 },
{ 0x03A8, 0x59 },
{ 0x03A9, 0x57 },
{ 0x03B1, 0x61 },
{ 0x03B2, 0x62 },
{ 0x03B3, 0x67 },
{ 0x03B4, 0x64 },
{ 0x03B5, 0x65 },
{ 0x03B6, 0x7A },
{ 0x03B7, 0x68 },
{ 0x03B8, 0x71 },
{ 0x03B9, 0x69 },
{ 0x03BA, 0x6B },
{ 0x03BB, 0x6C },
{ 0x03BC, 0x6D },
{ 0x03BD, 0x6E },
{ 0x03BE, 0x78 },
{ 0x03BF, 0x6F },
{ 0x03C0, 0x70 },
{ 0x03C1, 0x72 },
{ 0x03C2, 0x56 },
{ 0x03C3, 0x73 },
{ 0x03C4, 0x74 },
{ 0x03C5, 0x75 },
{ 0x03C6, 0x66 },
{ 0x03C7, 0x63 },
{ 0x03C8, 0x79 },
{ 0x03C9, 0x77 },
{ 0x03D1, 0x4A },
{ 0x03D2, 0xA1 },
{ 0x03D5, 0x6A },
{ 0x03D6, 0x76 },
{ 0x2022, 0xB7 },
{ 0x2026, 0xBC },
{ 0x2032, 0xA2 },
{ 0x2033, 0xB2 },
{ 0x2044, 0xA4 },
{ 0x20AC, 0xA0 },
{ 0x2111, 0xC1 },
{ 0x2118, 0xC3 },
{ 0x211C, 0xC2 },
{ 0x2126, 0x57 },
{ 0x2135, 0xC0 },
{ 0x2190, 0xAC },
{ 0x2191, 0xAD },
{ 0x2192, 0xAE },
{ 0x2193, 0xAF },
{ 0x2194, 0xAB },
{ 0x21B5, 0xBF },
{ 0x21D0, 0xDC },
{ 0x21D1, 0xDD },
{ 0x21D2, 0xDE },
{ 0x21D3, 0xDF },
{ 0x21D4, 0xDB },
{ 0x2200, 0x22 },
{ 0x2202, 0xB6 },
{ 0x2203, 0x24 },
{ 0x2205, 0xC6 },
{ 0x2206, 0x44 },
{ 0x2207, 0xD1 },
{ 0x2208, 0xCE },
{ 0x2209, 0xCF },
{ 0x220B, 0x27 },
{ 0x220F, 0xD5 },
{ 0x2211, 0xE5 },
{ 0x2212, 0x2D },
{ 0x2215, 0xA4 },
{ 0x2217, 0x2A },
{ 0x221A, 0xD6 },
{ 0x221D, 0xB5 },
{ 0x221E, 0xA5 },
{ 0x2220, 0xD0 },
{ 0x2227, 0xD9 },
{ 0x2228, 0xDA },
{ 0x2229, 0xC7 },
{ 0x222A, 0xC8 },
{ 0x222B, 0xF2 },
{ 0x2234, 0x5C },
{ 0x223C, 0x7E },
{ 0x2245, 0x40 },
{ 0x2248, 0xBB },
{ 0x2260, 0xB9 },
{ 0x2261, 0xBA },
{ 0x2264, 0xA3 },
{ 0x2265, 0xB3 },
{ 0x2282, 0xCC },
{ 0x2283, 0xC9 },
{ 0x2284, 0xCB },
{ 0x2286, 0xCD },
{ 0x2287, 0xCA },
{ 0x2295, 0xC5 },
{ 0x2297, 0xC4 },
{ 0x22A5, 0x5E },
{ 0x22C5, 0xD7 },
{ 0x2320, 0xF3 },
{ 0x2321, 0xF5 },
{ 0x2329, 0xE1 },
{ 0x232A, 0xF1 },
{ 0x25CA, 0xE0 },
{ 0x2660, 0xAA },
{ 0x2663, 0xA7 },
{ 0x2665, 0xA9 },
{ 0x2666, 0xA8 },
{ 0xF6D9, 0xD3 },
{ 0xF6DA, 0xD2 },
{ 0xF6DB, 0xD4 },
{ 0xF8E5, 0x60 },
{ 0xF8E6, 0xBD },
{ 0xF8E7, 0xBE },
{ 0xF8E8, 0xE2 },
{ 0xF8E9, 0xE3 },
{ 0xF8EA, 0xE4 },
{ 0xF8EB, 0xE6 },
{ 0xF8EC, 0xE7 },
{ 0xF8ED, 0xE8 },
{ 0xF8EE, 0xE9 },
{ 0xF8EF, 0xEA },
{ 0xF8F0, 0xEB },
{ 0xF8F1, 0xEC },
{ 0xF8F2, 0xED },
{ 0xF8F3, 0xEE },
{ 0xF8F4, 0xEF },
{ 0xF8F5, 0xF4 },
{ 0xF8F6, 0xF6 },
{ 0xF8F7, 0xF7 },
{ 0xF8F8, 0xF8 },
{ 0xF8F9, 0xF9 },
{ 0xF8FA, 0xFA },
{ 0xF8FB, 0xFB },
{ 0xF8FC, 0xFC },
{ 0xF8FD, 0xFD },
{ 0xF8FE, 0xFE },
};
static const FcCharMap AdobeSymbol = {
AdobeSymbolEnt,
sizeof (AdobeSymbolEnt) / sizeof (AdobeSymbolEnt[0]),
};
static const FcFontDecode fcFontDecoders[] = {
{ ft_encoding_unicode, 0, (1 << 21) - 1 },
{ ft_encoding_symbol, &AdobeSymbol, (1 << 16) - 1 },
{ ft_encoding_apple_roman, &AppleRoman, (1 << 16) - 1 },
};
#define NUM_DECODE (sizeof (fcFontDecoders) / sizeof (fcFontDecoders[0]))
FcChar32
FcFreeTypeUcs4ToPrivate (FcChar32 ucs4, const FcCharMap *map)
{
int low, high, mid;
FcChar16 bmp;
low = 0;
high = map->nent - 1;
if (ucs4 < map->ent[low].bmp || map->ent[high].bmp < ucs4)
return ~0;
while (low <= high)
{
mid = (high + low) >> 1;
bmp = map->ent[mid].bmp;
if (ucs4 == bmp)
return (FT_ULong) map->ent[mid].encode;
if (ucs4 < bmp)
high = mid - 1;
else
low = mid + 1;
}
return ~0;
}
FcChar32
FcFreeTypePrivateToUcs4 (FcChar32 private, const FcCharMap *map)
{
int i;
for (i = 0; i < map->nent; i++)
if (map->ent[i].encode == private)
return (FcChar32) map->ent[i].bmp;
return ~0;
}
const FcCharMap *
FcFreeTypeGetPrivateMap (FT_Encoding encoding)
{
int i;
for (i = 0; i < NUM_DECODE; i++)
if (fcFontDecoders[i].encoding == encoding)
return fcFontDecoders[i].map;
return 0;
}
FT_UInt
FcFreeTypeCharIndex (FT_Face face, FcChar32 ucs4)
{
int initial, offset, decode;
FT_UInt glyphindex;
FcChar32 charcode;
initial = 0;
if (face->charmap)
{
for (; initial < NUM_DECODE; initial++)
if (fcFontDecoders[initial].encoding == face->charmap->encoding)
break;
if (initial == NUM_DECODE)
initial = 0;
}
for (offset = 0; offset < NUM_DECODE; offset++)
{
decode = (initial + offset) % NUM_DECODE;
if (!face->charmap || face->charmap->encoding != fcFontDecoders[decode].encoding)
if (FT_Select_Charmap (face, fcFontDecoders[decode].encoding) != 0)
continue;
if (fcFontDecoders[decode].map)
{
charcode = FcFreeTypeUcs4ToPrivate (ucs4, fcFontDecoders[decode].map);
if (charcode == ~0)
continue;
}
else
charcode = ucs4;
glyphindex = FT_Get_Char_Index (face, (FT_ULong) charcode);
if (glyphindex)
return glyphindex;
}
return 0;
}
static FcBool
FcFreeTypeCheckGlyph (FT_Face face, FcChar32 ucs4,
FT_UInt glyph, FcBlanks *blanks)
{
FT_Int load_flags = FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
FT_GlyphSlot slot;
if (face->face_flags & FT_FACE_FLAG_SCALABLE)
load_flags |= FT_LOAD_NO_BITMAP;
if (FT_Load_Glyph (face, glyph, load_flags))
return FcFalse;
slot = face->glyph;
if (!glyph)
return FcFalse;
switch (slot->format) {
case ft_glyph_format_bitmap:
return FcTrue;
case ft_glyph_format_outline:
if (slot->outline.n_contours != 0)
return FcTrue;
if (!blanks || FcBlanksIsMember (blanks, ucs4))
return FcTrue;
default:
break;
}
return FcFalse;
}
FcCharSet *
FcFreeTypeCharSet (FT_Face face, FcBlanks *blanks)
{
FcChar32 page, off, ucs4;
#ifdef CHECK
FcChar32 font_max = 0;
#endif
FcCharSet *fcs;
FcCharLeaf *leaf;
const FcCharMap *map;
int o;
int i;
FT_UInt glyph;
fcs = FcCharSetCreate ();
if (!fcs)
goto bail0;
for (o = 0; o < NUM_DECODE; o++)
{
if (FT_Select_Charmap (face, fcFontDecoders[o].encoding) != 0)
continue;
map = fcFontDecoders[o].map;
if (map)
{
for (i = 0; i < map->nent; i++)
{
ucs4 = map->ent[i].bmp;
glyph = FT_Get_Char_Index (face, map->ent[i].encode);
if (glyph && FcFreeTypeCheckGlyph (face, ucs4, glyph, blanks))
{
leaf = FcCharSetFindLeafCreate (fcs, ucs4);
if (!leaf)
goto bail1;
leaf->map[(ucs4 & 0xff) >> 5] |= (1 << (ucs4 & 0x1f));
#ifdef CHECK
if (ucs4 > font_max)
font_max = ucs4;
#endif
}
}
}
else
{
FT_UInt gindex;
if (FT_Get_Char_Index (face, 0))
{
ucs4 = 0;
gindex = 1;
}
else
{
ucs4 = FT_Get_Next_Char (face, 0, &gindex);
if (!ucs4)
gindex = 0;
}
while (gindex)
{
page = ucs4 >> 8;
leaf = 0;
while ((ucs4 >> 8) == page)
{
glyph = FT_Get_Char_Index (face, ucs4);
if (glyph && FcFreeTypeCheckGlyph (face, ucs4,
glyph, blanks))
{
if (!leaf)
{
leaf = FcCharSetFindLeafCreate (fcs, ucs4);
if (!leaf)
goto bail1;
}
off = ucs4 & 0xff;
leaf->map[off >> 5] |= (1 << (off & 0x1f));
#ifdef CHECK
if (ucs4 > font_max)
font_max = ucs4;
#endif
}
ucs4++;
}
ucs4 = FT_Get_Next_Char (face, ucs4 - 1, &gindex);
if (!ucs4)
gindex = 0;
}
#ifdef CHECK
for (ucs4 = 0; ucs4 < 0x10000; ucs4++)
{
FcBool FT_Has, FC_Has;
FT_Has = FT_Get_Char_Index (face, ucs4) != 0;
FC_Has = FcCharSetHasChar (fcs, ucs4);
if (FT_Has != FC_Has)
{
printf ("0x%08x FT says %d FC says %d\n", ucs4, FT_Has, FC_Has);
}
}
#endif
}
}
#ifdef CHECK
printf ("%d glyphs %d encoded\n", (int) face->num_glyphs, FcCharSetCount (fcs));
for (ucs4 = 0; ucs4 <= font_max; ucs4++)
{
FcBool has_char = FcFreeTypeCharIndex (face, ucs4) != 0;
FcBool has_bit = FcCharSetHasChar (fcs, ucs4);
if (has_char && !has_bit)
printf ("Bitmap missing char 0x%x\n", ucs4);
else if (!has_char && has_bit)
printf ("Bitmap extra char 0x%x\n", ucs4);
}
#endif
return fcs;
bail1:
FcCharSetDestroy (fcs);
bail0:
return 0;
}