#include <stdlib.h>
#include <string.h>
#include <assert.h>
-#include <sys/mman.h>
#include "fcint.h"
-static FcPattern * fcpatterns = NULL;
-static int fcpattern_ptr, fcpattern_count;
-static FcPatternElt * fcpatternelts = NULL;
+static FcPattern ** _fcPatterns = 0;
+static int fcpattern_bank_count = 0, fcpattern_ptr, fcpattern_count;
+FcPatternElt ** _fcPatternElts = 0;
static int fcpatternelt_ptr, fcpatternelt_count;
-static FcValueList * fcvaluelists = NULL;
-static int fcvaluelist_ptr, fcvaluelist_count;
-
-static char * object_content;
-static int object_content_count;
-static int object_content_ptr;
-
-static FcBool
-FcPatternEltIsDynamic (FcPatternEltPtr pei);
+FcValueList ** _fcValueLists = 0;
+static int fcvaluelist_bank_count = 0, fcvaluelist_ptr, fcvaluelist_count;
static FcPatternEltPtr
FcPatternEltPtrCreateDynamic (FcPatternElt * e);
+/* If you are trying to duplicate an FcPattern which will be used for
+ * rendering, be aware that (internally) you also have to use
+ * FcPatternTransferFullFname to transfer the associated filename. If
+ * you are copying the font (externally) using FcPatternGetString,
+ * then everything's fine; this caveat only applies if you're copying
+ * the bits individually. */
+
FcPattern *
FcPatternCreate (void)
{
p->num = 0;
p->size = 0;
p->elts = FcPatternEltPtrCreateDynamic(0);
+ p->bank = FC_BANK_DYNAMIC;
p->ref = 1;
return p;
}
{
switch (v.type) {
case FcTypeString:
- FcObjectPtrDestroy (v.u.si);
+ FcStrFree ((FcChar8 *) v.u.s);
break;
case FcTypeMatrix:
- FcMatrixPtrDestroy (v.u.mi);
+ FcMatrixFree ((FcMatrix *) v.u.m);
break;
case FcTypeCharSet:
- FcCharSetPtrDestroy (v.u.ci);
+ FcCharSetDestroy ((FcCharSet *) v.u.c);
break;
case FcTypeLangSet:
- FcLangSetPtrDestroy (v.u.li);
+ FcLangSetDestroy ((FcLangSet *) v.u.l);
break;
default:
break;
}
}
+FcValue
+FcValueCanonicalize (const FcValue *v)
+{
+ if (v->type & FC_STORAGE_STATIC)
+ {
+ FcValue new = *v;
+
+ switch (v->type & ~FC_STORAGE_STATIC)
+ {
+ case FcTypeString:
+ new.u.s = fc_value_string(v);
+ new.type = FcTypeString;
+ break;
+ case FcTypeCharSet:
+ new.u.c = fc_value_charset(v);
+ new.type = FcTypeCharSet;
+ break;
+ case FcTypeLangSet:
+ new.u.l = fc_value_langset(v);
+ new.type = FcTypeLangSet;
+ break;
+ }
+ return new;
+ }
+ return *v;
+}
+
FcValue
FcValueSave (FcValue v)
{
switch (v.type) {
case FcTypeString:
- v.u.si = FcObjectPtrCreateDynamic(FcStrCopy (FcObjectPtrU(v.u.si)));
- if (!FcObjectPtrU(v.u.si))
+ v.u.s = FcStrCopy (v.u.s);
+ if (!v.u.s)
v.type = FcTypeVoid;
break;
case FcTypeMatrix:
- v.u.mi = FcMatrixPtrCreateDynamic
- (FcMatrixCopy (FcMatrixPtrU(v.u.mi)));
- if (!FcMatrixPtrU(v.u.mi))
+ v.u.m = FcMatrixCopy (v.u.m);
+ if (!v.u.m)
v.type = FcTypeVoid;
break;
case FcTypeCharSet:
- v.u.ci = FcCharSetPtrCreateDynamic
- (FcCharSetCopy (FcCharSetPtrU(v.u.ci)));
- if (!FcCharSetPtrU(v.u.ci))
+ v.u.c = FcCharSetCopy ((FcCharSet *) v.u.c);
+ if (!v.u.c)
v.type = FcTypeVoid;
break;
case FcTypeLangSet:
- v.u.li = FcLangSetPtrCreateDynamic
- (FcLangSetCopy (FcLangSetPtrU(v.u.li)));
- if (!FcLangSetPtrU(v.u.li))
+ v.u.l = FcLangSetCopy (v.u.l);
+ if (!v.u.l)
v.type = FcTypeVoid;
break;
default:
{
switch (FcValueListPtrU(l)->value.type) {
case FcTypeString:
- FcObjectPtrDestroy (FcValueListPtrU(l)->value.u.si);
+ FcStrFree ((FcChar8 *)FcValueListPtrU(l)->value.u.s);
break;
case FcTypeMatrix:
- FcMatrixPtrDestroy (FcValueListPtrU(l)->value.u.mi);
+ FcMatrixFree ((FcMatrix *)FcValueListPtrU(l)->value.u.m);
break;
case FcTypeCharSet:
FcCharSetDestroy
- (FcCharSetPtrU (FcValueListPtrU(l)->value.u.ci));
+ ((FcCharSet *) (FcValueListPtrU(l)->value.u.c));
break;
case FcTypeLangSet:
FcLangSetDestroy
- (FcLangSetPtrU (FcValueListPtrU(l)->value.u.li));
+ ((FcLangSet *) (FcValueListPtrU(l)->value.u.l));
break;
default:
break;
}
next = FcValueListPtrU(l)->next;
-
FcMemFree (FC_MEM_VALLIST, sizeof (FcValueList));
- if (l.storage == FcStorageDynamic)
+ if (l.bank == FC_BANK_DYNAMIC)
free(l.u.dyn);
}
}
case FcTypeDouble:
return va.u.d == vb.u.d;
case FcTypeString:
- return FcStrCmpIgnoreCase (FcObjectPtrU(va.u.si),
- FcObjectPtrU(vb.u.si)) == 0;
+ return FcStrCmpIgnoreCase (va.u.s, vb.u.s) == 0;
case FcTypeBool:
return va.u.b == vb.u.b;
case FcTypeMatrix:
- return FcMatrixEqual (FcMatrixPtrU(va.u.mi),
- FcMatrixPtrU(vb.u.mi));
+ return FcMatrixEqual (va.u.m, vb.u.m);
case FcTypeCharSet:
- return FcCharSetEqual (FcCharSetPtrU(va.u.ci),
- FcCharSetPtrU(vb.u.ci));
+ return FcCharSetEqual (va.u.c, vb.u.c);
case FcTypeFTFace:
return va.u.f == vb.u.f;
case FcTypeLangSet:
- return FcLangSetEqual (FcLangSetPtrU(va.u.li),
- FcLangSetPtrU(vb.u.li));
+ return FcLangSetEqual (va.u.l, vb.u.l);
}
return FcFalse;
}
return (FcChar32) d;
}
-static FcChar32
+FcChar32
FcStringHash (const FcChar8 *s)
{
FcChar8 c;
}
static FcChar32
-FcValueHash (FcValue v)
+FcValueHash (const FcValue *v0)
{
+ FcValue v = FcValueCanonicalize(v0);
switch (v.type) {
case FcTypeVoid:
return 0;
case FcTypeDouble:
return FcDoubleHash (v.u.d);
case FcTypeString:
- return FcStringHash (FcObjectPtrU(v.u.si));
+ return FcStringHash (v.u.s);
case FcTypeBool:
return (FcChar32) v.u.b;
case FcTypeMatrix:
- {
- FcMatrix * m = FcMatrixPtrU(v.u.mi);
- return (FcDoubleHash (m->xx) ^
- FcDoubleHash (m->xy) ^
- FcDoubleHash (m->yx) ^
- FcDoubleHash (m->yy));
- }
+ return (FcDoubleHash (v.u.m->xx) ^
+ FcDoubleHash (v.u.m->xy) ^
+ FcDoubleHash (v.u.m->yx) ^
+ FcDoubleHash (v.u.m->yy));
case FcTypeCharSet:
- return (FcChar32) (FcCharSetPtrU(v.u.ci))->num;
+ return (FcChar32) v.u.c->num;
case FcTypeFTFace:
return FcStringHash ((const FcChar8 *) ((FT_Face) v.u.f)->family_name) ^
FcStringHash ((const FcChar8 *) ((FT_Face) v.u.f)->style_name);
case FcTypeLangSet:
- return FcLangSetHash (FcLangSetPtrU(v.u.li));
+ return FcLangSetHash (v.u.l);
}
return FcFalse;
}
while (FcValueListPtrU(l))
{
hash = ((hash << 1) | (hash >> 31)) ^
- FcValueHash (FcValueListPtrU(l)->value);
+ FcValueHash (&FcValueListPtrU(l)->value);
l = FcValueListPtrU(l)->next;
}
return hash;
if (p->ref == FC_REF_CONSTANT || --p->ref > 0)
return;
+ if (FcPatternFindFullFname (p))
+ {
+ FcStrFree ((FcChar8 *)FcPatternFindFullFname (p));
+ FcPatternAddFullFname (p, 0);
+ }
+
for (i = 0; i < p->num; i++)
FcValueListDestroy ((FcPatternEltU(p->elts)+i)->values);
p->num = 0;
- if (FcPatternEltU(p->elts) && FcPatternEltIsDynamic(p->elts))
+ if (FcPatternEltU(p->elts) && p->elts.bank == FC_BANK_DYNAMIC)
{
FcMemFree (FC_MEM_PATELT, p->size * sizeof (FcPatternElt));
free (FcPatternEltU(p->elts));
static int FcValueListFrozenCount[FcTypeLangSet + 1];
static int FcValueListFrozenBytes[FcTypeLangSet + 1];
-static char *FcValueListFrozenName[] = {
+static char FcValueListFrozenName[][8] = {
"Void",
"Integer",
"Double",
for (l = h; FcValueListPtrU(l);
l = FcValueListPtrU(l)->next, new++)
{
- if (FcValueListPtrU(l)->value.type == FcTypeString)
+ if ((FcValueListPtrU(l)->value.type & ~FC_STORAGE_STATIC) == FcTypeString)
{
new->value.type = FcTypeString;
- new->value.u.si = FcObjectStaticName
- (FcObjectPtrU(FcValueListPtrU(l)->value.u.si));
+ new->value.u.s = FcStrStaticName
+ (fc_value_string(&FcValueListPtrU(l)->value));
}
else
{
- new->value = FcValueSave (FcValueListPtrU(l)->value);
+ new->value = FcValueSave (FcValueCanonicalize
+ (&FcValueListPtrU(l)->value));
}
new->binding = FcValueListPtrU(l)->binding;
if (FcValueListPtrU(FcValueListPtrU(l)->next))
(FcPatternEltU(b->elts)+i)->object;
}
+ if (FcPatternFindElt (b, FC_FILE))
+ FcPatternTransferFullFname (ep, b);
+
ent->hash = hash;
ent->next = *bucket;
*bucket = ent;
if (!FcValueListPtrU((FcPatternEltU(p->elts)+i)->values))
goto bail;
}
+
+ if (FcPatternFindElt (p, FC_FILE))
+ FcPatternTransferFullFname (b, p);
+
/*
* Freeze base
*/
return n;
}
-void
-FcPatternThawAll (void)
-{
- FcPatternBaseThawAll ();
- FcValueListThawAll ();
-}
-
static int
FcPatternPosition (const FcPattern *p, const char *object)
{
int low, high, mid, c;
FcObjectPtr obj;
- obj = FcObjectStaticName(object);
+ obj = FcObjectToPtr(object);
low = 0;
high = p->num - 1;
c = 1;
FcMemAlloc (FC_MEM_PATELT, s * sizeof (FcPatternElt));
while (p->size < s)
{
- (FcPatternEltU(p->elts)+p->size)->object = FcObjectPtrCreateDynamic(0);
+ (FcPatternEltU(p->elts)+p->size)->object = 0;
(FcPatternEltU(p->elts)+p->size)->values =
FcValueListPtrCreateDynamic(0);
p->size++;
/* bump count */
p->num++;
- (FcPatternEltU(p->elts)+i)->object = FcObjectStaticName (object);
+ (FcPatternEltU(p->elts)+i)->object = FcObjectToPtr (object);
(FcPatternEltU(p->elts)+i)->values = FcValueListPtrCreateDynamic(0);
}
for (i = 0; i < p->num; i++)
{
h = (((h << 1) | (h >> 31)) ^
- FcStringHash ((const FcChar8 *) FcObjectPtrU(((FcPatternEltU(p->elts)+i)->object))) ^
+ FcStringHash ((FcChar8 *)FcObjectPtrU ((FcPatternEltU(p->elts)+i)->object)) ^
FcValueListHash ((FcPatternEltU(p->elts)+i)->values));
}
return h;
for (i = 0; i < os->nobject; i++)
{
- ea = FcPatternFindElt (pai, FcObjectPtrU(os->objects[i]));
- eb = FcPatternFindElt (pbi, FcObjectPtrU(os->objects[i]));
+ ea = FcPatternFindElt (pai, os->objects[i]);
+ eb = FcPatternFindElt (pbi, os->objects[i]);
if (ea)
{
if (!eb)
{
FcPatternElt *e;
FcValueListPtr new, *prev;
- FcValueList * newp;
+ FcValueList *newp;
+ FcObjectPtr objectPtr;
if (p->ref == FC_REF_CONSTANT)
goto bail0;
if (value.type == FcTypeVoid)
goto bail1;
+ /* quick and dirty hack to enable FcCompareFamily/FcCompareString
+ * speedup: only allow strings to be added under the FC_FAMILY,
+ * FC_FOUNDRY, FC_STYLE, FC_RASTERIZER keys.
+ * and charsets under FC_CHARSET key.
+ * This is slightly semantically different from the old behaviour,
+ * but fonts shouldn't be getting non-strings here anyway.
+ * a better hack would use FcBaseObjectTypes to check all objects. */
+ objectPtr = FcObjectToPtr(object);
+ if ((objectPtr == FcObjectToPtr(FC_FAMILY)
+ || objectPtr == FcObjectToPtr(FC_FOUNDRY)
+ || objectPtr == FcObjectToPtr(FC_STYLE)
+ || objectPtr == FcObjectToPtr(FC_RASTERIZER))
+ && value.type != FcTypeString)
+ goto bail1;
+ if (objectPtr == FcObjectToPtr(FC_CHARSET)
+ && value.type != FcTypeCharSet)
+ goto bail1;
+
FcValueListPtrU(new)->value = value;
FcValueListPtrU(new)->binding = binding;
FcValueListPtrU(new)->next = FcValueListPtrCreateDynamic(0);
bail2:
switch (value.type) {
case FcTypeString:
- FcStrFree ((FcChar8 *) FcObjectPtrU(value.u.si));
+ FcStrFree ((FcChar8 *) value.u.s);
break;
case FcTypeMatrix:
- FcMatrixFree (FcMatrixPtrU(value.u.mi));
+ FcMatrixFree ((FcMatrix *) value.u.m);
break;
case FcTypeCharSet:
- FcCharSetDestroy (FcCharSetPtrU(value.u.ci));
+ FcCharSetDestroy ((FcCharSet *) value.u.c);
break;
case FcTypeLangSet:
- FcLangSetDestroy (FcLangSetPtrU(value.u.li));
+ FcLangSetDestroy ((FcLangSet *) value.u.l);
break;
default:
break;
(FcPatternEltU(p->elts) + p->num - (e + 1)) *
sizeof (FcPatternElt));
p->num--;
- (FcPatternEltU(p->elts)+p->num)->object = FcObjectPtrCreateDynamic(0);
+ (FcPatternEltU(p->elts)+p->num)->object = 0;
(FcPatternEltU(p->elts)+p->num)->values = FcValueListPtrCreateDynamic(0);
return FcTrue;
}
FcValue v;
v.type = FcTypeString;
- v.u.si = FcObjectPtrCreateDynamic(s);
+ v.u.s = FcStrStaticName(s);
return FcPatternAdd (p, object, v, FcTrue);
}
FcValue v;
v.type = FcTypeMatrix;
- v.u.mi = FcMatrixPtrCreateDynamic((FcMatrix *) s);
+ v.u.m = s;
return FcPatternAdd (p, object, v, FcTrue);
}
FcValue v;
v.type = FcTypeCharSet;
- v.u.ci = FcCharSetPtrCreateDynamic((FcCharSet *)c);
+ v.u.c = (FcCharSet *)c;
return FcPatternAdd (p, object, v, FcTrue);
}
FcValue v;
v.type = FcTypeLangSet;
- v.u.li = FcLangSetPtrCreateDynamic((FcLangSet *)ls);
+ v.u.l = (FcLangSet *)ls;
return FcPatternAdd (p, object, v, FcTrue);
}
{
if (!id)
{
- *v = FcValueListPtrU(l)->value;
+ *v = FcValueCanonicalize(&FcValueListPtrU(l)->value);
return FcResultMatch;
}
id--;
return r;
if (v.type != FcTypeString)
return FcResultTypeMismatch;
- *s = (FcChar8 *) FcObjectPtrU(v.u.si);
+
+ if (FcObjectToPtr(object) == FcObjectToPtr(FC_FILE))
+ {
+ const char *fn, *fpath;
+ FcChar8 *fname;
+ int size;
+
+ fn = FcPatternFindFullFname(p);
+ if (fn)
+ {
+ *s = (FcChar8 *) fn;
+ return FcResultMatch;
+ }
+
+ if (!p->bank)
+ {
+ *s = (FcChar8 *) v.u.s;
+ return FcResultMatch;
+ }
+
+ fpath = FcCacheFindBankDir (p->bank);
+ size = strlen((char*)fpath) + 1 + strlen ((char *)v.u.s) + 1;
+ fname = malloc (size);
+ if (!fname)
+ return FcResultOutOfMemory;
+
+ FcMemAlloc (FC_MEM_STRING, size);
+ strcpy ((char *)fname, (char *)fpath);
+ strcat ((char *)fname, "/");
+ strcat ((char *)fname, (char *)v.u.s);
+
+ FcPatternAddFullFname (p, (const char *)fname);
+ *s = (FcChar8 *)fname;
+ return FcResultMatch;
+ }
+
+ *s = (FcChar8 *) v.u.s;
return FcResultMatch;
}
return r;
if (v.type != FcTypeMatrix)
return FcResultTypeMismatch;
- *m = FcMatrixPtrU(v.u.mi);
+ *m = (FcMatrix *)v.u.m;
return FcResultMatch;
}
return r;
if (v.type != FcTypeCharSet)
return FcResultTypeMismatch;
- *c = FcCharSetPtrU(v.u.ci);
+ *c = (FcCharSet *)v.u.c;
return FcResultMatch;
}
return r;
if (v.type != FcTypeLangSet)
return FcResultTypeMismatch;
- *ls = FcLangSetPtrU(v.u.li);
+ *ls = (FcLangSet *)v.u.l;
return FcResultMatch;
}
FcValueListPtrU(l);
l = FcValueListPtrU(l)->next)
if (!FcPatternAdd (new, FcObjectPtrU((e + i)->object),
- FcValueListPtrU(l)->value, FcTrue))
+ FcValueCanonicalize(&FcValueListPtrU(l)->value),
+ FcTrue))
goto bail1;
}
+ FcPatternTransferFullFname (new, orig);
return new;
v = FcValueListPtrU(v)->next)
{
if (!FcPatternAddWithBinding (p, FcObjectPtrU(e->object),
- FcValueListPtrU(v)->value,
+ FcValueCanonicalize(&FcValueListPtrU(v)->value),
FcValueListPtrU(v)->binding, FcTrue))
return FcFalse;
}
}
#define OBJECT_HASH_SIZE 31
-struct objectBucket {
+static struct objectBucket {
struct objectBucket *next;
FcChar32 hash;
-};
-static struct objectBucket **buckets = 0;
+} *FcObjectBuckets[OBJECT_HASH_SIZE];
-FcObjectPtr
-FcObjectStaticName (const char *name)
+const FcChar8 *
+FcStrStaticName (const FcChar8 *name)
{
- FcChar32 hash = FcStringHash ((const FcChar8 *) name);
+ FcChar32 hash = FcStringHash (name);
struct objectBucket **p;
struct objectBucket *b;
- const char * nn;
int size;
- FcObjectPtr new;
-
- if (!buckets)
- {
- buckets = malloc(sizeof (struct objectBucket *)*OBJECT_HASH_SIZE);
- memset (buckets, 0, sizeof (struct objectBucket *)*OBJECT_HASH_SIZE);
- }
- for (p = &buckets[hash % OBJECT_HASH_SIZE]; (b = *p); p = &(b->next))
- if (b->hash == hash && !strcmp (name, FcObjectPtrU(*((FcObjectPtr *) (b + 1)))))
- return *((FcObjectPtr *) (b + 1));
- size = sizeof (struct objectBucket) + sizeof (FcObjectPtr) + 1;
- b = malloc (size);
- FcMemAlloc (FC_MEM_STATICSTR, size);
+ for (p = &FcObjectBuckets[hash % OBJECT_HASH_SIZE]; (b = *p); p = &(b->next))
+ if (b->hash == hash && !strcmp ((char *)name, (char *) (b + 1)))
+ return (FcChar8 *) (b + 1);
+ size = sizeof (struct objectBucket) + strlen ((char *)name) + 1;
+ b = malloc (size + sizeof (int));
+ /* workaround glibc bug which reads strlen in groups of 4 */
+ FcMemAlloc (FC_MEM_STATICSTR, size + sizeof (int));
if (!b)
- return FcObjectPtrCreateDynamic(0);
+ return NULL;
b->next = 0;
b->hash = hash;
- nn = malloc(strlen(name)+1);
- if (!nn)
- goto bail;
- strcpy ((char *)nn, name);
- new = FcObjectPtrCreateDynamic ((char *) nn);
- *((FcObjectPtr *)(b+1)) = new;
+ strcpy ((char *) (b + 1), (char *)name);
*p = b;
- return new;
-
- bail:
- free(b);
- return FcObjectPtrCreateDynamic(0);
+ return (FcChar8 *) (b + 1);
}
-FcPatternElt *
-FcPatternEltU (FcPatternEltPtr pei)
+static void
+FcStrStaticNameFini (void)
{
- switch (pei.storage)
+ int i, size;
+ struct objectBucket *b, *next;
+ char *name;
+
+ for (i = 0; i < OBJECT_HASH_SIZE; i++)
{
- case FcStorageStatic:
- if (pei.u.stat == 0) return 0;
- return &fcpatternelts[pei.u.stat];
- case FcStorageDynamic:
- return pei.u.dyn;
- default:
- return 0;
+ for (b = FcObjectBuckets[i]; b; b = next)
+ {
+ next = b->next;
+ name = (char *) (b + 1);
+ size = sizeof (struct objectBucket) + strlen (name) + 1;
+ FcMemFree (FC_MEM_STATICSTR, size);
+ free (b);
+ }
+ FcObjectBuckets[i] = 0;
}
}
+void
+FcPatternFini (void)
+{
+ FcPatternBaseThawAll ();
+ FcValueListThawAll ();
+ FcStrStaticNameFini ();
+ FcObjectStaticNameFini ();
+}
+
static FcPatternEltPtr
FcPatternEltPtrCreateDynamic (FcPatternElt * e)
{
FcPatternEltPtr new;
- new.storage = FcStorageDynamic;
+ new.bank = FC_BANK_DYNAMIC;
new.u.dyn = e;
return new;
}
static FcPatternEltPtr
-FcPatternEltPtrCreateStatic (int i)
+FcPatternEltPtrCreateStatic (int bank, int i)
{
FcPatternEltPtr new;
- new.storage = FcStorageStatic;
+ new.bank = bank;
new.u.stat = i;
return new;
}
-static FcBool
-FcPatternEltIsDynamic (FcPatternEltPtr pei)
-{
- return pei.storage == FcStorageDynamic;
-}
+static void
+FcStrNewBank (void);
+static int
+FcStrNeededBytes (const FcChar8 * s);
+static int
+FcStrNeededBytesAlign (void);
+static void *
+FcStrDistributeBytes (FcCache * metadata, void * block_ptr);
+static const FcChar8 *
+FcStrSerialize (int bank, const FcChar8 * s);
+static void *
+FcStrUnserialize (FcCache * metadata, void *block_ptr);
-struct objectTree {
- struct objectTree * left, * right;
- char * s;
-};
+static void
+FcValueListNewBank (void);
+static int
+FcValueListNeededBytes (FcValueList * vl);
+static int
+FcValueListNeededBytesAlign (void);
+static void *
+FcValueListDistributeBytes (FcCache * metadata, void *block_ptr);
+static FcValueListPtr
+FcValueListSerialize(int bank, FcValueList *pi);
+static void *
+FcValueListUnserialize (FcCache * metadata, void *block_ptr);
-FcObjectPtr
-FcObjectPtrCreateDynamic (const char * s)
-{
- FcObjectPtr new;
- new.storage = FcStorageDynamic;
- new.u.dyn = s;
- if (s)
- new.hash = FcStringHash(s);
- else
- new.hash = 0;
- return new;
-}
void
-FcObjectPtrDestroy (FcObjectPtr p)
+FcPatternNewBank (void)
{
- if (p.storage == FcStorageDynamic)
- FcStrFree ((char *)p.u.dyn);
-}
+ fcpattern_count = 0;
+ fcpatternelt_count = 0;
-const char *
-FcObjectPtrU (FcObjectPtr si)
-{
- switch (si.storage)
- {
- case FcStorageStatic:
- if (si.u.stat == 0) return 0;
- return &object_content[si.u.stat];
- case FcStorageDynamic:
- return si.u.dyn;
- default:
- return 0;
- }
+ FcStrNewBank();
+ FcValueListNewBank();
}
int
-FcObjectPtrCompare (const FcObjectPtr a, const FcObjectPtr b)
+FcPatternNeededBytes (FcPattern * p)
{
- int r = a.hash - b.hash;
+ int i, cum = 0, c;
- if (r == 0)
- return strcmp (FcObjectPtrU(a), FcObjectPtrU(b));
- return r;
+ fcpattern_count++;
+ fcpatternelt_count += p->num;
+
+ for (i = 0; i < p->num; i++)
+ {
+ c = FcValueListNeededBytes (FcValueListPtrU
+ (((FcPatternEltU(p->elts)+i)->values)));
+ if (c < 0)
+ return c;
+ cum += c;
+ }
+
+ return cum + sizeof (FcPattern) + sizeof(FcPatternElt)*p->num;
}
-void
-FcObjectClearStatic(void)
+int
+FcPatternNeededBytesAlign (void)
{
- object_content = 0;
- object_content_count = 0;
- object_content_ptr = 0;
+ return __alignof__ (FcPattern) + __alignof__ (FcPatternElt) +
+ FcValueListNeededBytesAlign ();
}
-static FcObjectPtr
-FcObjectSerialize (FcObjectPtr si)
+static FcBool
+FcPatternEnsureBank (int bi)
{
- struct objectBucket **p;
- struct objectBucket *b;
+ FcPattern **pp;
+ FcPatternElt **ep;
+ int i;
- if (!object_content)
+ if (!_fcPatterns || fcpattern_bank_count <= bi)
{
- object_content = malloc(object_content_count * sizeof(char));
- if (!object_content)
- return FcObjectPtrCreateDynamic(0);
- }
+ int new_count = bi + 4;
+ pp = realloc (_fcPatterns, sizeof (FcPattern *) * new_count);
+ if (!pp)
+ return 0;
- if (!buckets)
- return FcObjectPtrCreateDynamic(0);
+ FcMemAlloc (FC_MEM_PATTERN, sizeof (FcPattern *) * new_count);
+ _fcPatterns = pp;
- for (p = &buckets[si.hash % OBJECT_HASH_SIZE]; (b = *p); p = &(b->next))
- if (b->hash == si.hash && !strcmp (FcObjectPtrU(si), FcObjectPtrU(*((FcObjectPtr *) (b + 1)))))
- {
- FcObjectPtr *op = (FcObjectPtr *) (b + 1);
- if (op->storage == FcStorageStatic)
- return *op;
-
- if (object_content_ptr >= object_content_count)
- return FcObjectPtrCreateDynamic(0);
+ ep = realloc (_fcPatternElts, sizeof (FcPatternElt *) * new_count);
+ if (!ep)
+ return 0;
- strcpy (object_content+object_content_ptr,
- FcObjectPtrU(si));
+ FcMemAlloc (FC_MEM_PATELT, sizeof (FcPatternElt *) * new_count);
+ _fcPatternElts = ep;
- op->storage = FcStorageStatic;
- op->u.stat = object_content_ptr;
-
- object_content_ptr += strlen(FcObjectPtrU(si))+1;
-
- return *op;
+ for (i = fcpattern_bank_count; i < new_count; i++)
+ {
+ _fcPatterns[i] = 0;
+ _fcPatternElts[i] = 0;
}
- return FcObjectPtrCreateDynamic(0);
-}
+ fcpattern_bank_count = new_count;
+ }
-FcBool
-FcObjectPrepareSerialize (FcObjectPtr si)
-{
- object_content_count += strlen(FcObjectPtrU(si)) + 1;
+ FcMemAlloc (FC_MEM_PATTERN, sizeof (FcPattern) * fcpattern_count);
return FcTrue;
}
-void
-FcPatternClearStatic (void)
+void *
+FcPatternDistributeBytes (FcCache * metadata, void * block_ptr)
{
- fcpatterns = 0;
- fcpattern_ptr = 0;
- fcpattern_count = 0;
+ int bi = FcCacheBankToIndex(metadata->bank);
+
+ if (!FcPatternEnsureBank(bi))
+ return 0;
- fcpatternelts = 0;
+ fcpattern_ptr = 0;
+ block_ptr = ALIGN(block_ptr, FcPattern);
+ _fcPatterns[bi] = (FcPattern *)block_ptr;
+ block_ptr = (void *)((char *)block_ptr +
+ (sizeof (FcPattern) * fcpattern_count));
+
+ FcMemAlloc (FC_MEM_PATELT, sizeof (FcPatternElt) * fcpatternelt_count);
fcpatternelt_ptr = 0;
- fcpatternelt_count = 0;
-}
+ block_ptr = ALIGN(block_ptr, FcPatternElt);
+ _fcPatternElts[bi] = (FcPatternElt *)block_ptr;
+ block_ptr = (void *)((char *)block_ptr +
+ (sizeof (FcPatternElt) * fcpatternelt_count));
-void
-FcValueListClearStatic (void)
-{
- fcvaluelists = 0;
- fcvaluelist_ptr = 0;
- fcvaluelist_count = 0;
+ metadata->pattern_count = fcpattern_count;
+ metadata->patternelt_count = fcpatternelt_count;
+
+ block_ptr = FcStrDistributeBytes (metadata, block_ptr);
+ block_ptr = FcValueListDistributeBytes (metadata, block_ptr);
+ return block_ptr;
}
-FcBool
-FcPatternPrepareSerialize (FcPattern * p)
+FcPattern *
+FcPatternSerialize (int bank, FcPattern *old)
{
- int i;
+ FcPattern *p;
+ FcPatternElt *e, *nep;
+ FcValueList * nv;
+ FcValueListPtr v, nv_head, nvp;
+ int i, elts, bi = FcCacheBankToIndex(bank);
- fcpattern_count++;
- fcpatternelt_count += p->num;
+ p = &_fcPatterns[bi][fcpattern_ptr++];
+ p->bank = bank;
+ elts = fcpatternelt_ptr;
+ nep = &_fcPatternElts[bi][elts];
+ if (!nep)
+ return FcFalse;
- for (i = 0; i < p->num; i++)
+ fcpatternelt_ptr += old->num;
+
+ for (e = FcPatternEltU(old->elts), i=0; i < old->num; i++, e++)
{
- FcObjectPrepareSerialize
- ((FcPatternEltU(p->elts)+i)->object);
- if (!FcValueListPrepareSerialize
- (FcValueListPtrU(((FcPatternEltU(p->elts)+i)->values))))
- return FcFalse;
+ v = e->values;
+ nvp = nv_head = FcValueListSerialize(bank, FcValueListPtrU(v));
+ if (!FcValueListPtrU(nv_head))
+ return 0;
+ nv = FcValueListPtrU(nvp);
+
+ for (;
+ FcValueListPtrU(v);
+ v = FcValueListPtrU(v)->next,
+ nv = FcValueListPtrU(nv->next))
+ {
+
+ if (FcValueListPtrU(FcValueListPtrU(v)->next))
+ {
+ nvp = FcValueListSerialize
+ (bank, FcValueListPtrU(FcValueListPtrU(v)->next));
+ nv->next = nvp;
+ }
+ }
+
+ nep[i].values = nv_head;
+ nep[i].object = e->object;
}
- return FcTrue;
+ p->elts = old->elts;
+ p->elts = FcPatternEltPtrCreateStatic(bank, elts);
+ p->size = old->num;
+ p->num = old->num;
+ p->ref = FC_REF_CONSTANT;
+ return p;
}
-FcBool
-FcValueListPrepareSerialize (FcValueList *p)
+void *
+FcPatternUnserialize (FcCache * metadata, void *block_ptr)
+{
+ int bi = FcCacheBankToIndex(metadata->bank);
+ if (!FcPatternEnsureBank(bi))
+ return FcFalse;
+
+ FcMemAlloc (FC_MEM_PATTERN, sizeof (FcPattern) * metadata->pattern_count);
+ block_ptr = ALIGN(block_ptr, FcPattern);
+ _fcPatterns[bi] = (FcPattern *)block_ptr;
+ block_ptr = (void *)((char *)block_ptr +
+ (sizeof (FcPattern) * metadata->pattern_count));
+
+ FcMemAlloc (FC_MEM_PATELT,
+ sizeof (FcPatternElt) * metadata->patternelt_count);
+ block_ptr = ALIGN(block_ptr, FcPatternElt);
+ _fcPatternElts[bi] = (FcPatternElt *)block_ptr;
+ block_ptr = (void *)((char *)block_ptr +
+ (sizeof (FcPatternElt) * metadata->patternelt_count));
+
+ block_ptr = FcStrUnserialize (metadata, block_ptr);
+ block_ptr = FcValueListUnserialize (metadata, block_ptr);
+
+ return block_ptr;
+}
+
+static void
+FcValueListNewBank (void)
+{
+ fcvaluelist_count = 0;
+
+ FcCharSetNewBank();
+ FcLangSetNewBank();
+}
+
+static int
+FcValueListNeededBytes (FcValueList *p)
{
FcValueList *vl;
+ int cum = 0;
for (vl = p;
vl;
vl = FcValueListPtrU(vl->next))
{
- FcValue v = vl->value;
+ FcValue v = FcValueCanonicalize(&vl->value); // unserialize just in case
switch (v.type)
{
- case FcTypeMatrix:
- FcMatrixPrepareSerialize(FcMatrixPtrU(v.u.mi));
- break;
case FcTypeCharSet:
- FcCharSetPrepareSerialize(FcCharSetPtrU(v.u.ci));
+ cum += FcCharSetNeededBytes(v.u.c);
break;
case FcTypeLangSet:
- FcLangSetPrepareSerialize(FcLangSetPtrU(v.u.li));
+ cum += FcLangSetNeededBytes(v.u.l);
break;
case FcTypeString:
- FcObjectPrepareSerialize(v.u.si);
+ cum += FcStrNeededBytes(v.u.s);
default:
break;
}
fcvaluelist_count++;
+ cum += sizeof (FcValueList);
}
- return FcTrue;
+ return cum;
}
-FcPattern *
-FcPatternSerialize (FcPattern *old)
+static int
+FcValueListNeededBytesAlign (void)
{
- FcPattern *p;
- FcPatternElt *e, *nep;
- FcValueList * nv;
- FcValueListPtr v, nv_head, nvp;
- int i, elts;
+ return FcCharSetNeededBytesAlign() + FcLangSetNeededBytesAlign() +
+ FcStrNeededBytesAlign() + __alignof__ (FcValueList);
+}
- if (!fcpatterns)
+static FcBool
+FcValueListEnsureBank (int bi)
+{
+ FcValueList **pvl;
+
+ if (!_fcValueLists || fcvaluelist_bank_count <= bi)
{
- p = malloc (sizeof (FcPattern) * fcpattern_count);
- if (!p)
- goto bail;
+ int new_count = bi + 2, i;
- FcMemAlloc (FC_MEM_PATTERN, sizeof (FcPattern) * fcpattern_count);
- fcpatterns = p;
- fcpattern_ptr = 0;
+ pvl = realloc (_fcValueLists, sizeof (FcValueList *) * new_count);
+ if (!pvl)
+ return FcFalse;
- e = malloc (sizeof (FcPatternElt) * fcpatternelt_count);
- if (!e)
- goto bail1;
+ FcMemAlloc (FC_MEM_VALLIST, sizeof (FcValueList *) * new_count);
- FcMemAlloc (FC_MEM_PATELT, sizeof (FcPatternElt) * fcpatternelt_count);
- fcpatternelts = e;
- fcpatternelt_ptr = 0;
- }
+ _fcValueLists = pvl;
+ for (i = fcvaluelist_bank_count; i < new_count; i++)
+ _fcValueLists[i] = 0;
- p = FcPatternCreate();
- elts = fcpatternelt_ptr;
- nep = &fcpatternelts[elts];
- if (!nep)
- return FcFalse;
- fcpatternelt_ptr += old->num;
-
- for (e = FcPatternEltU(old->elts), i=0; i < old->num; i++, e++)
- {
- v = e->values;
- nvp = nv_head = FcValueListSerialize(FcValueListPtrU(v));
- if (!FcValueListPtrU(nv_head))
- goto bail2;
- nv = FcValueListPtrU(nvp);
-
- for (;
- FcValueListPtrU(v);
- v = FcValueListPtrU(v)->next,
- nv = FcValueListPtrU(nv->next))
- {
-
- if (FcValueListPtrU(FcValueListPtrU(v)->next))
- {
- nvp = FcValueListSerialize
- (FcValueListPtrU(FcValueListPtrU(v)->next));
- nv->next = nvp;
- }
- }
-
- nep[i].values = nv_head;
- nep[i].object = FcObjectSerialize
- (FcObjectStaticName(FcObjectPtrU(e->object)));
+ fcvaluelist_bank_count = new_count;
}
-
- p->elts = FcPatternEltPtrCreateStatic(elts);
- p->size = old->num;
- p->ref = FC_REF_CONSTANT;
- return p;
-
- bail2:
- free (fcpatternelts);
- bail1:
- free (fcpatterns);
- bail:
- return 0;
- }
+ return FcTrue;
+}
-FcValueListPtr
-FcValueListSerialize(FcValueList *pi)
+static void *
+FcValueListDistributeBytes (FcCache * metadata, void *block_ptr)
+{
+ int bi = FcCacheBankToIndex(metadata->bank);
+
+ if (!FcValueListEnsureBank(bi))
+ return 0;
+
+ FcMemAlloc (FC_MEM_VALLIST, sizeof (FcValueList) * fcvaluelist_count);
+ fcvaluelist_ptr = 0;
+ block_ptr = ALIGN(block_ptr, FcValueList);
+ _fcValueLists[bi] = (FcValueList *)block_ptr;
+ block_ptr = (void *)((char *)block_ptr +
+ (sizeof (FcValueList) * fcvaluelist_count));
+ metadata->valuelist_count = fcvaluelist_count;
+
+ block_ptr = FcCharSetDistributeBytes(metadata, block_ptr);
+ block_ptr = FcLangSetDistributeBytes(metadata, block_ptr);
+
+ return block_ptr;
+}
+
+static FcValueListPtr
+FcValueListSerialize(int bank, FcValueList *pi)
{
FcValueListPtr new;
FcValue * v;
- FcValueList * vl;
+ int bi = FcCacheBankToIndex(bank);
- if (!fcvaluelists)
+ if (!pi)
{
- vl = malloc (sizeof (FcValueList) * fcvaluelist_count);
- if (!vl)
- return FcValueListPtrCreateDynamic(0);
-
- FcMemAlloc (FC_MEM_VALLIST, sizeof (FcValueList) * fcvaluelist_count);
- fcvaluelists = vl;
- fcvaluelist_ptr = 0;
+ new.bank = FC_BANK_DYNAMIC;
+ new.u.dyn = 0;
+ return new;
}
- fcvaluelists[fcvaluelist_ptr] = *pi;
- new.storage = FcStorageStatic;
+ _fcValueLists[bi][fcvaluelist_ptr] = *pi;
+ new.bank = bank;
new.u.stat = fcvaluelist_ptr++;
- v = &fcvaluelists[new.u.stat].value;
+ _fcValueLists[bi][new.u.stat].value = FcValueCanonicalize (&pi->value);
+ v = &_fcValueLists[bi][new.u.stat].value;
switch (v->type)
{
case FcTypeString:
- if (FcObjectPtrU(v->u.si))
+ if (v->u.s)
{
- FcObjectPtr si =
- FcObjectSerialize(FcObjectStaticName(FcObjectPtrU(v->u.si)));
- if (!FcObjectPtrU(v->u.si))
+ const FcChar8 * s = FcStrSerialize(bank, v->u.s);
+ if (!s)
return FcValueListPtrCreateDynamic(pi);
- v->u.si = si;
+ v->u.s_off = s - (const FcChar8 *)v;
+ v->type |= FC_STORAGE_STATIC;
}
break;
case FcTypeMatrix:
- if (FcMatrixPtrU(v->u.mi))
- {
- FcMatrixPtr mi = FcMatrixSerialize(FcMatrixPtrU(v->u.mi));
-
- if (!FcMatrixPtrU(mi))
- return FcValueListPtrCreateDynamic(pi);
- v->u.mi = mi;
- }
break;
case FcTypeCharSet:
- if (FcCharSetPtrU(v->u.ci))
+ if (v->u.c)
{
- FcCharSetPtr ci = FcCharSetSerialize(FcCharSetPtrU(v->u.ci));
- if (!FcCharSetPtrU(v->u.ci))
+ FcCharSet * c = FcCharSetSerialize(bank, (FcCharSet *)v->u.c);
+ if (!c)
return FcValueListPtrCreateDynamic(pi);
- v->u.ci = ci;
+ v->u.c_off = (char *)c - (char *)v;
+ v->type |= FC_STORAGE_STATIC;
}
break;
case FcTypeLangSet:
- if (FcLangSetPtrU(v->u.li))
+ if (v->u.l)
{
- FcLangSetPtr li = FcLangSetSerialize(FcLangSetPtrU(v->u.li));
- if (!FcLangSetPtrU(v->u.li))
+ FcLangSet * l = FcLangSetSerialize(bank, (FcLangSet *)v->u.l);
+ if (!l)
return FcValueListPtrCreateDynamic(pi);
- v->u.li = li;
+ v->u.l_off = (char *)l - (char *)v;
+ v->type |= FC_STORAGE_STATIC;
}
break;
default:
return new;
}
-FcValueList *
-FcValueListPtrU (FcValueListPtr pi)
+static void *
+FcValueListUnserialize (FcCache * metadata, void *block_ptr)
{
- switch (pi.storage)
- {
- case FcStorageStatic:
- if (pi.u.stat == 0) return 0;
- return &fcvaluelists[pi.u.stat];
- case FcStorageDynamic:
- return pi.u.dyn;
- default:
+ int bi = FcCacheBankToIndex(metadata->bank);
+
+ if (!FcValueListEnsureBank(bi))
return 0;
- }
+
+ FcMemAlloc (FC_MEM_VALLIST,
+ sizeof (FcValueList) * metadata->valuelist_count);
+ block_ptr = ALIGN(block_ptr, FcValueList);
+ _fcValueLists[bi] = (FcValueList *)block_ptr;
+ block_ptr = (void *)((char *)block_ptr +
+ (sizeof (FcValueList) * metadata->valuelist_count));
+
+ block_ptr = FcCharSetUnserialize(metadata, block_ptr);
+ block_ptr = FcLangSetUnserialize(metadata, block_ptr);
+
+ return block_ptr;
}
FcValueListPtr
{
FcValueListPtr r;
- r.storage = FcStorageDynamic;
+ r.bank = FC_BANK_DYNAMIC;
r.u.dyn = p;
return r;
}
+
+static FcChar8 ** static_strs;
+static int static_str_bank_count = 0, fcstr_ptr, fcstr_count;
+
+static struct objectBucket *FcStrBuckets[OBJECT_HASH_SIZE];
+
+static void
+FcStrNewBank (void)
+{
+ int i, size;
+ struct objectBucket *b, *next;
+ char *name;
+
+ for (i = 0; i < OBJECT_HASH_SIZE; i++)
+ {
+ for (b = FcStrBuckets[i]; b; b = next)
+ {
+ next = b->next;
+ name = (char *) (b + 1);
+ size = sizeof (struct objectBucket) + strlen (name) + 1;
+ FcMemFree (FC_MEM_STATICSTR, size);
+ free (b);
+ }
+ FcStrBuckets[i] = 0;
+ }
+
+ fcstr_count = 0;
+}
+
+static int
+FcStrNeededBytes (const FcChar8 * s)
+{
+ FcChar32 hash = FcStringHash ((const FcChar8 *) s);
+ struct objectBucket **p;
+ struct objectBucket *b;
+ int size;
+
+ for (p = &FcStrBuckets[hash % OBJECT_HASH_SIZE]; (b = *p); p = &(b->next))
+ if (b->hash == hash && !strcmp ((char *)s, (char *) (b + 1)))
+ return 0;
+ size = sizeof (struct objectBucket) + strlen ((char *)s) + 1 + sizeof(char *);
+ b = malloc (size);
+ FcMemAlloc (FC_MEM_STATICSTR, size);
+ if (!b)
+ return -1;
+ b->next = 0;
+ b->hash = hash;
+ strcpy ((char *) (b + 1), (char *)s);
+
+ /* Yes, the following line is convoluted. However, it is
+ * incorrect to replace the with a memset, because the C
+ * specification doesn't guarantee that the null pointer is
+ * the same as the zero bit pattern. */
+ *(char **)((char *) (b + 1) + strlen((char *)s) + 1) = 0;
+ *p = b;
+
+ fcstr_count += strlen((char *)s) + 1;
+ return strlen((char *)s) + 1;
+}
+
+static int
+FcStrNeededBytesAlign (void)
+{
+ return __alignof__ (char);
+}
+
+static FcBool
+FcStrEnsureBank (int bi)
+{
+ FcChar8 ** ss;
+
+ if (!static_strs || static_str_bank_count <= bi)
+ {
+ int new_count = bi + 4, i;
+ ss = realloc (static_strs, sizeof (const char *) * new_count);
+ if (!ss)
+ return FcFalse;
+
+ FcMemAlloc (FC_MEM_STRING, sizeof (const char *) * (new_count-static_str_bank_count));
+ static_strs = ss;
+
+ for (i = static_str_bank_count; i < new_count; i++)
+ static_strs[i] = 0;
+ static_str_bank_count = new_count;
+ }
+ return FcTrue;
+}
+
+static void *
+FcStrDistributeBytes (FcCache * metadata, void * block_ptr)
+{
+ int bi = FcCacheBankToIndex(metadata->bank);
+ if (!FcStrEnsureBank(bi))
+ return 0;
+
+ FcMemAlloc (FC_MEM_STRING, sizeof (char) * fcstr_count);
+ block_ptr = ALIGN (block_ptr, FcChar8);
+ static_strs[bi] = (FcChar8 *)block_ptr;
+ block_ptr = (void *)((char *)block_ptr + (sizeof (char) * fcstr_count));
+ metadata->str_count = fcstr_count;
+ fcstr_ptr = 0;
+
+ return block_ptr;
+}
+
+static const FcChar8 *
+FcStrSerialize (int bank, const FcChar8 * s)
+{
+ FcChar32 hash = FcStringHash ((const FcChar8 *) s);
+ struct objectBucket **p;
+ struct objectBucket *b;
+ int bi = FcCacheBankToIndex(bank);
+
+ for (p = &FcStrBuckets[hash % OBJECT_HASH_SIZE]; (b = *p); p = &(b->next))
+ if (b->hash == hash && !strcmp ((char *)s, (char *) (b + 1)))
+ {
+ FcChar8 * t = *(FcChar8 **)(((FcChar8 *)(b + 1)) + strlen ((char *)s) + 1);
+ if (!t)
+ {
+ strcpy((char *)(static_strs[bi] + fcstr_ptr), (char *)s);
+ *(FcChar8 **)((FcChar8 *) (b + 1) + strlen((char *)s) + 1) = (static_strs[bi] + fcstr_ptr);
+ fcstr_ptr += strlen((char *)s) + 1;
+ t = *(FcChar8 **)(((FcChar8 *)(b + 1)) + strlen ((char *)s) + 1);
+ }
+ return t;
+ }
+ return 0;
+}
+
+static void *
+FcStrUnserialize (FcCache * metadata, void *block_ptr)
+{
+ int bi = FcCacheBankToIndex(metadata->bank);
+ if (!FcStrEnsureBank(bi))
+ return 0;
+
+ FcMemAlloc (FC_MEM_STRING, sizeof (char) * metadata->str_count);
+ block_ptr = ALIGN (block_ptr, FcChar8);
+ static_strs[bi] = (FcChar8 *)block_ptr;
+ block_ptr = (void *)((char *)block_ptr +
+ (sizeof (char) * metadata->str_count));
+
+ return block_ptr;
+}
+
+/* we don't store these in the FcPattern itself because
+ * we don't want to serialize the directory names */
+
+/* I suppose this should be cleaned, too... */
+typedef struct _FcPatternDirMapping {
+ const FcPattern *p;
+ const char *fname;
+} FcPatternDirMapping;
+
+#define PATTERNDIR_HASH_SIZE 31
+static struct patternDirBucket {
+ struct patternDirBucket *next;
+ FcPatternDirMapping m;
+} FcPatternDirBuckets[PATTERNDIR_HASH_SIZE];
+
+void
+FcPatternAddFullFname (const FcPattern *p, const char *fname)
+{
+ struct patternDirBucket *pb;
+
+ /* N.B. FcPatternHash fails, since it's contents-based, not
+ * address-based, and we're in the process of mutating the FcPattern. */
+ for (pb = &FcPatternDirBuckets
+ [((int)p / sizeof (FcPattern *)) % PATTERNDIR_HASH_SIZE];
+ pb->m.p != p && pb->next;
+ pb = pb->next)
+ ;
+
+ if (pb->m.p == p)
+ {
+ pb->m.fname = fname;
+ return;
+ }
+
+ pb->next = malloc (sizeof (struct patternDirBucket));
+ if (!pb->next)
+ return;
+ FcMemAlloc (FC_MEM_CACHE, sizeof (struct patternDirBucket));
+
+ pb->next->next = 0;
+ pb->next->m.p = p;
+ pb->next->m.fname = fname;
+}
+
+const char *
+FcPatternFindFullFname (const FcPattern *p)
+{
+ struct patternDirBucket *pb;
+
+ for (pb = &FcPatternDirBuckets
+ [((int)p / sizeof (FcPattern *)) % PATTERNDIR_HASH_SIZE];
+ pb; pb = pb->next)
+ if (pb->m.p == p)
+ return pb->m.fname;
+
+ return 0;
+}
+
+void
+FcPatternTransferFullFname (const FcPattern *new, const FcPattern *orig)
+{
+ FcChar8 * s;
+ FcPatternGetString (orig, FC_FILE, 0, &s);
+ FcPatternAddFullFname (new,
+ (char *)FcStrCopy
+ ((FcChar8 *)FcPatternFindFullFname(orig)));
+}
git.wh0rd.org / fontconfig.git / blobdiff