#include <stdio.h>
static double
-FcCompareNumber (char *object, FcValue value1, FcValue value2)
+FcCompareNumber (FcValue *value1, FcValue *value2)
{
double v1, v2, v;
- switch (value1.type) {
+ switch (value1->type) {
case FcTypeInteger:
- v1 = (double) value1.u.i;
+ v1 = (double) value1->u.i;
break;
case FcTypeDouble:
- v1 = value1.u.d;
+ v1 = value1->u.d;
break;
default:
return -1.0;
}
- switch (value2.type) {
+ switch (value2->type) {
case FcTypeInteger:
- v2 = (double) value2.u.i;
+ v2 = (double) value2->u.i;
break;
case FcTypeDouble:
- v2 = value2.u.d;
+ v2 = value2->u.d;
break;
default:
return -1.0;
v = v2 - v1;
if (v < 0)
v = -v;
- return (double) v;
+ return v;
}
static double
-FcCompareString (char *object, FcValue value1, FcValue value2)
+FcCompareString (FcValue *v1, FcValue *v2)
{
- if (value2.type != FcTypeString || value1.type != FcTypeString)
- return -1.0;
- return (double) FcStrCmpIgnoreCase (value1.u.s, value2.u.s) != 0;
+ return (double) FcStrCmpIgnoreCase (fc_value_string(v1), fc_value_string(v2)) != 0;
}
static double
-FcCompareFamily (char *object, FcValue value1, FcValue value2)
+FcCompareFamily (FcValue *v1, FcValue *v2)
{
- if (value2.type != FcTypeString || value1.type != FcTypeString)
- return -1.0;
- return (double) FcStrCmpIgnoreBlanksAndCase (value1.u.s, value2.u.s) != 0;
+ /* rely on the guarantee in FcPatternAddWithBinding that
+ * families are always FcTypeString. */
+ const FcChar8* v1_string = fc_value_string(v1);
+ const FcChar8* v2_string = fc_value_string(v2);
+
+ if (FcToLower(*v1_string) != FcToLower(*v2_string))
+ return 1.0;
+
+ return (double) FcStrCmpIgnoreBlanksAndCase (v1_string, v2_string) != 0;
}
static double
-FcCompareLang (char *object, FcValue value1, FcValue value2)
+FcCompareLang (FcValue *v1, FcValue *v2)
{
FcLangResult result;
+ FcValue value1 = FcValueCanonicalize(v1), value2 = FcValueCanonicalize(v2);
switch (value1.type) {
case FcTypeLangSet:
result = FcLangSetCompare (value1.u.l, value2.u.l);
break;
case FcTypeString:
- result = FcLangSetHasLang (value1.u.l, value2.u.s);
+ result = FcLangSetHasLang (value1.u.l,
+ value2.u.s);
break;
default:
return -1.0;
result = FcLangSetHasLang (value2.u.l, value1.u.s);
break;
case FcTypeString:
- result = FcLangCompare (value1.u.s, value2.u.s);
+ result = FcLangCompare (value1.u.s,
+ value2.u.s);
break;
default:
return -1.0;
}
static double
-FcCompareBool (char *object, FcValue value1, FcValue value2)
+FcCompareBool (FcValue *v1, FcValue *v2)
{
- if (value2.type != FcTypeBool || value1.type != FcTypeBool)
+ if (fc_storage_type(v2) != FcTypeBool || fc_storage_type(v1) != FcTypeBool)
return -1.0;
- return (double) value2.u.b != value1.u.b;
+ return (double) v2->u.b != v1->u.b;
}
static double
-FcCompareCharSet (char *object, FcValue value1, FcValue value2)
+FcCompareCharSet (FcValue *v1, FcValue *v2)
{
- if (value2.type != FcTypeCharSet || value1.type != FcTypeCharSet)
- return -1.0;
- return (double) FcCharSetSubtractCount (value1.u.c, value2.u.c);
+ return (double) FcCharSetSubtractCount (fc_value_charset(v1), fc_value_charset(v2));
}
static double
-FcCompareSize (char *object, FcValue value1, FcValue value2)
+FcCompareSize (FcValue *value1, FcValue *value2)
{
double v1, v2, v;
- switch (value1.type) {
+ switch (value1->type) {
case FcTypeInteger:
- v1 = value1.u.i;
+ v1 = value1->u.i;
break;
case FcTypeDouble:
- v1 = value1.u.d;
+ v1 = value1->u.d;
break;
default:
return -1;
}
- switch (value2.type) {
+ switch (value2->type) {
case FcTypeInteger:
- v2 = value2.u.i;
+ v2 = value2->u.i;
break;
case FcTypeDouble:
- v2 = value2.u.d;
+ v2 = value2->u.d;
break;
default:
return -1;
}
typedef struct _FcMatcher {
- char *object;
- double (*compare) (char *object, FcValue value1, FcValue value2);
+ const char *object;
+ double (*compare) (FcValue *value1, FcValue *value2);
int strong, weak;
} FcMatcher;
#define NUM_MATCH_VALUES 15
static FcBool
-FcCompareValueList (const char *object,
- FcValueList *v1orig, /* pattern */
- FcValueList *v2orig, /* target */
+FcCompareValueList (FcObjectPtr o,
+ FcValueListPtr v1orig, /* pattern */
+ FcValueListPtr v2orig, /* target */
FcValue *bestValue,
double *value,
FcResult *result)
{
- FcValueList *v1, *v2;
+ FcValueListPtr v1, v2;
+ FcValueList *v1_ptrU, *v2_ptrU;
double v, best, bestStrong, bestWeak;
int i;
int j;
-
+ const char* object = FcObjectPtrU(o);
+
/*
* Locate the possible matching entry by examining the
* first few characters in object
*/
i = -1;
- switch (FcToLower (object[0])) {
+ switch (object[0]) {
case 'f':
- switch (FcToLower (object[1])) {
+ switch (object[1]) {
case 'o':
- switch (FcToLower (object[2])) {
+ switch (object[2]) {
case 'u':
i = MATCH_FOUNDRY; break;
case 'n':
case 'l':
i = MATCH_LANG; break;
case 's':
- switch (FcToLower (object[1])) {
+ switch (object[1]) {
case 'p':
i = MATCH_SPACING; break;
case 't':
case 'p':
i = MATCH_PIXEL_SIZE; break;
case 'w':
- switch (FcToLower (object[1])) {
+ switch (object[1]) {
case 'i':
i = MATCH_WIDTH; break;
case 'e':
(FcChar8 *) object) != 0)
{
if (bestValue)
- *bestValue = v2orig->value;
- return FcTrue;
- }
-#if 0
- for (i = 0; i < NUM_MATCHER; i++)
- {
- if (!FcStrCmpIgnoreCase ((FcChar8 *) _FcMatchers[i].object,
- (FcChar8 *) object))
- break;
- }
- if (i == NUM_MATCHER)
- {
- if (bestValue)
- *bestValue = v2orig->value;
+ *bestValue = FcValueCanonicalize(&FcValueListPtrU(v2orig)->value);
return FcTrue;
}
-#endif
best = 1e99;
bestStrong = 1e99;
bestWeak = 1e99;
j = 0;
- for (v1 = v1orig; v1; v1 = v1->next)
+ for (v1 = v1orig, v1_ptrU = FcValueListPtrU(v1); v1_ptrU;
+ v1 = FcValueListPtrU(v1)->next, v1_ptrU = FcValueListPtrU(v1))
{
- for (v2 = v2orig; v2; v2 = v2->next)
+ for (v2 = v2orig, v2_ptrU = FcValueListPtrU(v2); FcValueListPtrU(v2);
+ v2 = FcValueListPtrU(v2)->next)
{
- v = (*_FcMatchers[i].compare) (_FcMatchers[i].object,
- v1->value,
- v2->value);
+ v = (*_FcMatchers[i].compare) (&v1_ptrU->value,
+ &v2_ptrU->value);
if (v < 0)
{
*result = FcResultTypeMismatch;
return FcFalse;
}
- if (FcDebug () & FC_DBG_MATCHV)
- printf (" v %g j %d ", v, j);
v = v * 100 + j;
if (v < best)
{
if (bestValue)
- *bestValue = v2->value;
+ *bestValue = FcValueCanonicalize(&v2_ptrU->value);
best = v;
}
- if (v1->binding == FcValueBindingStrong)
+ if (v1_ptrU->binding == FcValueBindingStrong)
{
if (v < bestStrong)
bestStrong = v;
i2 = 0;
while (i1 < pat->num && i2 < fnt->num)
{
- i = strcmp (pat->elts[i1].object, fnt->elts[i2].object);
+ FcPatternElt *elt_i1 = FcPatternEltU(pat->elts)+i1;
+ FcPatternElt *elt_i2 = FcPatternEltU(fnt->elts)+i2;
+
+ i = FcObjectPtrCompare(elt_i1->object, elt_i2->object);
if (i > 0)
i2++;
else if (i < 0)
i1++;
else
{
- if (!FcCompareValueList (pat->elts[i1].object,
- pat->elts[i1].values,
- fnt->elts[i2].values,
- 0,
- value,
- result))
+ if (!FcCompareValueList (elt_i1->object,
+ elt_i1->values, elt_i2->values,
+ 0, value, result))
return FcFalse;
i1++;
i2++;
}
}
return FcTrue;
-#if 0
- for (i1 = 0; i1 < pat->num; i1++)
- {
- for (i2 = 0; i2 < fnt->num; i2++)
- {
- if (!strcmp (pat->elts[i1].object, fnt->elts[i2].object))
- {
- break;
- }
- }
- }
- return FcTrue;
-#endif
}
FcPattern *
return 0;
for (i = 0; i < font->num; i++)
{
- fe = &font->elts[i];
- pe = FcPatternFindElt (pat, fe->object);
+ fe = FcPatternEltU(font->elts)+i;
+ pe = FcPatternFindElt (pat, FcObjectPtrU(fe->object));
if (pe)
{
if (!FcCompareValueList (pe->object, pe->values,
}
}
else
- v = fe->values->value;
- FcPatternAdd (new, fe->object, v, FcFalse);
+ v = FcValueCanonicalize(&FcValueListPtrU(fe->values)->value);
+ FcPatternAdd (new, FcObjectPtrU(fe->object), v, FcFalse);
}
for (i = 0; i < pat->num; i++)
{
- pe = &pat->elts[i];
- fe = FcPatternFindElt (font, pe->object);
+ pe = FcPatternEltU(pat->elts)+i;
+ fe = FcPatternFindElt (font, FcObjectPtrU(pe->object));
if (!fe)
- FcPatternAdd (new, pe->object, pe->values->value, FcTrue);
+ FcPatternAdd (new, FcObjectPtrU(pe->object),
+ FcValueCanonicalize(&FcValueListPtrU(pe->values)->value), FcTrue);
}
+
+ if (FcPatternFindElt (font, FC_FILE))
+ FcPatternTransferFullFname (new, font);
+
FcConfigSubstituteWithPat (config, new, pat, FcMatchFont);
return new;
}
FcPatternGet (p, FC_LANG, i, &patternLang) == FcResultMatch &&
FcPatternGet (nodeps[f]->pattern, FC_LANG, 0, &nodeLang) == FcResultMatch)
{
- double compare = FcCompareLang (FC_LANG, patternLang,
- nodeLang);
+ double compare = FcCompareLang (&patternLang, &nodeLang);
if (compare >= 0 && compare < 2)
{
if (FcDebug () & FC_DBG_MATCHV)