fontconfig: Branch 'master' - 15 commits

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



 src/fccfg.c   |  682 ++++++++++++++++++++++++++++++++++++++--------------------
 src/fcint.h   |   11 
 src/fcmatch.c |  183 +++++++++++++--
 src/fcstr.c   |  103 ++++++--
 4 files changed, 697 insertions(+), 282 deletions(-)

New commits:
commit ff7d314ab5f04d3ad54d5165b81d87894d7a8dfe
Author: Matthias Clasen <mclasen@xxxxxxxxxx>
Date:   Tue Aug 25 18:12:07 2020 -0400

    Fix up FC_LIKELY macros
    
    __builtin_expect returns the same type as the expression,
    so enforce that we pass in a boolean expression.
    
    Pointed out by Emmanuele Bassi.

diff --git a/src/fcint.h b/src/fcint.h
index fb173b5..a3b192d 100644
--- a/src/fcint.h
+++ b/src/fcint.h
@@ -61,8 +61,8 @@
 #define FC_LIKELY(expr) (expr)
 #define FC_UNLIKELY(expr) (expr)
 #else
-#define FC_LIKELY(expr) (__builtin_expect (expr, 1))
-#define FC_UNLIKELY(expr) (__builtin_expect (expr, 0))
+#define FC_LIKELY(expr) (__builtin_expect (((expr) ? 1 : 0), 1))
+#define FC_UNLIKELY(expr) (__builtin_expect (((expr) ? 1 : 0), 0))
 #endif
 
 #ifdef _WIN32
commit e117d6768c5cf5ae37405d03ed6d3b076e713dde
Author: Matthias Clasen <mclasen@xxxxxxxxxx>
Date:   Tue Aug 25 07:26:32 2020 -0400

    Fixup: Handle patterns without family
    
    Pointed out by Akira Tagoh.

diff --git a/src/fcmatch.c b/src/fcmatch.c
index 16d03de..df6db71 100644
--- a/src/fcmatch.c
+++ b/src/fcmatch.c
@@ -525,25 +525,28 @@ FcCompareDataInit (FcPattern     *pat,
                                free);
 
     elt = FcPatternObjectFindElt (pat, FC_FAMILY_OBJECT);
-    for (l = FcPatternEltValues(elt), i = 0; l; l = FcValueListNext(l), i++)
+    if (elt)
     {
-        key = FcValueString (&l->value);
-        if (!FcHashTableFind (table, key, (void **)&e))
+        for (l = FcPatternEltValues(elt), i = 0; l; l = FcValueListNext(l), i++)
         {
-            e = malloc (sizeof (FamilyEntry));
-            e->strong_value = 1e99;
-            e->weak_value = 1e99;
-            FcHashTableAdd (table, (void *)key, e);
-        }
-        if (l->binding == FcValueBindingWeak)
-        {
-            if (i < e->weak_value)
-                e->weak_value = i;
-        }
-        else
-        {
-            if (i < e->strong_value)
-                e->strong_value = i;
+            key = FcValueString (&l->value);
+            if (!FcHashTableFind (table, key, (void **)&e))
+            {
+                e = malloc (sizeof (FamilyEntry));
+                e->strong_value = 1e99;
+                e->weak_value = 1e99;
+                FcHashTableAdd (table, (void *)key, e);
+            }
+            if (l->binding == FcValueBindingWeak)
+            {
+                if (i < e->weak_value)
+                    e->weak_value = i;
+            }
+            else
+            {
+                if (i < e->strong_value)
+                    e->strong_value = i;
+            }
         }
     }
 
commit 51d40491fc483787ba66fb76344ff7d4c13a39b3
Author: Matthias Clasen <mclasen@xxxxxxxxxx>
Date:   Mon Aug 24 07:59:50 2020 -0400

    Use FC_UNLIKELY

