/*
- * $XFree86: xc/lib/fontconfig/src/fccharset.c,v 1.6 2002/03/27 04:33:55 keithp Exp $
+ * fontconfig/src/fccharset.c
*
- * Copyright © 2001 Keith Packard, member of The XFree86 Project, Inc.
+ * 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
* representations about the suitability of this software for any purpose. It
* is provided "as is" without express or implied warranty.
*
- * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * 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 <stdlib.h>
#include "fcint.h"
+#include <stdlib.h>
/* #define CHECK */
-static int
-FcCharSetLevels (FcChar32 ucs4)
-{
- if (ucs4 <= 0xff)
- return 1;
- if (ucs4 <= 0xffff)
- return 2;
- if (ucs4 <= 0xffffff)
- return 3;
- return 4;
-}
-
-static FcBool
-FcCharSetCheckLevel (FcCharSet *fcs, FcChar32 ucs4)
-{
- int level = FcCharSetLevels (ucs4);
-
- if (level <= fcs->levels)
- return FcTrue;
- while (fcs->levels < level)
- {
- if (fcs->levels == 0)
- {
- FcCharLeaf *leaf;
-
- leaf = (FcCharLeaf *) calloc (1, sizeof (FcCharLeaf));
- if (!leaf)
- return FcFalse;
- FcMemAlloc (FC_MEM_CHARNODE, sizeof (FcCharLeaf));
- fcs->node.leaf = leaf;
- }
- else
- {
- FcCharBranch *branch;
-
- branch = (FcCharBranch *) calloc (1, sizeof (FcCharBranch));
- if (!branch)
- return FcFalse;
- FcMemAlloc (FC_MEM_CHARNODE, sizeof (FcCharBranch));
- branch->nodes[0] = fcs->node;
- fcs->node.branch = branch;
- }
- ++fcs->levels;
- }
- return FcTrue;
-}
-
FcCharSet *
FcCharSetCreate (void)
{
return 0;
FcMemAlloc (FC_MEM_CHARSET, sizeof (FcCharSet));
fcs->ref = 1;
- fcs->levels = 0;
- fcs->node.leaf = 0;
- fcs->constant = FcFalse;
+ fcs->num = 0;
+ fcs->leaves_offset = 0;
+ fcs->numbers_offset = 0;
return fcs;
}
-FcCharSet *
-FcCharSetNew (void);
-
FcCharSet *
FcCharSetNew (void)
{
return FcCharSetCreate ();
}
-static void
-FcCharNodeDestroy (FcCharNode node, int level)
+void
+FcCharSetDestroy (FcCharSet *fcs)
{
- int i;
-
- switch (level) {
- case 0:
- break;
- case 1:
- FcMemFree (FC_MEM_CHARNODE, sizeof (FcCharLeaf));
- free (node.leaf);
- break;
- default:
- for (i = 0; i < 256; i++)
- if (node.branch->nodes[i].branch)
- FcCharNodeDestroy (node.branch->nodes[i], level - 1);
- FcMemFree (FC_MEM_CHARNODE, sizeof (FcCharBranch));
- free (node.branch);
+ int i;
+
+ if (fcs->ref == FC_REF_CONSTANT)
+ {
+ FcCacheObjectDereference (fcs);
+ return;
+ }
+ if (--fcs->ref > 0)
+ return;
+ for (i = 0; i < fcs->num; i++)
+ {
+ FcMemFree (FC_MEM_CHARLEAF, sizeof (FcCharLeaf));
+ free (FcCharSetLeaf (fcs, i));
+ }
+ if (fcs->num)
+ {
+ /* the numbers here are estimates */
+ FcMemFree (FC_MEM_CHARSET, fcs->num * sizeof (intptr_t));
+ free (FcCharSetLeaves (fcs));
+ FcMemFree (FC_MEM_CHARSET, fcs->num * sizeof (FcChar16));
+ free (FcCharSetNumbers (fcs));
}
+ FcMemFree (FC_MEM_CHARSET, sizeof (FcCharSet));
+ free (fcs);
}
-void
-FcCharSetDestroy (FcCharSet *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)
{
- if (fcs->constant)
- return;
- if (--fcs->ref <= 0)
+ FcChar16 *numbers = FcCharSetNumbers(fcs);
+ FcChar16 page;
+ int low = start;
+ int high = fcs->num - 1;
+
+ if (!numbers)
+ return -1;
+ while (low <= high)
{
- FcCharNodeDestroy (fcs->node, fcs->levels);
- FcMemFree (FC_MEM_CHARSET, sizeof (FcCharSet));
- free (fcs);
+ 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, returning
- * null if it doesn't exist
+ * 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 l;
- const FcCharNode *prev;
- FcCharNode node;
- FcChar32 i;
-
- prev = &fcs->node;
- l = fcs->levels;
- while (--l > 0)
+ 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))
{
- node = *prev;
- if (!node.branch)
- return 0;
- i = (ucs4 >> (l << 3)) & 0xff;
- prev = &node.branch->nodes[i];
+ if (!fcs->num)
+ {
+ unsigned int alloced = 8;
+ leaves = malloc (alloced * sizeof (*leaves));
+ numbers = malloc (alloced * sizeof (*numbers));
+ FcMemAlloc (FC_MEM_CHARSET, alloced * sizeof (*leaves));
+ FcMemAlloc (FC_MEM_CHARSET, alloced * sizeof (*numbers));
+ }
+ else
+ {
+ unsigned int alloced = fcs->num;
+ intptr_t *new_leaves, distance;
+
+ FcMemFree (FC_MEM_CHARSET, alloced * sizeof (*leaves));
+ FcMemFree (FC_MEM_CHARSET, alloced * sizeof (*numbers));
+
+ alloced *= 2;
+ new_leaves = realloc (leaves, alloced * sizeof (*leaves));
+ numbers = realloc (numbers, alloced * sizeof (*numbers));
+
+ FcMemAlloc (FC_MEM_CHARSET, alloced * sizeof (*leaves));
+ FcMemAlloc (FC_MEM_CHARSET, alloced * sizeof (*numbers));
+
+ 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;
+ }
+
+ if (!leaves || !numbers)
+ return FcFalse;
+
+ fcs->leaves_offset = FcPtrToOffset (fcs, leaves);
+ fcs->numbers_offset = FcPtrToOffset (fcs, numbers);
}
- return prev->leaf;
+
+ 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;
}
/*
* if desired
*/
-static FcCharLeaf *
+FcCharLeaf *
FcCharSetFindLeafCreate (FcCharSet *fcs, FcChar32 ucs4)
{
- int l;
- FcCharNode *prev, node;
- FcChar32 i;
+ int pos;
+ FcCharLeaf *leaf;
- if (!FcCharSetCheckLevel (fcs, ucs4))
- return FcFalse;
- prev = &fcs->node;
- l = fcs->levels;
- while (--l > 0)
+ 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))
{
- node = *prev;
- if (!node.branch)
- {
- node.branch = calloc (1, sizeof (FcCharBranch));
- if (!node.branch)
- return 0;
- FcMemAlloc (FC_MEM_CHARNODE, sizeof (FcCharBranch));
- *prev = node;
- }
- i = (ucs4 >> (l << 3)) & 0xff;
- prev = &node.branch->nodes[i];
+ free (leaf);
+ return 0;
}
- node = *prev;
- if (!node.leaf)
+ 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)
{
- node.leaf = calloc (1, sizeof (FcCharLeaf));
- if (!node.leaf)
- return 0;
- FcMemAlloc (FC_MEM_CHARNODE, sizeof (FcCharLeaf));
- *prev = node;
+ FcMemFree (FC_MEM_CHARLEAF, sizeof (FcCharLeaf));
+ free (FcCharSetLeaf (fcs, pos));
+ FcCharSetLeaves(fcs)[pos] = FcPtrToOffset (FcCharSetLeaves(fcs),
+ leaf);
+ return FcTrue;
}
- return node.leaf;
+ pos = -pos - 1;
+ return FcCharSetPutLeaf (fcs, ucs4, leaf, pos);
}
FcBool
FcCharLeaf *leaf;
FcChar32 *b;
- if (fcs->constant)
+ if (fcs->ref == FC_REF_CONSTANT)
return FcFalse;
leaf = FcCharSetFindLeafCreate (fcs, ucs4);
if (!leaf)
typedef struct _fcCharSetIter {
FcCharLeaf *leaf;
FcChar32 ucs4;
+ int pos;
} FcCharSetIter;
/*
- * Find the nearest leaf at or beyond *ucs4, return 0 if no leaf
- * exists
+ * Set iter->leaf to the leaf containing iter->ucs4 or higher
*/
-static FcCharLeaf *
-FcCharSetIterLeaf (FcCharNode node, int level, FcChar32 *ucs4)
+
+static void
+FcCharSetIterSet (const FcCharSet *fcs, FcCharSetIter *iter)
{
- if (level <= 1)
- return node.leaf;
- else if (!node.branch)
- return 0;
- else
- {
- int shift = ((level - 1) << 3);
- FcChar32 inc = 1 << shift;
- FcChar32 mask = ~(inc - 1);
- FcChar32 byte = (*ucs4 >> shift) & 0xff;
- FcCharLeaf *leaf;
+ int pos = FcCharSetFindLeafPos (fcs, iter->ucs4);
- for (;;)
+ if (pos < 0)
+ {
+ pos = -pos - 1;
+ if (pos == fcs->num)
{
- leaf = FcCharSetIterLeaf (node.branch->nodes[byte],
- level - 1,
- ucs4);
- if (leaf)
- break;
- /* step to next branch, resetting lower indices */
- *ucs4 = (*ucs4 & mask) + inc;
- byte = (byte + 1) & 0xff;
- if (byte == 0)
- break;
+ iter->ucs4 = ~0;
+ iter->leaf = 0;
+ return;
}
- return leaf;
+ iter->ucs4 = (FcChar32) FcCharSetNumbers(fcs)[pos] << 8;
}
+ iter->leaf = FcCharSetLeaf(fcs, pos);
+ iter->pos = pos;
}
static void
-FcCharSetIterSet (const FcCharSet *fcs, FcCharSetIter *iter)
+FcCharSetIterNext (const FcCharSet *fcs, FcCharSetIter *iter)
{
- if (FcCharSetLevels (iter->ucs4) > fcs->levels)
+ int pos = iter->pos + 1;
+ if (pos >= fcs->num)
+ {
+ iter->ucs4 = ~0;
iter->leaf = 0;
+ }
else
- iter->leaf = FcCharSetIterLeaf (fcs->node, fcs->levels,
- &iter->ucs4);
- if (!iter->leaf)
- iter->ucs4 = ~0;
+ {
+ iter->ucs4 = (FcChar32) FcCharSetNumbers(fcs)[pos] << 8;
+ iter->leaf = FcCharSetLeaf(fcs, pos);
+ iter->pos = pos;
+ }
}
-static void
-FcCharSetIterNext (const FcCharSet *fcs, FcCharSetIter *iter)
-{
- iter->ucs4 += 0x100;
- FcCharSetIterSet (fcs, iter);
-}
static void
FcCharSetIterStart (const FcCharSet *fcs, FcCharSetIter *iter)
{
iter->ucs4 = 0;
+ iter->pos = 0;
FcCharSetIterSet (fcs, iter);
}
FcCharSet *
FcCharSetCopy (FcCharSet *src)
{
- src->ref++;
+ if (src->ref != FC_REF_CONSTANT)
+ src->ref++;
+ else
+ FcCacheObjectReference (src);
return src;
}
goto bail0;
FcCharSetIterStart (a, &ai);
FcCharSetIterStart (b, &bi);
- while ((ai.leaf || bonly) && (bi.leaf || aonly))
+ while ((ai.leaf || (bonly && bi.leaf)) && (bi.leaf || (aonly && ai.leaf)))
{
if (ai.ucs4 < bi.ucs4)
{
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->ref == FC_REF_CONSTANT) {
+ 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,
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
int i = 256/32;
if (ai.ucs4 == bi.ucs4)
{
- FcChar32 *bm = bi.leaf->map;;
+ FcChar32 *bm = bi.leaf->map;
while (i--)
count += FcCharSetPopCount (*am++ & ~*bm++);
}
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;
+ 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
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;
+}
+
/*
* ASCII representation of charsets.
*
* it's not exactly human readable output. As a special case, 0 is encoded as a space
*/
-static unsigned char charToValue[256] = {
+static const unsigned char charToValue[256] = {
/* "" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
/* "\b" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
/* "\020" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
/* "\370" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
};
-static FcChar8 valueToChar[0x55] = {
+static const FcChar8 valueToChar[0x55] = {
/* 0x00 */ '!', '#', '$', '%', '&', '(', ')', '*',
/* 0x08 */ '+', '.', '/', '0', '1', '2', '3', '4',
/* 0x10 */ '5', '6', '7', '8', '9', ';', '<', '>',
FcCharSet *c;
FcChar32 ucs4;
FcCharLeaf *leaf;
+ FcCharLeaf temp;
+ FcChar32 bits;
int i;
c = FcCharSetCreate ();
string = FcCharSetParseValue (string, &ucs4);
if (!string)
goto bail1;
- leaf = FcCharSetFindLeafCreate (c, ucs4);
- if (!leaf)
- goto bail1;
+ bits = 0;
for (i = 0; i < 256/32; i++)
{
- string = FcCharSetParseValue (string, &leaf->map[i]);
+ string = FcCharSetParseValue (string, &temp.map[i]);
if (!string)
goto bail1;
+ bits |= temp.map[i];
+ }
+ if (bits)
+ {
+ leaf = malloc (sizeof (FcCharLeaf));
+ if (!leaf)
+ goto bail1;
+ *leaf = temp;
+ if (!FcCharSetInsertLeaf (c, ucs4, leaf))
+ goto bail1;
}
}
return c;
bail1:
- FcCharSetDestroy (c);
+ if (c->num)
+ {
+ FcMemFree (FC_MEM_CHARSET, c->num * sizeof (FcCharLeaf *));
+ free (FcCharSetLeaves (c));
+ }
+ if (c->num)
+ {
+ FcMemFree (FC_MEM_CHARSET, c->num * sizeof (FcChar16));
+ free (FcCharSetNumbers (c));
+ }
+ FcMemFree (FC_MEM_CHARSET, sizeof (FcCharSet));
+ free (c);
bail0:
- return 0;
+ return NULL;
}
FcBool
return FcTrue;
}
-#include <freetype/freetype.h>
-#include <fontconfig/fcfreetype.h>
+typedef struct _FcCharLeafEnt FcCharLeafEnt;
-/*
- * Figure out whether the available freetype has FT_Get_Next_Char
- */
+struct _FcCharLeafEnt {
+ FcCharLeafEnt *next;
+ FcChar32 hash;
+ FcCharLeaf leaf;
+};
-#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
+#define FC_CHAR_LEAF_BLOCK (4096 / sizeof (FcCharLeafEnt))
+#define FC_CHAR_LEAF_HASH_SIZE 257
-/*
- * For our purposes, this approximation is sufficient
- */
-#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 _FcCharSetEnt FcCharSetEnt;
-typedef struct _FcCharEnt {
- FcChar16 bmp;
- unsigned char encode;
-} FcCharEnt;
-
-typedef struct _FcCharMap {
- const FcCharEnt *ent;
- int nent;
-} FcCharMap;
-
-typedef struct _FcFontDecode {
- FT_Encoding encoding;
- const FcCharMap *map;
- FcChar32 max;
-} FcFontDecode;
-
-static const FcCharEnt AppleRomanEnt[] = {
- { 0x0020, 0x20 }, /* SPACE */
- { 0x0021, 0x21 }, /* EXCLAMATION MARK */
- { 0x0022, 0x22 }, /* QUOTATION MARK */
- { 0x0023, 0x23 }, /* NUMBER SIGN */
- { 0x0024, 0x24 }, /* DOLLAR SIGN */
- { 0x0025, 0x25 }, /* PERCENT SIGN */
- { 0x0026, 0x26 }, /* AMPERSAND */
- { 0x0027, 0x27 }, /* APOSTROPHE */
- { 0x0028, 0x28 }, /* LEFT PARENTHESIS */
- { 0x0029, 0x29 }, /* RIGHT PARENTHESIS */
- { 0x002A, 0x2A }, /* ASTERISK */
- { 0x002B, 0x2B }, /* PLUS SIGN */
- { 0x002C, 0x2C }, /* COMMA */
- { 0x002D, 0x2D }, /* HYPHEN-MINUS */
- { 0x002E, 0x2E }, /* FULL STOP */
- { 0x002F, 0x2F }, /* SOLIDUS */
- { 0x0030, 0x30 }, /* DIGIT ZERO */
- { 0x0031, 0x31 }, /* DIGIT ONE */
- { 0x0032, 0x32 }, /* DIGIT TWO */
- { 0x0033, 0x33 }, /* DIGIT THREE */
- { 0x0034, 0x34 }, /* DIGIT FOUR */
- { 0x0035, 0x35 }, /* DIGIT FIVE */
- { 0x0036, 0x36 }, /* DIGIT SIX */
- { 0x0037, 0x37 }, /* DIGIT SEVEN */
- { 0x0038, 0x38 }, /* DIGIT EIGHT */
- { 0x0039, 0x39 }, /* DIGIT NINE */
- { 0x003A, 0x3A }, /* COLON */
- { 0x003B, 0x3B }, /* SEMICOLON */
- { 0x003C, 0x3C }, /* LESS-THAN SIGN */
- { 0x003D, 0x3D }, /* EQUALS SIGN */
- { 0x003E, 0x3E }, /* GREATER-THAN SIGN */
- { 0x003F, 0x3F }, /* QUESTION MARK */
- { 0x0040, 0x40 }, /* COMMERCIAL AT */
- { 0x0041, 0x41 }, /* LATIN CAPITAL LETTER A */
- { 0x0042, 0x42 }, /* LATIN CAPITAL LETTER B */
- { 0x0043, 0x43 }, /* LATIN CAPITAL LETTER C */
- { 0x0044, 0x44 }, /* LATIN CAPITAL LETTER D */
- { 0x0045, 0x45 }, /* LATIN CAPITAL LETTER E */
- { 0x0046, 0x46 }, /* LATIN CAPITAL LETTER F */
- { 0x0047, 0x47 }, /* LATIN CAPITAL LETTER G */
- { 0x0048, 0x48 }, /* LATIN CAPITAL LETTER H */
- { 0x0049, 0x49 }, /* LATIN CAPITAL LETTER I */
- { 0x004A, 0x4A }, /* LATIN CAPITAL LETTER J */
- { 0x004B, 0x4B }, /* LATIN CAPITAL LETTER K */
- { 0x004C, 0x4C }, /* LATIN CAPITAL LETTER L */
- { 0x004D, 0x4D }, /* LATIN CAPITAL LETTER M */
- { 0x004E, 0x4E }, /* LATIN CAPITAL LETTER N */
- { 0x004F, 0x4F }, /* LATIN CAPITAL LETTER O */
- { 0x0050, 0x50 }, /* LATIN CAPITAL LETTER P */
- { 0x0051, 0x51 }, /* LATIN CAPITAL LETTER Q */
- { 0x0052, 0x52 }, /* LATIN CAPITAL LETTER R */
- { 0x0053, 0x53 }, /* LATIN CAPITAL LETTER S */
- { 0x0054, 0x54 }, /* LATIN CAPITAL LETTER T */
- { 0x0055, 0x55 }, /* LATIN CAPITAL LETTER U */
- { 0x0056, 0x56 }, /* LATIN CAPITAL LETTER V */
- { 0x0057, 0x57 }, /* LATIN CAPITAL LETTER W */
- { 0x0058, 0x58 }, /* LATIN CAPITAL LETTER X */
- { 0x0059, 0x59 }, /* LATIN CAPITAL LETTER Y */
- { 0x005A, 0x5A }, /* LATIN CAPITAL LETTER Z */
- { 0x005B, 0x5B }, /* LEFT SQUARE BRACKET */
- { 0x005C, 0x5C }, /* REVERSE SOLIDUS */
- { 0x005D, 0x5D }, /* RIGHT SQUARE BRACKET */
- { 0x005E, 0x5E }, /* CIRCUMFLEX ACCENT */
- { 0x005F, 0x5F }, /* LOW LINE */
- { 0x0060, 0x60 }, /* GRAVE ACCENT */
- { 0x0061, 0x61 }, /* LATIN SMALL LETTER A */
- { 0x0062, 0x62 }, /* LATIN SMALL LETTER B */
- { 0x0063, 0x63 }, /* LATIN SMALL LETTER C */
- { 0x0064, 0x64 }, /* LATIN SMALL LETTER D */
- { 0x0065, 0x65 }, /* LATIN SMALL LETTER E */
- { 0x0066, 0x66 }, /* LATIN SMALL LETTER F */
- { 0x0067, 0x67 }, /* LATIN SMALL LETTER G */
- { 0x0068, 0x68 }, /* LATIN SMALL LETTER H */
- { 0x0069, 0x69 }, /* LATIN SMALL LETTER I */
- { 0x006A, 0x6A }, /* LATIN SMALL LETTER J */
- { 0x006B, 0x6B }, /* LATIN SMALL LETTER K */
- { 0x006C, 0x6C }, /* LATIN SMALL LETTER L */
- { 0x006D, 0x6D }, /* LATIN SMALL LETTER M */
- { 0x006E, 0x6E }, /* LATIN SMALL LETTER N */
- { 0x006F, 0x6F }, /* LATIN SMALL LETTER O */
- { 0x0070, 0x70 }, /* LATIN SMALL LETTER P */
- { 0x0071, 0x71 }, /* LATIN SMALL LETTER Q */
- { 0x0072, 0x72 }, /* LATIN SMALL LETTER R */
- { 0x0073, 0x73 }, /* LATIN SMALL LETTER S */
- { 0x0074, 0x74 }, /* LATIN SMALL LETTER T */
- { 0x0075, 0x75 }, /* LATIN SMALL LETTER U */
- { 0x0076, 0x76 }, /* LATIN SMALL LETTER V */
- { 0x0077, 0x77 }, /* LATIN SMALL LETTER W */
- { 0x0078, 0x78 }, /* LATIN SMALL LETTER X */
- { 0x0079, 0x79 }, /* LATIN SMALL LETTER Y */
- { 0x007A, 0x7A }, /* LATIN SMALL LETTER Z */
- { 0x007B, 0x7B }, /* LEFT CURLY BRACKET */
- { 0x007C, 0x7C }, /* VERTICAL LINE */
- { 0x007D, 0x7D }, /* RIGHT CURLY BRACKET */
- { 0x007E, 0x7E }, /* TILDE */
- { 0x00A0, 0xCA }, /* NO-BREAK SPACE */
- { 0x00A1, 0xC1 }, /* INVERTED EXCLAMATION MARK */
- { 0x00A2, 0xA2 }, /* CENT SIGN */
- { 0x00A3, 0xA3 }, /* POUND SIGN */
- { 0x00A5, 0xB4 }, /* YEN SIGN */
- { 0x00A7, 0xA4 }, /* SECTION SIGN */
- { 0x00A8, 0xAC }, /* DIAERESIS */
- { 0x00A9, 0xA9 }, /* COPYRIGHT SIGN */
- { 0x00AA, 0xBB }, /* FEMININE ORDINAL INDICATOR */
- { 0x00AB, 0xC7 }, /* LEFT-POINTING DOUBLE ANGLE QUOTATION MARK */
- { 0x00AC, 0xC2 }, /* NOT SIGN */
- { 0x00AE, 0xA8 }, /* REGISTERED SIGN */
- { 0x00AF, 0xF8 }, /* MACRON */
- { 0x00B0, 0xA1 }, /* DEGREE SIGN */
- { 0x00B1, 0xB1 }, /* PLUS-MINUS SIGN */
- { 0x00B4, 0xAB }, /* ACUTE ACCENT */
- { 0x00B5, 0xB5 }, /* MICRO SIGN */
- { 0x00B6, 0xA6 }, /* PILCROW SIGN */
- { 0x00B7, 0xE1 }, /* MIDDLE DOT */
- { 0x00B8, 0xFC }, /* CEDILLA */
- { 0x00BA, 0xBC }, /* MASCULINE ORDINAL INDICATOR */
- { 0x00BB, 0xC8 }, /* RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK */
- { 0x00BF, 0xC0 }, /* INVERTED QUESTION MARK */
- { 0x00C0, 0xCB }, /* LATIN CAPITAL LETTER A WITH GRAVE */
- { 0x00C1, 0xE7 }, /* LATIN CAPITAL LETTER A WITH ACUTE */
- { 0x00C2, 0xE5 }, /* LATIN CAPITAL LETTER A WITH CIRCUMFLEX */
- { 0x00C3, 0xCC }, /* LATIN CAPITAL LETTER A WITH TILDE */
- { 0x00C4, 0x80 }, /* LATIN CAPITAL LETTER A WITH DIAERESIS */
- { 0x00C5, 0x81 }, /* LATIN CAPITAL LETTER A WITH RING ABOVE */
- { 0x00C6, 0xAE }, /* LATIN CAPITAL LETTER AE */
- { 0x00C7, 0x82 }, /* LATIN CAPITAL LETTER C WITH CEDILLA */
- { 0x00C8, 0xE9 }, /* LATIN CAPITAL LETTER E WITH GRAVE */
- { 0x00C9, 0x83 }, /* LATIN CAPITAL LETTER E WITH ACUTE */
- { 0x00CA, 0xE6 }, /* LATIN CAPITAL LETTER E WITH CIRCUMFLEX */
- { 0x00CB, 0xE8 }, /* LATIN CAPITAL LETTER E WITH DIAERESIS */
- { 0x00CC, 0xED }, /* LATIN CAPITAL LETTER I WITH GRAVE */
- { 0x00CD, 0xEA }, /* LATIN CAPITAL LETTER I WITH ACUTE */
- { 0x00CE, 0xEB }, /* LATIN CAPITAL LETTER I WITH CIRCUMFLEX */
- { 0x00CF, 0xEC }, /* LATIN CAPITAL LETTER I WITH DIAERESIS */
- { 0x00D1, 0x84 }, /* LATIN CAPITAL LETTER N WITH TILDE */
- { 0x00D2, 0xF1 }, /* LATIN CAPITAL LETTER O WITH GRAVE */
- { 0x00D3, 0xEE }, /* LATIN CAPITAL LETTER O WITH ACUTE */
- { 0x00D4, 0xEF }, /* LATIN CAPITAL LETTER O WITH CIRCUMFLEX */
- { 0x00D5, 0xCD }, /* LATIN CAPITAL LETTER O WITH TILDE */
- { 0x00D6, 0x85 }, /* LATIN CAPITAL LETTER O WITH DIAERESIS */
- { 0x00D8, 0xAF }, /* LATIN CAPITAL LETTER O WITH STROKE */
- { 0x00D9, 0xF4 }, /* LATIN CAPITAL LETTER U WITH GRAVE */
- { 0x00DA, 0xF2 }, /* LATIN CAPITAL LETTER U WITH ACUTE */
- { 0x00DB, 0xF3 }, /* LATIN CAPITAL LETTER U WITH CIRCUMFLEX */
- { 0x00DC, 0x86 }, /* LATIN CAPITAL LETTER U WITH DIAERESIS */
- { 0x00DF, 0xA7 }, /* LATIN SMALL LETTER SHARP S */
- { 0x00E0, 0x88 }, /* LATIN SMALL LETTER A WITH GRAVE */
- { 0x00E1, 0x87 }, /* LATIN SMALL LETTER A WITH ACUTE */
- { 0x00E2, 0x89 }, /* LATIN SMALL LETTER A WITH CIRCUMFLEX */
- { 0x00E3, 0x8B }, /* LATIN SMALL LETTER A WITH TILDE */
- { 0x00E4, 0x8A }, /* LATIN SMALL LETTER A WITH DIAERESIS */
- { 0x00E5, 0x8C }, /* LATIN SMALL LETTER A WITH RING ABOVE */
- { 0x00E6, 0xBE }, /* LATIN SMALL LETTER AE */
- { 0x00E7, 0x8D }, /* LATIN SMALL LETTER C WITH CEDILLA */
- { 0x00E8, 0x8F }, /* LATIN SMALL LETTER E WITH GRAVE */
- { 0x00E9, 0x8E }, /* LATIN SMALL LETTER E WITH ACUTE */
- { 0x00EA, 0x90 }, /* LATIN SMALL LETTER E WITH CIRCUMFLEX */
- { 0x00EB, 0x91 }, /* LATIN SMALL LETTER E WITH DIAERESIS */
- { 0x00EC, 0x93 }, /* LATIN SMALL LETTER I WITH GRAVE */
- { 0x00ED, 0x92 }, /* LATIN SMALL LETTER I WITH ACUTE */
- { 0x00EE, 0x94 }, /* LATIN SMALL LETTER I WITH CIRCUMFLEX */
- { 0x00EF, 0x95 }, /* LATIN SMALL LETTER I WITH DIAERESIS */
- { 0x00F1, 0x96 }, /* LATIN SMALL LETTER N WITH TILDE */
- { 0x00F2, 0x98 }, /* LATIN SMALL LETTER O WITH GRAVE */
- { 0x00F3, 0x97 }, /* LATIN SMALL LETTER O WITH ACUTE */
- { 0x00F4, 0x99 }, /* LATIN SMALL LETTER O WITH CIRCUMFLEX */
- { 0x00F5, 0x9B }, /* LATIN SMALL LETTER O WITH TILDE */
- { 0x00F6, 0x9A }, /* LATIN SMALL LETTER O WITH DIAERESIS */
- { 0x00F7, 0xD6 }, /* DIVISION SIGN */
- { 0x00F8, 0xBF }, /* LATIN SMALL LETTER O WITH STROKE */
- { 0x00F9, 0x9D }, /* LATIN SMALL LETTER U WITH GRAVE */
- { 0x00FA, 0x9C }, /* LATIN SMALL LETTER U WITH ACUTE */
- { 0x00FB, 0x9E }, /* LATIN SMALL LETTER U WITH CIRCUMFLEX */
- { 0x00FC, 0x9F }, /* LATIN SMALL LETTER U WITH DIAERESIS */
- { 0x00FF, 0xD8 }, /* LATIN SMALL LETTER Y WITH DIAERESIS */
- { 0x0131, 0xF5 }, /* LATIN SMALL LETTER DOTLESS I */
- { 0x0152, 0xCE }, /* LATIN CAPITAL LIGATURE OE */
- { 0x0153, 0xCF }, /* LATIN SMALL LIGATURE OE */
- { 0x0178, 0xD9 }, /* LATIN CAPITAL LETTER Y WITH DIAERESIS */
- { 0x0192, 0xC4 }, /* LATIN SMALL LETTER F WITH HOOK */
- { 0x02C6, 0xF6 }, /* MODIFIER LETTER CIRCUMFLEX ACCENT */
- { 0x02C7, 0xFF }, /* CARON */
- { 0x02D8, 0xF9 }, /* BREVE */
- { 0x02D9, 0xFA }, /* DOT ABOVE */
- { 0x02DA, 0xFB }, /* RING ABOVE */
- { 0x02DB, 0xFE }, /* OGONEK */
- { 0x02DC, 0xF7 }, /* SMALL TILDE */
- { 0x02DD, 0xFD }, /* DOUBLE ACUTE ACCENT */
- { 0x03A9, 0xBD }, /* GREEK CAPITAL LETTER OMEGA */
- { 0x03C0, 0xB9 }, /* GREEK SMALL LETTER PI */
- { 0x2013, 0xD0 }, /* EN DASH */
- { 0x2014, 0xD1 }, /* EM DASH */
- { 0x2018, 0xD4 }, /* LEFT SINGLE QUOTATION MARK */
- { 0x2019, 0xD5 }, /* RIGHT SINGLE QUOTATION MARK */
- { 0x201A, 0xE2 }, /* SINGLE LOW-9 QUOTATION MARK */
- { 0x201C, 0xD2 }, /* LEFT DOUBLE QUOTATION MARK */
- { 0x201D, 0xD3 }, /* RIGHT DOUBLE QUOTATION MARK */
- { 0x201E, 0xE3 }, /* DOUBLE LOW-9 QUOTATION MARK */
- { 0x2020, 0xA0 }, /* DAGGER */
- { 0x2021, 0xE0 }, /* DOUBLE DAGGER */
- { 0x2022, 0xA5 }, /* BULLET */
- { 0x2026, 0xC9 }, /* HORIZONTAL ELLIPSIS */
- { 0x2030, 0xE4 }, /* PER MILLE SIGN */
- { 0x2039, 0xDC }, /* SINGLE LEFT-POINTING ANGLE QUOTATION MARK */
- { 0x203A, 0xDD }, /* SINGLE RIGHT-POINTING ANGLE QUOTATION MARK */
- { 0x2044, 0xDA }, /* FRACTION SLASH */
- { 0x20AC, 0xDB }, /* EURO SIGN */
- { 0x2122, 0xAA }, /* TRADE MARK SIGN */
- { 0x2202, 0xB6 }, /* PARTIAL DIFFERENTIAL */
- { 0x2206, 0xC6 }, /* INCREMENT */
- { 0x220F, 0xB8 }, /* N-ARY PRODUCT */
- { 0x2211, 0xB7 }, /* N-ARY SUMMATION */
- { 0x221A, 0xC3 }, /* SQUARE ROOT */
- { 0x221E, 0xB0 }, /* INFINITY */
- { 0x222B, 0xBA }, /* INTEGRAL */
- { 0x2248, 0xC5 }, /* ALMOST EQUAL TO */
- { 0x2260, 0xAD }, /* NOT EQUAL TO */
- { 0x2264, 0xB2 }, /* LESS-THAN OR EQUAL TO */
- { 0x2265, 0xB3 }, /* GREATER-THAN OR EQUAL TO */
- { 0x25CA, 0xD7 }, /* LOZENGE */
- { 0xF8FF, 0xF0 }, /* Apple logo */
- { 0xFB01, 0xDE }, /* LATIN SMALL LIGATURE FI */
- { 0xFB02, 0xDF }, /* LATIN SMALL LIGATURE FL */
+struct _FcCharSetEnt {
+ FcCharSetEnt *next;
+ FcChar32 hash;
+ FcCharSet set;
};
-static const FcCharMap AppleRoman = {
- AppleRomanEnt,
- sizeof (AppleRomanEnt) / sizeof (AppleRomanEnt[0])
-};
+typedef struct _FcCharSetOrigEnt FcCharSetOrigEnt;
-static const FcCharEnt AdobeSymbolEnt[] = {
- { 0x0020, 0x20 }, /* SPACE # space */
- { 0x0021, 0x21 }, /* EXCLAMATION MARK # exclam */
- { 0x0023, 0x23 }, /* NUMBER SIGN # numbersign */
- { 0x0025, 0x25 }, /* PERCENT SIGN # percent */
- { 0x0026, 0x26 }, /* AMPERSAND # ampersand */
- { 0x0028, 0x28 }, /* LEFT PARENTHESIS # parenleft */
- { 0x0029, 0x29 }, /* RIGHT PARENTHESIS # parenright */
- { 0x002B, 0x2B }, /* PLUS SIGN # plus */
- { 0x002C, 0x2C }, /* COMMA # comma */
- { 0x002E, 0x2E }, /* FULL STOP # period */
- { 0x002F, 0x2F }, /* SOLIDUS # slash */
- { 0x0030, 0x30 }, /* DIGIT ZERO # zero */
- { 0x0031, 0x31 }, /* DIGIT ONE # one */
- { 0x0032, 0x32 }, /* DIGIT TWO # two */
- { 0x0033, 0x33 }, /* DIGIT THREE # three */
- { 0x0034, 0x34 }, /* DIGIT FOUR # four */
- { 0x0035, 0x35 }, /* DIGIT FIVE # five */
- { 0x0036, 0x36 }, /* DIGIT SIX # six */
- { 0x0037, 0x37 }, /* DIGIT SEVEN # seven */
- { 0x0038, 0x38 }, /* DIGIT EIGHT # eight */
- { 0x0039, 0x39 }, /* DIGIT NINE # nine */
- { 0x003A, 0x3A }, /* COLON # colon */
- { 0x003B, 0x3B }, /* SEMICOLON # semicolon */
- { 0x003C, 0x3C }, /* LESS-THAN SIGN # less */
- { 0x003D, 0x3D }, /* EQUALS SIGN # equal */
- { 0x003E, 0x3E }, /* GREATER-THAN SIGN # greater */
- { 0x003F, 0x3F }, /* QUESTION MARK # question */
- { 0x005B, 0x5B }, /* LEFT SQUARE BRACKET # bracketleft */
- { 0x005D, 0x5D }, /* RIGHT SQUARE BRACKET # bracketright */
- { 0x005F, 0x5F }, /* LOW LINE # underscore */
- { 0x007B, 0x7B }, /* LEFT CURLY BRACKET # braceleft */
- { 0x007C, 0x7C }, /* VERTICAL LINE # bar */
- { 0x007D, 0x7D }, /* RIGHT CURLY BRACKET # braceright */
- { 0x00A0, 0x20 }, /* NO-BREAK SPACE # space */
- { 0x00AC, 0xD8 }, /* NOT SIGN # logicalnot */
- { 0x00B0, 0xB0 }, /* DEGREE SIGN # degree */
- { 0x00B1, 0xB1 }, /* PLUS-MINUS SIGN # plusminus */
- { 0x00B5, 0x6D }, /* MICRO SIGN # mu */
- { 0x00D7, 0xB4 }, /* MULTIPLICATION SIGN # multiply */
- { 0x00F7, 0xB8 }, /* DIVISION SIGN # divide */
- { 0x0192, 0xA6 }, /* LATIN SMALL LETTER F WITH HOOK # florin */
- { 0x0391, 0x41 }, /* GREEK CAPITAL LETTER ALPHA # Alpha */
- { 0x0392, 0x42 }, /* GREEK CAPITAL LETTER BETA # Beta */
- { 0x0393, 0x47 }, /* GREEK CAPITAL LETTER GAMMA # Gamma */
- { 0x0394, 0x44 }, /* GREEK CAPITAL LETTER DELTA # Delta */
- { 0x0395, 0x45 }, /* GREEK CAPITAL LETTER EPSILON # Epsilon */
- { 0x0396, 0x5A }, /* GREEK CAPITAL LETTER ZETA # Zeta */
- { 0x0397, 0x48 }, /* GREEK CAPITAL LETTER ETA # Eta */
- { 0x0398, 0x51 }, /* GREEK CAPITAL LETTER THETA # Theta */
- { 0x0399, 0x49 }, /* GREEK CAPITAL LETTER IOTA # Iota */
- { 0x039A, 0x4B }, /* GREEK CAPITAL LETTER KAPPA # Kappa */
- { 0x039B, 0x4C }, /* GREEK CAPITAL LETTER LAMDA # Lambda */
- { 0x039C, 0x4D }, /* GREEK CAPITAL LETTER MU # Mu */
- { 0x039D, 0x4E }, /* GREEK CAPITAL LETTER NU # Nu */
- { 0x039E, 0x58 }, /* GREEK CAPITAL LETTER XI # Xi */
- { 0x039F, 0x4F }, /* GREEK CAPITAL LETTER OMICRON # Omicron */
- { 0x03A0, 0x50 }, /* GREEK CAPITAL LETTER PI # Pi */
- { 0x03A1, 0x52 }, /* GREEK CAPITAL LETTER RHO # Rho */
- { 0x03A3, 0x53 }, /* GREEK CAPITAL LETTER SIGMA # Sigma */
- { 0x03A4, 0x54 }, /* GREEK CAPITAL LETTER TAU # Tau */
- { 0x03A5, 0x55 }, /* GREEK CAPITAL LETTER UPSILON # Upsilon */
- { 0x03A6, 0x46 }, /* GREEK CAPITAL LETTER PHI # Phi */
- { 0x03A7, 0x43 }, /* GREEK CAPITAL LETTER CHI # Chi */
- { 0x03A8, 0x59 }, /* GREEK CAPITAL LETTER PSI # Psi */
- { 0x03A9, 0x57 }, /* GREEK CAPITAL LETTER OMEGA # Omega */
- { 0x03B1, 0x61 }, /* GREEK SMALL LETTER ALPHA # alpha */
- { 0x03B2, 0x62 }, /* GREEK SMALL LETTER BETA # beta */
- { 0x03B3, 0x67 }, /* GREEK SMALL LETTER GAMMA # gamma */
- { 0x03B4, 0x64 }, /* GREEK SMALL LETTER DELTA # delta */
- { 0x03B5, 0x65 }, /* GREEK SMALL LETTER EPSILON # epsilon */
- { 0x03B6, 0x7A }, /* GREEK SMALL LETTER ZETA # zeta */
- { 0x03B7, 0x68 }, /* GREEK SMALL LETTER ETA # eta */
- { 0x03B8, 0x71 }, /* GREEK SMALL LETTER THETA # theta */
- { 0x03B9, 0x69 }, /* GREEK SMALL LETTER IOTA # iota */
- { 0x03BA, 0x6B }, /* GREEK SMALL LETTER KAPPA # kappa */
- { 0x03BB, 0x6C }, /* GREEK SMALL LETTER LAMDA # lambda */
- { 0x03BC, 0x6D }, /* GREEK SMALL LETTER MU # mu */
- { 0x03BD, 0x6E }, /* GREEK SMALL LETTER NU # nu */
- { 0x03BE, 0x78 }, /* GREEK SMALL LETTER XI # xi */
- { 0x03BF, 0x6F }, /* GREEK SMALL LETTER OMICRON # omicron */
- { 0x03C0, 0x70 }, /* GREEK SMALL LETTER PI # pi */
- { 0x03C1, 0x72 }, /* GREEK SMALL LETTER RHO # rho */
- { 0x03C2, 0x56 }, /* GREEK SMALL LETTER FINAL SIGMA # sigma1 */
- { 0x03C3, 0x73 }, /* GREEK SMALL LETTER SIGMA # sigma */
- { 0x03C4, 0x74 }, /* GREEK SMALL LETTER TAU # tau */
- { 0x03C5, 0x75 }, /* GREEK SMALL LETTER UPSILON # upsilon */
- { 0x03C6, 0x66 }, /* GREEK SMALL LETTER PHI # phi */
- { 0x03C7, 0x63 }, /* GREEK SMALL LETTER CHI # chi */
- { 0x03C8, 0x79 }, /* GREEK SMALL LETTER PSI # psi */
- { 0x03C9, 0x77 }, /* GREEK SMALL LETTER OMEGA # omega */
- { 0x03D1, 0x4A }, /* GREEK THETA SYMBOL # theta1 */
- { 0x03D2, 0xA1 }, /* GREEK UPSILON WITH HOOK SYMBOL # Upsilon1 */
- { 0x03D5, 0x6A }, /* GREEK PHI SYMBOL # phi1 */
- { 0x03D6, 0x76 }, /* GREEK PI SYMBOL # omega1 */
- { 0x2022, 0xB7 }, /* BULLET # bullet */
- { 0x2026, 0xBC }, /* HORIZONTAL ELLIPSIS # ellipsis */
- { 0x2032, 0xA2 }, /* PRIME # minute */
- { 0x2033, 0xB2 }, /* DOUBLE PRIME # second */
- { 0x2044, 0xA4 }, /* FRACTION SLASH # fraction */
- { 0x20AC, 0xA0 }, /* EURO SIGN # Euro */
- { 0x2111, 0xC1 }, /* BLACK-LETTER CAPITAL I # Ifraktur */
- { 0x2118, 0xC3 }, /* SCRIPT CAPITAL P # weierstrass */
- { 0x211C, 0xC2 }, /* BLACK-LETTER CAPITAL R # Rfraktur */
- { 0x2126, 0x57 }, /* OHM SIGN # Omega */
- { 0x2135, 0xC0 }, /* ALEF SYMBOL # aleph */
- { 0x2190, 0xAC }, /* LEFTWARDS ARROW # arrowleft */
- { 0x2191, 0xAD }, /* UPWARDS ARROW # arrowup */
- { 0x2192, 0xAE }, /* RIGHTWARDS ARROW # arrowright */
- { 0x2193, 0xAF }, /* DOWNWARDS ARROW # arrowdown */
- { 0x2194, 0xAB }, /* LEFT RIGHT ARROW # arrowboth */
- { 0x21B5, 0xBF }, /* DOWNWARDS ARROW WITH CORNER LEFTWARDS # carriagereturn */
- { 0x21D0, 0xDC }, /* LEFTWARDS DOUBLE ARROW # arrowdblleft */
- { 0x21D1, 0xDD }, /* UPWARDS DOUBLE ARROW # arrowdblup */
- { 0x21D2, 0xDE }, /* RIGHTWARDS DOUBLE ARROW # arrowdblright */
- { 0x21D3, 0xDF }, /* DOWNWARDS DOUBLE ARROW # arrowdbldown */
- { 0x21D4, 0xDB }, /* LEFT RIGHT DOUBLE ARROW # arrowdblboth */
- { 0x2200, 0x22 }, /* FOR ALL # universal */
- { 0x2202, 0xB6 }, /* PARTIAL DIFFERENTIAL # partialdiff */
- { 0x2203, 0x24 }, /* THERE EXISTS # existential */
- { 0x2205, 0xC6 }, /* EMPTY SET # emptyset */
- { 0x2206, 0x44 }, /* INCREMENT # Delta */
- { 0x2207, 0xD1 }, /* NABLA # gradient */
- { 0x2208, 0xCE }, /* ELEMENT OF # element */
- { 0x2209, 0xCF }, /* NOT AN ELEMENT OF # notelement */
- { 0x220B, 0x27 }, /* CONTAINS AS MEMBER # suchthat */
- { 0x220F, 0xD5 }, /* N-ARY PRODUCT # product */
- { 0x2211, 0xE5 }, /* N-ARY SUMMATION # summation */
- { 0x2212, 0x2D }, /* MINUS SIGN # minus */
- { 0x2215, 0xA4 }, /* DIVISION SLASH # fraction */
- { 0x2217, 0x2A }, /* ASTERISK OPERATOR # asteriskmath */
- { 0x221A, 0xD6 }, /* SQUARE ROOT # radical */
- { 0x221D, 0xB5 }, /* PROPORTIONAL TO # proportional */
- { 0x221E, 0xA5 }, /* INFINITY # infinity */
- { 0x2220, 0xD0 }, /* ANGLE # angle */
- { 0x2227, 0xD9 }, /* LOGICAL AND # logicaland */
- { 0x2228, 0xDA }, /* LOGICAL OR # logicalor */
- { 0x2229, 0xC7 }, /* INTERSECTION # intersection */
- { 0x222A, 0xC8 }, /* UNION # union */
- { 0x222B, 0xF2 }, /* INTEGRAL # integral */
- { 0x2234, 0x5C }, /* THEREFORE # therefore */
- { 0x223C, 0x7E }, /* TILDE OPERATOR # similar */
- { 0x2245, 0x40 }, /* APPROXIMATELY EQUAL TO # congruent */
- { 0x2248, 0xBB }, /* ALMOST EQUAL TO # approxequal */
- { 0x2260, 0xB9 }, /* NOT EQUAL TO # notequal */
- { 0x2261, 0xBA }, /* IDENTICAL TO # equivalence */
- { 0x2264, 0xA3 }, /* LESS-THAN OR EQUAL TO # lessequal */
- { 0x2265, 0xB3 }, /* GREATER-THAN OR EQUAL TO # greaterequal */
- { 0x2282, 0xCC }, /* SUBSET OF # propersubset */
- { 0x2283, 0xC9 }, /* SUPERSET OF # propersuperset */
- { 0x2284, 0xCB }, /* NOT A SUBSET OF # notsubset */
- { 0x2286, 0xCD }, /* SUBSET OF OR EQUAL TO # reflexsubset */
- { 0x2287, 0xCA }, /* SUPERSET OF OR EQUAL TO # reflexsuperset */
- { 0x2295, 0xC5 }, /* CIRCLED PLUS # circleplus */
- { 0x2297, 0xC4 }, /* CIRCLED TIMES # circlemultiply */
- { 0x22A5, 0x5E }, /* UP TACK # perpendicular */
- { 0x22C5, 0xD7 }, /* DOT OPERATOR # dotmath */
- { 0x2320, 0xF3 }, /* TOP HALF INTEGRAL # integraltp */
- { 0x2321, 0xF5 }, /* BOTTOM HALF INTEGRAL # integralbt */
- { 0x2329, 0xE1 }, /* LEFT-POINTING ANGLE BRACKET # angleleft */
- { 0x232A, 0xF1 }, /* RIGHT-POINTING ANGLE BRACKET # angleright */
- { 0x25CA, 0xE0 }, /* LOZENGE # lozenge */
- { 0x2660, 0xAA }, /* BLACK SPADE SUIT # spade */
- { 0x2663, 0xA7 }, /* BLACK CLUB SUIT # club */
- { 0x2665, 0xA9 }, /* BLACK HEART SUIT # heart */
- { 0x2666, 0xA8 }, /* BLACK DIAMOND SUIT # diamond */
- { 0xF6D9, 0xD3 }, /* COPYRIGHT SIGN SERIF # copyrightserif (CUS) */
- { 0xF6DA, 0xD2 }, /* REGISTERED SIGN SERIF # registerserif (CUS) */
- { 0xF6DB, 0xD4 }, /* TRADE MARK SIGN SERIF # trademarkserif (CUS) */
- { 0xF8E5, 0x60 }, /* RADICAL EXTENDER # radicalex (CUS) */
- { 0xF8E6, 0xBD }, /* VERTICAL ARROW EXTENDER # arrowvertex (CUS) */
- { 0xF8E7, 0xBE }, /* HORIZONTAL ARROW EXTENDER # arrowhorizex (CUS) */
- { 0xF8E8, 0xE2 }, /* REGISTERED SIGN SANS SERIF # registersans (CUS) */
- { 0xF8E9, 0xE3 }, /* COPYRIGHT SIGN SANS SERIF # copyrightsans (CUS) */
- { 0xF8EA, 0xE4 }, /* TRADE MARK SIGN SANS SERIF # trademarksans (CUS) */
- { 0xF8EB, 0xE6 }, /* LEFT PAREN TOP # parenlefttp (CUS) */
- { 0xF8EC, 0xE7 }, /* LEFT PAREN EXTENDER # parenleftex (CUS) */
- { 0xF8ED, 0xE8 }, /* LEFT PAREN BOTTOM # parenleftbt (CUS) */
- { 0xF8EE, 0xE9 }, /* LEFT SQUARE BRACKET TOP # bracketlefttp (CUS) */
- { 0xF8EF, 0xEA }, /* LEFT SQUARE BRACKET EXTENDER # bracketleftex (CUS) */
- { 0xF8F0, 0xEB }, /* LEFT SQUARE BRACKET BOTTOM # bracketleftbt (CUS) */
- { 0xF8F1, 0xEC }, /* LEFT CURLY BRACKET TOP # bracelefttp (CUS) */
- { 0xF8F2, 0xED }, /* LEFT CURLY BRACKET MID # braceleftmid (CUS) */
- { 0xF8F3, 0xEE }, /* LEFT CURLY BRACKET BOTTOM # braceleftbt (CUS) */
- { 0xF8F4, 0xEF }, /* CURLY BRACKET EXTENDER # braceex (CUS) */
- { 0xF8F5, 0xF4 }, /* INTEGRAL EXTENDER # integralex (CUS) */
- { 0xF8F6, 0xF6 }, /* RIGHT PAREN TOP # parenrighttp (CUS) */
- { 0xF8F7, 0xF7 }, /* RIGHT PAREN EXTENDER # parenrightex (CUS) */
- { 0xF8F8, 0xF8 }, /* RIGHT PAREN BOTTOM # parenrightbt (CUS) */
- { 0xF8F9, 0xF9 }, /* RIGHT SQUARE BRACKET TOP # bracketrighttp (CUS) */
- { 0xF8FA, 0xFA }, /* RIGHT SQUARE BRACKET EXTENDER # bracketrightex (CUS) */
- { 0xF8FB, 0xFB }, /* RIGHT SQUARE BRACKET BOTTOM # bracketrightbt (CUS) */
- { 0xF8FC, 0xFC }, /* RIGHT CURLY BRACKET TOP # bracerighttp (CUS) */
- { 0xF8FD, 0xFD }, /* RIGHT CURLY BRACKET MID # bracerightmid (CUS) */
- { 0xF8FE, 0xFE }, /* RIGHT CURLY BRACKET BOTTOM # bracerightbt (CUS) */
+struct _FcCharSetOrigEnt {
+ FcCharSetOrigEnt *next;
+ const FcCharSet *orig;
+ const FcCharSet *frozen;
};
-static const FcCharMap AdobeSymbol = {
- AdobeSymbolEnt,
- sizeof (AdobeSymbolEnt) / sizeof (AdobeSymbolEnt[0]),
+#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 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]))
-static FT_ULong
-FcFreeTypeMapChar (FcChar32 ucs4, const FcCharMap *map)
+static FcCharLeafEnt *
+FcCharLeafEntCreate (FcCharSetFreezer *freezer)
{
- 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 (high - low > 1)
+ if (!freezer->leaf_remain)
{
- mid = (high + low) >> 1;
- bmp = map->ent[mid].bmp;
- if (ucs4 == bmp)
- return (FT_ULong) map->ent[mid].encode;
- if (ucs4 < bmp)
- high = mid;
- else
- low = mid;
+ 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;
+ FcMemAlloc (FC_MEM_CHARLEAF, FC_CHAR_LEAF_BLOCK * sizeof (FcCharLeafEnt));
+ freezer->leaf_remain = FC_CHAR_LEAF_BLOCK;
}
- for (mid = low; mid <= high; mid++)
+ 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 (ucs4 == map->ent[mid].bmp)
- return (FT_ULong) map->ent[mid].encode;
+ if (ent->hash == hash && !memcmp (&ent->leaf, leaf, sizeof (FcCharLeaf)))
+ return &ent->leaf;
}
- return ~0;
+
+ ent = FcCharLeafEntCreate(freezer);
+ if (!ent)
+ return 0;
+ ent->leaf = *leaf;
+ ent->hash = hash;
+ ent->next = *bucket;
+ *bucket = ent;
+ return &ent->leaf;
}
-/*
- * Map a UCS4 glyph to a glyph index. Use all available encoding
- * tables to try and find one that works. This information is expected
- * to be cached by higher levels, so performance isn't critical
- */
+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);
+ return hash;
+}
-FT_UInt
-FcFreeTypeCharIndex (FT_Face face, FcChar32 ucs4)
+static FcBool
+FcCharSetFreezeOrig (FcCharSetFreezer *freezer, const FcCharSet *orig, const FcCharSet *frozen)
{
- int initial, offset, decode;
- FT_UInt glyphindex;
- FT_ULong charcode;
+ 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;
+}
- initial = 0;
- /*
- * Find the current encoding
- */
- if (face->charmap)
- {
- for (; initial < NUM_DECODE; initial++)
- if (fcFontDecoders[initial].encoding == face->charmap->encoding)
- break;
- if (initial == NUM_DECODE)
- initial = 0;
- }
- /*
- * Check each encoding for the glyph, starting with the current one
- */
- for (offset = 0; offset < NUM_DECODE; offset++)
+static FcCharSet *
+FcCharSetFreezeBase (FcCharSetFreezer *freezer, FcCharSet *fcs, const FcCharSet *orig)
+{
+ 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)
{
- 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)
+ if (ent->hash == hash &&
+ ent->set.num == fcs->num &&
+ !memcmp (FcCharSetNumbers(&ent->set),
+ FcCharSetNumbers(fcs),
+ fcs->num * sizeof (FcChar16)))
{
- charcode = FcFreeTypeMapChar (ucs4, fcFontDecoders[decode].map);
- if (charcode == ~0)
- continue;
+ 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;
}
- else
- charcode = (FT_ULong) ucs4;
- glyphindex = FT_Get_Char_Index (face, 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;
-
- /*
- * When using scalable fonts, only report those glyphs
- * which can be scaled; otherwise those fonts will
- * only be available at some sizes, and never when
- * transformed. Avoid this by simply reporting bitmap-only
- * glyphs as missing
- */
- if (face->face_flags & FT_FACE_FLAG_SCALABLE)
- load_flags |= FT_LOAD_NO_BITMAP;
+ size = (sizeof (FcCharSetEnt) +
+ fcs->num * sizeof (FcCharLeaf *) +
+ fcs->num * sizeof (FcChar16));
+ ent = malloc (size);
+ if (!ent)
+ return 0;
+ FcMemAlloc (FC_MEM_CHARSET, size);
- if (FT_Load_Glyph (face, glyph, load_flags))
- return FcFalse;
+ freezer->charsets_allocated++;
- slot = face->glyph;
- if (!glyph)
- return FcFalse;
+ ent->set.ref = FC_REF_CONSTANT;
+ 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));
- switch (slot->format) {
- case ft_glyph_format_bitmap:
- /*
- * Bitmaps are assumed to be reasonable; if
- * this proves to be a rash assumption, this
- * code can be easily modified
- */
- return FcTrue;
- case ft_glyph_format_outline:
- /*
- * Glyphs with contours are always OK
- */
- if (slot->outline.n_contours != 0)
- return FcTrue;
- /*
- * Glyphs with no contours are only OK if
- * they're members of the Blanks set specified
- * in the configuration. If blanks isn't set,
- * then allow any glyph to be blank
- */
- if (!blanks || FcBlanksIsMember (blanks, ucs4))
- return FcTrue;
- /* fall through ... */
- default:
- break;
+ 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;
}
- return FcFalse;
+
+ ent->hash = hash;
+ ent->next = *bucket;
+ *bucket = ent;
+
+ return &ent->set;
}
-FcCharSet *
-FcFreeTypeCharSet (FT_Face face, FcBlanks *blanks)
+static const FcCharSet *
+FcCharSetFindFrozen (FcCharSetFreezer *freezer, const FcCharSet *orig)
{
- FcChar32 page, off, max, ucs4;
-#ifdef CHECK
- FcChar32 font_max = 0;
-#endif
- FcCharSet *fcs;
- FcCharLeaf *leaf;
- const FcCharMap *map;
- int o;
+ 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;
- FT_UInt glyph;
- fcs = FcCharSetCreate ();
- if (!fcs)
+ b = FcCharSetCreate ();
+ if (!b)
goto bail0;
-
- for (o = 0; o < NUM_DECODE; o++)
+ for (i = 0; i < fcs->num; i++)
{
- if (FT_Select_Charmap (face, fcFontDecoders[o].encoding) != 0)
- continue;
- map = fcFontDecoders[o].map;
- if (map)
+ l = FcCharSetFreezeLeaf (freezer, FcCharSetLeaf(fcs, i));
+ if (!l)
+ goto bail1;
+ if (!FcCharSetInsertLeaf (b, FcCharSetNumbers(fcs)[i] << 8, l))
+ goto bail1;
+ }
+ n = FcCharSetFreezeBase (freezer, b, fcs);
+ if (!FcCharSetFreezeOrig (freezer, fcs, n))
+ {
+ n = NULL;
+ goto bail1;
+ }
+ freezer->charsets_seen++;
+ freezer->leaves_seen += fcs->num;
+bail1:
+ if (b->num)
+ {
+ FcMemFree (FC_MEM_CHARSET, b->num * sizeof (FcCharLeaf *));
+ free (FcCharSetLeaves (b));
+ }
+ if (b->num)
+ {
+ FcMemFree (FC_MEM_CHARSET, b->num * sizeof (FcChar16));
+ free (FcCharSetNumbers (b));
+ }
+ FcMemFree (FC_MEM_CHARSET, sizeof (FcCharSet));
+ 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)
{
- /*
- * Non-Unicode tables are easy; there's a list of all possible
- * characters
- */
- 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
- }
- }
+ next = ent->next;
+ FcMemFree (FC_MEM_CHARSET, (sizeof (FcCharSetEnt) +
+ ent->set.num * sizeof (FcCharLeaf *) +
+ ent->set.num * sizeof (FcChar16)));
+ free (ent);
}
- else
+ }
+
+ for (i = 0; i < FC_CHAR_SET_HASH_SIZE; i++)
+ {
+ FcCharSetOrigEnt *ent, *next;
+ for (ent = freezer->orig_hash_table[i]; ent; ent = next)
{
- FT_UInt gindex;
-
- max = fcFontDecoders[o].max;
- /*
- * Find the first encoded character in the font
- */
- if (FT_Get_Char_Index (face, 0))
- {
- ucs4 = 0;
- gindex = 1;
- }
- else
- {
- ucs4 = FT_Get_Next_Char (face, 0, &gindex);
- if (!ucs4)
- gindex = 0;
- }
+ next = ent->next;
+ free (ent);
+ }
+ }
- 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;
+ for (i = 0; i < freezer->leaf_block_count; i++)
+ {
+ free (freezer->leaf_blocks[i]);
+ FcMemFree (FC_MEM_CHARLEAF, FC_CHAR_LEAF_BLOCK * sizeof (FcCharLeafEnt));
+ }
- 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
+ free (freezer->leaf_blocks);
+ free (freezer);
+}
+
+FcBool
+FcCharSetSerializeAlloc (FcSerialize *serialize, const FcCharSet *cs)
+{
+ intptr_t *leaves;
+ FcChar16 *numbers;
+ int i;
+
+ if (cs->ref != FC_REF_CONSTANT)
+ {
+ 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);
}
-#ifdef CHECK
- printf ("%d glyphs %d encoded\n", (int) face->num_glyphs, FcCharSetCount (fcs));
- for (ucs4 = 0; ucs4 <= font_max; ucs4++)
+
+ 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 (cs->ref != FC_REF_CONSTANT && serialize->cs_freezer)
{
- FcBool has_char = FcFreeTypeCharIndex (face, ucs4) != 0;
- FcBool has_bit = FcCharSetHasChar (fcs, ucs4);
+ cs = FcCharSetFindFrozen (serialize->cs_freezer, cs);
+ if (!cs)
+ return NULL;
+ }
+
+ cs_serialized = FcSerializePtr (serialize, cs);
+ if (!cs_serialized)
+ return NULL;
+
+ cs_serialized->ref = FC_REF_CONSTANT;
+ cs_serialized->num = cs->num;
- 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);
+ 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];
+ }
}
-#endif
- return fcs;
-bail1:
- FcCharSetDestroy (fcs);
-bail0:
- return 0;
+ else
+ {
+ cs_serialized->leaves_offset = 0;
+ cs_serialized->numbers_offset = 0;
+ }
+
+ return cs_serialized;
}
-
+#define __fccharset__
+#include "fcaliastail.h"
+#undef __fccharset__
git.wh0rd.org / fontconfig.git / blobdiff