X-Git-Url: https://git.wh0rd.org/?a=blobdiff_plain;f=src%2Ffccfg.c;h=635fdead213badc1f22d13665dc8e3f4d51f9865;hb=97c3d5b692c7a45dc1d923fe04b6f2e011583d2d;hp=561294974092b03a9a8d5a2ddf3c279d8e68efb4;hpb=28f93bc4122337f59afad31e610ce17c3d2b00a2;p=fontconfig.git

diff --git a/src/fccfg.c b/src/fccfg.c
index 5612949..635fdea 100644
--- a/src/fccfg.c
+++ b/src/fccfg.c
@@ -1,7 +1,7 @@
 /*
  * $RCSId: xc/lib/fontconfig/src/fccfg.c,v 1.23 2002/08/31 22:17:32 keithp Exp $
  *
- * Copyright © 2000 Keith Packard
+ * Copyright © 2000 Keith Packard
  *
  * Permission to use, copy, modify, distribute, and sell this software and its
  * documentation for any purpose is hereby granted without fee, provided that
@@ -23,6 +23,8 @@
  */
 
 #include "fcint.h"
+#include <dirent.h>
+#include <sys/types.h>
 
 #if defined (_WIN32) && (defined (PIC) || defined (DLL_EXPORT))
 #define STRICT
@@ -67,40 +69,23 @@ FcConfigCreate (void)
     if (!config->rejectGlobs)
 	goto bail5;
 
-    config->cache = 0;
-    if (FcConfigHome())
-	if (!FcConfigSetCache (config, (FcChar8 *) ("~/" FC_USER_CACHE_FILE)))
-	    goto bail6;
-
-#ifdef _WIN32
-    if (config->cache == 0)
-    {
-	/* If no home, use the temp folder. */
-	FcChar8	    dummy[1];
-	int	    templen = GetTempPath (1, dummy);
-	FcChar8     *temp = malloc (templen + 1);
-
-	if (temp)
-	{
-	    FcChar8 *cache_dir;
-
-	    GetTempPath (templen + 1, temp);
-	    cache_dir = FcStrPlus (temp, FC_USER_CACHE_FILE);
-	    free (temp);
-	    if (!FcConfigSetCache (config, cache_dir))
-	    {
-		FcStrFree (cache_dir);
-		goto bail6;
-	    }
-	    FcStrFree (cache_dir);
-	}
-    }
-#endif
+    config->acceptPatterns = FcFontSetCreate ();
+    if (!config->acceptPatterns)
+	goto bail6;
+    
+    config->rejectPatterns = FcFontSetCreate ();
+    if (!config->rejectPatterns)
+	goto bail7;
 
+    config->cacheDirs = FcStrSetCreate ();
+    if (!config->cacheDirs)
+	goto bail8;
+    
     config->blanks = 0;
 
     config->substPattern = 0;
     config->substFont = 0;
+    config->substScan = 0;
     config->maxObjects = 0;
     for (set = FcSetSystem; set <= FcSetApplication; set++)
 	config->fonts[set] = 0;
@@ -110,6 +95,10 @@ FcConfigCreate (void)
     
     return config;
 
+bail8:
+    FcFontSetDestroy (config->rejectPatterns);
+bail7:
+    FcFontSetDestroy (config->acceptPatterns);
 bail6:
     FcStrSetDestroy (config->rejectGlobs);
 bail5:
@@ -127,11 +116,6 @@ bail0:
     return 0;
 }
 
-typedef struct _FcFileTime {
-    time_t  time;
-    FcBool  set;
-} FcFileTime;
-
 static FcFileTime
 FcConfigNewestFile (FcStrSet *files)
 {
@@ -154,6 +138,19 @@ FcConfigNewestFile (FcStrSet *files)
     return newest;
 }
 