diff --git a/src/fcstr.c b/src/fcstr.c
index f1f75dc..8971b71 100644
--- a/src/fcstr.c
+++ b/src/fcstr.c
@@ -164,7 +164,7 @@ FcStrCaseWalkerNextNonDelim (FcCaseWalker *w, const char *delims)
 {
     FcChar8	r;
 
-    if (__builtin_expect (w->read != NULL, 0))
+    if (FC_UNLIKELY (w->read != NULL))
     {
 	if ((r = *w->read++))
 	    return r;
@@ -175,7 +175,7 @@ FcStrCaseWalkerNextNonDelim (FcCaseWalker *w, const char *delims)
 	r = *w->src++;
     } while (r != 0 && delims && strchr (delims, r));
 
-    if (__builtin_expect ((r & 0xc0) == 0xc0, 0))
+    if (FC_UNLIKELY ((r & 0xc0) == 0xc0))
 	return FcStrCaseWalkerLong (w, r);
     if ('A' <= r && r <= 'Z')
         r = r - 'A' + 'a';
@@ -187,7 +187,7 @@ FcStrCaseWalkerNextNonBlank (FcCaseWalker *w)
 {
     FcChar8	r;
 
-    if (__builtin_expect (w->read != NULL, 0))
+    if (FC_UNLIKELY (w->read != NULL))
     {
 	if ((r = *w->read++))
 	    return r;
@@ -198,7 +198,7 @@ FcStrCaseWalkerNextNonBlank (FcCaseWalker *w)
 	r = *w->src++;
     } while (r == ' ');
 
-    if (__builtin_expect ((r & 0xc0) == 0xc0, 0))
+    if (FC_UNLIKELY ((r & 0xc0) == 0xc0))
 	return FcStrCaseWalkerLong (w, r);
     if ('A' <= r && r <= 'Z')
         r = r - 'A' + 'a';
@@ -210,7 +210,7 @@ FcStrCaseWalkerNext (FcCaseWalker *w)
 {
     FcChar8	r;
 
-    if (__builtin_expect (w->read != NULL, 0))
+    if (FC_UNLIKELY (w->read != NULL))
     {
 	if ((r = *w->read++))
 	    return r;
@@ -219,7 +219,7 @@ FcStrCaseWalkerNext (FcCaseWalker *w)
 
     r = *w->src++;
 
-    if (__builtin_expect ((r & 0xc0) == 0xc0, 0))
+    if (FC_UNLIKELY ((r & 0xc0) == 0xc0))
 	return FcStrCaseWalkerLong (w, r);
     if ('A' <= r && r <= 'Z')
         r = r - 'A' + 'a';
commit 76699a4813a05fd89114a29965d2532adc1553b0
Author: Matthias Clasen <mclasen@xxxxxxxxxx>
Date:   Mon Aug 24 07:59:18 2020 -0400

    Add FC_LIKELY and FC_UNLIKELY macros
    
    These wrap __builtin_expect where it exists.

diff --git a/src/fcint.h b/src/fcint.h
index 08a0cd6..fb173b5 100644
--- a/src/fcint.h
+++ b/src/fcint.h
@@ -57,6 +57,14 @@
 #define FC_CONFIG_PATH "fonts.conf"
 #endif
 
+#ifdef _WIN32
+#define FC_LIKELY(expr) (expr)
+#define FC_UNLIKELY(expr) (expr)
+#else
+#define FC_LIKELY(expr) (__builtin_expect (expr, 1))
+#define FC_UNLIKELY(expr) (__builtin_expect (expr, 0))
+#endif
+
 #ifdef _WIN32
 #  include "fcwindows.h"
 typedef UINT (WINAPI *pfnGetSystemWindowsDirectory)(LPSTR, UINT);
commit 835f9bbdbe7c023bce27f699c8906ace9b62a051
Author: Matthias Clasen <mclasen@xxxxxxxxxx>
Date:   Sat Aug 22 02:35:24 2020 -0400

    Fixup: Promote ints to ranges when appropriate
    
    Pointed out by Akira Tagoh.

diff --git a/src/fccfg.c b/src/fccfg.c
index 13bd0ff..f86f680 100644
--- a/src/fccfg.c
+++ b/src/fccfg.c
@@ -939,6 +939,13 @@ FcConfigPromote (FcValue v, FcValue u, FcValuePromotionBuffer *buf)
     case FcTypeInteger:
         v.type = FcTypeDouble;
         v.u.d = (double) v.u.i;
+        /* Fallthrough */
+    case FcTypeDouble:
+        if (u.type == FcTypeRange && buf)
+        {
+            v.u.r = FcRangePromote (v.u.d, buf);
+            v.type = FcTypeRange;
+        }
         break;
     case FcTypeVoid:
         if (u.type == FcTypeMatrix)
@@ -964,13 +971,6 @@ FcConfigPromote (FcValue v, FcValue u, FcValuePromotionBuffer *buf)
             v.type = FcTypeLangSet;
         }
         break;
-    case FcTypeDouble:
-        if (u.type == FcTypeRange && buf)
-        {
-            v.u.r = FcRangePromote (v.u.d, buf);
-            v.type = FcTypeRange;
-        }
-        break;
     default:
         break;
     }
commit 148ebf98edb498d786f4c1107ec116e1afdf9541
Author: Matthias Clasen <mclasen@xxxxxxxxxx>
Date:   Sat Aug 22 00:57:25 2020 -0400

    Use __builtin_expect in a few places
    
    utf8 is extremely rare in the strings we see in
    font configuration, so this seems to be a good
    case for __builtin_expect.

diff --git a/src/fcstr.c b/src/fcstr.c
index dc9940a..f1f75dc 100644
--- a/src/fcstr.c
+++ b/src/fcstr.c
@@ -164,7 +164,7 @@ FcStrCaseWalkerNextNonDelim (FcCaseWalker *w, const char *delims)
 {
     FcChar8	r;
 
-    if (w->read)
+    if (__builtin_expect (w->read != NULL, 0))
     {
 	if ((r = *w->read++))
 	    return r;
@@ -175,7 +175,7 @@ FcStrCaseWalkerNextNonDelim (FcCaseWalker *w, const char *delims)
 	r = *w->src++;
     } while (r != 0 && delims && strchr (delims, r));
 
-    if ((r & 0xc0) == 0xc0)
+    if (__builtin_expect ((r & 0xc0) == 0xc0, 0))
 	return FcStrCaseWalkerLong (w, r);
     if ('A' <= r && r <= 'Z')
         r = r - 'A' + 'a';
@@ -187,7 +187,7 @@ FcStrCaseWalkerNextNonBlank (FcCaseWalker *w)
 {
     FcChar8	r;
 
-    if (w->read)
+    if (__builtin_expect (w->read != NULL, 0))
     {
 	if ((r = *w->read++))
 	    return r;
@@ -198,7 +198,7 @@ FcStrCaseWalkerNextNonBlank (FcCaseWalker *w)
 	r = *w->src++;
     } while (r == ' ');
 
-    if ((r & 0xc0) == 0xc0)
+    if (__builtin_expect ((r & 0xc0) == 0xc0, 0))
 	return FcStrCaseWalkerLong (w, r);
     if ('A' <= r && r <= 'Z')
         r = r - 'A' + 'a';
@@ -210,7 +210,7 @@ FcStrCaseWalkerNext (FcCaseWalker *w)
 {
     FcChar8	r;
 
-    if (w->read)
+    if (__builtin_expect (w->read != NULL, 0))
     {
 	if ((r = *w->read++))
 	    return r;
@@ -219,7 +219,7 @@ FcStrCaseWalkerNext (FcCaseWalker *w)
 
     r = *w->src++;
 
-    if ((r & 0xc0) == 0xc0)
+    if (__builtin_expect ((r & 0xc0) == 0xc0, 0))
 	return FcStrCaseWalkerLong (w, r);
     if ('A' <= r && r <= 'Z')
         r = r - 'A' + 'a';
commit 13015a0a6ed15ef2e0241a92ef05233dc51ce23b
Author: Matthias Clasen <mclasen@xxxxxxxxxx>
Date:   Tue Aug 18 16:33:57 2020 -0400

    Use a hash table for families in FcConfigSubstitute
    
    Use the same approach we used for FcFontMatch, and
    keep a hash table of family names. We only speed
    up the no-match case, for now.

diff --git a/src/fccfg.c b/src/fccfg.c
index 803cd68..13bd0ff 100644
--- a/src/fccfg.c
+++ b/src/fccfg.c
@@ -1579,12 +1579,128 @@ FcConfigEvaluate (FcPattern *p, FcPattern *p_pat, FcMatchKind kind, FcExpr *e)
     return v;
 }
 
+/* The bulk of the time in FcConfigSubstitute is spent walking
+ * lists of family names. We speed this up with a hash table.
+ * Since we need to take the ignore-blanks option into account,
+ * we use two separate hash tables.
+ */
+typedef struct
+{
+  int count;
+} FamilyTableEntry;
+
+
+typedef struct
+{
+  FcHashTable *family_blank_hash;
+  FcHashTable *family_hash;
+} FamilyTable;
+
+static FcBool
+FamilyTableLookup (FamilyTable   *table,
+                   FcOp           _op,
+                   const FcChar8 *s)
+{
+    FamilyTableEntry *fe;
+    int flags = FC_OP_GET_FLAGS (_op);
+    FcHashTable *hash;
+
+    if (flags & FcOpFlagIgnoreBlanks)
+        hash = table->family_blank_hash;
+    else
+        hash = table->family_hash;
+
+    return FcHashTableFind (hash, (const void *)s, (void **)&fe);
+}
+
+static void
+FamilyTableAdd (FamilyTable    *table,
+                FcValueListPtr  values)
+{
+    FcValueListPtr ll;
+    for (ll = values; ll; ll = FcValueListNext (ll))
+        {
+            const FcChar8 *s = FcValueString (&ll->value);
+            FamilyTableEntry *fe;
+
+            if (!FcHashTableFind (table->family_hash, (const void *)s, (void **)&fe))
+            {
+                fe = malloc (sizeof (FamilyTableEntry));
+                fe->count = 0;
+                FcHashTableAdd (table->family_hash, (void *)s, fe);
+            }
+            fe->count++;
+
+            if (!FcHashTableFind (table->family_blank_hash, (const void *)s, (void **)&fe))
+            {
+                fe = malloc (sizeof (FamilyTableEntry));
+                fe->count = 0;
+                FcHashTableAdd (table->family_blank_hash, (void *)s, fe);
+            }
+            fe->count++;
+       }
+}
+
+static void
+FamilyTableDel (FamilyTable   *table,
+                const FcChar8 *s)
+{
+    FamilyTableEntry *fe;
+
+    if (FcHashTableFind (table->family_hash, (void *)s, (void **)&fe))
+    {
+        fe->count--;
+        if (fe->count == 0)
+            FcHashTableRemove (table->family_hash, (void *)s);
+    }
+
+    if (FcHashTableFind (table->family_blank_hash, (void *)s, (void **)&fe))
+    {
+        fe->count--;
+        if (fe->count == 0)
+            FcHashTableRemove (table->family_blank_hash, (void *)s);
+    }
+}
+
+static void
+FamilyTableInit (FamilyTable *table,
+                 FcPattern *p)
+{
+    FcPatternElt *e;
+
+    table->family_blank_hash = FcHashTableCreate ((FcHashFunc)FcStrHashIgnoreBlanksAndCase,
+                                          (FcCompareFunc)FcStrCmpIgnoreBlanksAndCase,
+                                          NULL,
+                                          NULL,
+                                          NULL,
+                                          free);
+    table->family_hash = FcHashTableCreate ((FcHashFunc)FcStrHashIgnoreCase,
+                                          (FcCompareFunc)FcStrCmpIgnoreCase,
+                                          NULL,
+                                          NULL,
+                                          NULL,
+                                          free);
+    e = FcPatternObjectFindElt (p, FC_FAMILY_OBJECT);
+    if (e)
+        FamilyTableAdd (table, FcPatternEltValues (e));
+}
+
+static void
+FamilyTableClear (FamilyTable *table)
+{
+    if (table->family_blank_hash)
+        FcHashTableDestroy (table->family_blank_hash);
+    if (table->family_hash)
+        FcHashTableDestroy (table->family_hash);
+}
+
 static FcValueList *
 FcConfigMatchValueList (FcPattern	*p,
 			FcPattern	*p_pat,
 			FcMatchKind      kind,
 			FcTest		*t,
-			FcValueList	*values)
+			FcValueList	*values,
+                        FamilyTable     *table)
 {
     FcValueList	    *ret = 0;
     FcExpr	    *e = t->expr;
@@ -1605,6 +1721,14 @@ FcConfigMatchValueList (FcPattern	*p,
 	    e = 0;
 	}
 
+        if (t->object == FC_FAMILY_OBJECT && table)
+        {
+            if (!FamilyTableLookup (table, t->op, FcValueString (&value)))
+            {
+                    ret = 0;
+                    goto done;
+            }
+        }
 	for (v = values; v; v = FcValueListNext(v))
 	{
 	    /* Compare the pattern value to the match expression value */
@@ -1624,6 +1748,7 @@ FcConfigMatchValueList (FcPattern	*p,
 		}
 	    }
 	}
+done:
 	FcValueDestroy (value);
     }
     return ret;
@@ -1666,7 +1791,8 @@ FcConfigAdd (FcValueListPtr *head,
 	     FcValueList    *position,
 	     FcBool	    append,
 	     FcValueList    *new,
-	     FcObject        object)
+	     FcObject        object,
+             FamilyTable    *table)
 {
     FcValueListPtr  *prev, l, last, v;
     FcValueBinding  sameBinding;
@@ -1692,6 +1818,11 @@ FcConfigAdd (FcValueListPtr *head,
 	}
     }
 
+    if (object == FC_FAMILY_OBJECT && table)
+    {
+        FamilyTableAdd (table, new);
+    }
+
     if (position)
 	sameBinding = position->binding;
     else
@@ -1758,10 +1889,17 @@ FcConfigAdd (FcValueListPtr *head,
 
 static void
 FcConfigDel (FcValueListPtr *head,
-	     FcValueList    *position)
+	     FcValueList    *position,
+             FcObject        object,
+             FamilyTable    *table)
 {
     FcValueListPtr *prev;
 
+    if (object == FC_FAMILY_OBJECT && table)
+    {
+        FamilyTableDel (table, FcValueString (&position->value));
+    }
+
     for (prev = head; *prev != NULL; prev = &(*prev)->next)
     {
 	if (*prev == position)
@@ -1776,9 +1914,10 @@ FcConfigDel (FcValueListPtr *head,
 
 static void
 FcConfigPatternAdd (FcPattern	*p,
-		    FcObject	object,
+		    FcObject	 object,
 		    FcValueList	*list,
-		    FcBool	append)
+		    FcBool	 append,
+                    FamilyTable *table)
 {
     if (list)
     {
@@ -1786,7 +1925,7 @@ FcConfigPatternAdd (FcPattern	*p,
 
 	if (!e)
 	    return;
-	FcConfigAdd (&e->values, 0, append, list, object);
+	FcConfigAdd (&e->values, 0, append, list, object, table);
     }
 }
 
@@ -1795,13 +1934,14 @@ FcConfigPatternAdd (FcPattern	*p,
  */
 static void
 FcConfigPatternDel (FcPattern	*p,
-		    FcObject	object)
+		    FcObject	 object,
+                    FamilyTable *table)
 {
     FcPatternElt    *e = FcPatternObjectFindElt (p, object);
     if (!e)
 	return;
     while (e->values != NULL)
-	FcConfigDel (&e->values, e->values);
+	FcConfigDel (&e->values, e->values, object, table);
 }
 
 static void
@@ -1834,6 +1974,8 @@ FcConfigSubstituteWithPat (FcConfig    *config,
     int		    i, nobjs;
     FcBool	    retval = FcTrue;
     FcTest	    **tst = NULL;
+    FamilyTable     data;
+    FamilyTable     *table = &data;
 
     if (kind < FcMatchKindBegin || kind >= FcMatchKindEnd)
 	return FcFalse;
@@ -1931,6 +2073,9 @@ FcConfigSubstituteWithPat (FcConfig    *config,
 	printf ("FcConfigSubstitute ");
 	FcPatternPrint (p);
     }
+
+    FamilyTableInit (&data, p);
+
     FcPtrListIterInit (s, &iter);
     for (; FcPtrListIterIsValid (s, &iter); FcPtrListIterNext (s, &iter))
     {
@@ -1967,9 +2112,15 @@ FcConfigSubstituteWithPat (FcConfig    *config,
 			FcTestPrint (r->u.test);
 		    }
 		    if (kind == FcMatchFont && r->u.test->kind == FcMatchPattern)
+                    {
 			m = p_pat;
+                        table = NULL;
+                    }
 		    else
+                    {
 			m = p;
+                        table = &data;
+                    }
 		    if (m)
 			e = FcPatternObjectFindElt (m, r->u.test->object);
 		    else
@@ -2002,7 +2153,7 @@ FcConfigSubstituteWithPat (FcConfig    *config,
 		     * Check to see if there is a match, mark the location
 		     * to apply match-relative edits
 		     */
-		    vl = FcConfigMatchValueList (m, p_pat, kind, r->u.test, e->values);
+		    vl = FcConfigMatchValueList (m, p_pat, kind, r->u.test, e->values, table);
 		    /* different 'kind' won't be the target of edit */
 		    if (!value[object] && kind == r->u.test->kind)
 			value[object] = vl;
@@ -2026,7 +2177,7 @@ FcConfigSubstituteWithPat (FcConfig    *config,
 		    /*
 		     * Evaluate the list of expressions
 		     */
-		    l = FcConfigValues (p, p_pat,kind,  r->u.edit->expr, r->u.edit->binding);
+		    l = FcConfigValues (p, p_pat, kind, r->u.edit->expr, r->u.edit->binding);
 		    if (tst[object] && (tst[object]->kind == FcMatchFont || kind == FcMatchPattern))
 			elt[object] = FcPatternObjectFindElt (p, tst[object]->object);
 
@@ -2044,12 +2195,12 @@ FcConfigSubstituteWithPat (FcConfig    *config,
 			    /*
 			     * Append the new list of values after the current value
 			     */
-			    FcConfigAdd (&elt[object]->values, thisValue, FcTrue, l, r->u.edit->object);
+			    FcConfigAdd (&elt[object]->values, thisValue, FcTrue, l, r->u.edit->object, table);
 			    /*
 			     * Delete the marked value
 			     */
 			    if (thisValue)
-				FcConfigDel (&elt[object]->values, thisValue);
+				FcConfigDel (&elt[object]->values, thisValue, object, table);
 			    /*
 			     * Adjust a pointer into the value list to ensure
 			     * future edits occur at the same place
@@ -2063,8 +2214,8 @@ FcConfigSubstituteWithPat (FcConfig    *config,
 			 * Delete all of the values and insert
 			 * the new set
 			 */
-			FcConfigPatternDel (p, r->u.edit->object);
-			FcConfigPatternAdd (p, r->u.edit->object, l, FcTrue);
+			FcConfigPatternDel (p, r->u.edit->object, table);
+			FcConfigPatternAdd (p, r->u.edit->object, l, FcTrue, table);
 			/*
 			 * Adjust a pointer into the value list as they no
 			 * longer point to anything valid
@@ -2074,33 +2225,33 @@ FcConfigSubstituteWithPat (FcConfig    *config,
 		    case FcOpPrepend:
 			if (value[object])
 			{
-			    FcConfigAdd (&elt[object]->values, value[object], FcFalse, l, r->u.edit->object);
+			    FcConfigAdd (&elt[object]->values, value[object], FcFalse, l, r->u.edit->object, table);
 			    break;
 			}
 			/* fall through ... */
 		    case FcOpPrependFirst:
-			FcConfigPatternAdd (p, r->u.edit->object, l, FcFalse);
+			FcConfigPatternAdd (p, r->u.edit->object, l, FcFalse, table);
 			break;
 		    case FcOpAppend:
 			if (value[object])
 			{
-			    FcConfigAdd (&elt[object]->values, value[object], FcTrue, l, r->u.edit->object);
+			    FcConfigAdd (&elt[object]->values, value[object], FcTrue, l, r->u.edit->object, table);
 			    break;
 			}
 			/* fall through ... */
 		    case FcOpAppendLast:
-			FcConfigPatternAdd (p, r->u.edit->object, l, FcTrue);
+			FcConfigPatternAdd (p, r->u.edit->object, l, FcTrue, table);
 			break;
 		    case FcOpDelete:
 			if (value[object])
 			{
-			    FcConfigDel (&elt[object]->values, value[object]);
+			    FcConfigDel (&elt[object]->values, value[object], object, table);
 			    FcValueListDestroy (l);
 			    break;
 			}
 			/* fall through ... */
 		    case FcOpDeleteAll:
-			FcConfigPatternDel (p, r->u.edit->object);
+			FcConfigPatternDel (p, r->u.edit->object, table);
 			FcValueListDestroy (l);
 			break;
 		    default:
@@ -2130,6 +2281,7 @@ FcConfigSubstituteWithPat (FcConfig    *config,
 	FcPatternPrint (p);
     }
 bail1:
+    FamilyTableClear (&data);
     if (elt)
 	free (elt);
     if (value)
commit 7deb07e38e31da787875cb65db2ecb0dc0d5807f
Author: Matthias Clasen <mclasen@xxxxxxxxxx>
Date:   Fri Aug 21 09:12:35 2020 -0400

    Speed up FcCompareLang and FcCompareBool
    
    Avoid FcCanonicalize here too.

diff --git a/src/fcmatch.c b/src/fcmatch.c
index 289204e..16d03de 100644
--- a/src/fcmatch.c
+++ b/src/fcmatch.c
@@ -104,30 +104,27 @@ static double
 FcCompareLang (const FcValue *v1, const FcValue *v2, FcValue *bestValue)
 {
     FcLangResult    result;
-    FcValue value1 = FcValueCanonicalize(v1), value2 = FcValueCanonicalize(v2);
 
-    switch ((int) value1.type) {
+    switch ((int) v1->type) {
     case FcTypeLangSet:
-	switch ((int) value2.type) {
+	switch ((int) v2->type) {
 	case FcTypeLangSet:
-	    result = FcLangSetCompare (value1.u.l, value2.u.l);
+	    result = FcLangSetCompare (FcValueLangSet (v1), FcValueLangSet (v2));
 	    break;
 	case FcTypeString:
-	    result = FcLangSetHasLang (value1.u.l,
-				       value2.u.s);
+	    result = FcLangSetHasLang (FcValueLangSet (v1), FcValueString (v2));
 	    break;
 	default:
 	    return -1.0;
 	}
 	break;
     case FcTypeString:
-	switch ((int) value2.type) {
+	switch ((int) v2->type) {
 	case FcTypeLangSet:
-	    result = FcLangSetHasLang (value2.u.l, value1.u.s);
+	    result = FcLangSetHasLang (FcValueLangSet (v2), FcValueString (v1));
 	    break;
 	case FcTypeString:
-	    result = FcLangCompare (value1.u.s,
-				    value2.u.s);
+	    result = FcLangCompare (FcValueString (v1), FcValueString (v2));
 	    break;
 	default:
 	    return -1.0;
@@ -154,10 +151,11 @@ FcCompareBool (const FcValue *v1, const FcValue *v2, FcValue *bestValue)
     if (v2->type != FcTypeBool || v1->type != FcTypeBool)
 	return -1.0;
 
+    bestValue->type = FcTypeBool;
     if (v2->u.b != FcDontCare)
-	*bestValue = FcValueCanonicalize (v2);
+	bestValue->u.b = v2->u.b;
     else
-	*bestValue = FcValueCanonicalize (v1);
+	bestValue->u.b = v1->u.b;
 
     return (double) ((v2->u.b ^ v1->u.b) == 1);
 }
commit 09729c9032e66da30c24d8268e444b2e6dd0e0d7
Author: Matthias Clasen <mclasen@xxxxxxxxxx>
Date:   Fri Aug 21 00:49:04 2020 -0400

    Speed up FcConfigCompareValue
    
    Avoid FcValueCanonicalize when we can, to avoid
    unnecessary copying of FcValue structs.

diff --git a/src/fccfg.c b/src/fccfg.c
index 8e7a682..803cd68 100644
--- a/src/fccfg.c
+++ b/src/fccfg.c
@@ -982,192 +982,215 @@ FcConfigCompareValue (const FcValue	*left_o,
 		      unsigned int      op_,
 		      const FcValue	*right_o)
 {
-    FcValue     left = FcValueCanonicalize(left_o);
-    FcValue     right = FcValueCanonicalize(right_o);
+    FcValue     left;
+    FcValue     right;
     FcBool	ret = FcFalse;
     FcOp	op = FC_OP_GET_OP (op_);
     int		flags = FC_OP_GET_FLAGS (op_);
 
-    if (left.type != right.type)
+    if (left_o->type != right_o->type)
     {
+        left = FcValueCanonicalize(left_o);
+        right = FcValueCanonicalize(right_o);
         FcValuePromotionBuffer buf1, buf2;
         left = FcConfigPromote (left, right, &buf1);
         right = FcConfigPromote (right, left, &buf2);
-        if (left.type != right.type)
+        left_o = &left;
+        right_o = &right;
+        if (left_o->type != right_o->type)
         {
 	    if (op == FcOpNotEqual || op == FcOpNotContains)
 	        ret = FcTrue;
             return ret;
         }
     }
-    switch (left.type) {
+    switch (left_o->type) {
     case FcTypeUnknown:
         break;	/* No way to guess how to compare for this object */
-    case FcTypeInteger:
+    case FcTypeInteger: {
+        int l = left_o->u.i;
+        int r = right_o->u.i;
         switch ((int) op) {
         case FcOpEqual:
         case FcOpContains:
         case FcOpListing:
-            ret = left.u.i == right.u.i;
+            ret = l == r;
             break;
         case FcOpNotEqual:
         case FcOpNotContains:
-            ret = left.u.i != right.u.i;
+            ret = l != r;
             break;
         case FcOpLess:
-            ret = left.u.i < right.u.i;
+            ret = l < r;
             break;
         case FcOpLessEqual:
-            ret = left.u.i <= right.u.i;
+            ret = l <= r;
             break;
         case FcOpMore:
-            ret = left.u.i > right.u.i;
+            ret = l > r;
             break;
         case FcOpMoreEqual:
-            ret = left.u.i >= right.u.i;
+            ret = l >= r;
             break;
         default:
             break;
         }
         break;
-    case FcTypeDouble:
+    }
+    case FcTypeDouble: {
+        double l = left_o->u.d;
+        double r = right_o->u.d;
         switch ((int) op) {
         case FcOpEqual:
         case FcOpContains:
         case FcOpListing:
-            ret = left.u.d == right.u.d;
+            ret = l == r;
             break;
         case FcOpNotEqual:
         case FcOpNotContains:
-            ret = left.u.d != right.u.d;
+            ret = l != r;
             break;
         case FcOpLess:
-            ret = left.u.d < right.u.d;
+            ret = l < r;
             break;
         case FcOpLessEqual:
-            ret = left.u.d <= right.u.d;
+            ret = l <= r;
             break;
         case FcOpMore:
-            ret = left.u.d > right.u.d;
+            ret = l > r;
             break;
         case FcOpMoreEqual:
-            ret = left.u.d >= right.u.d;
+            ret = l >= r;
             break;
         default:
             break;
         }
         break;
-    case FcTypeBool:
+    }
+    case FcTypeBool: {
+        FcBool l = left_o->u.b;
+        FcBool r = right_o->u.b;
         switch ((int) op) {
         case FcOpEqual:
-            ret = left.u.b == right.u.b;
+            ret = l == r;
             break;
         case FcOpContains:
         case FcOpListing:
-            ret = left.u.b == right.u.b || left.u.b >= FcDontCare;
+            ret = l == r || l >= FcDontCare;
             break;
         case FcOpNotEqual:
-            ret = left.u.b != right.u.b;
+            ret = l != r;
             break;
         case FcOpNotContains:
-            ret = !(left.u.b == right.u.b || left.u.b >= FcDontCare);
+            ret = !(l == r || l >= FcDontCare);
             break;
         case FcOpLess:
-            ret = left.u.b != right.u.b && right.u.b >= FcDontCare;
+            ret = l != r && r >= FcDontCare;
             break;
         case FcOpLessEqual:
-            ret = left.u.b == right.u.b || right.u.b >= FcDontCare;
+            ret = l == r || r >= FcDontCare;
             break;
         case FcOpMore:
-            ret = left.u.b != right.u.b && left.u.b >= FcDontCare;
+            ret = l != r && l >= FcDontCare;
             break;
         case FcOpMoreEqual:
-            ret = left.u.b == right.u.b || left.u.b >= FcDontCare;
+            ret = l == r || l >= FcDontCare;
             break;
         default:
             break;
         }
         break;
-    case FcTypeString:
+    }
+    case FcTypeString: {
+        const FcChar8 *l = FcValueString (left_o);
+        const FcChar8 *r = FcValueString (right_o);
         switch ((int) op) {
         case FcOpEqual:
         case FcOpListing:
             if (flags & FcOpFlagIgnoreBlanks)
-                ret = FcStrCmpIgnoreBlanksAndCase (left.u.s, right.u.s) == 0;
+                ret = FcStrCmpIgnoreBlanksAndCase (l, r) == 0;
             else
-                ret = FcStrCmpIgnoreCase (left.u.s, right.u.s) == 0;
+                ret = FcStrCmpIgnoreCase (l, r) == 0;
             break;
         case FcOpContains:
-            ret = FcStrStrIgnoreCase (left.u.s, right.u.s) != 0;
+            ret = FcStrStrIgnoreCase (l, r) != 0;
             break;
         case FcOpNotEqual:
             if (flags & FcOpFlagIgnoreBlanks)
-                ret = FcStrCmpIgnoreBlanksAndCase (left.u.s, right.u.s) != 0;
+                ret = FcStrCmpIgnoreBlanksAndCase (l, r) != 0;
             else
-                ret = FcStrCmpIgnoreCase (left.u.s, right.u.s) != 0;
+                ret = FcStrCmpIgnoreCase (l, r) != 0;
             break;
         case FcOpNotContains:
-            ret = FcStrStrIgnoreCase (left.u.s, right.u.s) == 0;
+            ret = FcStrStrIgnoreCase (l, r) == 0;
             break;
         default:
             break;
         }
         break;
-    case FcTypeMatrix:
+    }
+    case FcTypeMatrix: {
         switch ((int) op) {
         case FcOpEqual:
         case FcOpContains:
         case FcOpListing:
-            ret = FcMatrixEqual (left.u.m, right.u.m);
+            ret = FcMatrixEqual (left_o->u.m, right_o->u.m);
             break;
         case FcOpNotEqual:
         case FcOpNotContains:
-            ret = !FcMatrixEqual (left.u.m, right.u.m);
+            ret = !FcMatrixEqual (left_o->u.m, right_o->u.m);
             break;
         default:
             break;
         }
         break;
-    case FcTypeCharSet:
+    }
+    case FcTypeCharSet: {
+        const FcCharSet *l = FcValueCharSet (left_o);
+        const FcCharSet *r = FcValueCharSet (right_o);
         switch ((int) op) {
         case FcOpContains:
         case FcOpListing:
             /* left contains right if right is a subset of left */
-            ret = FcCharSetIsSubset (right.u.c, left.u.c);
+            ret = FcCharSetIsSubset (r, l);
             break;
         case FcOpNotContains:
             /* left contains right if right is a subset of left */
-            ret = !FcCharSetIsSubset (right.u.c, left.u.c);
+            ret = !FcCharSetIsSubset (r, l);
             break;
         case FcOpEqual:
-            ret = FcCharSetEqual (left.u.c, right.u.c);
+            ret = FcCharSetEqual (l, r);
             break;
         case FcOpNotEqual:
-            ret = !FcCharSetEqual (left.u.c, right.u.c);
+            ret = !FcCharSetEqual (l, r);
             break;
         default:
             break;
         }
         break;
-    case FcTypeLangSet:
+    }
+    case FcTypeLangSet: {
+        const FcLangSet *l = FcValueLangSet (left_o);
+        const FcLangSet *r = FcValueLangSet (right_o);
         switch ((int) op) {
         case FcOpContains:
         case FcOpListing:
-            ret = FcLangSetContains (left.u.l, right.u.l);
+            ret = FcLangSetContains (l, r);
             break;
         case FcOpNotContains:
-            ret = !FcLangSetContains (left.u.l, right.u.l);
+            ret = !FcLangSetContains (l, r);
             break;
         case FcOpEqual:
-            ret = FcLangSetEqual (left.u.l, right.u.l);
+            ret = FcLangSetEqual (l, r);
             break;
         case FcOpNotEqual:
-            ret = !FcLangSetEqual (left.u.l, right.u.l);
+            ret = !FcLangSetEqual (l, r);
             break;
         default:
             break;
         }
         break;
+    }
     case FcTypeVoid:
         switch ((int) op) {
         case FcOpEqual:
@@ -1184,20 +1207,23 @@ FcConfigCompareValue (const FcValue	*left_o,
         case FcOpEqual:
         case FcOpContains:
         case FcOpListing:
-            ret = left.u.f == right.u.f;
+            ret = left_o->u.f == right_o->u.f;
             break;
         case FcOpNotEqual:
         case FcOpNotContains:
-            ret = left.u.f != right.u.f;
+            ret = left_o->u.f != right_o->u.f;
             break;
         default:
             break;
         }
         break;
-    case FcTypeRange:
-        ret = FcRangeCompare (op, left.u.r, right.u.r);
+    case FcTypeRange: {
+        const FcRange *l = FcValueRange (left_o);
+        const FcRange *r = FcValueRange (right_o);
+        ret = FcRangeCompare (op, l, r);
         break;
     }
+    }
     return ret;
 }
 
commit 9d4e5d0f25dd592316d1728f95f40fe5967b120c
Author: Matthias Clasen <mclasen@xxxxxxxxxx>
Date:   Thu Aug 20 23:45:19 2020 -0400

    Speed up FcConfigCompareValue
    
    Make FcConfigPromote use a switch instead of
    an if-else cascade, and avoid calling it when
    we can.
    
    Note that we need to add a case for integers
    in FcConfigCompareValue, since we are no longer
    promoting integers to doubles unconditionally.

diff --git a/src/fccfg.c b/src/fccfg.c
index cb4d3e0..8e7a682 100644
--- a/src/fccfg.c
+++ b/src/fccfg.c
@@ -934,35 +934,45 @@ FcConfigAddRule (FcConfig	*config,
 static FcValue
 FcConfigPromote (FcValue v, FcValue u, FcValuePromotionBuffer *buf)
 {
-    if (v.type == FcTypeInteger)
-    {
-	v.type = FcTypeDouble;
-	v.u.d = (double) v.u.i;
-    }
-    else if (v.type == FcTypeVoid && u.type == FcTypeMatrix)
-    {
-	v.u.m = &FcIdentityMatrix;
-	v.type = FcTypeMatrix;
-    }
-    else if (buf && v.type == FcTypeString && u.type == FcTypeLangSet)
-    {
-	v.u.l = FcLangSetPromote (v.u.s, buf);
-	v.type = FcTypeLangSet;
-    }
-    else if (buf && v.type == FcTypeVoid && u.type == FcTypeLangSet)
-    {
-	v.u.l = FcLangSetPromote (NULL, buf);
-	v.type = FcTypeLangSet;
-    }
-    else if (buf && v.type == FcTypeVoid && u.type == FcTypeCharSet)
-    {
-	v.u.c = FcCharSetPromote (buf);
-	v.type = FcTypeCharSet;
-    }
-    if (buf && v.type == FcTypeDouble && u.type == FcTypeRange)
-    {
-	v.u.r = FcRangePromote (v.u.d, buf);
-	v.type = FcTypeRange;
+    switch (v.type)
+    {
+    case FcTypeInteger:
+        v.type = FcTypeDouble;
+        v.u.d = (double) v.u.i;
+        break;
+    case FcTypeVoid:
+        if (u.type == FcTypeMatrix)
+        {
+            v.u.m = &FcIdentityMatrix;
+            v.type = FcTypeMatrix;
+        }
+        else if (u.type == FcTypeLangSet && buf)
+        {
+            v.u.l = FcLangSetPromote (NULL, buf);
+            v.type = FcTypeLangSet;
+        }
+        else if (u.type == FcTypeCharSet && buf)
+        {
+            v.u.c = FcCharSetPromote (buf);
+            v.type = FcTypeCharSet;
+        }
+        break;
+    case FcTypeString:
+        if (u.type == FcTypeLangSet && buf)
+        {
+            v.u.l = FcLangSetPromote (v.u.s, buf);
+            v.type = FcTypeLangSet;
+        }
+        break;
+    case FcTypeDouble:
+        if (u.type == FcTypeRange && buf)
+        {
+            v.u.r = FcRangePromote (v.u.d, buf);
+            v.type = FcTypeRange;
+        }
+        break;
+    default:
+        break;
     }
     return v;
 }
@@ -972,195 +982,221 @@ FcConfigCompareValue (const FcValue	*left_o,
 		      unsigned int      op_,
 		      const FcValue	*right_o)
 {
-    FcValue	left = FcValueCanonicalize(left_o);
-    FcValue	right = FcValueCanonicalize(right_o);
+    FcValue     left = FcValueCanonicalize(left_o);
+    FcValue     right = FcValueCanonicalize(right_o);
     FcBool	ret = FcFalse;
     FcOp	op = FC_OP_GET_OP (op_);
     int		flags = FC_OP_GET_FLAGS (op_);
-    FcValuePromotionBuffer buf1, buf2;
 
-    left = FcConfigPromote (left, right, &buf1);
-    right = FcConfigPromote (right, left, &buf2);
-    if (left.type == right.type)
-    {
-	switch (left.type) {
-	case FcTypeUnknown:
-	    break;	/* No way to guess how to compare for this object */
-	case FcTypeInteger:
-	    break;	/* FcConfigPromote prevents this from happening */
-	case FcTypeDouble:
-	    switch ((int) op) {
-	    case FcOpEqual:
-	    case FcOpContains:
-	    case FcOpListing:
-		ret = left.u.d == right.u.d;
-		break;
-	    case FcOpNotEqual:
-	    case FcOpNotContains:
-		ret = left.u.d != right.u.d;
-		break;
-	    case FcOpLess:
-		ret = left.u.d < right.u.d;
-		break;
-	    case FcOpLessEqual:
-		ret = left.u.d <= right.u.d;
-		break;
-	    case FcOpMore:
-		ret = left.u.d > right.u.d;
-		break;
-	    case FcOpMoreEqual:
-		ret = left.u.d >= right.u.d;
-		break;
-	    default:
-		break;
-	    }
-	    break;
-	case FcTypeBool:
-	    switch ((int) op) {
-	    case FcOpEqual:
-		ret = left.u.b == right.u.b;
-		break;
-	    case FcOpContains:
-	    case FcOpListing:
-		ret = left.u.b == right.u.b || left.u.b >= FcDontCare;
-		break;
-	    case FcOpNotEqual:
-		ret = left.u.b != right.u.b;
-		break;
-	    case FcOpNotContains:
-		ret = !(left.u.b == right.u.b || left.u.b >= FcDontCare);
-		break;
-	    case FcOpLess:
-		ret = left.u.b != right.u.b && right.u.b >= FcDontCare;
-		break;
-	    case FcOpLessEqual:
-		ret = left.u.b == right.u.b || right.u.b >= FcDontCare;
-		break;
-	    case FcOpMore:
-		ret = left.u.b != right.u.b && left.u.b >= FcDontCare;
-		break;
-	    case FcOpMoreEqual:
-		ret = left.u.b == right.u.b || left.u.b >= FcDontCare;
-		break;
-	    default:
-		break;
-	    }
-	    break;
-	case FcTypeString:
-	    switch ((int) op) {
-	    case FcOpEqual:
-	    case FcOpListing:
-		if (flags & FcOpFlagIgnoreBlanks)
-		    ret = FcStrCmpIgnoreBlanksAndCase (left.u.s, right.u.s) == 0;
-		else
-		    ret = FcStrCmpIgnoreCase (left.u.s, right.u.s) == 0;
-		break;
-	    case FcOpContains:
-		ret = FcStrStrIgnoreCase (left.u.s, right.u.s) != 0;
-		break;
-	    case FcOpNotEqual:
-		if (flags & FcOpFlagIgnoreBlanks)
-		    ret = FcStrCmpIgnoreBlanksAndCase (left.u.s, right.u.s) != 0;
-		else
-		    ret = FcStrCmpIgnoreCase (left.u.s, right.u.s) != 0;
-		break;
-	    case FcOpNotContains:
-		ret = FcStrStrIgnoreCase (left.u.s, right.u.s) == 0;
-		break;
-	    default:
-		break;
-	    }
-	    break;
-	case FcTypeMatrix:
-	    switch ((int) op) {
-	    case FcOpEqual:
-	    case FcOpContains:
-	    case FcOpListing:
-		ret = FcMatrixEqual (left.u.m, right.u.m);
-		break;
-	    case FcOpNotEqual:
-	    case FcOpNotContains:
-		ret = !FcMatrixEqual (left.u.m, right.u.m);
-		break;
-	    default:
-		break;
-	    }
-	    break;
-	case FcTypeCharSet:
-	    switch ((int) op) {
-	    case FcOpContains:
-	    case FcOpListing:
-		/* left contains right if right is a subset of left */
-		ret = FcCharSetIsSubset (right.u.c, left.u.c);
-		break;
-	    case FcOpNotContains:
-		/* left contains right if right is a subset of left */
-		ret = !FcCharSetIsSubset (right.u.c, left.u.c);
-		break;
-	    case FcOpEqual:
-		ret = FcCharSetEqual (left.u.c, right.u.c);
-		break;
-	    case FcOpNotEqual:
-		ret = !FcCharSetEqual (left.u.c, right.u.c);
-		break;
-	    default:
-		break;
-	    }
-	    break;
-	case FcTypeLangSet:
-	    switch ((int) op) {
-	    case FcOpContains:
-	    case FcOpListing:
-		ret = FcLangSetContains (left.u.l, right.u.l);
-		break;
-	    case FcOpNotContains:
-		ret = !FcLangSetContains (left.u.l, right.u.l);
-		break;
-	    case FcOpEqual:
-		ret = FcLangSetEqual (left.u.l, right.u.l);
-		break;
-	    case FcOpNotEqual:
-		ret = !FcLangSetEqual (left.u.l, right.u.l);
-		break;
-	    default:
-		break;
-	    }
-	    break;
-	case FcTypeVoid:
-	    switch ((int) op) {
-	    case FcOpEqual:
-	    case FcOpContains:
-	    case FcOpListing:
-		ret = FcTrue;
-		break;
-	    default:
-		break;
-	    }
-	    break;
-	case FcTypeFTFace:
-	    switch ((int) op) {
-	    case FcOpEqual:
-	    case FcOpContains:
-	    case FcOpListing:
-		ret = left.u.f == right.u.f;
-		break;
-	    case FcOpNotEqual:
-	    case FcOpNotContains:
-		ret = left.u.f != right.u.f;
-		break;
-	    default:
-		break;
-	    }
-	    break;
-	case FcTypeRange:
-	    ret = FcRangeCompare (op, left.u.r, right.u.r);
-	    break;
-	}
-    }
-    else
-    {
-	if (op == FcOpNotEqual || op == FcOpNotContains)
-	    ret = FcTrue;
+    if (left.type != right.type)
+    {
+        FcValuePromotionBuffer buf1, buf2;
+        left = FcConfigPromote (left, right, &buf1);
+        right = FcConfigPromote (right, left, &buf2);
+        if (left.type != right.type)
+        {
+	    if (op == FcOpNotEqual || op == FcOpNotContains)
+	        ret = FcTrue;
+            return ret;
+        }
+    }
+    switch (left.type) {
+    case FcTypeUnknown:
+        break;	/* No way to guess how to compare for this object */
+    case FcTypeInteger:
+        switch ((int) op) {
+        case FcOpEqual:
+        case FcOpContains:
+        case FcOpListing:
+            ret = left.u.i == right.u.i;
+            break;
+        case FcOpNotEqual:
+        case FcOpNotContains:
+            ret = left.u.i != right.u.i;
+            break;
+        case FcOpLess:
+            ret = left.u.i < right.u.i;
+            break;
+        case FcOpLessEqual:
+            ret = left.u.i <= right.u.i;
+            break;
+        case FcOpMore:
+            ret = left.u.i > right.u.i;
+            break;
+        case FcOpMoreEqual:
+            ret = left.u.i >= right.u.i;
+            break;
+        default:
+            break;
+        }
+        break;
+    case FcTypeDouble:
+        switch ((int) op) {
+        case FcOpEqual:
+        case FcOpContains:
+        case FcOpListing:
+            ret = left.u.d == right.u.d;
+            break;
+        case FcOpNotEqual:
+        case FcOpNotContains:
+            ret = left.u.d != right.u.d;
+            break;
+        case FcOpLess:
+            ret = left.u.d < right.u.d;
+            break;
+        case FcOpLessEqual:
+            ret = left.u.d <= right.u.d;
+            break;
+        case FcOpMore:
+            ret = left.u.d > right.u.d;
+            break;
+        case FcOpMoreEqual:
+            ret = left.u.d >= right.u.d;
+            break;
+        default:
+            break;
+        }
+        break;
+    case FcTypeBool:
+        switch ((int) op) {
+        case FcOpEqual:
+            ret = left.u.b == right.u.b;
+            break;
+        case FcOpContains:
+        case FcOpListing:
+            ret = left.u.b == right.u.b || left.u.b >= FcDontCare;
+            break;
+        case FcOpNotEqual:
+            ret = left.u.b != right.u.b;
+            break;
+        case FcOpNotContains:
+            ret = !(left.u.b == right.u.b || left.u.b >= FcDontCare);
+            break;
+        case FcOpLess:
+            ret = left.u.b != right.u.b && right.u.b >= FcDontCare;
+            break;
+        case FcOpLessEqual:
+            ret = left.u.b == right.u.b || right.u.b >= FcDontCare;
+            break;
+        case FcOpMore:
+            ret = left.u.b != right.u.b && left.u.b >= FcDontCare;
+            break;
+        case FcOpMoreEqual:
+            ret = left.u.b == right.u.b || left.u.b >= FcDontCare;
+            break;
+        default:
+            break;
+        }
+        break;
+    case FcTypeString:
+        switch ((int) op) {
+        case FcOpEqual:
+        case FcOpListing:
+            if (flags & FcOpFlagIgnoreBlanks)
+                ret = FcStrCmpIgnoreBlanksAndCase (left.u.s, right.u.s) == 0;
+            else
+                ret = FcStrCmpIgnoreCase (left.u.s, right.u.s) == 0;
+            break;
+        case FcOpContains:
+            ret = FcStrStrIgnoreCase (left.u.s, right.u.s) != 0;
+            break;
+        case FcOpNotEqual:
+            if (flags & FcOpFlagIgnoreBlanks)
+                ret = FcStrCmpIgnoreBlanksAndCase (left.u.s, right.u.s) != 0;
+            else
+                ret = FcStrCmpIgnoreCase (left.u.s, right.u.s) != 0;
+            break;
+        case FcOpNotContains:
+            ret = FcStrStrIgnoreCase (left.u.s, right.u.s) == 0;
+            break;
+        default:
+            break;
+        }
+        break;
+    case FcTypeMatrix:
+        switch ((int) op) {
+        case FcOpEqual:
+        case FcOpContains:
+        case FcOpListing:
+            ret = FcMatrixEqual (left.u.m, right.u.m);
+            break;
+        case FcOpNotEqual:
+        case FcOpNotContains:
+            ret = !FcMatrixEqual (left.u.m, right.u.m);
+            break;
+        default:
+            break;
+        }
+        break;
+    case FcTypeCharSet:
+        switch ((int) op) {
+        case FcOpContains:
+        case FcOpListing:
+            /* left contains right if right is a subset of left */
+            ret = FcCharSetIsSubset (right.u.c, left.u.c);
+            break;
+        case FcOpNotContains:
+            /* left contains right if right is a subset of left */
+            ret = !FcCharSetIsSubset (right.u.c, left.u.c);
+            break;
+        case FcOpEqual:
+            ret = FcCharSetEqual (left.u.c, right.u.c);
+            break;
+        case FcOpNotEqual:
+            ret = !FcCharSetEqual (left.u.c, right.u.c);
+            break;
+        default:
+            break;
+        }
+        break;
+    case FcTypeLangSet:
+        switch ((int) op) {
+        case FcOpContains:
+        case FcOpListing:
+            ret = FcLangSetContains (left.u.l, right.u.l);
+            break;
+        case FcOpNotContains:
+            ret = !FcLangSetContains (left.u.l, right.u.l);
+            break;
+        case FcOpEqual:
+            ret = FcLangSetEqual (left.u.l, right.u.l);
+            break;
+        case FcOpNotEqual:
+            ret = !FcLangSetEqual (left.u.l, right.u.l);
+            break;
+        default:
+            break;
+        }
+        break;
+    case FcTypeVoid:
+        switch ((int) op) {
+        case FcOpEqual:
+        case FcOpContains:
+        case FcOpListing:
+            ret = FcTrue;
+            break;
+        default:
+            break;
+        }
+        break;
+    case FcTypeFTFace:
+        switch ((int) op) {
+        case FcOpEqual:
+        case FcOpContains:
+        case FcOpListing:
+            ret = left.u.f == right.u.f;
+            break;
+        case FcOpNotEqual:
+        case FcOpNotContains:
+            ret = left.u.f != right.u.f;
+            break;
+        default:
+            break;
+        }
+        break;
+    case FcTypeRange:
+        ret = FcRangeCompare (op, left.u.r, right.u.r);
+        break;
     }
     return ret;
 }
commit 922168afe8bf48e872dc0a808fadefaa798a42ce
Author: Matthias Clasen <mclasen@xxxxxxxxxx>
Date:   Fri Aug 21 08:19:13 2020 -0400

    Speed up fonthashint matching
    
    When we don't need to differentiate between weak and strong,
    we can exit the loop in FcCompareValueList once we found a
    best match.
    
    This change helps reducing the amount of list walking we do
    for fonthashint, where careless config files end up creating
    lists with ~100 booleans :( We don't want to walk all those
    to the end, over and over again.
    
    We are already special-casing family, and the only other case
    where weak != strong, PostScript names, doesn't have long lists
    of values, so the limitation to weak == strong doesn't matter
    much in practice.

diff --git a/src/fcmatch.c b/src/fcmatch.c
index 969b855..289204e 100644
--- a/src/fcmatch.c
+++ b/src/fcmatch.c
@@ -408,6 +408,7 @@ FcCompareValueList (FcObject	     object,
     FcValueListPtr  v1, v2;
     double    	    v, best, bestStrong, bestWeak;
     int		    j, k, pos = 0;
+    int weak, strong;
 
     if (!match)
     {
@@ -418,11 +419,13 @@ FcCompareValueList (FcObject	     object,
 	return FcTrue;
     }
 
+    weak    = match->weak;
+    strong  = match->strong;
+
     best = 1e99;
     bestStrong = 1e99;
     bestWeak = 1e99;
-    j = 0;
-    for (v1 = v1orig; v1; v1 = FcValueListNext(v1))
+    for (v1 = v1orig, j = 0; v1; v1 = FcValueListNext(v1), j++)
     {
 	for (v2 = v2orig, k = 0; v2; v2 = FcValueListNext(v2), k++)
 	{
@@ -441,7 +444,13 @@ FcCompareValueList (FcObject	     object,
 		best = v;
 		pos = k;
 	    }
-	    if (v1->binding == FcValueBindingStrong)
+            if (weak == strong)
+            {
+                /* found the best possible match */
+                if (best < 1000)
+                    goto done;
+            }
+            else if (v1->binding == FcValueBindingStrong)
 	    {
 		if (v < bestStrong)
 		    bestStrong = v;
@@ -452,8 +461,8 @@ FcCompareValueList (FcObject	     object,
 		    bestWeak = v;
 	    }
 	}
-	j++;
     }
+done:
     if (FcDebug () & FC_DBG_MATCHV)
     {
 	printf (" %s: %g ", FcObjectName (object), best);
@@ -464,8 +473,6 @@ FcCompareValueList (FcObject	     object,
     }
     if (value)
     {
-	int weak    = match->weak;
-	int strong  = match->strong;
 	if (weak == strong)
 	    value[strong] += best;
 	else
commit 1b0cb23adcdf0c2b136b41d805b157f0c6d75ad4
Author: Matthias Clasen <mclasen@xxxxxxxxxx>
Date:   Tue Aug 18 15:02:21 2020 -0400

    Add a shortcut for FcQualAny matching
    
    When checking whether a test matches a pattern,
    we cut the loop short for FcQualAll when we see
    the first non-matching value, but for FcQualAny
    we were always walking the full list. This patch
    cuts the loop short for FcQualAny when we see the
    first matching value.

diff --git a/src/fccfg.c b/src/fccfg.c
index 74e8746..cb4d3e0 100644
--- a/src/fccfg.c
+++ b/src/fccfg.c
@@ -1550,6 +1550,8 @@ FcConfigMatchValueList (FcPattern	*p,
 	    {
 		if (!ret)
 		    ret = v;
+                if (t->qual != FcQualAll)
+                    break;
 	    }
 	    else
 	    {
commit 8022ab4aff469a8f095ce3168d879d3e0b3605ef
Author: Matthias Clasen <mclasen@xxxxxxxxxx>
Date:   Tue Aug 18 10:54:43 2020 -0400

    Use a hash table for family matching
    
    With the way typical font configurations look, matching the lists
    of families is the bottleneck for both FcFontMatch and FcFontSort.
    After installing the Noto fonts on my system, an innocent match
    pattern like "Cantarell 14" turns into a monster with a list of
    300 family names after calling FcConfigSubstitute().
    
    With this setup, every FcFontSort call takes 80-100 ms, which is
    entirely incompatible with using FcFontSort for anything interactive.
    And many font choosers render every font in itself, causing on average
    one FcFontSort call per font.
    
    On my system, it takes more than 20 seconds to open the GTK font
    chooser dialog, with frequent stalls when scrolling.
    
    This patch special-cases font families and replaces the list
    walking for comparison with a hash table lookup. With this
    patch, the FcFontSort time goes to ~10ms per call. Which is
    still not good enough for calling it dozens of times when
    scrolling, but a significant improvement.

diff --git a/src/fcmatch.c b/src/fcmatch.c
index e370e8b..969b855 100644
--- a/src/fcmatch.c
+++ b/src/fcmatch.c
@@ -480,6 +480,109 @@ FcCompareValueList (FcObject	     object,
     return FcTrue;
 }
 
+/* The bulk of the time in FcFontMatch and FcFontSort goes to
+ * walking long lists of family names. We speed this up with a
+ * hash table.
+ */
+typedef struct
+{
+    double strong_value;
+    double weak_value;
+} FamilyEntry;
+
+typedef struct
+{
+    FcHashTable *family_hash;
+} FcCompareData;
+
+static void
+FcCompareDataClear (FcCompareData *data)
+{
+    FcHashTableDestroy (data->family_hash);
+}
+
+static void
+FcCompareDataInit (FcPattern     *pat,
+                   FcCompareData *data)
+{
+    FcHashTable *table;
+    FcPatternElt *elt;
+    FcValueListPtr l;
+    int i;
+    const void *key;
+    FamilyEntry *e;
+
+    table = FcHashTableCreate ((FcHashFunc)FcStrHashIgnoreBlanksAndCase,
+                               (FcCompareFunc)FcStrCmpIgnoreBlanksAndCase,
+                               NULL,
+                               NULL,
+                               NULL,
+                               free);
+
+    elt = FcPatternObjectFindElt (pat, FC_FAMILY_OBJECT);
+    for (l = FcPatternEltValues(elt), i = 0; l; l = FcValueListNext(l), i++)
+    {
+        key = FcValueString (&l->value);
+        if (!FcHashTableFind (table, key, (void **)&e))
+        {
+            e = malloc (sizeof (FamilyEntry));
+            e->strong_value = 1e99;
+            e->weak_value = 1e99;
+            FcHashTableAdd (table, (void *)key, e);
+        }
+        if (l->binding == FcValueBindingWeak)
+        {
+            if (i < e->weak_value)
+                e->weak_value = i;
+        }
+        else
+        {
+            if (i < e->strong_value)
+                e->strong_value = i;
+        }
+    }
+
+    data->family_hash = table;
+}
+
+static FcBool
+FcCompareFamilies (FcPattern       *pat,
+                   FcValueListPtr   v1orig,
+                   FcPattern       *fnt,
+                   FcValueListPtr   v2orig,
+                   double          *value,
+                   FcResult        *result,
+                   FcHashTable     *table)
+{
+    FcValueListPtr v2;
+    double strong_value;
+    double weak_value;
+    const void *key;
+    FamilyEntry *e;
+
+    assert (table != NULL);
+
+    strong_value = 1e99;
+    weak_value = 1e99;
+
+    for (v2 = v2orig; v2; v2 = FcValueListNext(v2))
+    {
+        key = FcValueString (&v2->value);
+        if (FcHashTableFind (table, key, (void **)&e))
+        {
+            if (e->strong_value < strong_value)
+                strong_value = e->strong_value;
+            if (e->weak_value < weak_value)
+                weak_value = e->weak_value;
+        }
+    }
+
+    value[PRI_FAMILY_STRONG] = strong_value;
+    value[PRI_FAMILY_WEAK] = weak_value;
+
+    return FcTrue;
+}
+
 /*
  * Return a value indicating the distance between the two lists of
  * values
@@ -489,7 +592,8 @@ static FcBool
 FcCompare (FcPattern	*pat,
 	   FcPattern	*fnt,
 	   double	*value,
-	   FcResult	*result)
+	   FcResult	*result,
+           FcCompareData *data)
 {
     int		    i, i1, i2;
 
@@ -508,8 +612,18 @@ FcCompare (FcPattern	*pat,
 	    i2++;
 	else if (i < 0)
 	    i1++;
-	else
-	{
+	else if (elt_i1->object == FC_FAMILY_OBJECT && data->family_hash)
+        {
+            if (!FcCompareFamilies (pat, FcPatternEltValues(elt_i1),
+                                    fnt, FcPatternEltValues(elt_i2),
+                                    value, result,
+                                    data->family_hash))
+                return FcFalse;
+	    i1++;
+	    i2++;
+        }
+        else
+        {
 	    const FcMatcher *match = FcObjectToMatcher (elt_i1->object, FcFalse);
 	    if (!FcCompareValueList (elt_i1->object, match,
 				     FcPatternEltValues(elt_i1),
@@ -734,6 +848,7 @@ FcFontSetMatchInternal (FcFontSet   **sets,
     FcPattern	    *best;
     int		    i;
     int		    set;
+    FcCompareData   data;
 
     for (i = 0; i < PRI_END; i++)
 	bestscore[i] = 0;
@@ -743,6 +858,9 @@ FcFontSetMatchInternal (FcFontSet   **sets,
 	printf ("Match ");
 	FcPatternPrint (p);
     }
+
+    FcCompareDataInit (p, &data);
+
     for (set = 0; set < nsets; set++)
     {
 	s = sets[set];
@@ -755,8 +873,11 @@ FcFontSetMatchInternal (FcFontSet   **sets,
 		printf ("Font %d ", f);
 		FcPatternPrint (s->fonts[f]);
 	    }
-	    if (!FcCompare (p, s->fonts[f], score, result))
+	    if (!FcCompare (p, s->fonts[f], score, result, &data))
+            {
+                FcCompareDataClear (&data);
 		return 0;
+            }
 	    if (FcDebug () & FC_DBG_MATCHV)
 	    {
 		printf ("Score");
@@ -780,6 +901,9 @@ FcFontSetMatchInternal (FcFontSet   **sets,
 	    }
 	}
     }
+
+    FcCompareDataClear (&data);
+
     if (FcDebug () & FC_DBG_MATCH)
     {
 	printf ("Best score");
@@ -1015,6 +1139,7 @@ FcFontSetSort (FcConfig	    *config FC_UNUSED,
     int		    nPatternLang;
     FcBool    	    *patternLangSat;
     FcValue	    patternLang;
+    FcCompareData   data;
 
     assert (sets != NULL);
     assert (p != NULL);
@@ -1059,6 +1184,8 @@ FcFontSetSort (FcConfig	    *config FC_UNUSED,
     nodeps = (FcSortNode **) (nodes + nnodes);
     patternLangSat = (FcBool *) (nodeps + nnodes);
 
+    FcCompareDataInit (p, &data);
+
     new = nodes;
     nodep = nodeps;
     for (set = 0; set < nsets; set++)
@@ -1074,7 +1201,7 @@ FcFontSetSort (FcConfig	    *config FC_UNUSED,
 		FcPatternPrint (s->fonts[f]);
 	    }
 	    new->pattern = s->fonts[f];
-	    if (!FcCompare (p, new->pattern, new->score, result))
+	    if (!FcCompare (p, new->pattern, new->score, result, &data))
 		goto bail1;
 	    if (FcDebug () & FC_DBG_MATCHV)
 	    {
@@ -1091,6 +1218,8 @@ FcFontSetSort (FcConfig	    *config FC_UNUSED,
 	}
     }
 
+    FcCompareDataClear (&data);
+
     nnodes = new - nodes;
 
     qsort (nodeps, nnodes, sizeof (FcSortNode *),
commit 055843631b995f8acc778c94032c949844e8812b
Author: Matthias Clasen <mclasen@xxxxxxxxxx>
Date:   Fri Aug 21 08:05:18 2020 -0400

    Add a hash function for families
    
    Add a hash function that behaves like family
    comparison: ignoring case and blanks. This
    will be used to replace the list walking for
    finding family matches with a hash table.

diff --git a/src/fcint.h b/src/fcint.h
index 88e0701..08a0cd6 100644
--- a/src/fcint.h
+++ b/src/fcint.h
@@ -1328,6 +1328,9 @@ FcStrLastSlash (const FcChar8  *path);
 FcPrivate FcChar32
 FcStrHashIgnoreCase (const FcChar8 *s);
 
+FcPrivate FcChar32
+FcStrHashIgnoreBlanksAndCase (const FcChar8 *s);
+
 FcPrivate FcChar8 *
 FcStrCanonFilename (const FcChar8 *s);
 
diff --git a/src/fcstr.c b/src/fcstr.c
index 39ecbbb..dc9940a 100644
--- a/src/fcstr.c
+++ b/src/fcstr.c
@@ -320,6 +320,19 @@ FcStrHashIgnoreCase (const FcChar8 *s)
     return h;
 }
 
+FcChar32
+FcStrHashIgnoreBlanksAndCase (const FcChar8 *s)
+{
+    FcChar32	    h = 0;
+    FcCaseWalker    w;
+    FcChar8	    c;
+
+    FcStrCaseWalkerInit (s, &w);
+    while ((c = FcStrCaseWalkerNextNonBlank (&w)))
+	h = ((h << 3) ^ (h >> 3)) ^ c;
+    return h;
+}
+
 /*
  * Is the head of s1 equal to s2?
  */
commit 46d818df26f3585f9261c735129a606837406875
Author: Matthias Clasen <mclasen@xxxxxxxxxx>
Date:   Fri Aug 21 00:47:09 2020 -0400

    Special-case some of the string walking code
    
    Make variants of FcStrCaseWalkerNext for the two
    common cases, delim == NULL and delim == " ", to
    speed things up.
    
    These are inner loops, and having the conditions
    as simple as possible helps.

diff --git a/src/fcstr.c b/src/fcstr.c
index 864d4aa..39ecbbb 100644
--- a/src/fcstr.c
+++ b/src/fcstr.c
@@ -160,7 +160,7 @@ FcStrCaseWalkerLong (FcCaseWalker *w, FcChar8 r)
 }
 
 static FcChar8
-FcStrCaseWalkerNext (FcCaseWalker *w, const char *delims)
+FcStrCaseWalkerNextNonDelim (FcCaseWalker *w, const char *delims)
 {
     FcChar8	r;
 
@@ -182,6 +182,50 @@ FcStrCaseWalkerNext (FcCaseWalker *w, const char *delims)
     return r;
 }
 
+static FcChar8
+FcStrCaseWalkerNextNonBlank (FcCaseWalker *w)
+{
+    FcChar8	r;
+
+    if (w->read)
+    {
+	if ((r = *w->read++))
+	    return r;
+	w->read = 0;
+    }
+    do
+    {
+	r = *w->src++;
+    } while (r == ' ');
+
+    if ((r & 0xc0) == 0xc0)
+	return FcStrCaseWalkerLong (w, r);
+    if ('A' <= r && r <= 'Z')
+        r = r - 'A' + 'a';
+    return r;
+}
+
+static FcChar8
+FcStrCaseWalkerNext (FcCaseWalker *w)
+{
+    FcChar8	r;
+
+    if (w->read)
+    {
+	if ((r = *w->read++))
+	    return r;
+	w->read = 0;
+    }
+
+    r = *w->src++;
+
+    if ((r & 0xc0) == 0xc0)
+	return FcStrCaseWalkerLong (w, r);
+    if ('A' <= r && r <= 'Z')
+        r = r - 'A' + 'a';
+    return r;
+}
+
 FcChar8 *
 FcStrDowncase (const FcChar8 *s)
 {
@@ -190,13 +234,13 @@ FcStrDowncase (const FcChar8 *s)
     FcChar8	    *dst, *d;
 
     FcStrCaseWalkerInit (s, &w);
-    while (FcStrCaseWalkerNext (&w, NULL))
+    while (FcStrCaseWalkerNext (&w))
 	len++;
     d = dst = malloc (len + 1);
     if (!d)
 	return 0;
     FcStrCaseWalkerInit (s, &w);
-    while ((*d++ = FcStrCaseWalkerNext (&w, NULL)));
+    while ((*d++ = FcStrCaseWalkerNext (&w)));
     return dst;
 }
 
@@ -213,8 +257,8 @@ FcStrCmpIgnoreCase (const FcChar8 *s1, const FcChar8 *s2)
 
     for (;;)
     {
-	c1 = FcStrCaseWalkerNext (&w1, NULL);
-	c2 = FcStrCaseWalkerNext (&w2, NULL);
+	c1 = FcStrCaseWalkerNext (&w1);
+	c2 = FcStrCaseWalkerNext (&w2);
 	if (!c1 || (c1 != c2))
 	    break;
     }
@@ -223,12 +267,6 @@ FcStrCmpIgnoreCase (const FcChar8 *s1, const FcChar8 *s2)
 
 int
 FcStrCmpIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2)
-{
-    return FcStrCmpIgnoreCaseAndDelims (s1, s2, (const FcChar8 *)" ");
-}
-
-int
-FcStrCmpIgnoreCaseAndDelims (const FcChar8 *s1, const FcChar8 *s2, const FcChar8 *delims)
 {
     FcCaseWalker    w1, w2;
     FcChar8	    c1, c2;
@@ -240,8 +278,8 @@ FcStrCmpIgnoreCaseAndDelims (const FcChar8 *s1, const FcChar8 *s2, const FcChar8
 
     for (;;)
     {
-	c1 = FcStrCaseWalkerNext (&w1, (const char *)delims);
-	c2 = FcStrCaseWalkerNext (&w2, (const char *)delims);
+	c1 = FcStrCaseWalkerNextNonBlank (&w1);
+	c2 = FcStrCaseWalkerNextNonBlank (&w2);
 	if (!c1 || (c1 != c2))
 	    break;
     }
@@ -277,7 +315,7 @@ FcStrHashIgnoreCase (const FcChar8 *s)
     FcChar8	    c;
 
     FcStrCaseWalkerInit (s, &w);
-    while ((c = FcStrCaseWalkerNext (&w, NULL)))
+    while ((c = FcStrCaseWalkerNext (&w)))
 	h = ((h << 3) ^ (h >> 3)) ^ c;
     return h;
 }
@@ -297,8 +335,8 @@ FcStrIsAtIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2)
 
     for (;;)
     {
-	c1 = FcStrCaseWalkerNext (&w1, " ");
-	c2 = FcStrCaseWalkerNext (&w2, " ");
+	c1 = FcStrCaseWalkerNextNonBlank (&w1);
+	c2 = FcStrCaseWalkerNextNonBlank (&w2);
 	if (!c1 || (c1 != c2))
 	    break;
     }
@@ -356,8 +394,8 @@ FcStrIsAtIgnoreCase (const FcChar8 *s1, const FcChar8 *s2)
 
     for (;;)
     {
-	c1 = FcStrCaseWalkerNext (&w1, NULL);
-	c2 = FcStrCaseWalkerNext (&w2, NULL);
+	c1 = FcStrCaseWalkerNext (&w1);
+	c2 = FcStrCaseWalkerNext (&w2);
 	if (!c1 || (c1 != c2))
 	    break;
     }
@@ -425,8 +463,8 @@ FcStrMatchIgnoreCaseAndDelims (const FcChar8 *s1, const FcChar8 *s2, const FcCha
 
     for (;;)
     {
-	c1 = FcStrCaseWalkerNext (&w1, (const char *)delims);
-	c2 = FcStrCaseWalkerNext (&w2, (const char *)delims);
+	c1 = FcStrCaseWalkerNextNonDelim (&w1, (const char *)delims);
+	c2 = FcStrCaseWalkerNextNonDelim (&w2, (const char *)delims);
 	if (!c1 || (c1 != c2))
 	    break;
     }
@@ -493,12 +531,12 @@ FcStrStrIgnoreCase (const FcChar8 *s1, const FcChar8 *s2)
     FcStrCaseWalkerInit (s1, &w1);
     FcStrCaseWalkerInit (s2, &w2);
 
-    c2 = FcStrCaseWalkerNext (&w2, NULL);
+    c2 = FcStrCaseWalkerNext (&w2);
 
     for (;;)
     {
 	cur = w1.src;
-	c1 = FcStrCaseWalkerNext (&w1, NULL);
+	c1 = FcStrCaseWalkerNext (&w1);
 	if (!c1)
 	    break;
 	if (c1 == c2)
@@ -509,8 +547,8 @@ FcStrStrIgnoreCase (const FcChar8 *s1, const FcChar8 *s2)
 
 	    for (;;)
 	    {
-		c1t = FcStrCaseWalkerNext (&w1t, NULL);
-		c2t = FcStrCaseWalkerNext (&w2t, NULL);
+		c1t = FcStrCaseWalkerNext (&w1t);
+		c2t = FcStrCaseWalkerNext (&w2t);
 
 		if (!c2t)
 		    return cur;
_______________________________________________
Fontconfig mailing list
Fontconfig@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/fontconfig




[Index of Archives]     [Fedora Fonts]     [Fedora Users]     [Fedora Cloud]     [Kernel]     [Fedora Packaging]     [Fedora Desktop]     [PAM]     [Gimp Graphics Editor]     [Yosemite News]

  Powered by Linux