*/
#include "fcint.h"
+#include "fcftint.h"
#include <stdlib.h>
#include <string.h>
#include <assert.h>
static FcBool
-FcStrHashed (const FcChar8 *name);
+FcHashOwnsName(const FcChar8 *name);
FcPattern *
FcPatternCreate (void)
{
switch (v.type) {
case FcTypeString:
- if (!FcStrHashed (v.u.s))
+ if (!FcHashOwnsName(v.u.s))
FcStrFree ((FcChar8 *) v.u.s);
break;
case FcTypeMatrix:
{
switch (l->value.type) {
case FcTypeString:
- if (!FcStrHashed ((FcChar8 *)l->value.u.s))
+ if (!FcHashOwnsName((FcChar8 *)l->value.u.s))
FcStrFree ((FcChar8 *)l->value.u.s);
break;
case FcTypeMatrix:
for (i = 0; i < orig->num; i++)
{
for (l = FcPatternEltValues(e + i); l; l = FcValueListNext(l))
- if (!FcPatternObjectAdd (new, e[i].object,
- FcValueCanonicalize(&l->value),
- FcTrue))
+ {
+ if (!FcPatternObjectAddWithBinding (new, e[i].object,
+ FcValueCanonicalize(&l->value),
+ l->binding,
+ FcTrue))
goto bail1;
+
+ }
}
return new;
}
FcPattern *
-FcPatternVaBuild (FcPattern *orig, va_list va)
+FcPatternVaBuild (FcPattern *p, va_list va)
{
FcPattern *ret;
- FcPatternVapBuild (ret, orig, va);
+ FcPatternVapBuild (ret, p, va);
return ret;
}
FcPattern *
-FcPatternBuild (FcPattern *orig, ...)
+FcPatternBuild (FcPattern *p, ...)
{
va_list va;
- va_start (va, orig);
- FcPatternVapBuild (orig, orig, va);
+ va_start (va, p);
+ FcPatternVapBuild (p, p, va);
va_end (va);
- return orig;
+ return p;
}
/*
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;
} *FcObjectBuckets[OBJECT_HASH_SIZE];
static FcBool
-FcStrHashed (const FcChar8 *name)
+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 && !strcmp ((char *)name, (char *) (b + 1)))
+ if (b->hash == hash && ((char *)name == (char *) (b + 1)))
return FcTrue;
return FcFalse;
}
next = b->next;
name = (char *) (b + 1);
size = sizeof (struct objectBucket) + strlen (name) + 1;
- FcMemFree (FC_MEM_STATICSTR, size);
+ FcMemFree (FC_MEM_STATICSTR, size + sizeof (int));
free (b);
}
FcObjectBuckets[i] = 0;
head_serialized = vl_serialized;
vl_serialized->next = NULL;
- vl_serialized->value = vl->value;
+ 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)
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)
c_serialized,
FcCharSet);
break;
+ case FcTypeFTFace:
+ /* can't happen */
+ break;
case FcTypeLangSet:
l_serialized = FcLangSetSerialize (serialize, vl->value.u.l);
if (!l_serialized)
}
#define __fcpat__
#include "fcaliastail.h"
+#include "fcftaliastail.h"
#undef __fcpat__