+FcFileTime
+FcConfigModifiedTime (FcConfig *config)
+{
+    if (!config)
+    {
+	FcFileTime v = { 0, FcFalse };
+	config = FcConfigGetCurrent ();
+	if (!config)
+	    return v;
+    }
+    return FcConfigNewestFile (config->configFiles);
+}
+
 FcBool
 FcConfigUptoDate (FcConfig *config)
 {
@@ -204,18 +201,19 @@ FcConfigDestroy (FcConfig *config)
 
     FcStrSetDestroy (config->configDirs);
     FcStrSetDestroy (config->fontDirs);
+    FcStrSetDestroy (config->cacheDirs);
     FcStrSetDestroy (config->configFiles);
     FcStrSetDestroy (config->acceptGlobs);
     FcStrSetDestroy (config->rejectGlobs);
+    FcFontSetDestroy (config->acceptPatterns);
+    FcFontSetDestroy (config->rejectPatterns);
 
     if (config->blanks)
 	FcBlanksDestroy (config->blanks);
 
-    if (config->cache)
-	FcStrFree (config->cache);
-
     FcSubstDestroy (config->substPattern);
     FcSubstDestroy (config->substFont);
+    FcSubstDestroy (config->substScan);
     for (set = FcSetSystem; set <= FcSetApplication; set++)
 	if (config->fonts[set])
 	    FcFontSetDestroy (config->fonts[set]);
@@ -225,58 +223,121 @@ FcConfigDestroy (FcConfig *config)
 }
 
 /*
- * Scan the current list of directories in the configuration
- * and build the set of available fonts. Update the
- * per-user cache file to reflect the new configuration
+ * Add cache to configuration, adding fonts and directories
  */
 
 FcBool
-FcConfigBuildFonts (FcConfig *config)
+FcConfigAddCache (FcConfig *config, FcCache *cache, 
+		  FcSetName set, FcStrSet *dirSet)
 {
-    FcFontSet	    *fonts;
-    FcGlobalCache   *cache;
-    FcStrList	    *list;
-    FcChar8	    *dir;
+    FcFontSet	*fs;
+    intptr_t	*dirs;
+    int		i;
+
+    /*
+     * Add fonts
+     */
+    fs = FcCacheSet (cache);
+    if (fs)
+    {
+	int	nref = 0;
+	
+	for (i = 0; i < fs->nfont; i++)
+	{
+	    FcPattern	*font = FcFontSetFont (fs, i);
+	    FcChar8	*font_file;
 
-    fonts = FcFontSetCreate ();
-    if (!fonts)
-	goto bail0;
+	    /*
+	     * Check to see if font is banned by filename
+	     */
+	    if (FcPatternObjectGetString (font, FC_FILE_OBJECT,
+					  0, &font_file) == FcResultMatch &&
+		!FcConfigAcceptFilename (config, font_file))
+	    {
+		continue;
+	    }
+		
+	    /*
+	     * Check to see if font is banned by pattern
+	     */
+	    if (!FcConfigAcceptFont (config, font))
+		continue;
+		
+	    nref++;
+	    FcFontSetAdd (config->fonts[set], font);
+	}
+	FcDirCacheReference (cache, nref);
+    }
+
+    /*
+     * Add directories
+     */
+    dirs = FcCacheDirs (cache);
+    if (dirs)
+    {
+	for (i = 0; i < cache->dirs_count; i++)
+	{
+	    FcChar8	*dir = FcOffsetToPtr (dirs, dirs[i], FcChar8);
+	    if (FcConfigAcceptFilename (config, dir))
+		FcStrSetAddFilename (dirSet, dir);
+	}
+    }
+    return FcTrue;
+}
+
+static FcBool
+FcConfigAddDirList (FcConfig *config, FcSetName set, FcStrSet *dirSet)
+{
+    FcStrList	    *dirlist;
+    FcChar8	    *dir;
+    FcCache	    *cache;
     
-    cache = FcGlobalCacheCreate ();
-    if (!cache)
-	goto bail1;
+    dirlist = FcStrListCreate (dirSet);
+    if (!dirlist)
+        return FcFalse;
+	
+    while ((dir = FcStrListNext (dirlist)))
+    {
+	if (FcDebug () & FC_DBG_FONTSET)
+	    printf ("adding fonts from%s\n", dir);
+	cache = FcDirCacheRead (dir, FcFalse, config);
+	if (!cache)
+	    continue;
+	FcConfigAddCache (config, cache, set, dirSet);
+	FcDirCacheUnload (cache);
+    }
+    FcStrListDone (dirlist);
+    return FcTrue;
+}
 
