]> git.wh0rd.org - fontconfig.git/blobdiff - src/fcmatch.c
git.wh0rd.org / fontconfig.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fix more gcc4 warnings:
[fontconfig.git] / src / fcmatch.c
diff --git a/src/fcmatch.c b/src/fcmatch.c
index 9afe495169b6ffa4b354dd4cefedeecd9a014852..a359a8b883b96b5d1fee4937e387b1b581290a51 100644 (file)
--- a/src/fcmatch.c
+++ b/src/fcmatch.c
@@ -28,26 +28,26 @@
 #include <stdio.h>
 
 static double
-FcCompareNumber (char *object, FcValue value1, FcValue value2)
+FcCompareNumber (const char *object, 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;
@@ -59,25 +59,28 @@ FcCompareNumber (char *object, FcValue value1, FcValue value2)
 }
 
 static double
-FcCompareString (char *object, FcValue value1, FcValue value2)
+FcCompareString (const char *object, FcValue *v1, FcValue *v2)
 {
+    FcValue value1 = FcValueCanonicalize(v1), value2 = FcValueCanonicalize(v2);
     if (value2.type != FcTypeString || value1.type != FcTypeString)
        return -1.0;
     return (double) FcStrCmpIgnoreCase (value1.u.s, value2.u.s) != 0;
 }
 
 static double
-FcCompareFamily (char *object, FcValue value1, FcValue value2)
+FcCompareFamily (const char *object, FcValue *v1, FcValue *v2)
 {
+    FcValue value1 = FcValueCanonicalize(v1), value2 = FcValueCanonicalize(v2);
     if (value2.type != FcTypeString || value1.type != FcTypeString)
        return -1.0;
     return (double) FcStrCmpIgnoreBlanksAndCase (value1.u.s, value2.u.s) != 0;
 }
 
 static double
