* PERFORMANCE OF THIS SOFTWARE.
*/
-#include <stdlib.h>
-#include <sys/types.h>
-#include <sys/mman.h>
-#include <unistd.h>
#include "fcint.h"
+#include <stdlib.h>
FcObjectSet *
FcObjectSetCreate (void)
FcObjectSetAdd (FcObjectSet *os, const char *object)
{
int s;
- FcObjectPtr *objects;
- FcObjectPtr obj;
+ const char **objects;
int high, low, mid, c;
if (os->nobject == os->sobject)
{
s = os->sobject + 4;
if (os->objects)
- objects = (FcObjectPtr *) realloc ((void *) os->objects,
- s * sizeof (FcObjectPtr));
+ objects = (const char **) realloc ((void *) os->objects,
+ s * sizeof (const char *));
else
- objects = (FcObjectPtr *) malloc (s * sizeof (FcObjectPtr));
+ objects = (const char **) malloc (s * sizeof (const char *));
if (!objects)
return FcFalse;
if (os->sobject)
low = 0;
mid = 0;
c = 1;
- obj = FcObjectStaticName (object);
+ object = (char *)FcStrStaticName ((FcChar8 *)object);
while (low <= high)
{
mid = (low + high) >> 1;
- c = FcObjectPtrCompare(os->objects[mid], obj);
+ c = os->objects[mid] - object;
if (c == 0)
return FcTrue;
if (c < 0)
if (c < 0)
mid++;
memmove (os->objects + mid + 1, os->objects + mid,
- (os->nobject - mid) * sizeof (FcObjectPtr));
- os->objects[mid] = obj;
+ (os->nobject - mid) * sizeof (const char *));
+ os->objects[mid] = object;
os->nobject++;
return FcTrue;
}
* (OpListing is OpContains except for strings
* where it requires an exact match)
*/
- if (FcConfigCompareValue (FcValueListPtrU(fnt)->value,
+ if (FcConfigCompareValue (&FcValueListPtrU(fnt)->value,
FcOpListing,
- FcValueListPtrU(pat)->value))
+ &FcValueListPtrU(pat)->value))
break;
}
if (!FcValueListPtrU(fnt))
{
for (v2 = v2orig; FcValueListPtrU(v2);
v2 = FcValueListPtrU(v2)->next)
- if (FcValueEqual (FcValueListPtrU(v1)->value,
- FcValueListPtrU(v2)->value))
+ if (FcValueEqual (FcValueCanonicalize(&FcValueListPtrU(v1)->value),
+ FcValueCanonicalize(&FcValueListPtrU(v2)->value)))
break;
if (!FcValueListPtrU(v2))
return FcFalse;
{
for (v1 = v1orig; FcValueListPtrU(v1);
v1 = FcValueListPtrU(v1)->next)
- if (FcValueEqual (FcValueListPtrU(v1)->value,
- FcValueListPtrU(v2)->value))
+ if (FcValueEqual (FcValueCanonicalize(&FcValueListPtrU(v1)->value),
+ FcValueCanonicalize(&FcValueListPtrU(v2)->value)))
break;
if (!FcValueListPtrU(v1))
return FcFalse;
for (i = 0; i < os->nobject; i++)
{
- e1 = FcPatternFindElt (p1, FcObjectPtrU(os->objects[i]));
- e2 = FcPatternFindElt (p2, FcObjectPtrU(os->objects[i]));
+ e1 = FcPatternFindElt (p1, os->objects[i]);
+ e2 = FcPatternFindElt (p2, os->objects[i]);
if (!e1 && !e2)
continue;
if (!e1 || !e2)
}
static FcChar32
-FcListValueHash (FcValue v)
+FcListValueHash (FcValue *value)
{
+ FcValue v = FcValueCanonicalize(value);
switch (v.type) {
case FcTypeVoid:
return 0;
case FcTypeDouble:
return (FcChar32) (int) v.u.d;
case FcTypeString:
- return FcStrHashIgnoreCase (FcObjectPtrU(v.u.si));
+ return FcStrHashIgnoreCase (v.u.s);
case FcTypeBool:
return (FcChar32) v.u.b;
case FcTypeMatrix:
- return FcListMatrixHash (FcMatrixPtrU(v.u.mi));
+ return FcListMatrixHash (v.u.m);
case FcTypeCharSet:
- return FcCharSetCount (FcCharSetPtrU(v.u.ci));
+ return FcCharSetCount (v.u.c);
case FcTypeFTFace:
return (long) v.u.f;
case FcTypeLangSet:
- return FcLangSetHash (FcLangSetPtrU(v.u.li));
+ return FcLangSetHash (v.u.l);
}
return 0;
}
while (FcValueListPtrU(list))
{
- h = h ^ FcListValueHash (FcValueListPtrU(list)->value);
+ h = h ^ FcListValueHash (&FcValueListPtrU(list)->value);
list = FcValueListPtrU(list)->next;
}
return h;
for (n = 0; n < os->nobject; n++)
{
- e = FcPatternFindElt (font, FcObjectPtrU(os->objects[n]));
+ e = FcPatternFindElt (font, os->objects[n]);
if (e)
h = h ^ FcListValueListHash (e->values);
}
table->entries = 0;
}
+static int
+FcGetDefaultObjectLangIndex (FcPattern *font, const char *object)
+{
+ FcChar8 *lang = FcGetDefaultLang ();
+ FcPatternElt *e = FcPatternFindElt (font, object);
+ FcValueListPtr v;
+ FcValue value;
+ int idx = -1;
+ int i;
+
+ if (e)
+ {
+ for (v = e->values, i = 0; FcValueListPtrU(v); v = FcValueListPtrU(v)->next, ++i)
+ {
+ value = FcValueCanonicalize (&FcValueListPtrU (v)->value);
+
+ if (value.type == FcTypeString)
+ {
+ FcLangResult res = FcLangCompare (value.u.s, lang);
+ if (res == FcLangEqual || (res == FcLangDifferentCountry && idx < 0))
+ idx = i;
+ }
+ }
+ }
+
+ return (idx > 0) ? idx : 0;
+}
+
static FcBool
FcListAppend (FcListHashTable *table,
FcPattern *font,
FcValueListPtr v;
FcChar32 hash;
FcListBucket **prev, *bucket;
+ int familyidx = -1;
+ int fullnameidx = -1;
+ int styleidx = -1;
+ int defidx = 0;
+ int idx;
hash = FcListPatternHash (font, os);
for (prev = &table->buckets[hash % FC_LIST_HASH_SIZE];
for (o = 0; o < os->nobject; o++)
{
- e = FcPatternFindElt (font, FcObjectPtrU(os->objects[o]));
+ if (!strcmp (os->objects[o], FC_FAMILY) || !strcmp (os->objects[o], FC_FAMILYLANG))
+ {
+ if (familyidx < 0)
+ familyidx = FcGetDefaultObjectLangIndex (font, FC_FAMILYLANG);
+ defidx = familyidx;
+ }
+ else if (!strcmp (os->objects[o], FC_FULLNAME) || !strcmp (os->objects[o], FC_FULLNAMELANG))
+ {
+ if (fullnameidx < 0)
+ fullnameidx = FcGetDefaultObjectLangIndex (font, FC_FULLNAMELANG);
+ defidx = fullnameidx;
+ }
+ else if (!strcmp (os->objects[o], FC_STYLE) || !strcmp (os->objects[o], FC_STYLELANG))
+ {
+ if (styleidx < 0)
+ styleidx = FcGetDefaultObjectLangIndex (font, FC_STYLELANG);
+ defidx = styleidx;
+ }
+ else
+ defidx = 0;
+
+ e = FcPatternFindElt (font, os->objects[o]);
if (e)
{
- for (v = e->values; FcValueListPtrU(v);
- v = FcValueListPtrU(v)->next)
+ for (v = e->values, idx = 0; FcValueListPtrU(v);
+ v = FcValueListPtrU(v)->next, ++idx)
{
if (!FcPatternAdd (bucket->pattern,
- FcObjectPtrU(os->objects[o]),
- FcValueListPtrU(v)->value, FcTrue))
+ os->objects[o],
+ FcValueCanonicalize(&FcValueListPtrU(v)->value), defidx != idx))
goto bail2;
}
}