/* * $RCSId: xc/lib/fontconfig/src/fccharset.c,v 1.18 2002/08/22 07:36:44 keithp Exp $ * * 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 Keith Packard not be used in * advertising or publicity pertaining to distribution of the software without * specific, written prior permission. Keith Packard makes no * 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, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL KEITH PACKARD 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 #include "fcint.h" /* #define CHECK */ /* #define CHATTY */ static FcCharSet ** charsets = 0; static FcChar16 ** numbers = 0; static int charset_bank_count = 0, charset_ptr, charset_count; static int charset_numbers_ptr, charset_numbers_count; static FcCharLeaf ** leaves = 0; static int charset_leaf_ptr, charset_leaf_count; static int ** leaf_idx = 0; static int charset_leaf_idx_ptr, charset_leaf_idx_count; 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->bank = FC_BANK_DYNAMIC; fcs->u.dyn.leaves = 0; fcs->u.dyn.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; if (fcs->bank == FC_BANK_DYNAMIC) { for (i = 0; i < fcs->num; i++) { FcMemFree (FC_MEM_CHARLEAF, sizeof (FcCharLeaf)); free (fcs->u.dyn.leaves[i]); } if (fcs->u.dyn.leaves) { FcMemFree (FC_MEM_CHARSET, fcs->num * sizeof (FcCharLeaf *)); free (fcs->u.dyn.leaves); } if (fcs->u.dyn.numbers) { FcMemFree (FC_MEM_CHARSET, fcs->num * sizeof (FcChar16)); free (fcs->u.dyn.numbers); } } FcMemFree (FC_MEM_CHARSET, sizeof (FcCharSet)); free (fcs); } /* * 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) { FcChar16 *numbers = FcCharSetGetNumbers(fcs); 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 FcCharSetGetLeaf(fcs, 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->bank != FC_BANK_DYNAMIC) { int i; leaves = malloc ((fcs->num + 1) * sizeof (FcCharLeaf *)); if (!leaves) return FcFalse; FcMemAlloc (FC_MEM_CHARSET, (fcs->num + 1) * sizeof (FcCharLeaf *)); numbers = malloc ((fcs->num + 1) * sizeof (FcChar16)); if (!numbers) return FcFalse; FcMemAlloc (FC_MEM_CHARSET, (fcs->num + 1) * sizeof (FcChar16)); for (i = 0; i < fcs->num; i++) leaves[i] = FcCharSetGetLeaf(fcs, i); memcpy (numbers, FcCharSetGetNumbers(fcs), fcs->num * sizeof (FcChar16)); } else { if (!fcs->u.dyn.leaves) leaves = malloc (sizeof (FcCharLeaf *)); else leaves = realloc (fcs->u.dyn.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->u.dyn.leaves = leaves; if (!fcs->u.dyn.numbers) numbers = malloc (sizeof (FcChar16)); else numbers = realloc (fcs->u.dyn.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->u.dyn.numbers = numbers; } memmove (fcs->u.dyn.leaves + pos + 1, fcs->u.dyn.leaves + pos, (fcs->num - pos) * sizeof (FcCharLeaf *)); memmove (fcs->u.dyn.numbers + pos + 1, fcs->u.dyn.numbers + pos, (fcs->num - pos) * sizeof (FcChar16)); fcs->u.dyn.numbers[pos] = (FcChar16) ucs4; fcs->u.dyn.leaves[pos] = 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 FcCharSetGetLeaf(fcs, 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)); if (fcs->bank == FC_BANK_DYNAMIC) { free (fcs->u.dyn.leaves[pos]); fcs->u.dyn.leaves[pos] = leaf; } else { leaves[fcs->bank][leaf_idx[fcs->bank][fcs->u.stat.leafidx_offset]+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; } /* * 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) FcCharSetGetNumbers(fcs)[pos] << 8; } iter->leaf = FcCharSetGetLeaf(fcs, 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) FcCharSetGetNumbers(fcs)[pos] << 8; iter->leaf = FcCharSetGetLeaf(fcs, 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; iter->pos = 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) { /* hackmem 169 */ 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; } /* * 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 = FcCharSetGetNumbers(a)[ai]; bn = FcCharSetGetNumbers(b)[bi]; /* * Check matching pages */ if (an == bn) { FcChar32 *am = FcCharSetGetLeaf(a, ai)->map; FcChar32 *bm = FcCharSetGetLeaf(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 { int low = bi + 1; int high = b->num - 1; /* * Search for page 'an' in 'b' */ while (low <= high) { int mid = (low + high) >> 1; bn = FcCharSetGetNumbers(b)[mid]; if (bn == an) { high = mid; break; } if (bn < an) low = mid + 1; else high = mid - 1; } bi = high; while (bi < b->num && FcCharSetGetNumbers(b)[bi] < an) bi++; } } /* * 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; 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); 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. * * Each leaf is represented as 9 32-bit values, the code of the first character followed * by 8 32 bit values for the leaf itself. Each value is encoded as 5 ASCII characters, * only 85 different values are used to avoid control characters as well as the other * characters used to encode font names. 85**5 > 2^32 so things work out, but * it's not exactly human readable output. As a special case, 0 is encoded as a space */ 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, /* "\030" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* " " */ 0xff, 0x00, 0xff, 0x01, 0x02, 0x03, 0x04, 0xff, /* "(" */ 0x05, 0x06, 0x07, 0x08, 0xff, 0xff, 0x09, 0x0a, /* "0" */ 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, /* "8" */ 0x13, 0x14, 0xff, 0x15, 0x16, 0xff, 0x17, 0x18, /* "@" */ 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, /* "H" */ 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, /* "P" */ 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, /* "X" */ 0x31, 0x32, 0x33, 0x34, 0xff, 0x35, 0x36, 0xff, /* "`" */ 0xff, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, /* "h" */ 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, /* "p" */ 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, /* "x" */ 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0xff, /* "\200" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* "\210" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* "\220" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* "\230" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* "\240" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* "\250" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* "\260" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* "\270" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* "\300" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* "\310" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* "\320" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* "\330" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* "\340" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* "\350" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* "\360" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* "\370" */ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, }; static const FcChar8 valueToChar[0x55] = { /* 0x00 */ '!', '#', '$', '%', '&', '(', ')', '*', /* 0x08 */ '+', '.', '/', '0', '1', '2', '3', '4', /* 0x10 */ '5', '6', '7', '8', '9', ';', '<', '>', /* 0x18 */ '?', '@', 'A', 'B', 'C', 'D', 'E', 'F', /* 0x20 */ 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', /* 0x28 */ 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', /* 0x30 */ 'W', 'X', 'Y', 'Z', '[', ']', '^', 'a', /* 0x38 */ 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', /* 0x40 */ 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', /* 0x48 */ 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', /* 0x50 */ '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 **FcCharLeafBlocks; static int FcCharLeafBlockCount; static FcCharLeafEnt * FcCharLeafEntCreate (void) { static FcCharLeafEnt *block; static int remain; if (!remain) { FcCharLeafEnt **newBlocks; FcCharLeafBlockCount++; newBlocks = realloc (FcCharLeafBlocks, FcCharLeafBlockCount * sizeof (FcCharLeafEnt *)); if (!newBlocks) return 0; FcCharLeafBlocks = newBlocks; block = FcCharLeafBlocks[FcCharLeafBlockCount-1] = 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 FcCharLeafEnt *FcCharLeafHashTable[FC_CHAR_LEAF_HASH_SIZE]; static FcCharLeaf * FcCharSetFreezeLeaf (FcCharLeaf *leaf) { FcChar32 hash = FcCharLeafHash (leaf); FcCharLeafEnt **bucket = &FcCharLeafHashTable[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; } static void FcCharSetThawAllLeaf (void) { int i; for (i = 0; i < FC_CHAR_LEAF_HASH_SIZE; i++) FcCharLeafHashTable[i] = 0; FcCharLeafTotal = 0; FcCharLeafUsed = 0; for (i = 0; i < FcCharLeafBlockCount; i++) free (FcCharLeafBlocks[i]); free (FcCharLeafBlocks); FcCharLeafBlocks = 0; FcCharLeafBlockCount = 0; } 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; int i; /* hash in leaves */ for (i = 0; i < fcs->num * (int) (sizeof (FcCharLeaf *) / sizeof (FcChar32)); i++) hash = ((hash << 1) | (hash >> 31)) ^ (FcChar32)(FcCharSetGetLeaf(fcs, i)->map); /* hash in numbers */ for (i = 0; i < fcs->num; i++) hash = ((hash << 1) | (hash >> 31)) ^ *FcCharSetGetNumbers(fcs); return hash; } static int FcCharSetTotal; static int FcCharSetUsed; static int FcCharSetTotalEnts, FcCharSetUsedEnts; static FcCharSetEnt *FcCharSetHashTable[FC_CHAR_SET_HASH_SIZE]; static FcCharSet * FcCharSetFreezeBase (FcCharSet *fcs) { FcChar32 hash = FcCharSetHash (fcs); FcCharSetEnt **bucket = &FcCharSetHashTable[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 (FcCharSetGetNumbers(&ent->set), FcCharSetGetNumbers(fcs), fcs->num * sizeof (FcChar16))) { FcBool ok = FcTrue; int i; for (i = 0; i < fcs->num; i++) if (FcCharSetGetLeaf(&ent->set, i) != FcCharSetGetLeaf(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; FcMemAlloc (FC_MEM_CHARSET, size); FcCharSetUsed++; FcCharSetUsedEnts += fcs->num; ent->set.ref = FC_REF_CONSTANT; ent->set.num = fcs->num; ent->set.bank = fcs->bank; if (fcs->bank == FC_BANK_DYNAMIC) { if (fcs->num) { ent->set.u.dyn.leaves = (FcCharLeaf **) (ent + 1); ent->set.u.dyn.numbers = (FcChar16 *) (ent->set.u.dyn.leaves + fcs->num); memcpy (ent->set.u.dyn.leaves, fcs->u.dyn.leaves, fcs->num * sizeof (FcCharLeaf *)); memcpy (ent->set.u.dyn.numbers, fcs->u.dyn.numbers, fcs->num * sizeof (FcChar16)); } else { ent->set.u.dyn.leaves = 0; ent->set.u.dyn.numbers = 0; } } else { ent->set.u.stat.leafidx_offset = fcs->u.stat.leafidx_offset; ent->set.u.stat.numbers_offset = fcs->u.stat.numbers_offset; } ent->hash = hash; ent->next = *bucket; *bucket = ent; return &ent->set; } void FcCharSetThawAll (void) { int i; FcCharSetEnt *ent, *next; for (i = 0; i < FC_CHAR_SET_HASH_SIZE; i++) { for (ent = FcCharSetHashTable[i]; ent; ent = next) { next = ent->next; free (ent); } FcCharSetHashTable[i] = 0; } FcCharSetTotal = 0; FcCharSetTotalEnts = 0; FcCharSetUsed = 0; FcCharSetUsedEnts = 0; FcCharSetThawAllLeaf (); } 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 (FcCharSetGetLeaf(fcs, i)); if (!l) goto bail1; if (!FcCharSetInsertLeaf (b, FcCharSetGetNumbers(fcs)[i] << 8, l)) goto bail1; } n = FcCharSetFreezeBase (b); bail1: if (b->bank == FC_BANK_DYNAMIC) { if (b->u.dyn.leaves) { FcMemFree (FC_MEM_CHARSET, b->num * sizeof (FcCharLeaf *)); free (b->u.dyn.leaves); } if (b->u.dyn.numbers) { FcMemFree (FC_MEM_CHARSET, b->num * sizeof (FcChar16)); free (b->u.dyn.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->bank == FC_BANK_DYNAMIC) { if (c->u.dyn.leaves) { FcMemFree (FC_MEM_CHARSET, c->num * sizeof (FcCharLeaf *)); free (c->u.dyn.leaves); } if (c->u.dyn.numbers) { FcMemFree (FC_MEM_CHARSET, c->num * sizeof (FcChar16)); free (c->u.dyn.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; /* 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; } void FcCharSetNewBank(void) { charset_count = 0; charset_numbers_count = 0; charset_leaf_count = 0; charset_leaf_idx_count = 0; } int FcCharSetNeededBytes (const FcCharSet *c) { /* yes, there's redundancy */ charset_count++; charset_leaf_idx_count++; charset_leaf_count += c->num; charset_numbers_count += c->num; return sizeof (FcCharSet) + sizeof (int) + /* leaf_idx */ sizeof (FcCharLeaf) * c->num + /* leaf */ sizeof (FcChar16) * c->num; /* number */ } static FcBool FcCharSetEnsureBank (int bi) { if (!charsets || charset_bank_count <= bi) { int new_count = charset_bank_count + 2; FcCharSet ** cs; FcChar16 ** n; FcCharLeaf ** lvs; int ** lvi; int i; cs = realloc(charsets, sizeof(FcCharSet*) * new_count); if (!cs) return 0; n = realloc(numbers, sizeof(FcChar16*) * new_count); if (!n) return 0; lvs = realloc(leaves, sizeof(FcCharLeaf*) * new_count); if (!lvs) return 0; lvi = realloc(leaf_idx, sizeof(int*) * new_count); if (!lvi) return 0; charsets = cs; numbers = n; leaves = lvs; leaf_idx = lvi; for (i = charset_bank_count; i < new_count; i++) { charsets[i] = 0; numbers[i] = 0; leaves[i] = 0; leaf_idx[i] = 0; } charset_bank_count = new_count; } return FcTrue; } void * FcCharSetDistributeBytes (FcCache * metadata, void * block_ptr) { int bi = FcCacheBankToIndex(metadata->bank); if (!FcCharSetEnsureBank(bi)) return 0; charsets[bi] = (FcCharSet *)block_ptr; block_ptr = (void *)((char *)block_ptr + (sizeof (FcCharSet) * charset_count)); numbers[bi] = (FcChar16 *)block_ptr; block_ptr = (void *)((char *)block_ptr + (sizeof(FcChar16) * charset_numbers_count)); leaves[bi] = (FcCharLeaf *)block_ptr; block_ptr = (void *)((char *)block_ptr + (sizeof(FcCharLeaf) * charset_leaf_count)); leaf_idx[bi] = (int *)block_ptr; block_ptr = (void *)((char *)block_ptr + (sizeof(int) * charset_leaf_idx_count)); metadata->charset_count = charset_count; metadata->charset_numbers_count = charset_numbers_count; metadata->charset_leaf_count = charset_leaf_count; metadata->charset_leaf_idx_count = charset_leaf_idx_count; charset_ptr = 0; charset_leaf_ptr = 0; charset_leaf_idx_ptr = 0; charset_numbers_ptr = 0; return block_ptr; } FcCharSet * FcCharSetSerialize(int bank, FcCharSet *c) { int i; FcCharSet new; int bi = FcCacheBankToIndex(bank), cp = charset_ptr; new.ref = FC_REF_CONSTANT; new.bank = bank; new.u.stat.leafidx_offset = charset_leaf_idx_ptr; new.u.stat.numbers_offset = charset_numbers_ptr; new.num = c->num; charsets[bi][charset_ptr++] = new; leaf_idx[bi][charset_leaf_idx_ptr++] = charset_leaf_ptr; for (i = 0; i < c->num; i++) { memcpy (&leaves[bi][charset_leaf_ptr++], c->u.dyn.leaves[i], sizeof(FcCharLeaf)); numbers[bi][charset_numbers_ptr++] = c->u.dyn.numbers[i]; } return &charsets[bi][cp]; } void * FcCharSetUnserialize (FcCache metadata, void *block_ptr) { int bi = FcCacheBankToIndex(metadata.bank); if (!FcCharSetEnsureBank(bi)) return 0; charsets[bi] = (FcCharSet *)block_ptr; block_ptr = (void *)((char *)block_ptr + (sizeof (FcCharSet) * metadata.charset_count)); numbers[bi] = (FcChar16 *)block_ptr; block_ptr = (void *)((char *)block_ptr + (sizeof(FcChar16) * metadata.charset_numbers_count)); leaves[bi] = (FcCharLeaf *)block_ptr; block_ptr = (void *)((char *)block_ptr + (sizeof(FcCharLeaf) * metadata.charset_leaf_count)); leaf_idx[bi] = (int *)block_ptr; block_ptr = (void *)((char *)block_ptr + (sizeof(int) * metadata.charset_leaf_idx_count)); return block_ptr; } FcCharLeaf * FcCharSetGetLeaf(const FcCharSet *c, int i) { int bi; if (c->bank == FC_BANK_DYNAMIC) return c->u.dyn.leaves[i]; bi = FcCacheBankToIndex(c->bank); return &leaves[bi][leaf_idx[bi][c->u.stat.leafidx_offset]+i]; } FcChar16 * FcCharSetGetNumbers(const FcCharSet *c) { int bi; if (c->bank == FC_BANK_DYNAMIC) return c->u.dyn.numbers; bi = FcCacheBankToIndex(c->bank); return &numbers[bi][c->u.stat.numbers_offset]; }