-    if (config->cache)
-	FcGlobalCacheLoad (cache, config->cache);
+/*
+ * Scan the current list of directories in the configuration
+ * and build the set of available fonts.
+ */
 
-    list = FcConfigGetFontDirs (config);
-    if (!list)
-	goto bail1;
+FcBool
+FcConfigBuildFonts (FcConfig *config)
+{
+    FcFontSet	    *fonts;
 
-    while ((dir = FcStrListNext (list)))
+    if (!config)
     {
-	if (FcDebug () & FC_DBG_FONTSET)
-	    printf ("scan dir %s\n", dir);
-	FcDirScanConfig (fonts, config->fontDirs, cache, 
-			 config->blanks, dir, FcFalse, config);
+	config = FcConfigGetCurrent ();
+	if (!config)
+	    return FcFalse;
     }
+	
+    fonts = FcFontSetCreate ();
+    if (!fonts)
+	return FcFalse;
     
-    FcStrListDone (list);
+    FcConfigSetFonts (config, fonts, FcSetSystem);
     
+    if (!FcConfigAddDirList (config, FcSetSystem, config->fontDirs))
+	return FcFalse;
     if (FcDebug () & FC_DBG_FONTSET)
 	FcFontSetPrint (fonts);
-
-    if (config->cache)
-	FcGlobalCacheSave (cache, config->cache);
-    FcGlobalCacheDestroy (cache);
-
-    FcConfigSetFonts (config, fonts, FcSetSystem);
-    
     return FcTrue;
-bail1:
-    FcFontSetDestroy (fonts);
-bail0:
-    return FcFalse;
 }
 
 FcBool
@@ -347,6 +408,25 @@ FcConfigGetFontDirs (FcConfig	*config)
     return FcStrListCreate (config->fontDirs);
 }
 
+FcBool
+FcConfigAddCacheDir (FcConfig	    *config,
+		     const FcChar8  *d)
+{
+    return FcStrSetAddFilename (config->cacheDirs, d);
+}
+
+FcStrList *
+FcConfigGetCacheDirs (FcConfig	*config)
+{
+    if (!config)
+    {
+	config = FcConfigGetCurrent ();
+	if (!config)
+	    return 0;
+    }
+    return FcStrListCreate (config->cacheDirs);
+}
+    
 FcBool
 FcConfigAddConfigFile (FcConfig	    *config,
 		       const FcChar8   *f)
@@ -374,30 +454,10 @@ FcConfigGetConfigFiles (FcConfig    *config)
     return FcStrListCreate (config->configFiles);
 }
 
-FcBool
-FcConfigSetCache (FcConfig	*config,
-		  const FcChar8	*c)
-{
-    FcChar8    *new = FcStrCopyFilename (c);
-    
-    if (!new)
-	return FcFalse;
-    if (config->cache)
-	FcStrFree (config->cache);
-    config->cache = new;
-    return FcTrue;
-}
-
 FcChar8 *
 FcConfigGetCache (FcConfig  *config)
 {
-    if (!config)
-    {
-	config = FcConfigGetCurrent ();
-	if (!config)
-	    return 0;
-    }
-    return config->cache;
+    return NULL;
 }
 
 FcFontSet *
@@ -423,8 +483,6 @@ FcConfigSetFonts (FcConfig	*config,
     config->fonts[set] = fonts;
 }
 
