aboutsummaryrefslogtreecommitdiff
path: root/fontconfig/src/fcpat.c
diff options
context:
space:
mode:
Diffstat (limited to 'fontconfig/src/fcpat.c')
-rw-r--r--fontconfig/src/fcpat.c2526
1 files changed, 1263 insertions, 1263 deletions
diff --git a/fontconfig/src/fcpat.c b/fontconfig/src/fcpat.c
index 76263b655..0fb2e506c 100644
--- a/fontconfig/src/fcpat.c
+++ b/fontconfig/src/fcpat.c
@@ -1,1263 +1,1263 @@
-/*
- * Copyright © 2000 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.
- *
- * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
- * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
- */
-
-#include "fcint.h"
-#include "fcftint.h"
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
-
-static FcBool
-FcHashOwnsName(const FcChar8 *name);
-
-FcPattern *
-FcPatternCreate (void)
-{
- FcPattern *p;
-
- p = (FcPattern *) malloc (sizeof (FcPattern));
- if (!p)
- return 0;
- FcMemAlloc (FC_MEM_PATTERN, sizeof (FcPattern));
- p->num = 0;
- p->size = 0;
- p->elts_offset = FcPtrToOffset (p, NULL);
- p->ref = 1;
- return p;
-}
-
-void
-FcValueDestroy (FcValue v)
-{
- switch (v.type) {
- case FcTypeString:
- if (!FcHashOwnsName(v.u.s))
- FcStrFree ((FcChar8 *) v.u.s);
- break;
- case FcTypeMatrix:
- FcMatrixFree ((FcMatrix *) v.u.m);
- break;
- case FcTypeCharSet:
- FcCharSetDestroy ((FcCharSet *) v.u.c);
- break;
- case FcTypeLangSet:
- FcLangSetDestroy ((FcLangSet *) v.u.l);
- break;
- default:
- break;
- }
-}
-
-FcValue
-FcValueCanonicalize (const FcValue *v)
-{
- FcValue new;
-
- switch (v->type)
- {
- case FcTypeString:
- new.u.s = FcValueString(v);
- new.type = FcTypeString;
- break;
- case FcTypeCharSet:
- new.u.c = FcValueCharSet(v);
- new.type = FcTypeCharSet;
- break;
- case FcTypeLangSet:
- new.u.l = FcValueLangSet(v);
- new.type = FcTypeLangSet;
- break;
- default:
- new = *v;
- break;
- }
- return new;
-}
-
-FcValue
-FcValueSave (FcValue v)
-{
- switch (v.type) {
- case FcTypeString:
- v.u.s = FcStrStaticName (v.u.s);
- if (!v.u.s)
- v.type = FcTypeVoid;
- break;
- case FcTypeMatrix:
- v.u.m = FcMatrixCopy (v.u.m);
- if (!v.u.m)
- v.type = FcTypeVoid;
- break;
- case FcTypeCharSet:
- v.u.c = FcCharSetCopy ((FcCharSet *) v.u.c);
- if (!v.u.c)
- v.type = FcTypeVoid;
- break;
- case FcTypeLangSet:
- v.u.l = FcLangSetCopy (v.u.l);
- if (!v.u.l)
- v.type = FcTypeVoid;
- break;
- default:
- break;
- }
- return v;
-}
-
-void
-FcValueListDestroy (FcValueListPtr l)
-{
- FcValueListPtr next;
- for (; l; l = next)
- {
- switch (l->value.type) {
- case FcTypeString:
- if (!FcHashOwnsName((FcChar8 *)l->value.u.s))
- FcStrFree ((FcChar8 *)l->value.u.s);
- break;
- case FcTypeMatrix:
- FcMatrixFree ((FcMatrix *)l->value.u.m);
- break;
- case FcTypeCharSet:
- FcCharSetDestroy
- ((FcCharSet *) (l->value.u.c));
- break;
- case FcTypeLangSet:
- FcLangSetDestroy
- ((FcLangSet *) (l->value.u.l));
- break;
- default:
- break;
- }
- next = FcValueListNext(l);
- FcMemFree (FC_MEM_VALLIST, sizeof (FcValueList));
- free(l);
- }
-}
-
-FcBool
-FcValueEqual (FcValue va, FcValue vb)
-{
- if (va.type != vb.type)
- {
- if (va.type == FcTypeInteger)
- {
- va.type = FcTypeDouble;
- va.u.d = va.u.i;
- }
- if (vb.type == FcTypeInteger)
- {
- vb.type = FcTypeDouble;
- vb.u.d = vb.u.i;
- }
- if (va.type != vb.type)
- return FcFalse;
- }
- switch (va.type) {
- case FcTypeVoid:
- return FcTrue;
- case FcTypeInteger:
- return va.u.i == vb.u.i;
- case FcTypeDouble:
- return va.u.d == vb.u.d;
- case FcTypeString:
- return FcStrCmpIgnoreCase (va.u.s, vb.u.s) == 0;
- case FcTypeBool:
- return va.u.b == vb.u.b;
- case FcTypeMatrix:
- return FcMatrixEqual (va.u.m, vb.u.m);
- case FcTypeCharSet:
- return FcCharSetEqual (va.u.c, vb.u.c);
- case FcTypeFTFace:
- return va.u.f == vb.u.f;
- case FcTypeLangSet:
- return FcLangSetEqual (va.u.l, vb.u.l);
- }
- return FcFalse;
-}
-
-static FcChar32
-FcDoubleHash (double d)
-{
- if (d < 0)
- d = -d;
- if (d > 0xffffffff)
- d = 0xffffffff;
- return (FcChar32) d;
-}
-
-FcChar32
-FcStringHash (const FcChar8 *s)
-{
- FcChar8 c;
- FcChar32 h = 0;
-
- if (s)
- while ((c = *s++))
- h = ((h << 1) | (h >> 31)) ^ c;
- return h;
-}
-
-static FcChar32
-FcValueHash (const FcValue *v)
-{
- switch (v->type) {
- case FcTypeVoid:
- return 0;
- case FcTypeInteger:
- return (FcChar32) v->u.i;
- case FcTypeDouble:
- return FcDoubleHash (v->u.d);
- case FcTypeString:
- return FcStringHash (FcValueString(v));
- case FcTypeBool:
- return (FcChar32) v->u.b;
- case FcTypeMatrix:
- 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) FcValueCharSet(v)->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 (FcValueLangSet(v));
- }
- return FcFalse;
-}
-
-static FcBool
-FcValueListEqual (FcValueListPtr la, FcValueListPtr lb)
-{
- if (la == lb)
- return FcTrue;
-
- while (la && lb)
- {
- if (!FcValueEqual (la->value, lb->value))
- return FcFalse;
- la = FcValueListNext(la);
- lb = FcValueListNext(lb);
- }
- if (la || lb)
- return FcFalse;
- return FcTrue;
-}
-
-static FcChar32
-FcValueListHash (FcValueListPtr l)
-{
- FcChar32 hash = 0;
-
- for (; l; l = FcValueListNext(l))
- {
- hash = ((hash << 1) | (hash >> 31)) ^ FcValueHash (&l->value);
- }
- return hash;
-}
-
-void
-FcPatternDestroy (FcPattern *p)
-{
- int i;
- FcPatternElt *elts;
-
- if (p->ref == FC_REF_CONSTANT)
- {
- FcCacheObjectDereference (p);
- return;
- }
-
- if (--p->ref > 0)
- return;
-
- elts = FcPatternElts (p);
- for (i = 0; i < p->num; i++)
- FcValueListDestroy (FcPatternEltValues(&elts[i]));
-
- FcMemFree (FC_MEM_PATELT, p->size * sizeof (FcPatternElt));
- free (elts);
- FcMemFree (FC_MEM_PATTERN, sizeof (FcPattern));
- free (p);
-}
-
-static int
-FcPatternObjectPosition (const FcPattern *p, FcObject object)
-{
- int low, high, mid, c;
- FcPatternElt *elts = FcPatternElts(p);
-
- low = 0;
- high = p->num - 1;
- c = 1;
- mid = 0;
- while (low <= high)
- {
- mid = (low + high) >> 1;
- c = elts[mid].object - object;
- if (c == 0)
- return mid;
- if (c < 0)
- low = mid + 1;
- else
- high = mid - 1;
- }
- if (c < 0)
- mid++;
- return -(mid + 1);
-}
-
-FcPatternElt *
-FcPatternObjectFindElt (const FcPattern *p, FcObject object)
-{
- int i = FcPatternObjectPosition (p, object);
- if (i < 0)
- return 0;
- return &FcPatternElts(p)[i];
-}
-
-FcPatternElt *
-FcPatternObjectInsertElt (FcPattern *p, FcObject object)
-{
- int i;
- FcPatternElt *e;
-
- i = FcPatternObjectPosition (p, object);
- if (i < 0)
- {
- i = -i - 1;
-
- /* reallocate array */
- if (p->num + 1 >= p->size)
- {
- int s = p->size + 16;
- if (p->size)
- {
- FcPatternElt *e0 = FcPatternElts(p);
- e = (FcPatternElt *) realloc (e0, s * sizeof (FcPatternElt));
- if (!e) /* maybe it was mmapped */
- {
- e = malloc(s * sizeof (FcPatternElt));
- if (e)
- memcpy(e, e0, p->num * sizeof (FcPatternElt));
- }
- }
- else
- e = (FcPatternElt *) malloc (s * sizeof (FcPatternElt));
- if (!e)
- return FcFalse;
- p->elts_offset = FcPtrToOffset (p, e);
- if (p->size)
- FcMemFree (FC_MEM_PATELT, p->size * sizeof (FcPatternElt));
- FcMemAlloc (FC_MEM_PATELT, s * sizeof (FcPatternElt));
- while (p->size < s)
- {
- e[p->size].object = 0;
- e[p->size].values = NULL;
- p->size++;
- }
- }
-
- e = FcPatternElts(p);
- /* move elts up */
- memmove (e + i + 1,
- e + i,
- sizeof (FcPatternElt) *
- (p->num - i));
-
- /* bump count */
- p->num++;
-
- e[i].object = object;
- e[i].values = NULL;
- }
-
- return FcPatternElts(p) + i;
-}
-
-FcBool
-FcPatternEqual (const FcPattern *pa, const FcPattern *pb)
-{
- int i;
- FcPatternElt *pae, *pbe;
-
- if (pa == pb)
- return FcTrue;
-
- if (pa->num != pb->num)
- return FcFalse;
- pae = FcPatternElts(pa);
- pbe = FcPatternElts(pb);
- for (i = 0; i < pa->num; i++)
- {
- if (pae[i].object != pbe[i].object)
- return FcFalse;
- if (!FcValueListEqual (FcPatternEltValues(&pae[i]),
- FcPatternEltValues(&pbe[i])))
- return FcFalse;
- }
- return FcTrue;
-}
-
-FcChar32
-FcPatternHash (const FcPattern *p)
-{
- int i;
- FcChar32 h = 0;
- FcPatternElt *pe = FcPatternElts(p);
-
- for (i = 0; i < p->num; i++)
- {
- h = (((h << 1) | (h >> 31)) ^
- pe[i].object ^
- FcValueListHash (FcPatternEltValues(&pe[i])));
- }
- return h;
-}
-
-FcBool
-FcPatternEqualSubset (const FcPattern *pai, const FcPattern *pbi, const FcObjectSet *os)
-{
- FcPatternElt *ea, *eb;
- int i;
-
- for (i = 0; i < os->nobject; i++)
- {
- FcObject object = FcObjectFromName (os->objects[i]);
- ea = FcPatternObjectFindElt (pai, object);
- eb = FcPatternObjectFindElt (pbi, object);
- if (ea)
- {
- if (!eb)
- return FcFalse;
- if (!FcValueListEqual (FcPatternEltValues(ea), FcPatternEltValues(eb)))
- return FcFalse;
- }
- else
- {
- if (eb)
- return FcFalse;
- }
- }
- return FcTrue;
-}
-
-FcBool
-FcPatternObjectAddWithBinding (FcPattern *p,
- FcObject object,
- FcValue value,
- FcValueBinding binding,
- FcBool append)
-{
- FcPatternElt *e;
- FcValueListPtr new, *prev;
-
- if (p->ref == FC_REF_CONSTANT)
- goto bail0;
-
- new = malloc (sizeof (FcValueList));
- if (!new)
- goto bail0;
-
- memset(new, 0, sizeof (FcValueList));
- FcMemAlloc (FC_MEM_VALLIST, sizeof (FcValueList));
- value = FcValueSave (value);
- if (value.type == FcTypeVoid)
- goto bail1;
-
- /*
- * Make sure the stored type is valid for built-in objects
- */
- if (!FcObjectValidType (object, value.type))
- {
- if (FcDebug() & FC_DBG_OBJTYPES)
- {
- printf ("FcPattern object %s does not accept value ",
- FcObjectName (object));
- FcValuePrint (value);
- }
- goto bail1;
- }
-
- new->value = value;
- new->binding = binding;
- new->next = NULL;
-
- e = FcPatternObjectInsertElt (p, object);
- if (!e)
- goto bail2;
-
- if (append)
- {
- for (prev = &e->values; *prev; prev = &(*prev)->next)
- ;
- *prev = new;
- }
- else
- {
- new->next = e->values;
- e->values = new;
- }
-
- return FcTrue;
-
-bail2:
- FcValueDestroy (value);
-bail1:
- FcMemFree (FC_MEM_VALLIST, sizeof (FcValueList));
- free (new);
-bail0:
- return FcFalse;
-}
-
-FcBool
-FcPatternObjectAdd (FcPattern *p, FcObject object, FcValue value, FcBool append)
-{
- return FcPatternObjectAddWithBinding (p, object,
- value, FcValueBindingStrong, append);
-}
-
-FcBool
-FcPatternAdd (FcPattern *p, const char *object, FcValue value, FcBool append)
-{
- return FcPatternObjectAddWithBinding (p, FcObjectFromName (object),
- value, FcValueBindingStrong, append);
-}
-
-FcBool
-FcPatternAddWeak (FcPattern *p, const char *object, FcValue value, FcBool append)
-{
- return FcPatternObjectAddWithBinding (p, FcObjectFromName (object),
- value, FcValueBindingWeak, append);
-}
-
-FcBool
-FcPatternObjectDel (FcPattern *p, FcObject object)
-{
- FcPatternElt *e;
-
- e = FcPatternObjectFindElt (p, object);
- if (!e)
- return FcFalse;
-
- /* destroy value */
- FcValueListDestroy (e->values);
-
- /* shuffle existing ones down */
- memmove (e, e+1,
- (FcPatternElts(p) + p->num - (e + 1)) *
- sizeof (FcPatternElt));
- p->num--;
- e = FcPatternElts(p) + p->num;
- e->object = 0;
- e->values = NULL;
- return FcTrue;
-}
-
-FcBool
-FcPatternDel (FcPattern *p, const char *object)
-{
- return FcPatternObjectDel (p, FcObjectFromName (object));
-}
-
-FcBool
-FcPatternRemove (FcPattern *p, const char *object, int id)
-{
- FcPatternElt *e;
- FcValueListPtr *prev, l;
-
- e = FcPatternObjectFindElt (p, FcObjectFromName (object));
- if (!e)
- return FcFalse;
- for (prev = &e->values; (l = *prev); prev = &l->next)
- {
- if (!id)
- {
- *prev = l->next;
- l->next = NULL;
- FcValueListDestroy (l);
- if (!e->values)
- FcPatternDel (p, object);
- return FcTrue;
- }
- id--;
- }
- return FcFalse;
-}
-
-FcBool
-FcPatternObjectAddInteger (FcPattern *p, FcObject object, int i)
-{
- FcValue v;
-
- v.type = FcTypeInteger;
- v.u.i = i;
- return FcPatternObjectAdd (p, object, v, FcTrue);
-}
-
-FcBool
-FcPatternAddInteger (FcPattern *p, const char *object, int i)
-{
- return FcPatternObjectAddInteger (p, FcObjectFromName (object), i);
-}
-
-FcBool
-FcPatternObjectAddDouble (FcPattern *p, FcObject object, double d)
-{
- FcValue v;
-
- v.type = FcTypeDouble;
- v.u.d = d;
- return FcPatternObjectAdd (p, object, v, FcTrue);
-}
-
-
-FcBool
-FcPatternAddDouble (FcPattern *p, const char *object, double d)
-{
- return FcPatternObjectAddDouble (p, FcObjectFromName (object), d);
-}
-
-FcBool
-FcPatternObjectAddString (FcPattern *p, FcObject object, const FcChar8 *s)
-{
- FcValue v;
-
- if (!s)
- {
- v.type = FcTypeVoid;
- v.u.s = 0;
- return FcPatternObjectAdd (p, object, v, FcTrue);
- }
-
- v.type = FcTypeString;
- v.u.s = FcStrStaticName(s);
- return FcPatternObjectAdd (p, object, v, FcTrue);
-}
-
-FcBool
-FcPatternAddString (FcPattern *p, const char *object, const FcChar8 *s)
-{
- return FcPatternObjectAddString (p, FcObjectFromName (object), s);
-}
-
-FcBool
-FcPatternAddMatrix (FcPattern *p, const char *object, const FcMatrix *s)
-{
- FcValue v;
-
- v.type = FcTypeMatrix;
- v.u.m = s;
- return FcPatternAdd (p, object, v, FcTrue);
-}
-
-
-FcBool
-FcPatternObjectAddBool (FcPattern *p, FcObject object, FcBool b)
-{
- FcValue v;
-
- v.type = FcTypeBool;
- v.u.b = b;
- return FcPatternObjectAdd (p, object, v, FcTrue);
-}
-
-FcBool
-FcPatternAddBool (FcPattern *p, const char *object, FcBool b)
-{
- return FcPatternObjectAddBool (p, FcObjectFromName (object), b);
-}
-
-FcBool
-FcPatternAddCharSet (FcPattern *p, const char *object, const FcCharSet *c)
-{
- FcValue v;
-
- v.type = FcTypeCharSet;
- v.u.c = (FcCharSet *)c;
- return FcPatternAdd (p, object, v, FcTrue);
-}
-
-FcBool
-FcPatternAddFTFace (FcPattern *p, const char *object, const FT_Face f)
-{
- FcValue v;
-
- v.type = FcTypeFTFace;
- v.u.f = (void *) f;
- return FcPatternAdd (p, object, v, FcTrue);
-}
-
-FcBool
-FcPatternAddLangSet (FcPattern *p, const char *object, const FcLangSet *ls)
-{
- FcValue v;
-
- v.type = FcTypeLangSet;
- v.u.l = (FcLangSet *)ls;
- return FcPatternAdd (p, object, v, FcTrue);
-}
-
-FcResult
-FcPatternObjectGet (const FcPattern *p, FcObject object, int id, FcValue *v)
-{
- FcPatternElt *e;
- FcValueListPtr l;
-
- e = FcPatternObjectFindElt (p, object);
- if (!e)
- return FcResultNoMatch;
- for (l = FcPatternEltValues(e); l; l = FcValueListNext(l))
- {
- if (!id)
- {
- *v = FcValueCanonicalize(&l->value);
- return FcResultMatch;
- }
- id--;
- }
- return FcResultNoId;
-}
-
-FcResult
-FcPatternGet (const FcPattern *p, const char *object, int id, FcValue *v)
-{
- return FcPatternObjectGet (p, FcObjectFromName (object), id, v);
-}
-
-FcResult
-FcPatternObjectGetInteger (const FcPattern *p, FcObject object, int id, int *i)
-{
- FcValue v;
- FcResult r;
-
- r = FcPatternObjectGet (p, object, id, &v);
- if (r != FcResultMatch)
- return r;
- switch (v.type) {
- case FcTypeDouble:
- *i = (int) v.u.d;
- break;
- case FcTypeInteger:
- *i = v.u.i;
- break;
- default:
- return FcResultTypeMismatch;
- }
- return FcResultMatch;
-}
-
-FcResult
-FcPatternGetInteger (const FcPattern *p, const char *object, int id, int *i)
-{
- return FcPatternObjectGetInteger (p, FcObjectFromName (object), id, i);
-}
-
-
-FcResult
-FcPatternObjectGetDouble (const FcPattern *p, FcObject object, int id, double *d)
-{
- FcValue v;
- FcResult r;
-
- r = FcPatternObjectGet (p, object, id, &v);
- if (r != FcResultMatch)
- return r;
- switch (v.type) {
- case FcTypeDouble:
- *d = v.u.d;
- break;
- case FcTypeInteger:
- *d = (double) v.u.i;
- break;
- default:
- return FcResultTypeMismatch;
- }
- return FcResultMatch;
-}
-
-FcResult
-FcPatternGetDouble (const FcPattern *p, const char *object, int id, double *d)
-{
- return FcPatternObjectGetDouble (p, FcObjectFromName (object), id, d);
-}
-
-FcResult
-FcPatternObjectGetString (const FcPattern *p, FcObject object, int id, FcChar8 ** s)
-{
- FcValue v;
- FcResult r;
-
- r = FcPatternObjectGet (p, object, id, &v);
- if (r != FcResultMatch)
- return r;
- if (v.type != FcTypeString)
- return FcResultTypeMismatch;
-
- *s = (FcChar8 *) v.u.s;
- return FcResultMatch;
-}
-
-FcResult
-FcPatternGetString (const FcPattern *p, const char *object, int id, FcChar8 ** s)
-{
- return FcPatternObjectGetString (p, FcObjectFromName (object), id, s);
-}
-
-FcResult
-FcPatternGetMatrix(const FcPattern *p, const char *object, int id, FcMatrix **m)
-{
- FcValue v;
- FcResult r;
-
- r = FcPatternGet (p, object, id, &v);
- if (r != FcResultMatch)
- return r;
- if (v.type != FcTypeMatrix)
- return FcResultTypeMismatch;
- *m = (FcMatrix *)v.u.m;
- return FcResultMatch;
-}
-
-
-FcResult
-FcPatternGetBool(const FcPattern *p, const char *object, int id, FcBool *b)
-{
- FcValue v;
- FcResult r;
-
- r = FcPatternGet (p, object, id, &v);
- if (r != FcResultMatch)
- return r;
- if (v.type != FcTypeBool)
- return FcResultTypeMismatch;
- *b = v.u.b;
- return FcResultMatch;
-}
-
-FcResult
-FcPatternGetCharSet(const FcPattern *p, const char *object, int id, FcCharSet **c)
-{
- FcValue v;
- FcResult r;
-
- r = FcPatternGet (p, object, id, &v);
- if (r != FcResultMatch)
- return r;
- if (v.type != FcTypeCharSet)
- return FcResultTypeMismatch;
- *c = (FcCharSet *)v.u.c;
- return FcResultMatch;
-}
-
-FcResult
-FcPatternGetFTFace(const FcPattern *p, const char *object, int id, FT_Face *f)
-{
- FcValue v;
- FcResult r;
-
- r = FcPatternGet (p, object, id, &v);
- if (r != FcResultMatch)
- return r;
- if (v.type != FcTypeFTFace)
- return FcResultTypeMismatch;
- *f = (FT_Face) v.u.f;
- return FcResultMatch;
-}
-
-FcResult
-FcPatternGetLangSet(const FcPattern *p, const char *object, int id, FcLangSet **ls)
-{
- FcValue v;
- FcResult r;
-
- r = FcPatternGet (p, object, id, &v);
- if (r != FcResultMatch)
- return r;
- if (v.type != FcTypeLangSet)
- return FcResultTypeMismatch;
- *ls = (FcLangSet *)v.u.l;
- return FcResultMatch;
-}
-
-FcPattern *
-FcPatternDuplicate (const FcPattern *orig)
-{
- FcPattern *new;
- FcPatternElt *e;
- int i;
- FcValueListPtr l;
-
- new = FcPatternCreate ();
- if (!new)
- goto bail0;
-
- e = FcPatternElts(orig);
-
- for (i = 0; i < orig->num; i++)
- {
- for (l = FcPatternEltValues(e + i); l; l = FcValueListNext(l))
- {
- if (!FcPatternObjectAddWithBinding (new, e[i].object,
- FcValueCanonicalize(&l->value),
- l->binding,
- FcTrue))
- goto bail1;
-
- }
- }
-
- return new;
-
-bail1:
- FcPatternDestroy (new);
-bail0:
- return 0;
-}
-
-void
-FcPatternReference (FcPattern *p)
-{
- if (p->ref != FC_REF_CONSTANT)
- p->ref++;
- else
- FcCacheObjectReference (p);
-}
-
-FcPattern *
-FcPatternVaBuild (FcPattern *p, va_list va)
-{
- FcPattern *ret;
-
- FcPatternVapBuild (ret, p, va);
- return ret;
-}
-
-FcPattern *
-FcPatternBuild (FcPattern *p, ...)
-{
- va_list va;
-
- va_start (va, p);
- FcPatternVapBuild (p, p, va);
- va_end (va);
- return p;
-}
-
-/*
- * Add all of the elements in 's' to 'p'
- */
-FcBool
-FcPatternAppend (FcPattern *p, FcPattern *s)
-{
- int i;
- FcPatternElt *e;
- FcValueListPtr v;
-
- for (i = 0; i < s->num; i++)
- {
- e = FcPatternElts(s)+i;
- for (v = FcPatternEltValues(e); v; v = FcValueListNext(v))
- {
- if (!FcPatternObjectAddWithBinding (p, e->object,
- FcValueCanonicalize(&v->value),
- v->binding, FcTrue))
- return FcFalse;
- }
- }
- return FcTrue;
-}
-
-FcPattern *
-FcPatternFilter (FcPattern *p, const FcObjectSet *os)
-{
- int i;
- FcPattern *ret;
- FcPatternElt *e;
- FcValueListPtr v;
-
- if (!os)
- return FcPatternDuplicate (p);
-
- ret = FcPatternCreate ();
- if (!ret)
- return NULL;
-
- for (i = 0; i < os->nobject; i++)
- {
- FcObject object = FcObjectFromName (os->objects[i]);
- e = FcPatternObjectFindElt (p, object);
- if (e)
- {
- for (v = FcPatternEltValues(e); v; v = FcValueListNext(v))
- {
- if (!FcPatternObjectAddWithBinding (ret, e->object,
- FcValueCanonicalize(&v->value),
- v->binding, FcTrue))
- goto bail0;
- }
- }
- }
- return ret;
-
-bail0:
- FcPatternDestroy (ret);
- return NULL;
-}
-
-#define OBJECT_HASH_SIZE 31
-static struct objectBucket {
- struct objectBucket *next;
- FcChar32 hash;
-} *FcObjectBuckets[OBJECT_HASH_SIZE];
-
-static FcBool
-FcHashOwnsName (const FcChar8 *name)
-{
- FcChar32 hash = FcStringHash (name);
- struct objectBucket **p;
- struct objectBucket *b;
-
- for (p = &FcObjectBuckets[hash % OBJECT_HASH_SIZE]; (b = *p); p = &(b->next))
- if (b->hash == hash && ((char *)name == (char *) (b + 1)))
- return FcTrue;
- return FcFalse;
-}
-
-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)
-{
- int i, size;
- struct objectBucket *b, *next;
- char *name;
-
- 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 + sizeof (int));
- free (b);
- }
- FcObjectBuckets[i] = 0;
- }
-}
-
-void
-FcPatternFini (void)
-{
- FcStrStaticNameFini ();
- FcObjectFini ();
-}
-
-FcBool
-FcPatternSerializeAlloc (FcSerialize *serialize, const FcPattern *pat)
-{
- int i;
- FcPatternElt *elts = FcPatternElts(pat);
-
- if (!FcSerializeAlloc (serialize, pat, sizeof (FcPattern)))
- return FcFalse;
- if (!FcSerializeAlloc (serialize, elts, pat->num * sizeof (FcPatternElt)))
- return FcFalse;
- for (i = 0; i < pat->num; i++)
- if (!FcValueListSerializeAlloc (serialize, FcPatternEltValues(elts+i)))
- return FcFalse;
- return FcTrue;
-}
-
-FcPattern *
-FcPatternSerialize (FcSerialize *serialize, const FcPattern *pat)
-{
- FcPattern *pat_serialized;
- FcPatternElt *elts = FcPatternElts (pat);
- FcPatternElt *elts_serialized;
- FcValueList *values_serialized;
- int i;
-
- pat_serialized = FcSerializePtr (serialize, pat);
- if (!pat_serialized)
- return NULL;
- *pat_serialized = *pat;
- pat_serialized->size = pat->num;
- pat_serialized->ref = FC_REF_CONSTANT;
-
- elts_serialized = FcSerializePtr (serialize, elts);
- if (!elts_serialized)
- return NULL;
-
- pat_serialized->elts_offset = FcPtrToOffset (pat_serialized,
- elts_serialized);
-
- for (i = 0; i < pat->num; i++)
- {
- values_serialized = FcValueListSerialize (serialize, FcPatternEltValues (elts+i));
- if (!values_serialized)
- return NULL;
- elts_serialized[i].object = elts[i].object;
- elts_serialized[i].values = FcPtrToEncodedOffset (&elts_serialized[i],
- values_serialized,
- FcValueList);
- }
- if (FcDebug() & FC_DBG_CACHEV) {
- printf ("Raw pattern:\n");
- FcPatternPrint (pat);
- printf ("Serialized pattern:\n");
- FcPatternPrint (pat_serialized);
- printf ("\n");
- }
- return pat_serialized;
-}
-
-FcBool
-FcValueListSerializeAlloc (FcSerialize *serialize, const FcValueList *vl)
-{
- while (vl)
- {
- if (!FcSerializeAlloc (serialize, vl, sizeof (FcValueList)))
- return FcFalse;
- switch (vl->value.type) {
- case FcTypeString:
- if (!FcStrSerializeAlloc (serialize, vl->value.u.s))
- return FcFalse;
- break;
- case FcTypeCharSet:
- if (!FcCharSetSerializeAlloc (serialize, vl->value.u.c))
- return FcFalse;
- break;
- case FcTypeLangSet:
- if (!FcLangSetSerializeAlloc (serialize, vl->value.u.l))
- return FcFalse;
- break;
- default:
- break;
- }
- vl = vl->next;
- }
- return FcTrue;
-}
-
-FcValueList *
-FcValueListSerialize (FcSerialize *serialize, const FcValueList *vl)
-{
- FcValueList *vl_serialized;
- FcChar8 *s_serialized;
- FcCharSet *c_serialized;
- FcLangSet *l_serialized;
- FcValueList *head_serialized = NULL;
- FcValueList *prev_serialized = NULL;
-
- while (vl)
- {
- vl_serialized = FcSerializePtr (serialize, vl);
- if (!vl_serialized)
- return NULL;
-
- if (prev_serialized)
- prev_serialized->next = FcPtrToEncodedOffset (prev_serialized,
- vl_serialized,
- FcValueList);
- else
- head_serialized = vl_serialized;
-
- vl_serialized->next = NULL;
- vl_serialized->value.type = vl->value.type;
- switch (vl->value.type) {
- case FcTypeInteger:
- vl_serialized->value.u.i = vl->value.u.i;
- break;
- case FcTypeDouble:
- vl_serialized->value.u.d = vl->value.u.d;
- break;
- case FcTypeString:
- s_serialized = FcStrSerialize (serialize, vl->value.u.s);
- if (!s_serialized)
- return NULL;
- vl_serialized->value.u.s = FcPtrToEncodedOffset (&vl_serialized->value,
- s_serialized,
- FcChar8);
- break;
- case FcTypeBool:
- vl_serialized->value.u.b = vl->value.u.b;
- break;
- case FcTypeMatrix:
- /* can't happen */
- break;
- case FcTypeCharSet:
- c_serialized = FcCharSetSerialize (serialize, vl->value.u.c);
- if (!c_serialized)
- return NULL;
- vl_serialized->value.u.c = FcPtrToEncodedOffset (&vl_serialized->value,
- c_serialized,
- FcCharSet);
- break;
- case FcTypeFTFace:
- /* can't happen */
- break;
- case FcTypeLangSet:
- l_serialized = FcLangSetSerialize (serialize, vl->value.u.l);
- if (!l_serialized)
- return NULL;
- vl_serialized->value.u.l = FcPtrToEncodedOffset (&vl_serialized->value,
- l_serialized,
- FcLangSet);
- break;
- default:
- break;
- }
- prev_serialized = vl_serialized;
- vl = vl->next;
- }
- return head_serialized;
-}
-#define __fcpat__
-#include "fcaliastail.h"
-#include "fcftaliastail.h"
-#undef __fcpat__
+/*
+ * Copyright © 2000 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 the author(s) not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission. The authors make no
+ * representations about the suitability of this software for any purpose. It
+ * is provided "as is" without express or implied warranty.
+ *
+ * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "fcint.h"
+#include "fcftint.h"
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+static FcBool
+FcHashOwnsName(const FcChar8 *name);
+
+FcPattern *
+FcPatternCreate (void)
+{
+ FcPattern *p;
+
+ p = (FcPattern *) malloc (sizeof (FcPattern));
+ if (!p)
+ return 0;
+ FcMemAlloc (FC_MEM_PATTERN, sizeof (FcPattern));
+ p->num = 0;
+ p->size = 0;
+ p->elts_offset = FcPtrToOffset (p, NULL);
+ p->ref = 1;
+ return p;
+}
+
+void
+FcValueDestroy (FcValue v)
+{
+ switch (v.type) {
+ case FcTypeString:
+ if (!FcHashOwnsName(v.u.s))
+ FcStrFree ((FcChar8 *) v.u.s);
+ break;
+ case FcTypeMatrix:
+ FcMatrixFree ((FcMatrix *) v.u.m);
+ break;
+ case FcTypeCharSet:
+ FcCharSetDestroy ((FcCharSet *) v.u.c);
+ break;
+ case FcTypeLangSet:
+ FcLangSetDestroy ((FcLangSet *) v.u.l);
+ break;
+ default:
+ break;
+ }
+}
+
+FcValue
+FcValueCanonicalize (const FcValue *v)
+{
+ FcValue new;
+
+ switch (v->type)
+ {
+ case FcTypeString:
+ new.u.s = FcValueString(v);
+ new.type = FcTypeString;
+ break;
+ case FcTypeCharSet:
+ new.u.c = FcValueCharSet(v);
+ new.type = FcTypeCharSet;
+ break;
+ case FcTypeLangSet:
+ new.u.l = FcValueLangSet(v);
+ new.type = FcTypeLangSet;
+ break;
+ default:
+ new = *v;
+ break;
+ }
+ return new;
+}
+
+FcValue
+FcValueSave (FcValue v)
+{
+ switch (v.type) {
+ case FcTypeString:
+ v.u.s = FcStrStaticName (v.u.s);
+ if (!v.u.s)
+ v.type = FcTypeVoid;
+ break;
+ case FcTypeMatrix:
+ v.u.m = FcMatrixCopy (v.u.m);
+ if (!v.u.m)
+ v.type = FcTypeVoid;
+ break;
+ case FcTypeCharSet:
+ v.u.c = FcCharSetCopy ((FcCharSet *) v.u.c);
+ if (!v.u.c)
+ v.type = FcTypeVoid;
+ break;
+ case FcTypeLangSet:
+ v.u.l = FcLangSetCopy (v.u.l);
+ if (!v.u.l)
+ v.type = FcTypeVoid;
+ break;
+ default:
+ break;
+ }
+ return v;
+}
+
+void
+FcValueListDestroy (FcValueListPtr l)
+{
+ FcValueListPtr next;
+ for (; l; l = next)
+ {
+ switch (l->value.type) {
+ case FcTypeString:
+ if (!FcHashOwnsName((FcChar8 *)l->value.u.s))
+ FcStrFree ((FcChar8 *)l->value.u.s);
+ break;
+ case FcTypeMatrix:
+ FcMatrixFree ((FcMatrix *)l->value.u.m);
+ break;
+ case FcTypeCharSet:
+ FcCharSetDestroy
+ ((FcCharSet *) (l->value.u.c));
+ break;
+ case FcTypeLangSet:
+ FcLangSetDestroy
+ ((FcLangSet *) (l->value.u.l));
+ break;
+ default:
+ break;
+ }
+ next = FcValueListNext(l);
+ FcMemFree (FC_MEM_VALLIST, sizeof (FcValueList));
+ free(l);
+ }
+}
+
+FcBool
+FcValueEqual (FcValue va, FcValue vb)
+{
+ if (va.type != vb.type)
+ {
+ if (va.type == FcTypeInteger)
+ {
+ va.type = FcTypeDouble;
+ va.u.d = va.u.i;
+ }
+ if (vb.type == FcTypeInteger)
+ {
+ vb.type = FcTypeDouble;
+ vb.u.d = vb.u.i;
+ }
+ if (va.type != vb.type)
+ return FcFalse;
+ }
+ switch (va.type) {
+ case FcTypeVoid:
+ return FcTrue;
+ case FcTypeInteger:
+ return va.u.i == vb.u.i;
+ case FcTypeDouble:
+ return va.u.d == vb.u.d;
+ case FcTypeString:
+ return FcStrCmpIgnoreCase (va.u.s, vb.u.s) == 0;
+ case FcTypeBool:
+ return va.u.b == vb.u.b;
+ case FcTypeMatrix:
+ return FcMatrixEqual (va.u.m, vb.u.m);
+ case FcTypeCharSet:
+ return FcCharSetEqual (va.u.c, vb.u.c);
+ case FcTypeFTFace:
+ return va.u.f == vb.u.f;
+ case FcTypeLangSet:
+ return FcLangSetEqual (va.u.l, vb.u.l);
+ }
+ return FcFalse;
+}
+
+static FcChar32
+FcDoubleHash (double d)
+{
+ if (d < 0)
+ d = -d;
+ if (d > 0xffffffff)
+ d = 0xffffffff;
+ return (FcChar32) d;
+}
+
+FcChar32
+FcStringHash (const FcChar8 *s)
+{
+ FcChar8 c;
+ FcChar32 h = 0;
+
+ if (s)
+ while ((c = *s++))
+ h = ((h << 1) | (h >> 31)) ^ c;
+ return h;
+}
+
+static FcChar32
+FcValueHash (const FcValue *v)
+{
+ switch (v->type) {
+ case FcTypeVoid:
+ return 0;
+ case FcTypeInteger:
+ return (FcChar32) v->u.i;
+ case FcTypeDouble:
+ return FcDoubleHash (v->u.d);
+ case FcTypeString:
+ return FcStringHash (FcValueString(v));
+ case FcTypeBool:
+ return (FcChar32) v->u.b;
+ case FcTypeMatrix:
+ 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) FcValueCharSet(v)->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 (FcValueLangSet(v));
+ }
+ return FcFalse;
+}
+
+static FcBool
+FcValueListEqual (FcValueListPtr la, FcValueListPtr lb)
+{
+ if (la == lb)
+ return FcTrue;
+
+ while (la && lb)
+ {
+ if (!FcValueEqual (la->value, lb->value))
+ return FcFalse;
+ la = FcValueListNext(la);
+ lb = FcValueListNext(lb);
+ }
+ if (la || lb)
+ return FcFalse;
+ return FcTrue;
+}
+
+static FcChar32
+FcValueListHash (FcValueListPtr l)
+{
+ FcChar32 hash = 0;
+
+ for (; l; l = FcValueListNext(l))
+ {
+ hash = ((hash << 1) | (hash >> 31)) ^ FcValueHash (&l->value);
+ }
+ return hash;
+}
+
+void
+FcPatternDestroy (FcPattern *p)
+{
+ int i;
+ FcPatternElt *elts;
+
+ if (p->ref == FC_REF_CONSTANT)
+ {
+ FcCacheObjectDereference (p);
+ return;
+ }
+
+ if (--p->ref > 0)
+ return;
+
+ elts = FcPatternElts (p);
+ for (i = 0; i < p->num; i++)
+ FcValueListDestroy (FcPatternEltValues(&elts[i]));
+
+ FcMemFree (FC_MEM_PATELT, p->size * sizeof (FcPatternElt));
+ free (elts);
+ FcMemFree (FC_MEM_PATTERN, sizeof (FcPattern));
+ free (p);
+}
+
+static int
+FcPatternObjectPosition (const FcPattern *p, FcObject object)
+{
+ int low, high, mid, c;
+ FcPatternElt *elts = FcPatternElts(p);
+
+ low = 0;
+ high = p->num - 1;
+ c = 1;
+ mid = 0;
+ while (low <= high)
+ {
+ mid = (low + high) >> 1;
+ c = elts[mid].object - object;
+ if (c == 0)
+ return mid;
+ if (c < 0)
+ low = mid + 1;
+ else
+ high = mid - 1;
+ }
+ if (c < 0)
+ mid++;
+ return -(mid + 1);
+}
+
+FcPatternElt *
+FcPatternObjectFindElt (const FcPattern *p, FcObject object)
+{
+ int i = FcPatternObjectPosition (p, object);
+ if (i < 0)
+ return 0;
+ return &FcPatternElts(p)[i];
+}
+
+FcPatternElt *
+FcPatternObjectInsertElt (FcPattern *p, FcObject object)
+{
+ int i;
+ FcPatternElt *e;
+
+ i = FcPatternObjectPosition (p, object);
+ if (i < 0)
+ {
+ i = -i - 1;
+
+ /* reallocate array */
+ if (p->num + 1 >= p->size)
+ {
+ int s = p->size + 16;
+ if (p->size)
+ {
+ FcPatternElt *e0 = FcPatternElts(p);
+ e = (FcPatternElt *) realloc (e0, s * sizeof (FcPatternElt));
+ if (!e) /* maybe it was mmapped */
+ {
+ e = malloc(s * sizeof (FcPatternElt));
+ if (e)
+ memcpy(e, e0, p->num * sizeof (FcPatternElt));
+ }
+ }
+ else
+ e = (FcPatternElt *) malloc (s * sizeof (FcPatternElt));
+ if (!e)
+ return FcFalse;
+ p->elts_offset = FcPtrToOffset (p, e);
+ if (p->size)
+ FcMemFree (FC_MEM_PATELT, p->size * sizeof (FcPatternElt));
+ FcMemAlloc (FC_MEM_PATELT, s * sizeof (FcPatternElt));
+ while (p->size < s)
+ {
+ e[p->size].object = 0;
+ e[p->size].values = NULL;
+ p->size++;
+ }
+ }
+
+ e = FcPatternElts(p);
+ /* move elts up */
+ memmove (e + i + 1,
+ e + i,
+ sizeof (FcPatternElt) *
+ (p->num - i));
+
+ /* bump count */
+ p->num++;
+
+ e[i].object = object;
+ e[i].values = NULL;
+ }
+
+ return FcPatternElts(p) + i;
+}
+
+FcBool
+FcPatternEqual (const FcPattern *pa, const FcPattern *pb)
+{
+ int i;
+ FcPatternElt *pae, *pbe;
+
+ if (pa == pb)
+ return FcTrue;
+
+ if (pa->num != pb->num)
+ return FcFalse;
+ pae = FcPatternElts(pa);
+ pbe = FcPatternElts(pb);
+ for (i = 0; i < pa->num; i++)
+ {
+ if (pae[i].object != pbe[i].object)
+ return FcFalse;
+ if (!FcValueListEqual (FcPatternEltValues(&pae[i]),
+ FcPatternEltValues(&pbe[i])))
+ return FcFalse;
+ }
+ return FcTrue;
+}
+
+FcChar32
+FcPatternHash (const FcPattern *p)
+{
+ int i;
+ FcChar32 h = 0;
+ FcPatternElt *pe = FcPatternElts(p);
+
+ for (i = 0; i < p->num; i++)
+ {
+ h = (((h << 1) | (h >> 31)) ^
+ pe[i].object ^
+ FcValueListHash (FcPatternEltValues(&pe[i])));
+ }
+ return h;
+}
+
+FcBool
+FcPatternEqualSubset (const FcPattern *pai, const FcPattern *pbi, const FcObjectSet *os)
+{
+ FcPatternElt *ea, *eb;
+ int i;
+
+ for (i = 0; i < os->nobject; i++)
+ {
+ FcObject object = FcObjectFromName (os->objects[i]);
+ ea = FcPatternObjectFindElt (pai, object);
+ eb = FcPatternObjectFindElt (pbi, object);
+ if (ea)
+ {
+ if (!eb)
+ return FcFalse;
+ if (!FcValueListEqual (FcPatternEltValues(ea), FcPatternEltValues(eb)))
+ return FcFalse;
+ }
+ else
+ {
+ if (eb)
+ return FcFalse;
+ }
+ }
+ return FcTrue;
+}
+
+FcBool
+FcPatternObjectAddWithBinding (FcPattern *p,
+ FcObject object,
+ FcValue value,
+ FcValueBinding binding,
+ FcBool append)
+{
+ FcPatternElt *e;
+ FcValueListPtr new, *prev;
+
+ if (p->ref == FC_REF_CONSTANT)
+ goto bail0;
+
+ new = malloc (sizeof (FcValueList));
+ if (!new)
+ goto bail0;
+
+ memset(new, 0, sizeof (FcValueList));
+ FcMemAlloc (FC_MEM_VALLIST, sizeof (FcValueList));
+ value = FcValueSave (value);
+ if (value.type == FcTypeVoid)
+ goto bail1;
+
+ /*
+ * Make sure the stored type is valid for built-in objects
+ */
+ if (!FcObjectValidType (object, value.type))
+ {
+ if (FcDebug() & FC_DBG_OBJTYPES)
+ {
+ printf ("FcPattern object %s does not accept value ",
+ FcObjectName (object));
+ FcValuePrint (value);
+ }
+ goto bail1;
+ }
+
+ new->value = value;
+ new->binding = binding;
+ new->next = NULL;
+
+ e = FcPatternObjectInsertElt (p, object);
+ if (!e)
+ goto bail2;
+
+ if (append)
+ {
+ for (prev = &e->values; *prev; prev = &(*prev)->next)
+ ;
+ *prev = new;
+ }
+ else
+ {
+ new->next = e->values;
+ e->values = new;
+ }
+
+ return FcTrue;
+
+bail2:
+ FcValueDestroy (value);
+bail1:
+ FcMemFree (FC_MEM_VALLIST, sizeof (FcValueList));
+ free (new);
+bail0:
+ return FcFalse;
+}
+
+FcBool
+FcPatternObjectAdd (FcPattern *p, FcObject object, FcValue value, FcBool append)
+{
+ return FcPatternObjectAddWithBinding (p, object,
+ value, FcValueBindingStrong, append);
+}
+
+FcBool
+FcPatternAdd (FcPattern *p, const char *object, FcValue value, FcBool append)
+{
+ return FcPatternObjectAddWithBinding (p, FcObjectFromName (object),
+ value, FcValueBindingStrong, append);
+}
+
+FcBool
+FcPatternAddWeak (FcPattern *p, const char *object, FcValue value, FcBool append)
+{
+ return FcPatternObjectAddWithBinding (p, FcObjectFromName (object),
+ value, FcValueBindingWeak, append);
+}
+
+FcBool
+FcPatternObjectDel (FcPattern *p, FcObject object)
+{
+ FcPatternElt *e;
+
+ e = FcPatternObjectFindElt (p, object);
+ if (!e)
+ return FcFalse;
+
+ /* destroy value */
+ FcValueListDestroy (e->values);
+
+ /* shuffle existing ones down */
+ memmove (e, e+1,
+ (FcPatternElts(p) + p->num - (e + 1)) *
+ sizeof (FcPatternElt));
+ p->num--;
+ e = FcPatternElts(p) + p->num;
+ e->object = 0;
+ e->values = NULL;
+ return FcTrue;
+}
+
+FcBool
+FcPatternDel (FcPattern *p, const char *object)
+{
+ return FcPatternObjectDel (p, FcObjectFromName (object));
+}
+
+FcBool
+FcPatternRemove (FcPattern *p, const char *object, int id)
+{
+ FcPatternElt *e;
+ FcValueListPtr *prev, l;
+
+ e = FcPatternObjectFindElt (p, FcObjectFromName (object));
+ if (!e)
+ return FcFalse;
+ for (prev = &e->values; (l = *prev); prev = &l->next)
+ {
+ if (!id)
+ {
+ *prev = l->next;
+ l->next = NULL;
+ FcValueListDestroy (l);
+ if (!e->values)
+ FcPatternDel (p, object);
+ return FcTrue;
+ }
+ id--;
+ }
+ return FcFalse;
+}
+
+FcBool
+FcPatternObjectAddInteger (FcPattern *p, FcObject object, int i)
+{
+ FcValue v;
+
+ v.type = FcTypeInteger;
+ v.u.i = i;
+ return FcPatternObjectAdd (p, object, v, FcTrue);
+}
+
+FcBool
+FcPatternAddInteger (FcPattern *p, const char *object, int i)
+{
+ return FcPatternObjectAddInteger (p, FcObjectFromName (object), i);
+}
+
+FcBool
+FcPatternObjectAddDouble (FcPattern *p, FcObject object, double d)
+{
+ FcValue v;
+
+ v.type = FcTypeDouble;
+ v.u.d = d;
+ return FcPatternObjectAdd (p, object, v, FcTrue);
+}
+
+
+FcBool
+FcPatternAddDouble (FcPattern *p, const char *object, double d)
+{
+ return FcPatternObjectAddDouble (p, FcObjectFromName (object), d);
+}
+
+FcBool
+FcPatternObjectAddString (FcPattern *p, FcObject object, const FcChar8 *s)
+{
+ FcValue v;
+
+ if (!s)
+ {
+ v.type = FcTypeVoid;
+ v.u.s = 0;
+ return FcPatternObjectAdd (p, object, v, FcTrue);
+ }
+
+ v.type = FcTypeString;
+ v.u.s = FcStrStaticName(s);
+ return FcPatternObjectAdd (p, object, v, FcTrue);
+}
+
+FcBool
+FcPatternAddString (FcPattern *p, const char *object, const FcChar8 *s)
+{
+ return FcPatternObjectAddString (p, FcObjectFromName (object), s);
+}
+
+FcBool
+FcPatternAddMatrix (FcPattern *p, const char *object, const FcMatrix *s)
+{
+ FcValue v;
+
+ v.type = FcTypeMatrix;
+ v.u.m = s;
+ return FcPatternAdd (p, object, v, FcTrue);
+}
+
+
+FcBool
+FcPatternObjectAddBool (FcPattern *p, FcObject object, FcBool b)
+{
+ FcValue v;
+
+ v.type = FcTypeBool;
+ v.u.b = b;
+ return FcPatternObjectAdd (p, object, v, FcTrue);
+}
+
+FcBool
+FcPatternAddBool (FcPattern *p, const char *object, FcBool b)
+{
+ return FcPatternObjectAddBool (p, FcObjectFromName (object), b);
+}
+
+FcBool
+FcPatternAddCharSet (FcPattern *p, const char *object, const FcCharSet *c)
+{
+ FcValue v;
+
+ v.type = FcTypeCharSet;
+ v.u.c = (FcCharSet *)c;
+ return FcPatternAdd (p, object, v, FcTrue);
+}
+
+FcBool
+FcPatternAddFTFace (FcPattern *p, const char *object, const FT_Face f)
+{
+ FcValue v;
+
+ v.type = FcTypeFTFace;
+ v.u.f = (void *) f;
+ return FcPatternAdd (p, object, v, FcTrue);
+}
+
+FcBool
+FcPatternAddLangSet (FcPattern *p, const char *object, const FcLangSet *ls)
+{
+ FcValue v;
+
+ v.type = FcTypeLangSet;
+ v.u.l = (FcLangSet *)ls;
+ return FcPatternAdd (p, object, v, FcTrue);
+}
+
+FcResult
+FcPatternObjectGet (const FcPattern *p, FcObject object, int id, FcValue *v)
+{
+ FcPatternElt *e;
+ FcValueListPtr l;
+
+ e = FcPatternObjectFindElt (p, object);
+ if (!e)
+ return FcResultNoMatch;
+ for (l = FcPatternEltValues(e); l; l = FcValueListNext(l))
+ {
+ if (!id)
+ {
+ *v = FcValueCanonicalize(&l->value);
+ return FcResultMatch;
+ }
+ id--;
+ }
+ return FcResultNoId;
+}
+
+FcResult
+FcPatternGet (const FcPattern *p, const char *object, int id, FcValue *v)
+{
+ return FcPatternObjectGet (p, FcObjectFromName (object), id, v);
+}
+
+FcResult
+FcPatternObjectGetInteger (const FcPattern *p, FcObject object, int id, int *i)
+{
+ FcValue v;
+ FcResult r;
+
+ r = FcPatternObjectGet (p, object, id, &v);
+ if (r != FcResultMatch)
+ return r;
+ switch (v.type) {
+ case FcTypeDouble:
+ *i = (int) v.u.d;
+ break;
+ case FcTypeInteger:
+ *i = v.u.i;
+ break;
+ default:
+ return FcResultTypeMismatch;
+ }
+ return FcResultMatch;
+}
+
+FcResult
+FcPatternGetInteger (const FcPattern *p, const char *object, int id, int *i)
+{
+ return FcPatternObjectGetInteger (p, FcObjectFromName (object), id, i);
+}
+
+
+FcResult
+FcPatternObjectGetDouble (const FcPattern *p, FcObject object, int id, double *d)
+{
+ FcValue v;
+ FcResult r;
+
+ r = FcPatternObjectGet (p, object, id, &v);
+ if (r != FcResultMatch)
+ return r;
+ switch (v.type) {
+ case FcTypeDouble:
+ *d = v.u.d;
+ break;
+ case FcTypeInteger:
+ *d = (double) v.u.i;
+ break;
+ default:
+ return FcResultTypeMismatch;
+ }
+ return FcResultMatch;
+}
+
+FcResult
+FcPatternGetDouble (const FcPattern *p, const char *object, int id, double *d)
+{
+ return FcPatternObjectGetDouble (p, FcObjectFromName (object), id, d);
+}
+
+FcResult
+FcPatternObjectGetString (const FcPattern *p, FcObject object, int id, FcChar8 ** s)
+{
+ FcValue v;
+ FcResult r;
+
+ r = FcPatternObjectGet (p, object, id, &v);
+ if (r != FcResultMatch)
+ return r;
+ if (v.type != FcTypeString)
+ return FcResultTypeMismatch;
+
+ *s = (FcChar8 *) v.u.s;
+ return FcResultMatch;
+}
+
+FcResult
+FcPatternGetString (const FcPattern *p, const char *object, int id, FcChar8 ** s)
+{
+ return FcPatternObjectGetString (p, FcObjectFromName (object), id, s);
+}
+
+FcResult
+FcPatternGetMatrix(const FcPattern *p, const char *object, int id, FcMatrix **m)
+{
+ FcValue v;
+ FcResult r;
+
+ r = FcPatternGet (p, object, id, &v);
+ if (r != FcResultMatch)
+ return r;
+ if (v.type != FcTypeMatrix)
+ return FcResultTypeMismatch;
+ *m = (FcMatrix *)v.u.m;
+ return FcResultMatch;
+}
+
+
+FcResult
+FcPatternGetBool(const FcPattern *p, const char *object, int id, FcBool *b)
+{
+ FcValue v;
+ FcResult r;
+
+ r = FcPatternGet (p, object, id, &v);
+ if (r != FcResultMatch)
+ return r;
+ if (v.type != FcTypeBool)
+ return FcResultTypeMismatch;
+ *b = v.u.b;
+ return FcResultMatch;
+}
+
+FcResult
+FcPatternGetCharSet(const FcPattern *p, const char *object, int id, FcCharSet **c)
+{
+ FcValue v;
+ FcResult r;
+
+ r = FcPatternGet (p, object, id, &v);
+ if (r != FcResultMatch)
+ return r;
+ if (v.type != FcTypeCharSet)
+ return FcResultTypeMismatch;
+ *c = (FcCharSet *)v.u.c;
+ return FcResultMatch;
+}
+
+FcResult
+FcPatternGetFTFace(const FcPattern *p, const char *object, int id, FT_Face *f)
+{
+ FcValue v;
+ FcResult r;
+
+ r = FcPatternGet (p, object, id, &v);
+ if (r != FcResultMatch)
+ return r;
+ if (v.type != FcTypeFTFace)
+ return FcResultTypeMismatch;
+ *f = (FT_Face) v.u.f;
+ return FcResultMatch;
+}
+
+FcResult
+FcPatternGetLangSet(const FcPattern *p, const char *object, int id, FcLangSet **ls)
+{
+ FcValue v;
+ FcResult r;
+
+ r = FcPatternGet (p, object, id, &v);
+ if (r != FcResultMatch)
+ return r;
+ if (v.type != FcTypeLangSet)
+ return FcResultTypeMismatch;
+ *ls = (FcLangSet *)v.u.l;
+ return FcResultMatch;
+}
+
+FcPattern *
+FcPatternDuplicate (const FcPattern *orig)
+{
+ FcPattern *new;
+ FcPatternElt *e;
+ int i;
+ FcValueListPtr l;
+
+ new = FcPatternCreate ();
+ if (!new)
+ goto bail0;
+
+ e = FcPatternElts(orig);
+
+ for (i = 0; i < orig->num; i++)
+ {
+ for (l = FcPatternEltValues(e + i); l; l = FcValueListNext(l))
+ {
+ if (!FcPatternObjectAddWithBinding (new, e[i].object,
+ FcValueCanonicalize(&l->value),
+ l->binding,
+ FcTrue))
+ goto bail1;
+
+ }
+ }
+
+ return new;
+
+bail1:
+ FcPatternDestroy (new);
+bail0:
+ return 0;
+}
+
+void
+FcPatternReference (FcPattern *p)
+{
+ if (p->ref != FC_REF_CONSTANT)
+ p->ref++;
+ else
+ FcCacheObjectReference (p);
+}
+
+FcPattern *
+FcPatternVaBuild (FcPattern *p, va_list va)
+{
+ FcPattern *ret;
+
+ FcPatternVapBuild (ret, p, va);
+ return ret;
+}
+
+FcPattern *
+FcPatternBuild (FcPattern *p, ...)
+{
+ va_list va;
+
+ va_start (va, p);
+ FcPatternVapBuild (p, p, va);
+ va_end (va);
+ return p;
+}
+
+/*
+ * Add all of the elements in 's' to 'p'
+ */
+FcBool
+FcPatternAppend (FcPattern *p, FcPattern *s)
+{
+ int i;
+ FcPatternElt *e;
+ FcValueListPtr v;
+
+ for (i = 0; i < s->num; i++)
+ {
+ e = FcPatternElts(s)+i;
+ for (v = FcPatternEltValues(e); v; v = FcValueListNext(v))
+ {
+ if (!FcPatternObjectAddWithBinding (p, e->object,
+ FcValueCanonicalize(&v->value),
+ v->binding, FcTrue))
+ return FcFalse;
+ }
+ }
+ return FcTrue;
+}
+
+FcPattern *
+FcPatternFilter (FcPattern *p, const FcObjectSet *os)
+{
+ int i;
+ FcPattern *ret;
+ FcPatternElt *e;
+ FcValueListPtr v;
+
+ if (!os)
+ return FcPatternDuplicate (p);
+
+ ret = FcPatternCreate ();
+ if (!ret)
+ return NULL;
+
+ for (i = 0; i < os->nobject; i++)
+ {
+ FcObject object = FcObjectFromName (os->objects[i]);
+ e = FcPatternObjectFindElt (p, object);
+ if (e)
+ {
+ for (v = FcPatternEltValues(e); v; v = FcValueListNext(v))
+ {
+ if (!FcPatternObjectAddWithBinding (ret, e->object,
+ FcValueCanonicalize(&v->value),
+ v->binding, FcTrue))
+ goto bail0;
+ }
+ }
+ }
+ return ret;
+
+bail0:
+ FcPatternDestroy (ret);
+ return NULL;
+}
+
+#define OBJECT_HASH_SIZE 31
+static struct objectBucket {
+ struct objectBucket *next;
+ FcChar32 hash;
+} *FcObjectBuckets[OBJECT_HASH_SIZE];
+
+static FcBool
+FcHashOwnsName (const FcChar8 *name)
+{
+ FcChar32 hash = FcStringHash (name);
+ struct objectBucket **p;
+ struct objectBucket *b;
+
+ for (p = &FcObjectBuckets[hash % OBJECT_HASH_SIZE]; (b = *p); p = &(b->next))
+ if (b->hash == hash && ((char *)name == (char *) (b + 1)))
+ return FcTrue;
+ return FcFalse;
+}
+
+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)
+{
+ int i, size;
+ struct objectBucket *b, *next;
+ char *name;
+
+ 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 + sizeof (int));
+ free (b);
+ }
+ FcObjectBuckets[i] = 0;
+ }
+}
+
+void
+FcPatternFini (void)
+{
+ FcStrStaticNameFini ();
+ FcObjectFini ();
+}
+
+FcBool
+FcPatternSerializeAlloc (FcSerialize *serialize, const FcPattern *pat)
+{
+ int i;
+ FcPatternElt *elts = FcPatternElts(pat);
+
+ if (!FcSerializeAlloc (serialize, pat, sizeof (FcPattern)))
+ return FcFalse;
+ if (!FcSerializeAlloc (serialize, elts, pat->num * sizeof (FcPatternElt)))
+ return FcFalse;
+ for (i = 0; i < pat->num; i++)
+ if (!FcValueListSerializeAlloc (serialize, FcPatternEltValues(elts+i)))
+ return FcFalse;
+ return FcTrue;
+}
+
+FcPattern *
+FcPatternSerialize (FcSerialize *serialize, const FcPattern *pat)
+{
+ FcPattern *pat_serialized;
+ FcPatternElt *elts = FcPatternElts (pat);
+ FcPatternElt *elts_serialized;
+ FcValueList *values_serialized;
+ int i;
+
+ pat_serialized = FcSerializePtr (serialize, pat);
+ if (!pat_serialized)
+ return NULL;
+ *pat_serialized = *pat;
+ pat_serialized->size = pat->num;
+ pat_serialized->ref = FC_REF_CONSTANT;
+
+ elts_serialized = FcSerializePtr (serialize, elts);
+ if (!elts_serialized)
+ return NULL;
+
+ pat_serialized->elts_offset = FcPtrToOffset (pat_serialized,
+ elts_serialized);
+
+ for (i = 0; i < pat->num; i++)
+ {
+ values_serialized = FcValueListSerialize (serialize, FcPatternEltValues (elts+i));
+ if (!values_serialized)
+ return NULL;
+ elts_serialized[i].object = elts[i].object;
+ elts_serialized[i].values = FcPtrToEncodedOffset (&elts_serialized[i],
+ values_serialized,
+ FcValueList);
+ }
+ if (FcDebug() & FC_DBG_CACHEV) {
+ printf ("Raw pattern:\n");
+ FcPatternPrint (pat);
+ printf ("Serialized pattern:\n");
+ FcPatternPrint (pat_serialized);
+ printf ("\n");
+ }
+ return pat_serialized;
+}
+
+FcBool
+FcValueListSerializeAlloc (FcSerialize *serialize, const FcValueList *vl)
+{
+ while (vl)
+ {
+ if (!FcSerializeAlloc (serialize, vl, sizeof (FcValueList)))
+ return FcFalse;
+ switch (vl->value.type) {
+ case FcTypeString:
+ if (!FcStrSerializeAlloc (serialize, vl->value.u.s))
+ return FcFalse;
+ break;
+ case FcTypeCharSet:
+ if (!FcCharSetSerializeAlloc (serialize, vl->value.u.c))
+ return FcFalse;
+ break;
+ case FcTypeLangSet:
+ if (!FcLangSetSerializeAlloc (serialize, vl->value.u.l))
+ return FcFalse;
+ break;
+ default:
+ break;
+ }
+ vl = vl->next;
+ }
+ return FcTrue;
+}
+
+FcValueList *
+FcValueListSerialize (FcSerialize *serialize, const FcValueList *vl)
+{
+ FcValueList *vl_serialized;
+ FcChar8 *s_serialized;
+ FcCharSet *c_serialized;
+ FcLangSet *l_serialized;
+ FcValueList *head_serialized = NULL;
+ FcValueList *prev_serialized = NULL;
+
+ while (vl)
+ {
+ vl_serialized = FcSerializePtr (serialize, vl);
+ if (!vl_serialized)
+ return NULL;
+
+ if (prev_serialized)
+ prev_serialized->next = FcPtrToEncodedOffset (prev_serialized,
+ vl_serialized,
+ FcValueList);
+ else
+ head_serialized = vl_serialized;
+
+ vl_serialized->next = NULL;
+ vl_serialized->value.type = vl->value.type;
+ switch (vl->value.type) {
+ case FcTypeInteger:
+ vl_serialized->value.u.i = vl->value.u.i;
+ break;
+ case FcTypeDouble:
+ vl_serialized->value.u.d = vl->value.u.d;
+ break;
+ case FcTypeString:
+ s_serialized = FcStrSerialize (serialize, vl->value.u.s);
+ if (!s_serialized)
+ return NULL;
+ vl_serialized->value.u.s = FcPtrToEncodedOffset (&vl_serialized->value,
+ s_serialized,
+ FcChar8);
+ break;
+ case FcTypeBool:
+ vl_serialized->value.u.b = vl->value.u.b;
+ break;
+ case FcTypeMatrix:
+ /* can't happen */
+ break;
+ case FcTypeCharSet:
+ c_serialized = FcCharSetSerialize (serialize, vl->value.u.c);
+ if (!c_serialized)
+ return NULL;
+ vl_serialized->value.u.c = FcPtrToEncodedOffset (&vl_serialized->value,
+ c_serialized,
+ FcCharSet);
+ break;
+ case FcTypeFTFace:
+ /* can't happen */
+ break;
+ case FcTypeLangSet:
+ l_serialized = FcLangSetSerialize (serialize, vl->value.u.l);
+ if (!l_serialized)
+ return NULL;
+ vl_serialized->value.u.l = FcPtrToEncodedOffset (&vl_serialized->value,
+ l_serialized,
+ FcLangSet);
+ break;
+ default:
+ break;
+ }
+ prev_serialized = vl_serialized;
+ vl = vl->next;
+ }
+ return head_serialized;
+}
+#define __fcpat__
+#include "fcaliastail.h"
+#include "fcftaliastail.h"
+#undef __fcpat__
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-14 13:01:50 +0000