#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 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 = FcObjectStaticName(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
*/
int low, high, mid, c;
FcObjectPtr obj;
- obj = FcObjectStaticName(object);
+ obj = FcObjectToPtr(object);
low = 0;
high = p->num - 1;
c = 1;
/* 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;
FcValue v;
v.type = FcTypeString;
- v.u.si = FcObjectStaticName(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;
}
return FcTrue;
}
-FcPatternElt *
-FcPatternEltU (FcPatternEltPtr pei)
+#define OBJECT_HASH_SIZE 31
+static struct objectBucket {
+ struct objectBucket *next;
+ FcChar32 hash;
+} *FcObjectBuckets[OBJECT_HASH_SIZE];
+
+const FcChar8 *
+FcStrStaticName (const FcChar8 *name)
+{
+ FcChar32 hash = FcStringHash (name);
+ struct objectBucket **p;
+ struct objectBucket *b;
+ int 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 NULL;
+ b->next = 0;
+ b->hash = hash;
+ strcpy ((char *) (b + 1), (char *)name);
+ *p = b;
+ return (FcChar8 *) (b + 1);
+}
+
+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);
+
+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);
void
-FcPatternClearStatic (void)
+FcPatternNewBank (void)
{
- fcpatterns = 0;
- fcpattern_ptr = 0;
fcpattern_count = 0;
-
- fcpatternelts = 0;
- fcpatternelt_ptr = 0;
fcpatternelt_count = 0;
-}
-void
-FcValueListClearStatic (void)
-{
- fcvaluelists = 0;
- fcvaluelist_ptr = 0;
- fcvaluelist_count = 0;
+ FcStrNewBank();
+ FcValueListNewBank();
}
-static FcObjectPtr
-FcObjectSerialize (FcObjectPtr si);
-
-FcBool
-FcPatternPrepareSerialize (FcPattern * p)
+int
+FcPatternNeededBytes (FcPattern * p)
{
- int i;
+ int i, cum = 0, c;
fcpattern_count++;
fcpatternelt_count += p->num;
for (i = 0; i < p->num; i++)
{
- FcObjectPrepareSerialize
- ((FcPatternEltU(p->elts)+i)->object);
- if (!FcValueListPrepareSerialize
- (FcValueListPtrU(((FcPatternEltU(p->elts)+i)->values))))
- return FcFalse;
+ c = FcValueListNeededBytes (FcValueListPtrU
+ (((FcPatternEltU(p->elts)+i)->values)));
+ if (c < 0)
+ return c;
+ cum += c;
}
- return FcTrue;
+ return cum + sizeof (FcPattern) + sizeof(FcPatternElt)*p->num;
}
-FcBool
-FcValueListPrepareSerialize (FcValueList *p)
+int
+FcPatternNeededBytesAlign (void)
{
- FcValueList *vl;
+ return __alignof__ (FcPattern) + __alignof__ (FcPatternElt) +
+ FcValueListNeededBytesAlign ();
+}
- for (vl = p;
- vl;
- vl = FcValueListPtrU(vl->next))
+static FcBool
+FcPatternEnsureBank (int bi)
+{
+ FcPattern **pp;
+ FcPatternElt **ep;
+ int i;
+
+ if (!_fcPatterns || fcpattern_bank_count <= bi)
{
- FcValue v = vl->value;
+ int new_count = bi + 4;
+ pp = realloc (_fcPatterns, sizeof (FcPattern *) * new_count);
+ if (!pp)
+ return 0;
- switch (v.type)
+ FcMemAlloc (FC_MEM_PATTERN, sizeof (FcPattern *) * new_count);
+ _fcPatterns = pp;
+
+ ep = realloc (_fcPatternElts, sizeof (FcPatternElt *) * new_count);
+ if (!ep)
+ return 0;
+
+ FcMemAlloc (FC_MEM_PATELT, sizeof (FcPatternElt *) * new_count);
+ _fcPatternElts = ep;
+
+ for (i = fcpattern_bank_count; i < new_count; i++)
{
- case FcTypeMatrix:
- FcMatrixPrepareSerialize(FcMatrixPtrU(v.u.mi));
- break;
- case FcTypeCharSet:
- FcCharSetPrepareSerialize(FcCharSetPtrU(v.u.ci));
- break;
- case FcTypeLangSet:
- FcLangSetPrepareSerialize(FcLangSetPtrU(v.u.li));
- break;
- case FcTypeString:
- FcObjectPrepareSerialize(v.u.si);
- default:
- break;
+ _fcPatterns[i] = 0;
+ _fcPatternElts[i] = 0;
}
- fcvaluelist_count++;
+
+ fcpattern_bank_count = new_count;
}
-
+
+ FcMemAlloc (FC_MEM_PATTERN, sizeof (FcPattern) * fcpattern_count);
return FcTrue;
}
+void *
+FcPatternDistributeBytes (FcCache * metadata, void * block_ptr)
+{
+ int bi = FcCacheBankToIndex(metadata->bank);
+
+ if (!FcPatternEnsureBank(bi))
+ return 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;
+ block_ptr = ALIGN(block_ptr, FcPatternElt);
+ _fcPatternElts[bi] = (FcPatternElt *)block_ptr;
+ block_ptr = (void *)((char *)block_ptr +
+ (sizeof (FcPatternElt) * fcpatternelt_count));
+
+ 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;
+}
+
FcPattern *
-FcPatternSerialize (FcPattern *old)
+FcPatternSerialize (int bank, FcPattern *old)
{
FcPattern *p;
FcPatternElt *e, *nep;
FcValueList * nv;
FcValueListPtr v, nv_head, nvp;
- int i, elts;
-
- if (!fcpatterns)
- {
- p = malloc (sizeof (FcPattern) * fcpattern_count);
- if (!p)
- goto bail;
+ int i, elts, bi = FcCacheBankToIndex(bank);
- FcMemAlloc (FC_MEM_PATTERN, sizeof (FcPattern) * fcpattern_count);
- fcpatterns = p;
- fcpattern_ptr = 0;
-
- e = malloc (sizeof (FcPatternElt) * fcpatternelt_count);
- if (!e)
- goto bail1;
-
- FcMemAlloc (FC_MEM_PATELT, sizeof (FcPatternElt) * fcpatternelt_count);
- fcpatternelts = e;
- fcpatternelt_ptr = 0;
- }
-
- p = FcPatternCreate();
+ p = &_fcPatterns[bi][fcpattern_ptr++];
+ p->bank = bank;
elts = fcpatternelt_ptr;
- nep = &fcpatternelts[elts];
+ nep = &_fcPatternElts[bi][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));
+ nvp = nv_head = FcValueListSerialize(bank, FcValueListPtrU(v));
if (!FcValueListPtrU(nv_head))
- goto bail2;
+ return 0;
nv = FcValueListPtrU(nvp);
for (;
if (FcValueListPtrU(FcValueListPtrU(v)->next))
{
nvp = FcValueListSerialize
- (FcValueListPtrU(FcValueListPtrU(v)->next));
+ (bank, FcValueListPtrU(FcValueListPtrU(v)->next));
nv->next = nvp;
}
}
nep[i].values = nv_head;
- nep[i].object = FcObjectSerialize
- (FcObjectStaticName(FcObjectPtrU(e->object)));
+ nep[i].object = e->object;
}
-
- p->elts = FcPatternEltPtrCreateStatic(elts);
+
+ p->elts = old->elts;
+ p->elts = FcPatternEltPtrCreateStatic(bank, elts);
p->size = old->num;
+ p->num = old->num;
p->ref = FC_REF_CONSTANT;
return 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));
- bail2:
- free (fcpatternelts);
- bail1:
- free (fcpatterns);
- bail:
- return 0;
- }
+ 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);
-FcValueListPtr
-FcValueListSerialize(FcValueList *pi)
+ 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 = FcValueCanonicalize(&vl->value); // unserialize just in case
+
+ switch (v.type)
+ {
+ case FcTypeCharSet:
+ cum += FcCharSetNeededBytes(v.u.c);
+ break;
+ case FcTypeLangSet:
+ cum += FcLangSetNeededBytes(v.u.l);
+ break;
+ case FcTypeString:
+ cum += FcStrNeededBytes(v.u.s);
+ default:
+ break;
+ }
+ fcvaluelist_count++;
+ cum += sizeof (FcValueList);
+ }
+
+ return cum;
+}
+
+static int
+FcValueListNeededBytesAlign (void)
+{
+ return FcCharSetNeededBytesAlign() + FcLangSetNeededBytesAlign() +
+ FcStrNeededBytesAlign() + __alignof__ (FcValueList);
+}
+
+static FcBool
+FcValueListEnsureBank (int bi)
+{
+ FcValueList **pvl;
+
+ if (!_fcValueLists || fcvaluelist_bank_count <= bi)
+ {
+ int new_count = bi + 2, i;
+
+ pvl = realloc (_fcValueLists, sizeof (FcValueList *) * new_count);
+ if (!pvl)
+ return FcFalse;
+
+ FcMemAlloc (FC_MEM_VALLIST, sizeof (FcValueList *) * new_count);
+
+ _fcValueLists = pvl;
+ for (i = fcvaluelist_bank_count; i < new_count; i++)
+ _fcValueLists[i] = 0;
+
+ fcvaluelist_bank_count = new_count;
+ }
+ return FcTrue;
+}
+
+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;
}
-/* Indices allow us to convert dynamic strings into static
- * strings without having to reassign IDs. We do reassign IDs
- * when serializing, which effectively performs mark-and-sweep
- * garbage collection. */
-
-/* objectptr_count maps FcObjectPtr to:
- + offsets in objectcontent_static_buf (if positive)
- - entries in objectcontent_dynamic (if negative)
-*/
-static int objectptr_count = 1;
-static int objectptr_alloc = 0;
-static int * objectptr_indices = 0;
-
-/* invariant: objectcontent_static_buf must be sorted. */
-/* e.g. objectptr_static_buf = "name\0style\0weight\0" */
-static int objectcontent_static_bytes = 0;
-static char * objectcontent_static_buf;
+static FcChar8 ** static_strs;
+static int static_str_bank_count = 0, fcstr_ptr, fcstr_count;
-/* just a bunch of strings. */
-static int objectcontent_dynamic_count = 1;
-static int objectcontent_dynamic_alloc = 0;
-static const char ** objectcontent_dynamic = 0;
-static int * objectcontent_dynamic_refcount = 0;
+static struct objectBucket *FcStrBuckets[OBJECT_HASH_SIZE];
-#define OBJECT_HASH_SIZE 31
-struct objectBucket {
- struct objectBucket *next;
- FcChar32 hash;
-};
-static struct objectBucket **FcObjectBuckets = 0;
-
-FcObjectPtr
-FcObjectStaticName (const char *name)
+static void
+FcStrNewBank (void)
{
- FcChar32 hash = FcStringHash ((const FcChar8 *) name);
- struct objectBucket **p;
- struct objectBucket *b;
- const char * nn;
- int size;
- FcObjectPtr new;
-
- if (!FcObjectBuckets)
- {
- FcObjectBuckets = malloc(sizeof (struct objectBucket *)*OBJECT_HASH_SIZE);
- memset (FcObjectBuckets, 0, sizeof (struct objectBucket *)*OBJECT_HASH_SIZE);
- }
+ int i, size;
+ struct objectBucket *b, *next;
+ char *name;
- for (p = &FcObjectBuckets[hash % OBJECT_HASH_SIZE]; (b = *p); p = &(b->next))
+ for (i = 0; i < OBJECT_HASH_SIZE; i++)
{
- FcObjectPtr bp = *((FcObjectPtr *) (b + 1));
- if (b->hash == hash && FcObjectPtrU(bp) && !strcmp (name, FcObjectPtrU(bp)))
+ for (b = FcStrBuckets[i]; b; b = next)
{
- if (objectptr_indices[bp] < 0)
- objectcontent_dynamic_refcount[-objectptr_indices[bp]]++;
- return bp;
+ next = b->next;
+ name = (char *) (b + 1);
+ size = sizeof (struct objectBucket) + strlen (name) + 1;
+ FcMemFree (FC_MEM_STATICSTR, size);
+ free (b);
}
+ FcStrBuckets[i] = 0;
}
- /* didn't find it, so add a new dynamic string */
- if (objectcontent_dynamic_count >= objectcontent_dynamic_alloc)
- {
- int s = objectcontent_dynamic_alloc + 4;
+ fcstr_count = 0;
+}
- const char ** d = realloc (objectcontent_dynamic,
- s*sizeof(char *));
- if (!d)
- return 0;
- FcMemFree(FC_MEM_STATICSTR,
- objectcontent_dynamic_alloc * sizeof(char *));
- FcMemAlloc(FC_MEM_STATICSTR, s*sizeof(char *));
- objectcontent_dynamic = d;
- objectcontent_dynamic_alloc = s;
-
- int * rc = realloc (objectcontent_dynamic_refcount, s*sizeof(int));
- if (!rc)
- return 0;
- FcMemFree(FC_MEM_STATICSTR,
- objectcontent_dynamic_alloc * sizeof(int));
- FcMemAlloc(FC_MEM_STATICSTR, s * sizeof(int));
- objectcontent_dynamic_refcount = rc;
- }
- if (objectptr_count >= objectptr_alloc)
- {
- int s = objectptr_alloc + 4;
- int * d = realloc (objectptr_indices, s*sizeof(int));
- if (!d)
- return 0;
- FcMemFree(FC_MEM_STATICSTR, objectptr_alloc * sizeof(int));
- FcMemAlloc(FC_MEM_STATICSTR, s);
- objectptr_indices = d;
- objectptr_indices[0] = 0;
- objectptr_alloc = s;
- }
+static int
+FcStrNeededBytes (const FcChar8 * s)
+{
+ FcChar32 hash = FcStringHash ((const FcChar8 *) s);
+ struct objectBucket **p;
+ struct objectBucket *b;
+ int size;
- size = sizeof (struct objectBucket) + strlen (name) + 1;
+ 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);
- if (!b)
- return 0;
FcMemAlloc (FC_MEM_STATICSTR, size);
+ if (!b)
+ return -1;
b->next = 0;
b->hash = hash;
- nn = malloc(strlen(name)+1);
- if (!nn)
- goto bail;
- strcpy ((char *)nn, name);
- objectptr_indices[objectptr_count] = -objectcontent_dynamic_count;
- objectcontent_dynamic_refcount[objectcontent_dynamic_count] = 1;
- objectcontent_dynamic[objectcontent_dynamic_count++] = nn;
- new = objectptr_count++;
- *((FcObjectPtr *)(b+1)) = new;
+ 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;
- return new;
- bail:
- free(b);
- return 0;
+ fcstr_count += strlen((char *)s) + 1;
+ return strlen((char *)s) + 1;
}
-void
-FcObjectPtrDestroy (FcObjectPtr p)
-{
- if (objectptr_indices[p] < 0)
- {
- objectcontent_dynamic_refcount[-objectptr_indices[p]]--;
- if (objectcontent_dynamic_refcount[-objectptr_indices[p]] == 0)
- {
- /* this code doesn't seem to be reached terribly often. */
- /* (note that objectcontent_dynamic overapproximates
- * the use count, because not every result from
- * StaticName is stored. */
- FcStrFree((char *)objectcontent_dynamic[-objectptr_indices[p]]);
- objectcontent_dynamic[-objectptr_indices[p]] = 0;
- }
- }
-}
-
-const char *
-FcObjectPtrU (FcObjectPtr si)
+static int
+FcStrNeededBytesAlign (void)
{
- if (objectptr_indices[si] > 0)
- return &objectcontent_static_buf[objectptr_indices[si]];
- else
- return objectcontent_dynamic[-objectptr_indices[si]];
+ return __alignof__ (char);
}
-static FcBool objectptr_first_serialization = FcFalse;
-static int * object_old_id_to_new = 0;
-
-static void
-FcObjectRebuildStaticNameHashtable (void)
+static FcBool
+FcStrEnsureBank (int bi)
{
- int i;
- struct objectBucket *b, *bn;
+ FcChar8 ** ss;
- if (FcObjectBuckets)
+ if (!static_strs || static_str_bank_count <= bi)
{
- for (i = 0; i < OBJECT_HASH_SIZE; i++)
- {
- b = FcObjectBuckets[i];
- while (b)
- {
- bn = b->next;
- free(b);
- FcMemFree (FC_MEM_STATICSTR,
- sizeof (struct objectBucket)+sizeof (FcObjectPtr));
- b = bn;
- }
- }
- free (FcObjectBuckets);
- }
+ int new_count = bi + 4, i;
+ ss = realloc (static_strs, sizeof (const char *) * new_count);
+ if (!ss)
+ return FcFalse;
- FcObjectBuckets = malloc(sizeof (struct objectBucket *)*OBJECT_HASH_SIZE);
- memset (FcObjectBuckets, 0, sizeof (struct objectBucket *)*OBJECT_HASH_SIZE);
+ FcMemAlloc (FC_MEM_STRING, sizeof (const char *) * (new_count-static_str_bank_count));
+ static_strs = ss;
- for (i = 1; i < objectptr_count; i++)
- {
- if (FcObjectPtrU(i))
- {
- const char * name = FcObjectPtrU(i);
- FcChar32 hash = FcStringHash ((const FcChar8 *) name);
- struct objectBucket **p;
- int size;
-
- for (p = &FcObjectBuckets[hash % OBJECT_HASH_SIZE]; (b = *p);
- p = &(b->next))
- ;
- size = sizeof (struct objectBucket) + sizeof (FcObjectPtr);
- b = malloc (size);
- if (!b)
- return;
- FcMemAlloc (FC_MEM_STATICSTR, size);
- b->next = 0;
- b->hash = hash;
- *((FcObjectPtr *)(b+1)) = i;
- *p = b;
- }
+ for (i = static_str_bank_count; i < new_count; i++)
+ static_strs[i] = 0;
+ static_str_bank_count = new_count;
}
+ return FcTrue;
}
-/* Hmm. This will have a terrible effect on the memory size,
- * because the mmapped strings now get reallocated on the heap.
- * Is it all worth it? (Of course, the Serialization codepath is
- * not problematic.) */
-static FcBool
-FcObjectPtrConvertToStatic(FcBool renumber)
+static void *
+FcStrDistributeBytes (FcCache * metadata, void * block_ptr)
{
- int active_count, i, j, longest_string = 0,
- new_static_bytes = 1;
- char * fixed_length_buf, * new_static_buf, * p;
- int * new_indices;
-
- if (renumber)
- objectptr_first_serialization = FcFalse;
+ int bi = FcCacheBankToIndex(metadata->bank);
+ if (!FcStrEnsureBank(bi))
+ return 0;
- /* collect statistics */
- for (i = 1, active_count = 1; i < objectptr_count; i++)
- if (!renumber || object_old_id_to_new[i] == -1)
- {
- int sl = strlen(FcObjectPtrU(i));
- active_count++;
- if (sl > longest_string)
- longest_string = sl;
- new_static_bytes += sl + 1;
- }
-
- /* allocate storage */
- fixed_length_buf = malloc
- ((longest_string+1) * active_count * sizeof(char));
- if (!fixed_length_buf)
- goto bail;
- new_static_buf = malloc (new_static_bytes * sizeof(char));
- if (!new_static_buf)
- goto bail1;
- new_indices = malloc (active_count * sizeof(int));
- if (!new_indices)
- goto bail2;
-
- FcMemAlloc (FC_MEM_STATICSTR, new_static_bytes);
- FcMemFree (FC_MEM_STATICSTR, objectptr_count * sizeof (int));
- FcMemAlloc (FC_MEM_STATICSTR, active_count * sizeof (int));
-
- /* copy strings to temporary buffers */
- for (j = 0, i = 1; i < objectptr_count; i++)
- if (!renumber || object_old_id_to_new[i] == -1)
- {
- strcpy (fixed_length_buf+(j*(longest_string+1)), FcObjectPtrU(i));
- j++;
- }
-
- /* sort the new statics */
- qsort (fixed_length_buf, active_count-1, longest_string+1,
- (int (*)(const void *, const void *)) FcStrCmp);
-
- /* now we create the new static buffer in sorted order. */
- p = new_static_buf+1;
- for (i = 0; i < active_count-1; i++)
- {
- strcpy(p, fixed_length_buf + i * (longest_string+1));
- p += strlen(p)+1;
- }
+ 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;
- /* create translation table by iterating over sorted strings
- * and getting their old values */
- p = new_static_buf+1;
- for (i = 0; i < active_count-1; i++)
- {
- int n = FcObjectStaticName(fixed_length_buf+i*(longest_string+1));
- if (renumber)
- {
- object_old_id_to_new[n] = i;
- new_indices[i] = p-new_static_buf;
- }
- else
- new_indices[n] = p-new_static_buf;
- p += strlen(p)+1;
- }
+ return block_ptr;
+}
- free (objectptr_indices);
- objectptr_indices = new_indices;
- objectptr_count = active_count;
- objectptr_alloc = active_count;
+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);
- /* free old storage */
- for (i = 1; i < objectcontent_dynamic_count; i++)
- {
- if (objectcontent_dynamic[i])
+ for (p = &FcStrBuckets[hash % OBJECT_HASH_SIZE]; (b = *p); p = &(b->next))
+ if (b->hash == hash && !strcmp ((char *)s, (char *) (b + 1)))
{
- FcMemFree (FC_MEM_STATICSTR, strlen(objectcontent_dynamic[i])+1);
- free ((char *)objectcontent_dynamic[i]);
- }
- }
- free (objectcontent_dynamic);
- free (objectcontent_dynamic_refcount);
- FcMemFree (FC_MEM_STATICSTR, objectcontent_dynamic_count*sizeof (int));
- objectcontent_dynamic = 0;
- objectcontent_dynamic_refcount = 0;
- objectcontent_dynamic_count = 1;
- objectcontent_dynamic_alloc = 0;
- free (objectcontent_static_buf);
- FcMemFree (FC_MEM_STATICSTR, objectcontent_static_bytes);
- objectcontent_static_buf = new_static_buf;
- objectcontent_static_bytes = new_static_bytes;
-
- /* fix up hash table */
- FcObjectRebuildStaticNameHashtable();
-
- free (fixed_length_buf);
- return FcTrue;
-
- bail2:
- free (new_static_buf);
- bail1:
- free (fixed_length_buf);
- bail:
- return FcFalse;
+ 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;
}
-#define OBJECT_PTR_CONVERSION_TRIGGER 100000
-
-int
-FcObjectPtrCompare (const FcObjectPtr a, const FcObjectPtr b)
+static void *
+FcStrUnserialize (FcCache * metadata, void *block_ptr)
{
- /* This is the dynamic count. We could also use a static
- * count, i.e. the number of slow strings being created.
- * I think dyncount gives us a better estimate of inefficiency. -PL */
- static int compare_count = OBJECT_PTR_CONVERSION_TRIGGER;
-
- /* count on sortedness for fast objectptrs. */
- if ((a == b) || (objectptr_indices[a] > 0 && objectptr_indices[b] > 0))
- return objectptr_indices[a] - objectptr_indices[b];
+ int bi = FcCacheBankToIndex(metadata->bank);
+ if (!FcStrEnsureBank(bi))
+ return 0;
- compare_count--;
- if (!compare_count)
- {
- FcObjectPtrConvertToStatic(FcFalse);
- compare_count = OBJECT_PTR_CONVERSION_TRIGGER;
- }
+ 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 strcmp (FcObjectPtrU(a), FcObjectPtrU(b));
+ return block_ptr;
}
-void
-FcObjectClearStatic(void)
-{
- objectptr_count = 1;
- objectptr_alloc = 0;
- objectptr_indices = 0;
-
- objectcontent_static_bytes = 0;
- objectcontent_static_buf = 0;
+/* we don't store these in the FcPattern itself because
+ * we don't want to serialize the directory names */
- objectcontent_dynamic_count = 1;
- objectcontent_dynamic_alloc = 0;
- objectcontent_dynamic = 0;
- objectcontent_dynamic_refcount = 0;
+/* I suppose this should be cleaned, too... */
+typedef struct _FcPatternDirMapping {
+ const FcPattern *p;
+ const char *fname;
+} FcPatternDirMapping;
- object_old_id_to_new = 0;
-}
+#define PATTERNDIR_HASH_SIZE 31
+static struct patternDirBucket {
+ struct patternDirBucket *next;
+ FcPatternDirMapping m;
+} FcPatternDirBuckets[PATTERNDIR_HASH_SIZE];
-static FcObjectPtr
-FcObjectSerialize (FcObjectPtr si)
+void
+FcPatternAddFullFname (const FcPattern *p, const char *fname)
{
- if (objectptr_first_serialization)
- if (!FcObjectPtrConvertToStatic(FcTrue))
- return 0;
+ struct patternDirBucket *pb;
- return object_old_id_to_new[si];
-}
+ /* 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)
+ ;
-/* In the pre-serialization phase, mark the used strings with
- * -1 in the mapping array. */
-/* The first call to the serialization phase assigns actual
- * static indices to the strings (sweep). */
-FcBool
-FcObjectPrepareSerialize (FcObjectPtr si)
-{
- if (object_old_id_to_new == 0)
+ if (pb->m.p == p)
{
- object_old_id_to_new = malloc(objectptr_count * sizeof(int));
- if (!object_old_id_to_new)
- goto bail;
- memset (object_old_id_to_new, 0,
- objectptr_count * sizeof(int));
+ pb->m.fname = fname;
+ return;
}
- object_old_id_to_new[si] = -1;
- objectptr_first_serialization = FcTrue;
+ pb->next = malloc (sizeof (struct patternDirBucket));
+ if (!pb->next)
+ return;
+ FcMemAlloc (FC_MEM_CACHE, sizeof (struct patternDirBucket));
- return FcTrue;
-
- bail:
- return FcFalse;
+ pb->next->next = 0;
+ pb->next->m.p = p;
+ pb->next->m.fname = fname;
}
-static void
-FcObjectStaticNameFini (void)
+const char *
+FcPatternFindFullFname (const FcPattern *p)
{
- int i, size;
- struct objectBucket *b, *next;
- char *name;
+ struct patternDirBucket *pb;
- for (i = 0; i < OBJECT_HASH_SIZE; i++)
- {
- 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;
- }
+ 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
-FcPatternFini (void)
+FcPatternTransferFullFname (const FcPattern *new, const FcPattern *orig)
{
- FcPatternBaseThawAll ();
- FcValueListThawAll ();
- FcObjectStaticNameFini ();
+ FcChar8 * s;
+ FcPatternGetString (orig, FC_FILE, 0, &s);
+ FcPatternAddFullFname (new,
+ (char *)FcStrCopy
+ ((FcChar8 *)FcPatternFindFullFname(orig)));
}