-
-
 FcBlanks *
 FcConfigGetBlanks (FcConfig	*config)
 {
@@ -441,17 +499,21 @@ FcBool
 FcConfigAddBlank (FcConfig	*config,
 		  FcChar32    	blank)
 {
-    FcBlanks	*b;
+    FcBlanks	*b, *freeme = 0;
     
     b = config->blanks;
     if (!b)
     {
-	b = FcBlanksCreate ();
+	freeme = b = FcBlanksCreate ();
 	if (!b)
 	    return FcFalse;
     }
     if (!FcBlanksAdd (b, blank))
+    {
+        if (freeme)
+            FcBlanksDestroy (freeme);
 	return FcFalse;
+    }
     config->blanks = b;
     return FcTrue;
 }
@@ -491,14 +553,23 @@ FcConfigAddEdit (FcConfig	*config,
     FcTest	*t;
     int		num;
 
+    switch (kind) {
+    case FcMatchPattern:
+	prev = &config->substPattern;
+	break;
+    case FcMatchFont:
+	prev = &config->substFont;
+	break;
+    case FcMatchScan:
+	prev = &config->substScan;
+	break;
+    default:
+	return FcFalse;
+    }
     subst = (FcSubst *) malloc (sizeof (FcSubst));
     if (!subst)
 	return FcFalse;
     FcMemAlloc (FC_MEM_SUBST, sizeof (FcSubst));
-    if (kind == FcMatchPattern)
-	prev = &config->substPattern;
-    else
-	prev = &config->substFont;
     for (; *prev; prev = &(*prev)->next);
     *prev = subst;
     subst->next = 0;
@@ -548,12 +619,12 @@ FcConfigPromote (FcValue v, FcValue u)
 }
 
 FcBool
-FcConfigCompareValue (const FcValue	left_o,
+FcConfigCompareValue (const FcValue	*left_o,
 		      FcOp		op,
-		      const FcValue	right_o)
+		      const FcValue	*right_o)
 {
-    FcValue	left = left_o;
-    FcValue	right = right_o;
+    FcValue	left = FcValueCanonicalize(left_o);
+    FcValue	right = FcValueCanonicalize(right_o);
     FcBool	ret = FcFalse;
     
     left = FcConfigPromote (left, right);
@@ -615,9 +686,11 @@ FcConfigCompareValue (const FcValue	left_o,
 		ret = FcStrStrIgnoreCase (left.u.s, right.u.s) != 0;
 		break;
 	    case FcOpNotEqual:
-	    case FcOpNotContains:
 		ret = FcStrCmpIgnoreCase (left.u.s, right.u.s) != 0;
 		break;
+	    case FcOpNotContains:
+		ret = FcStrCmpIgnoreCase (left.u.s, right.u.s) == 0;
+		break;
 	    default:
 		break;
 	    }
@@ -665,7 +738,7 @@ FcConfigCompareValue (const FcValue	left_o,
 		ret = FcLangSetContains (left.u.l, right.u.l);
 		break;
 	    case FcOpNotContains:
-		ret = FcLangSetContains (left.u.l, right.u.l);
+		ret = !FcLangSetContains (left.u.l, right.u.l);
 		break;
 	    case FcOpEqual:
 		ret = FcLangSetEqual (left.u.l, right.u.l);
@@ -727,6 +800,7 @@ FcConfigEvaluate (FcPattern *p, FcExpr *e)
     FcValue	v, vl, vr;
     FcResult	r;
     FcMatrix	*m;
+    FcChar8     *str;
     
     switch (e->op) {
     case FcOpInteger:
@@ -739,8 +813,7 @@ FcConfigEvaluate (FcPattern *p, FcExpr *e)
 	break;
     case FcOpString:
 	v.type = FcTypeString;
-	v.u.s = e->u.sval;
-	v = FcValueSave (v);
+	v.u.s = FcStrStaticName(e->u.sval);
 	break;
     case FcOpMatrix:
 	v.type = FcTypeMatrix;
@@ -757,9 +830,10 @@ FcConfigEvaluate (FcPattern *p, FcExpr *e)
 	v.u.b = e->u.bval;
 	break;
     case FcOpField:
-	r = FcPatternGet (p, e->u.field, 0, &v);
+	r = FcPatternObjectGet (p, e->u.object, 0, &v);
 	if (r != FcResultMatch)
 	    v.type = FcTypeVoid;
+	v = FcValueSave (v);
 	break;
     case FcOpConst:
 	if (FcNameConstant (e->u.constant, &v.u.i))
@@ -792,7 +866,7 @@ FcConfigEvaluate (FcPattern *p, FcExpr *e)
 	vl = FcConfigEvaluate (p, e->u.tree.left);
 	vr = FcConfigEvaluate (p, e->u.tree.right);
 	v.type = FcTypeBool;
-	v.u.b = FcConfigCompareValue (vl, e->op, vr);
+	v.u.b = FcConfigCompareValue (&vl, e->op, &vr);
 	FcValueDestroy (vl);
 	FcValueDestroy (vr);
 	break;	
@@ -857,7 +931,10 @@ FcConfigEvaluate (FcPattern *p, FcExpr *e)
 		switch (e->op) {
 		case FcOpPlus:
 		    v.type = FcTypeString;
-		    v.u.s = FcStrPlus (vl.u.s, vr.u.s);
+		    str = FcStrPlus (vl.u.s, vr.u.s);
+		    v.u.s = FcStrStaticName (str);
+		    FcStrFree (str);
+			 
 		    if (!v.u.s)
 			v.type = FcTypeVoid;
 		    break;
@@ -1005,10 +1082,10 @@ FcConfigMatchValueList (FcPattern	*p,
 	    e = 0;
 	}
 
-	for (v = values; v; v = v->next)
+	for (v = values; v; v = FcValueListNext(v))
 	{
 	    /* Compare the pattern value to the match expression value */
-	    if (FcConfigCompareValue (v->value, t->op, value))
+	    if (FcConfigCompareValue (&v->value, t->op, &value))
 	    {
 		if (!ret)
 		    ret = v;
@@ -1041,39 +1118,40 @@ FcConfigValues (FcPattern *p, FcExpr *e, FcValueBinding binding)
     if (e->op == FcOpComma)
     {
 	l->value = FcConfigEvaluate (p, e->u.tree.left);
-	l->next  = FcConfigValues (p, e->u.tree.right, binding);
+	l->next = FcConfigValues (p, e->u.tree.right, binding);
     }
     else
     {
 	l->value = FcConfigEvaluate (p, e);
-	l->next  = 0;
+	l->next = NULL;
     }
     l->binding = binding;
-    while (l && l->value.type == FcTypeVoid)
+    if (l->value.type == FcTypeVoid)
     {
-	FcValueList	*next = l->next;
-	
+	FcValueList  *next = FcValueListNext(l);
+
 	FcMemFree (FC_MEM_VALLIST, sizeof (FcValueList));
 	free (l);
 	l = next;
     }
+
     return l;
 }
 
 static FcBool
-FcConfigAdd (FcValueList    **head,
+FcConfigAdd (FcValueListPtr *head,
 	     FcValueList    *position,
 	     FcBool	    append,
 	     FcValueList    *new)
 {
-    FcValueList	    **prev, *last, *v;
+    FcValueListPtr  *prev, last, v;
     FcValueBinding  sameBinding;
     
     if (position)
 	sameBinding = position->binding;
     else
 	sameBinding = FcValueBindingWeak;
-    for (v = new; v; v = v->next)
+    for (v = new; v != NULL; v = FcValueListNext(v))
 	if (v->binding == FcValueBindingSame)
 	    v->binding = sameBinding;
     if (append)
@@ -1081,14 +1159,16 @@ FcConfigAdd (FcValueList    **head,
 	if (position)
 	    prev = &position->next;
 	else
-	    for (prev = head; *prev; prev = &(*prev)->next)
+	    for (prev = head; *prev != NULL; 
+		 prev = &(*prev)->next)
 		;
     }
     else
     {
 	if (position)
 	{
-	    for (prev = head; *prev; prev = &(*prev)->next)
+	    for (prev = head; *prev != NULL; 
+		 prev = &(*prev)->next)
 	    {
 		if (*prev == position)
 		    break;
@@ -1099,7 +1179,7 @@ FcConfigAdd (FcValueList    **head,
 
 	if (FcDebug () & FC_DBG_EDIT)
 	{
-	    if (!*prev)
+	    if (*prev == NULL)
 		printf ("position not on list\n");
 	}
     }
@@ -1114,7 +1194,7 @@ FcConfigAdd (FcValueList    **head,
     if (new)
     {
 	last = new;
-	while (last->next)
+	while (last->next != NULL)
 	    last = last->next;
     
 	last->next = *prev;
@@ -1132,17 +1212,17 @@ FcConfigAdd (FcValueList    **head,
 }
 
 static void
-FcConfigDel (FcValueList    **head,
+FcConfigDel (FcValueListPtr *head,
 	     FcValueList    *position)
 {
-    FcValueList    **prev;
+    FcValueListPtr *prev;
 
-    for (prev = head; *prev; prev = &(*prev)->next)
+    for (prev = head; *prev != NULL; prev = &(*prev)->next)
     {
 	if (*prev == position)
 	{
 	    *prev = position->next;
-	    position->next = 0;
+	    position->next = NULL;
 	    FcValueListDestroy (position);
 	    break;
 	}
@@ -1151,13 +1231,13 @@ FcConfigDel (FcValueList    **head,
 
 static void
 FcConfigPatternAdd (FcPattern	*p,
-		    const char	*object,
+		    FcObject	object,
 		    FcValueList	*list,
 		    FcBool	append)
 {
     if (list)
     {
-	FcPatternElt    *e = FcPatternInsertElt (p, object);
+	FcPatternElt    *e = FcPatternObjectInsertElt (p, object);
     
 	if (!e)
 	    return;
@@ -1170,24 +1250,24 @@ FcConfigPatternAdd (FcPattern	*p,
  */
 static void
 FcConfigPatternDel (FcPattern	*p,
-		    const char	*object)
+		    FcObject	object)
 {
-    FcPatternElt    *e = FcPatternFindElt (p, object);
+    FcPatternElt    *e = FcPatternObjectFindElt (p, object);
     if (!e)
 	return;
-    while (e->values)
+    while (e->values != NULL)
 	FcConfigDel (&e->values, e->values);
 }
 
 static void
 FcConfigPatternCanon (FcPattern	    *p,
-		      const char    *object)
+		      FcObject	    object)
 {
-    FcPatternElt    *e = FcPatternFindElt (p, object);
+    FcPatternElt    *e = FcPatternObjectFindElt (p, object);
     if (!e)
 	return;
-    if (!e->values)
-	FcPatternDel (p, object);
+    if (e->values == NULL)
+	FcPatternObjectDel (p, object);
 }
 
 FcBool
@@ -1211,6 +1291,20 @@ FcConfigSubstituteWithPat (FcConfig    *config,
 	    return FcFalse;
     }
 
+    switch (kind) {
+    case FcMatchPattern:
+	s = config->substPattern;
+	break;
+    case FcMatchFont:
+	s = config->substFont;
+	break;
+    case FcMatchScan:
+	s = config->substScan;
+	break;
+    default:
+	return FcFalse;
+    }
+
     st = (FcSubState *) malloc (config->maxObjects * sizeof (FcSubState));
     if (!st && config->maxObjects)
 	return FcFalse;
@@ -1221,10 +1315,6 @@ FcConfigSubstituteWithPat (FcConfig    *config,
 	printf ("FcConfigSubstitute ");
 	FcPatternPrint (p);
     }
-    if (kind == FcMatchPattern)
-	s = config->substPattern;
-    else
-	s = config->substFont;
     for (; s; s = s->next)
     {
 	/*
@@ -1244,7 +1334,7 @@ FcConfigSubstituteWithPat (FcConfig    *config,
 	    else
 		m = p;
 	    if (m)
-		st[i].elt = FcPatternFindElt (m, t->field);
+		st[i].elt = FcPatternObjectFindElt (m, t->object);
 	    else
 		st[i].elt = 0;
 	    /*
@@ -1298,8 +1388,7 @@ FcConfigSubstituteWithPat (FcConfig    *config,
 	    for (t = s->test, i = 0; t; t = t->next, i++)
 	    {
 		if ((t->kind == FcMatchFont || kind == FcMatchPattern) &&
-		    !FcStrCmpIgnoreCase ((FcChar8 *) t->field, 
-					 (FcChar8 *) e->field))
+		    t->object == e->object)
 		{
 		    /* 
 		     * KLUDGE - the pattern may have been reallocated or
@@ -1308,7 +1397,7 @@ FcConfigSubstituteWithPat (FcConfig    *config,
 		     * the element again
 		     */
 		    if (e != s->edit && st[i].elt)
-			st[i].elt = FcPatternFindElt (p, t->field);
+			st[i].elt = FcPatternObjectFindElt (p, t->object);
 		    if (!st[i].elt)
 			t = 0;
 		    break;
@@ -1323,7 +1412,7 @@ FcConfigSubstituteWithPat (FcConfig    *config,
 		if (t)
 		{
 		    FcValueList	*thisValue = st[i].value;
-		    FcValueList	*nextValue = thisValue ? thisValue->next : 0;
+		    FcValueList	*nextValue = thisValue;
 		    
 		    /*
 		     * Append the new list of values after the current value
@@ -1332,7 +1421,8 @@ FcConfigSubstituteWithPat (FcConfig    *config,
 		    /*
 		     * Delete the marked value
 		     */
-		    FcConfigDel (&st[i].elt->values, thisValue);
+                    if (thisValue)
+			FcConfigDel (&st[i].elt->values, thisValue);
 		    /*
 		     * Adjust any pointers into the value list to ensure
 		     * future edits occur at the same place
@@ -1350,8 +1440,8 @@ FcConfigSubstituteWithPat (FcConfig    *config,
 		 * Delete all of the values and insert
 		 * the new set
 		 */
-		FcConfigPatternDel (p, e->field);
-		FcConfigPatternAdd (p, e->field, l, FcTrue);
+		FcConfigPatternDel (p, e->object);
+		FcConfigPatternAdd (p, e->object, l, FcTrue);
 		/*
 		 * Adjust any pointers into the value list as they no
 		 * longer point to anything valid
@@ -1374,7 +1464,7 @@ FcConfigSubstituteWithPat (FcConfig    *config,
 		}
 		/* fall through ... */
 	    case FcOpPrependFirst:
-		FcConfigPatternAdd (p, e->field, l, FcFalse);
+		FcConfigPatternAdd (p, e->object, l, FcFalse);
 		break;
 	    case FcOpAppend:
 		if (t)
@@ -1384,9 +1474,10 @@ FcConfigSubstituteWithPat (FcConfig    *config,
 		}
 		/* fall through ... */
 	    case FcOpAppendLast:
-		FcConfigPatternAdd (p, e->field, l, FcTrue);
+		FcConfigPatternAdd (p, e->object, l, FcTrue);
 		break;
 	    default:
+                FcValueListDestroy (l);
 		break;
 	    }
 	}
@@ -1395,7 +1486,7 @@ FcConfigSubstituteWithPat (FcConfig    *config,
 	 * any properties without data
 	 */
 	for (e = s->edit; e; e = e->next)
-	    FcConfigPatternCanon (p, e->field);
+	    FcConfigPatternCanon (p, e->object);
 
 	if (FcDebug () & FC_DBG_EDIT)
 	{
@@ -1489,7 +1580,9 @@ FcConfigFileExists (const FcChar8 *dir, const FcChar8 *file)
 #ifdef _WIN32
     if ((!path[0] || (path[strlen((char *) path)-1] != '/' &&
 		      path[strlen((char *) path)-1] != '\\')) &&
-	 (file[0] != '/' && file[0] != '\\'))
+	!(file[0] == '/' ||
+	  file[0] == '\\' ||
+	  (isalpha (file[0]) && file[1] == ':' && (file[2] == '/' || file[2] == '\\'))))
 	strcat ((char *) path, "\\");
 #else
     if ((!path[0] || path[strlen((char *) path)-1] != '/') && file[0] != '/')
@@ -1589,7 +1682,7 @@ FcConfigHome (void)
 	    home = getenv ("USERPROFILE");
 #endif
 
-	return home;
+	return (FcChar8 *) home;
     }
     return 0;
 }
@@ -1689,7 +1782,7 @@ FcConfigAppFontAddFile (FcConfig    *config,
 	FcConfigSetFonts (config, set, FcSetApplication);
     }
 	
-    if (!FcFileScanConfig (set, subdirs, 0, config->blanks, file, FcFalse, config))
+    if (!FcFileScanConfig (set, subdirs, config->blanks, file, config))
     {
 	FcStrSetDestroy (subdirs);
 	return FcFalse;
@@ -1702,6 +1795,7 @@ FcConfigAppFontAddFile (FcConfig    *config,
 	}
 	FcStrListDone (sublist);
     }
+    FcStrSetDestroy (subdirs);
     return FcTrue;
 }
 
@@ -1710,9 +1804,7 @@ FcConfigAppFontAddDir (FcConfig	    *config,
 		       const FcChar8   *dir)
 {
     FcFontSet	*set;
-    FcStrSet	*subdirs;
-    FcStrList	*sublist;
-    FcChar8	*subdir;
+    FcStrSet	*dirs;
     
     if (!config)
     {
@@ -1720,8 +1812,9 @@ FcConfigAppFontAddDir (FcConfig	    *config,
 	if (!config)
 	    return FcFalse;
     }
-    subdirs = FcStrSetCreate ();
-    if (!subdirs)
+
+    dirs = FcStrSetCreate ();
+    if (!dirs)
 	return FcFalse;
     
     set = FcConfigGetFonts (config, FcSetApplication);
@@ -1730,25 +1823,20 @@ FcConfigAppFontAddDir (FcConfig	    *config,
 	set = FcFontSetCreate ();
 	if (!set)
 	{
-	    FcStrSetDestroy (subdirs);
+	    FcStrSetDestroy (dirs);
 	    return FcFalse;
 	}
 	FcConfigSetFonts (config, set, FcSetApplication);
     }
     
-    if (!FcDirScanConfig (set, subdirs, 0, config->blanks, dir, FcFalse, config))
+    FcStrSetAddFilename (dirs, dir);
+    
+    if (!FcConfigAddDirList (config, FcSetApplication, dirs))
     {
-	FcStrSetDestroy (subdirs);
+	FcStrSetDestroy (dirs);
 	return FcFalse;
     }
-    if ((sublist = FcStrListCreate (subdirs)))
-    {
-	while ((subdir = FcStrListNext (sublist)))
-	{
-	    FcConfigAppFontAddDir (config, subdir);
-	}
-	FcStrListDone (sublist);
-    }
+    FcStrSetDestroy (dirs);
     return FcTrue;
 }
 
@@ -1837,3 +1925,43 @@ FcConfigAcceptFilename (FcConfig	*config,
 	return FcFalse;
     return FcTrue;
 }
+
+/*
+ * Manage font-pattern based font source selectors
+ */
+
+FcBool
+FcConfigPatternsAdd (FcConfig	*config,
+		     FcPattern	*pattern,
+		     FcBool	accept)
+{
+    FcFontSet	*set = accept ? config->acceptPatterns : config->rejectPatterns;
+
+    return FcFontSetAdd (set, pattern);
+}
+
+static FcBool
+FcConfigPatternsMatch (const FcFontSet	*patterns,
+		       const FcPattern	*font)
+{
+    int i;
+    
+    for (i = 0; i < patterns->nfont; i++)
+	if (FcListPatternMatchAny (patterns->fonts[i], font))
+	    return FcTrue;
+    return FcFalse;
+}
+
+FcBool
+FcConfigAcceptFont (FcConfig	    *config,
+		    const FcPattern *font)
+{
+    if (FcConfigPatternsMatch (config->acceptPatterns, font))
+	return FcTrue;
+    if (FcConfigPatternsMatch (config->rejectPatterns, font))
+	return FcFalse;
+    return FcTrue;
+}
+#define __fccfg__
+#include "fcaliastail.h"
+#undef __fccfg__