-FcCompareLang (char *object, FcValue value1, FcValue value2)
+FcCompareLang (const char *object, FcValue *v1, FcValue *v2)
 {
     FcLangResult    result;
+    FcValue value1 = FcValueCanonicalize(v1), value2 = FcValueCanonicalize(v2);
     
     switch (value1.type) {
     case FcTypeLangSet:
@@ -86,7 +89,8 @@ FcCompareLang (char *object, FcValue value1, FcValue value2)
            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;
@@ -98,7 +102,8 @@ FcCompareLang (char *object, FcValue value1, FcValue value2)
            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;
@@ -119,42 +124,44 @@ FcCompareLang (char *object, FcValue value1, FcValue value2)
 }
 
 static double
-FcCompareBool (char *object, FcValue value1, FcValue value2)
+FcCompareBool (const char *object, FcValue *value1, FcValue *value2)
 {
-    if (value2.type != FcTypeBool || value1.type != FcTypeBool)
+    if (value2->type != FcTypeBool || value1->type != FcTypeBool)
        return -1.0;
-    return (double) value2.u.b != value1.u.b;
+    return (double) value2->u.b != value1->u.b;
 }
 
 static double
-FcCompareCharSet (char *object, FcValue value1, FcValue value2)
+FcCompareCharSet (const char *object, FcValue *v1, FcValue *v2)
 {
+    FcValue value1 = FcValueCanonicalize(v1), value2 = FcValueCanonicalize(v2);
+    
     if (value2.type != FcTypeCharSet || value1.type != FcTypeCharSet)
        return -1.0;
     return (double) FcCharSetSubtractCount (value1.u.c, value2.u.c);
 }
 
 static double
-FcCompareSize (char *object, FcValue value1, FcValue value2)
+FcCompareSize (const char *object, 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;
@@ -168,8 +175,8 @@ FcCompareSize (char *object, FcValue value1, FcValue value2)
 }
 
 typedef struct _FcMatcher {
-    char           *object;
-    double         (*compare) (char *object, FcValue value1, FcValue value2);
+    const char     *object;
+    double         (*compare) (const char *object, FcValue *value1, FcValue *value2);
     int                    strong, weak;
 } FcMatcher;
 
@@ -241,13 +248,13 @@ static FcMatcher _FcMatchers [] = {
 
 static FcBool
 FcCompareValueList (const char  *object,
-                   FcValueList *v1orig,        /* pattern */
-                   FcValueList *v2orig,        /* target */
+                   FcValueListPtr v1orig,      /* pattern */
+                   FcValueListPtr v2orig,      /* target */
                    FcValue     *bestValue,
                    double      *value,
                    FcResult    *result)
 {
-    FcValueList    *v1, *v2;
+    FcValueListPtr v1, v2;
     double         v, best, bestStrong, bestWeak;
     int                    i;
     int                    j;
@@ -308,7 +315,7 @@ FcCompareValueList (const char  *object,
                            (FcChar8 *) object) != 0)
     {
        if (bestValue)
-           *bestValue = v2orig->value;
+           *bestValue = FcValueCanonicalize(&FcValueListPtrU(v2orig)->value);
        return FcTrue;
     }
 #if 0
@@ -329,13 +336,15 @@ FcCompareValueList (const char  *object,
     bestStrong = 1e99;
     bestWeak = 1e99;
     j = 0;
-    for (v1 = v1orig; v1; v1 = v1->next)
+    for (v1 = v1orig; FcValueListPtrU(v1); 
+        v1 = FcValueListPtrU(v1)->next)
     {
-       for (v2 = v2orig; v2; v2 = v2->next)
+       for (v2 = v2orig; FcValueListPtrU(v2); 
+            v2 = FcValueListPtrU(v2)->next)
        {
            v = (*_FcMatchers[i].compare) (_FcMatchers[i].object,
-                                           v1->value,
-                                           v2->value);
+                                           &FcValueListPtrU(v1)->value,
+                                           &FcValueListPtrU(v2)->value);
            if (v < 0)
            {
                *result = FcResultTypeMismatch;
@@ -347,10 +356,10 @@ FcCompareValueList (const char  *object,
            if (v < best)
            {
                if (bestValue)
-                   *bestValue = v2->value;
+                   *bestValue = FcValueCanonicalize(&FcValueListPtrU(v2)->value);
                best = v;
            }
-           if (v1->binding == FcValueBindingStrong)
+           if (FcValueListPtrU(v1)->binding == FcValueBindingStrong)
            {
                if (v < bestStrong)
                    bestStrong = v;
@@ -406,16 +415,17 @@ FcCompare (FcPattern      *pat,
     i2 = 0;
     while (i1 < pat->num && i2 < fnt->num)
     {
-       i = strcmp (pat->elts[i1].object, fnt->elts[i2].object);
+       i = FcObjectPtrCompare((FcPatternEltU(pat->elts)+i1)->object,
+                              (FcPatternEltU(fnt->elts)+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,
+           if (!FcCompareValueList (FcObjectPtrU((FcPatternEltU(pat->elts)+i1)->object),
+                                    (FcPatternEltU(pat->elts)+i1)->values,
+                                    (FcPatternEltU(fnt->elts)+i2)->values,
                                     0,
                                     value,
                                     result))
@@ -456,11 +466,11 @@ FcFontRenderPrepare (FcConfig         *config,
        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, 
+           if (!FcCompareValueList (FcObjectPtrU(pe->object), pe->values, 
                                     fe->values, &v, 0, &result))
            {
                FcPatternDestroy (new);
@@ -468,15 +478,16 @@ FcFontRenderPrepare (FcConfig         *config,
            }
        }
        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);
     }
     FcConfigSubstituteWithPat (config, new, pat, FcMatchFont);
     return new;
@@ -769,8 +780,8 @@ FcFontSetSort (FcConfig         *config,
                    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 (FC_LANG, &patternLang, 
+                                                    &nodeLang);
                    if (compare >= 0 && compare < 2)
                    {
                        if (FcDebug () & FC_DBG_MATCHV)
http://fontconfig.org/