X-Git-Url: https://git.wh0rd.org/?a=blobdiff_plain;f=src%2Ffccfg.c;h=95c50162d0959cf93917996182e8d3cf0c1225ee;hb=efe5eae26b2443363b1000b3197d1731a40f8af9;hp=baa1cbcc364c2c7924c9a4be37c45481adcc0b3c;hpb=d0f07b8d582499fdc6fa0ca6c5e2ef3727baddae;p=fontconfig.git

diff --git a/src/fccfg.c b/src/fccfg.c
index baa1cbc..95c5016 100644
--- a/src/fccfg.c
+++ b/src/fccfg.c
@@ -1,7 +1,7 @@
 /*
- * $XFree86: xc/lib/fontconfig/src/fccfg.c,v 1.7 2002/05/29 08:21:33 keithp Exp $
+ * fontconfig/src/fccfg.c
  *
- * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc.
+ * 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
@@ -13,9 +13,9 @@
  * representations about the suitability of this software for any purpose.  It
  * is provided "as is" without express or implied warranty.
  *
- * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
@@ -23,6 +23,18 @@
  */
 
 #include "fcint.h"
+#include <dirent.h>
+#include <sys/types.h>
+
+#if defined (_WIN32) && (defined (PIC) || defined (DLL_EXPORT))
+#define STRICT
+#include <windows.h>
+#undef STRICT
+#endif
+
+#if defined (_WIN32) && !defined (R_OK)
+#define R_OK 4
+#endif
 
 FcConfig    *_fcConfig;
 
@@ -49,23 +61,50 @@ FcConfigCreate (void)
     if (!config->fontDirs)
 	goto bail3;
     
-    config->cache = 0;
-    if (!FcConfigSetCache (config, (FcChar8 *) ("~/" FC_USER_CACHE_FILE)))
+    config->acceptGlobs = FcStrSetCreate ();
+    if (!config->acceptGlobs)
 	goto bail4;
 
+    config->rejectGlobs = FcStrSetCreate ();
+    if (!config->rejectGlobs)
+	goto bail5;
+
+    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;
 
     config->rescanTime = time(0);
     config->rescanInterval = 30;    
+
+    config->ref = 1;
     
     return config;
 
+bail8:
+    FcFontSetDestroy (config->rejectPatterns);
+bail7:
+    FcFontSetDestroy (config->acceptPatterns);
+bail6:
+    FcStrSetDestroy (config->rejectGlobs);
+bail5:
+    FcStrSetDestroy (config->acceptGlobs);
 bail4:
     FcStrSetDestroy (config->fontDirs);
 bail3:
@@ -79,27 +118,23 @@ bail0:
     return 0;
 }
 
-static time_t
+static FcFileTime
 FcConfigNewestFile (FcStrSet *files)
 {
     FcStrList	    *list = FcStrListCreate (files);
-    FcBool	    set = FcFalse;
-    time_t	    newest = 0;
+    FcFileTime	    newest = { 0, FcFalse };
     FcChar8	    *file;
     struct  stat    statb;
 
     if (list)
     {
 	while ((file = FcStrListNext (list)))
-	{
-	    if (stat ((char *) file, &statb) == 0)
-	    {
-		if (!set)
-		    newest = statb.st_mtime;
-		else if (statb.st_mtime - newest > 0)
-		    newest = statb.st_mtime;
-	    }
-	}
+	    if (FcStat ((char *) file, &statb) == 0)
+		if (!newest.set || statb.st_mtime - newest.time > 0)
+		{
+		    newest.set = FcTrue;
+		    newest.time = statb.st_mtime;
+		}
 	FcStrListDone (list);
     }
     return newest;
@@ -108,9 +143,8 @@ FcConfigNewestFile (FcStrSet *files)
 FcBool
 FcConfigUptoDate (FcConfig *config)
 {
-    time_t  config_time;
-    time_t  font_time;
-    time_t  now = time(0);
+    FcFileTime	config_time, config_dir_time, font_time;
+    time_t	now = time(0);
     if (!config)
     {
 	config = FcConfigGetCurrent ();
@@ -118,11 +152,24 @@ FcConfigUptoDate (FcConfig *config)
 	    return FcFalse;
     }
     config_time = FcConfigNewestFile (config->configFiles);
-    font_time = FcConfigNewestFile (config->configDirs);
-    if (config_time - config->rescanTime > 0 ||
-	font_time - config->rescanTime > 0)
+    config_dir_time = FcConfigNewestFile (config->configDirs);
+    font_time = FcConfigNewestFile (config->fontDirs);
+    if ((config_time.set && config_time.time - config->rescanTime > 0) ||
+	(config_dir_time.set && (config_dir_time.time - config->rescanTime) > 0) ||
+	(font_time.set && (font_time.time - config->rescanTime) > 0))
     {
-	return FcFalse;
+	/* We need to check for potential clock problems here (OLPC ticket #6046) */
+	if ((config_time.set && (config_time.time - now) > 0) ||
+    	(config_dir_time.set && (config_dir_time.time - now) > 0) ||
+        (font_time.set && (font_time.time - now) > 0))
+	{
+	    fprintf (stderr,
+                    "Fontconfig warning: Directory/file mtime in the future. New fonts may not be detected\n");
+	    config->rescanTime = now;
+	    return FcTrue;
+	}
+	else
+	    return FcFalse;
     }
     config->rescanTime = now;
     return FcTrue;
@@ -136,90 +183,189 @@ FcSubstDestroy (FcSubst *s)
     while (s)
     {
 	n = s->next;
-	FcTestDestroy (s->test);
-	FcEditDestroy (s->edit);
+	if (s->test)
+	    FcTestDestroy (s->test);
+	if (s->edit)
+	    FcEditDestroy (s->edit);
+	free (s);
+	FcMemFree (FC_MEM_SUBST, sizeof (FcSubst));
 	s = n;
     }
 }
 
+FcConfig *
+FcConfigReference (FcConfig *config)
+{
+    if (!config)
+    {
+	config = FcConfigGetCurrent ();
+	if (!config)
+	    return 0;
+    }
+
+    config->ref++;
+
+    return config;
+}
+
 void
 FcConfigDestroy (FcConfig *config)
 {
     FcSetName	set;
 
+    if (--config->ref > 0)
+	return;
+
     if (config == _fcConfig)
 	_fcConfig = 0;
 
     FcStrSetDestroy (config->configDirs);
     FcStrSetDestroy (config->fontDirs);
+    FcStrSetDestroy (config->cacheDirs);
     FcStrSetDestroy (config->configFiles);
+    FcStrSetDestroy (config->acceptGlobs);
+    FcStrSetDestroy (config->rejectGlobs);
+    FcFontSetDestroy (config->acceptPatterns);
+    FcFontSetDestroy (config->rejectPatterns);
 
-    FcStrFree (config->cache);
+    if (config->blanks)
+	FcBlanksDestroy (config->blanks);
 
     FcSubstDestroy (config->substPattern);
     FcSubstDestroy (config->substFont);
+    FcSubstDestroy (config->substScan);
     for (set = FcSetSystem; set <= FcSetApplication; set++)
 	if (config->fonts[set])
 	    FcFontSetDestroy (config->fonts[set]);
+
     free (config);
     FcMemFree (FC_MEM_CONFIG, sizeof (FcConfig));
 }
 
 /*
- * 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;
-    FcFileCache *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 = FcFileCacheCreate ();
-    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;
+}
 
-    FcFileCacheLoad (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);
-	FcDirScan (fonts, config->fontDirs, cache, config->blanks, dir, FcFalse);
+	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);
-
-    FcFileCacheSave (cache, config->cache);
-    FcFileCacheDestroy (cache);
-
-    FcConfigSetFonts (config, fonts, FcSetSystem);
-    
     return FcTrue;
-bail1:
-    FcFontSetDestroy (fonts);
-bail0:
-    return FcFalse;
 }
 
 FcBool
 FcConfigSetCurrent (FcConfig *config)
 {
+    if (config == _fcConfig)
+	return FcTrue;
+
     if (!config->fonts)
 	if (!FcConfigBuildFonts (config))
 	    return FcFalse;
@@ -285,6 +431,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)
@@ -312,30 +477,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 *
@@ -361,8 +506,6 @@ FcConfigSetFonts (FcConfig	*config,
     config->fonts[set] = fonts;
 }
 
-
-
 FcBlanks *
 FcConfigGetBlanks (FcConfig	*config)
 {
@@ -379,23 +522,27 @@ 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;
 }
 
 int
-FcConfigGetRescanInverval (FcConfig *config)
+FcConfigGetRescanInterval (FcConfig *config)
 {
     if (!config)
     {
@@ -407,7 +554,7 @@ FcConfigGetRescanInverval (FcConfig *config)
 }
 
 FcBool
-FcConfigSetRescanInverval (FcConfig *config, int rescanInterval)
+FcConfigSetRescanInterval (FcConfig *config, int rescanInterval)
 {
     if (!config)
     {
@@ -419,6 +566,22 @@ FcConfigSetRescanInverval (FcConfig *config, int rescanInterval)
     return FcTrue;
 }
 
+/*
+ * A couple of typos escaped into the library
+ */
+int
+FcConfigGetRescanInverval (FcConfig *config)
+{
+    return FcConfigGetRescanInterval (config);
+}
+
+FcBool
+FcConfigSetRescanInverval (FcConfig *config, int rescanInterval)
+{
+    return FcConfigSetRescanInterval (config, rescanInterval);
+}
+
+    
 FcBool
 FcConfigAddEdit (FcConfig	*config,
 		 FcTest		*test,
@@ -429,28 +592,42 @@ 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;
-    if (kind == FcMatchPattern)
-	prev = &config->substPattern;
-    else
-	prev = &config->substFont;
+    FcMemAlloc (FC_MEM_SUBST, sizeof (FcSubst));
     for (; *prev; prev = &(*prev)->next);
     *prev = subst;
     subst->next = 0;
     subst->test = test;
     subst->edit = edit;
-    if (FcDebug () & FC_DBG_EDIT)
-    {
-	printf ("Add Subst ");
-	FcSubstPrint (subst);
-    }
     num = 0;
     for (t = test; t; t = t->next)
+    {
+	if (t->kind == FcMatchDefault)
+	    t->kind = kind;
 	num++;
+    }
     if (config->maxObjects < num)
 	config->maxObjects = num;
+    if (FcDebug () & FC_DBG_EDIT)
+    {
+	printf ("Add Subst ");
+	FcSubstPrint (subst);
+    }
     return FcTrue;
 }
 
@@ -459,8 +636,6 @@ typedef struct _FcSubState {
     FcValueList    *value;
 } FcSubState;
 
-static const FcMatrix    FcIdentityMatrix = { 1, 0, 0, 1 };
-
 static FcValue
 FcConfigPromote (FcValue v, FcValue u)
 {
@@ -471,48 +646,55 @@ FcConfigPromote (FcValue v, FcValue u)
     }
     else if (v.type == FcTypeVoid && u.type == FcTypeMatrix)
     {
-	v.u.m = FcMatrixCopy (&FcIdentityMatrix);
-	if (v.u.m)
-	    v.type = FcTypeMatrix;
+	v.u.m = &FcIdentityMatrix;
+	v.type = FcTypeMatrix;
+    }
+    else if (v.type == FcTypeString && u.type == FcTypeLangSet)
+    {
+	v.u.l = FcLangSetPromote (v.u.s);
+	v.type = FcTypeLangSet;
     }
     return v;
 }
 
 FcBool
-FcConfigCompareValue (FcValue	m,
-		      FcOp	op,
-		      FcValue	v)
+FcConfigCompareValue (const FcValue	*left_o,
+		      FcOp		op,
+		      const FcValue	*right_o)
 {
-    FcBool    ret = FcFalse;
+    FcValue	left = FcValueCanonicalize(left_o);
+    FcValue	right = FcValueCanonicalize(right_o);
+    FcBool	ret = FcFalse;
     
-    m = FcConfigPromote (m, v);
-    v = FcConfigPromote (v, m);
-    if (m.type == v.type) 
+    left = FcConfigPromote (left, right);
+    right = FcConfigPromote (right, left);
+    if (left.type == right.type) 
     {
-	ret = FcFalse;
-	switch (m.type) {
+	switch (left.type) {
 	case FcTypeInteger:
 	    break;	/* FcConfigPromote prevents this from happening */
 	case FcTypeDouble:
 	    switch (op) {
 	    case FcOpEqual:
 	    case FcOpContains:
-		ret = m.u.d == v.u.d;
+	    case FcOpListing:
+		ret = left.u.d == right.u.d;
 		break;
-	    case FcOpNotEqual:    
-		ret = m.u.d != v.u.d;
+	    case FcOpNotEqual:
+	    case FcOpNotContains:
+		ret = left.u.d != right.u.d;
 		break;
 	    case FcOpLess:    
-		ret = m.u.d < v.u.d;
+		ret = left.u.d < right.u.d;
 		break;
 	    case FcOpLessEqual:    
-		ret = m.u.d <= v.u.d;
+		ret = left.u.d <= right.u.d;
 		break;
 	    case FcOpMore:    
-		ret = m.u.d > v.u.d;
+		ret = left.u.d > right.u.d;
 		break;
 	    case FcOpMoreEqual:    
-		ret = m.u.d >= v.u.d;
+		ret = left.u.d >= right.u.d;
 		break;
 	    default:
 		break;
@@ -522,10 +704,12 @@ FcConfigCompareValue (FcValue	m,
 	    switch (op) {
 	    case FcOpEqual:    
 	    case FcOpContains:
-		ret = m.u.b == v.u.b;
+	    case FcOpListing:
+		ret = left.u.b == right.u.b;
 		break;
-	    case FcOpNotEqual:    
-		ret = m.u.b != v.u.b;
+	    case FcOpNotEqual:
+	    case FcOpNotContains:
+		ret = left.u.b != right.u.b;
 		break;
 	    default:
 		break;
@@ -534,11 +718,17 @@ FcConfigCompareValue (FcValue	m,
 	case FcTypeString:
 	    switch (op) {
 	    case FcOpEqual:    
+	    case FcOpListing:
+		ret = FcStrCmpIgnoreCase (left.u.s, right.u.s) == 0;
+		break;
 	    case FcOpContains:
-		ret = FcStrCmpIgnoreCase (m.u.s, v.u.s) == 0;
+		ret = FcStrStrIgnoreCase (left.u.s, right.u.s) != 0;
+		break;
+	    case FcOpNotEqual:
+		ret = FcStrCmpIgnoreCase (left.u.s, right.u.s) != 0;
 		break;
-	    case FcOpNotEqual:    
-		ret = FcStrCmpIgnoreCase (m.u.s, v.u.s) != 0;
+	    case FcOpNotContains:
+		ret = FcStrStrIgnoreCase (left.u.s, right.u.s) == 0;
 		break;
 	    default:
 		break;
@@ -548,10 +738,12 @@ FcConfigCompareValue (FcValue	m,
 	    switch (op) {
 	    case FcOpEqual:
 	    case FcOpContains:
-		ret = FcMatrixEqual (m.u.m, v.u.m);
+	    case FcOpListing:
+		ret = FcMatrixEqual (left.u.m, right.u.m);
 		break;
 	    case FcOpNotEqual:
-		ret = !FcMatrixEqual (m.u.m, v.u.m);
+	    case FcOpNotContains:
+		ret = !FcMatrixEqual (left.u.m, right.u.m);
 		break;
 	    default:
 		break;
@@ -560,14 +752,38 @@ FcConfigCompareValue (FcValue	m,
 	case FcTypeCharSet:
 	    switch (op) {
 	    case FcOpContains:
-		/* m contains v if v is a subset of m */
-		ret = FcCharSetIsSubset (v.u.c, m.u.c);
+	    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 (m.u.c, v.u.c);
+		ret = FcCharSetEqual (left.u.c, right.u.c);
 		break;
 	    case FcOpNotEqual:
-		ret = !FcCharSetEqual (m.u.c, v.u.c);
+		ret = !FcCharSetEqual (left.u.c, right.u.c);
+		break;
+	    default:
+		break;
+	    }
+	    break;
+	case FcTypeLangSet:
+	    switch (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;
@@ -577,6 +793,7 @@ FcConfigCompareValue (FcValue	m,
 	    switch (op) {
 	    case FcOpEqual:
 	    case FcOpContains:
+	    case FcOpListing:
 		ret = FcTrue;
 		break;
 	    default:
@@ -586,31 +803,43 @@ FcConfigCompareValue (FcValue	m,
 	case FcTypeFTFace:
 	    switch (op) {
 	    case FcOpEqual:
-		ret = m.u.f == v.u.f;
+	    case FcOpContains:
+	    case FcOpListing:
+		ret = left.u.f == right.u.f;
 		break;
 	    case FcOpNotEqual:
-		ret = m.u.f != v.u.f;
+	    case FcOpNotContains:
+		ret = left.u.f != right.u.f;
 		break;
 	    default:
 		break;
 	    }
+	    break;
 	}
     }
     else
     {
-	if (op == FcOpNotEqual)
+	if (op == FcOpNotEqual || op == FcOpNotContains)
 	    ret = FcTrue;
     }
     return ret;
 }
 
 
+#define _FcDoubleFloor(d)	((int) (d))
+#define _FcDoubleCeil(d)	((double) (int) (d) == (d) ? (int) (d) : (int) ((d) + 1))
+#define FcDoubleFloor(d)	((d) >= 0 ? _FcDoubleFloor(d) : -_FcDoubleCeil(-(d)))
+#define FcDoubleCeil(d)		((d) >= 0 ? _FcDoubleCeil(d) : -_FcDoubleFloor(-(d)))
+#define FcDoubleRound(d)	FcDoubleFloor ((d) + 0.5)
+#define FcDoubleTrunc(d)	((d) >= 0 ? _FcDoubleFloor (d) : -_FcDoubleFloor (-(d)))
+
 static FcValue
 FcConfigEvaluate (FcPattern *p, FcExpr *e)
 {
     FcValue	v, vl, vr;
     FcResult	r;
     FcMatrix	*m;
+    FcChar8     *str;
     
     switch (e->op) {
     case FcOpInteger:
@@ -641,9 +870,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))
@@ -664,15 +894,24 @@ FcConfigEvaluate (FcPattern *p, FcExpr *e)
 	    v.type = FcTypeVoid;
 	FcValueDestroy (vl);
 	break;
-    case FcOpOr:
-    case FcOpAnd:
     case FcOpEqual:
-    case FcOpContains:
     case FcOpNotEqual:
     case FcOpLess:
     case FcOpLessEqual:
     case FcOpMore:
     case FcOpMoreEqual:
+    case FcOpContains:
+    case FcOpNotContains:
+    case FcOpListing:
+	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);
+	FcValueDestroy (vl);
+	FcValueDestroy (vr);
+	break;	
+    case FcOpOr:
+    case FcOpAnd:
     case FcOpPlus:
     case FcOpMinus:
     case FcOpTimes:
@@ -702,31 +941,6 @@ FcConfigEvaluate (FcPattern *p, FcExpr *e)
 		    v.type = FcTypeDouble;
 		    v.u.d = vl.u.d / vr.u.d; 
 		    break;
-		case FcOpEqual:
-		case FcOpContains:
-		    v.type = FcTypeBool; 
-		    v.u.b = vl.u.d == vr.u.d;
-		    break;
-		case FcOpNotEqual:    
-		    v.type = FcTypeBool; 
-		    v.u.b = vl.u.d != vr.u.d;
-		    break;
-		case FcOpLess:    
-		    v.type = FcTypeBool; 
-		    v.u.b = vl.u.d < vr.u.d;
-		    break;
-		case FcOpLessEqual:    
-		    v.type = FcTypeBool; 
-		    v.u.b = vl.u.d <= vr.u.d;
-		    break;
-		case FcOpMore:    
-		    v.type = FcTypeBool; 
-		    v.u.b = vl.u.d > vr.u.d;
-		    break;
-		case FcOpMoreEqual:    
-		    v.type = FcTypeBool; 
-		    v.u.b = vl.u.d >= vr.u.d;
-		    break;
 		default:
 		    v.type = FcTypeVoid; 
 		    break;
@@ -748,15 +962,6 @@ FcConfigEvaluate (FcPattern *p, FcExpr *e)
 		    v.type = FcTypeBool;
 		    v.u.b = vl.u.b && vr.u.b;
 		    break;
-		case FcOpEqual:
-		case FcOpContains:
-		    v.type = FcTypeBool;
-		    v.u.b = vl.u.b == vr.u.b;
-		    break;
-		case FcOpNotEqual:
-		    v.type = FcTypeBool;
-		    v.u.b = vl.u.b != vr.u.b;
-		    break;
 		default:
 		    v.type = FcTypeVoid; 
 		    break;
@@ -764,18 +969,12 @@ FcConfigEvaluate (FcPattern *p, FcExpr *e)
 		break;
 	    case FcTypeString:
 		switch (e->op) {
-		case FcOpEqual:
-		case FcOpContains:
-		    v.type = FcTypeBool;
-		    v.u.b = FcStrCmpIgnoreCase (vl.u.s, vr.u.s) == 0;
-		    break;
-		case FcOpNotEqual:
-		    v.type = FcTypeBool;
-		    v.u.b = FcStrCmpIgnoreCase (vl.u.s, vr.u.s) != 0;
-		    break;
 		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;
@@ -783,17 +982,9 @@ FcConfigEvaluate (FcPattern *p, FcExpr *e)
 		    v.type = FcTypeVoid;
 		    break;
 		}
+		break;
 	    case FcTypeMatrix:
 		switch (e->op) {
-		case FcOpEqual:
-		case FcOpContains:
-		    v.type = FcTypeBool;
-		    v.u.b = FcMatrixEqual (vl.u.m, vr.u.m);
-		    break;
-		case FcOpNotEqual:
-		    v.type = FcTypeBool;
-		    v.u.b = FcMatrixEqual (vl.u.m, vr.u.m);
-		    break;
 		case FcOpTimes:
 		    v.type = FcTypeMatrix;
 		    m = malloc (sizeof (FcMatrix));
@@ -813,26 +1004,6 @@ FcConfigEvaluate (FcPattern *p, FcExpr *e)
 		    break;
 		}
 		break;
-	    case FcTypeCharSet:
-		switch (e->op) {
-		case FcOpContains:
-		    /* vl contains vr if vr is a subset of vl */
-		    v.type = FcTypeBool;
-		    v.u.b = FcCharSetIsSubset (vr.u.c, vl.u.c);
-		    break;
-		case FcOpEqual:
-		    v.type = FcTypeBool;
-		    v.u.b = FcCharSetEqual (vl.u.c, vr.u.c);
-		    break;
-		case FcOpNotEqual:
-		    v.type = FcTypeBool;
-		    v.u.b = !FcCharSetEqual (vl.u.c, vr.u.c);
-		    break;
-		default:
-		    v.type = FcTypeVoid;
-		    break;
-		}
-		break;
 	    default:
 		v.type = FcTypeVoid;
 		break;
@@ -856,6 +1027,70 @@ FcConfigEvaluate (FcPattern *p, FcExpr *e)
 	}
 	FcValueDestroy (vl);
 	break;
+    case FcOpFloor:
+	vl = FcConfigEvaluate (p, e->u.tree.left);
+	switch (vl.type) {
+	case FcTypeInteger:
+	    v = vl;
+	    break;
+	case FcTypeDouble:
+	    v.type = FcTypeInteger;
+	    v.u.i = FcDoubleFloor (vl.u.d);
+	    break;
+	default:
+	    v.type = FcTypeVoid;
+	    break;
+	}
+	FcValueDestroy (vl);
+	break;
+    case FcOpCeil:
+	vl = FcConfigEvaluate (p, e->u.tree.left);
+	switch (vl.type) {
+	case FcTypeInteger:
+	    v = vl;
+	    break;
+	case FcTypeDouble:
+	    v.type = FcTypeInteger;
+	    v.u.i = FcDoubleCeil (vl.u.d);
+	    break;
+	default:
+	    v.type = FcTypeVoid;
+	    break;
+	}
+	FcValueDestroy (vl);
+	break;
+    case FcOpRound:
+	vl = FcConfigEvaluate (p, e->u.tree.left);
+	switch (vl.type) {
+	case FcTypeInteger:
+	    v = vl;
+	    break;
+	case FcTypeDouble:
+	    v.type = FcTypeInteger;
+	    v.u.i = FcDoubleRound (vl.u.d);
+	    break;
+	default:
+	    v.type = FcTypeVoid;
+	    break;
+	}
+	FcValueDestroy (vl);
+	break;
+    case FcOpTrunc:
+	vl = FcConfigEvaluate (p, e->u.tree.left);
+	switch (vl.type) {
+	case FcTypeInteger:
+	    v = vl;
+	    break;
+	case FcTypeDouble:
+	    v.type = FcTypeInteger;
+	    v.u.i = FcDoubleTrunc (vl.u.d);
+	    break;
+	default:
+	    v.type = FcTypeVoid;
+	    break;
+	}
+	FcValueDestroy (vl);
+	break;
     default:
 	v.type = FcTypeVoid;
 	break;
@@ -866,14 +1101,16 @@ FcConfigEvaluate (FcPattern *p, FcExpr *e)
 static FcValueList *
 FcConfigMatchValueList (FcPattern	*p,
 			FcTest		*t,
-			FcValueList	*v)
+			FcValueList	*values)
 {
     FcValueList	    *ret = 0;
     FcExpr	    *e = t->expr;
     FcValue	    value;
+    FcValueList	    *v;
     
     while (e)
     {
+	/* Compute the value of the match expression */
 	if (e->op == FcOpComma)
 	{
 	    value = FcConfigEvaluate (p, e->u.tree.left);
@@ -885,9 +1122,10 @@ FcConfigMatchValueList (FcPattern	*p,
 	    e = 0;
 	}
 
-	for (; v; v = v->next)
+	for (v = values; v; v = FcValueListNext(v))
 	{
-	    if (FcConfigCompareValue (v->value, t->op, value))
+	    /* Compare the pattern value to the match expression value */
+	    if (FcConfigCompareValue (&v->value, t->op, &value))
 	    {
 		if (!ret)
 		    ret = v;
@@ -907,7 +1145,7 @@ FcConfigMatchValueList (FcPattern	*p,
 }
 
 static FcValueList *
-FcConfigValues (FcPattern *p, FcExpr *e)
+FcConfigValues (FcPattern *p, FcExpr *e, FcValueBinding binding)
 {
     FcValueList	*l;
     
@@ -920,45 +1158,57 @@ FcConfigValues (FcPattern *p, FcExpr *e)
     if (e->op == FcOpComma)
     {
 	l->value = FcConfigEvaluate (p, e->u.tree.left);
-	l->next  = FcConfigValues (p, e->u.tree.right);
+	l->next = FcConfigValues (p, e->u.tree.right, binding);
     }
     else
     {
 	l->value = FcConfigEvaluate (p, e);
-	l->next  = 0;
+	l->next = NULL;
     }
-    while (l && l->value.type == FcTypeVoid)
+    l->binding = binding;
+    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;
+    FcValueListPtr  *prev, last, v;
+    FcValueBinding  sameBinding;
     
+    if (position)
+	sameBinding = position->binding;
+    else
+	sameBinding = FcValueBindingWeak;
+    for (v = new; v != NULL; v = FcValueListNext(v))
+	if (v->binding == FcValueBindingSame)
+	    v->binding = sameBinding;
     if (append)
     {
 	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;
@@ -969,7 +1219,7 @@ FcConfigAdd (FcValueList    **head,
 
 	if (FcDebug () & FC_DBG_EDIT)
 	{
-	    if (!*prev)
+	    if (*prev == NULL)
 		printf ("position not on list\n");
 	}
     }
@@ -984,7 +1234,7 @@ FcConfigAdd (FcValueList    **head,
     if (new)
     {
 	last = new;
-	while (last->next)
+	while (last->next != NULL)
 	    last = last->next;
     
 	last->next = *prev;
@@ -1002,17 +1252,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;
 	}
@@ -1021,13 +1271,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;
@@ -1040,30 +1290,31 @@ 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
-FcConfigSubstitute (FcConfig	*config,
-		    FcPattern	*p,
-		    FcMatchKind	kind)
+FcConfigSubstituteWithPat (FcConfig    *config,
+			   FcPattern   *p,
+			   FcPattern   *p_pat,
+			   FcMatchKind kind)
 {
     FcSubst	    *s;
     FcSubState	    *st;
@@ -1071,6 +1322,7 @@ FcConfigSubstitute (FcConfig	*config,
     FcTest	    *t;
     FcEdit	    *e;
     FcValueList	    *l;
+    FcPattern	    *m;
 
     if (!config)
     {
@@ -1079,6 +1331,20 @@ FcConfigSubstitute (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;
@@ -1089,10 +1355,6 @@ FcConfigSubstitute (FcConfig	*config,
 	printf ("FcConfigSubstitute ");
 	FcPatternPrint (p);
     }
-    if (kind == FcMatchPattern)
-	s = config->substPattern;
-    else
-	s = config->substFont;
     for (; s; s = s->next)
     {
 	/*
@@ -1106,7 +1368,15 @@ FcConfigSubstitute (FcConfig	*config,
 		printf ("FcConfigSubstitute test ");
 		FcTestPrint (t);
 	    }
-	    st[i].elt = FcPatternFindElt (p, t->field);
+	    st[i].elt = 0;
+	    if (kind == FcMatchFont && t->kind == FcMatchPattern)
+		m = p_pat;
+	    else
+		m = p;
+	    if (m)
+		st[i].elt = FcPatternObjectFindElt (m, t->object);
+	    else
+		st[i].elt = 0;
 	    /*
 	     * If there's no such field in the font,
 	     * then FcQualAll matches while FcQualAny does not
@@ -1125,9 +1395,13 @@ FcConfigSubstitute (FcConfig	*config,
 	     * Check to see if there is a match, mark the location
 	     * to apply match-relative edits
 	     */
-	    st[i].value = FcConfigMatchValueList (p, t, st[i].elt->values);
+	    st[i].value = FcConfigMatchValueList (m, t, st[i].elt->values);
 	    if (!st[i].value)
 		break;
+	    if (t->qual == FcQualFirst && st[i].value != st[i].elt->values)
+		break;
+	    if (t->qual == FcQualNotFirst && st[i].value == st[i].elt->values)
+		break;
 	}
 	if (t)
 	{
@@ -1145,13 +1419,30 @@ FcConfigSubstitute (FcConfig	*config,
 	    /*
 	     * Evaluate the list of expressions
 	     */
-	    l = FcConfigValues (p, e->expr);
+	    l = FcConfigValues (p, e->expr, e->binding);
 	    /*
-	     * Locate any test associated with this field
+	     * Locate any test associated with this field, skipping
+	     * tests associated with the pattern when substituting in
+	     * the font
 	     */
 	    for (t = s->test, i = 0; t; t = t->next, i++)
-		if (!FcStrCmpIgnoreCase ((FcChar8 *) t->field, (FcChar8 *) e->field))
+	    {
+		if ((t->kind == FcMatchFont || kind == FcMatchPattern) &&
+		    t->object == e->object)
+		{
+		    /* 
+		     * KLUDGE - the pattern may have been reallocated or
+		     * things may have been inserted or deleted above
+		     * this element by other edits.  Go back and find
+		     * the element again
+		     */
+		    if (e != s->edit && st[i].elt)
+			st[i].elt = FcPatternObjectFindElt (p, t->object);
+		    if (!st[i].elt)
+			t = 0;
 		    break;
+		}
+	    }
 	    switch (e->op) {
 	    case FcOpAssign:
 		/*
@@ -1161,7 +1452,7 @@ FcConfigSubstitute (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
@@ -1170,7 +1461,8 @@ FcConfigSubstitute (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
@@ -1188,8 +1480,8 @@ FcConfigSubstitute (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
@@ -1212,7 +1504,7 @@ FcConfigSubstitute (FcConfig	*config,
 		}
 		/* fall through ... */
 	    case FcOpPrependFirst:
-		FcConfigPatternAdd (p, e->field, l, FcFalse);
+		FcConfigPatternAdd (p, e->object, l, FcFalse);
 		break;
 	    case FcOpAppend:
 		if (t)
@@ -1222,9 +1514,10 @@ FcConfigSubstitute (FcConfig	*config,
 		}
 		/* fall through ... */
 	    case FcOpAppendLast:
-		FcConfigPatternAdd (p, e->field, l, FcTrue);
+		FcConfigPatternAdd (p, e->object, l, FcTrue);
 		break;
 	    default:
+                FcValueListDestroy (l);
 		break;
 	    }
 	}
@@ -1233,7 +1526,7 @@ FcConfigSubstitute (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)
 	{
@@ -1251,9 +1544,67 @@ FcConfigSubstitute (FcConfig	*config,
     return FcTrue;
 }
 
-#ifndef FONTCONFIG_PATH
-#define FONTCONFIG_PATH	"/etc/fonts"
-#endif
+FcBool
+FcConfigSubstitute (FcConfig	*config,
+		    FcPattern	*p,
+		    FcMatchKind	kind)
+{
+    return FcConfigSubstituteWithPat (config, p, 0, kind);
+}
+
+#if defined (_WIN32)
+
+#  define WIN32_LEAN_AND_MEAN
+#  define WIN32_EXTRA_LEAN
+#  include <windows.h>
+
+static FcChar8 fontconfig_path[1000] = "";
+
+#  if (defined (PIC) || defined (DLL_EXPORT))
+
+BOOL WINAPI
+DllMain (HINSTANCE hinstDLL,
+	 DWORD     fdwReason,
+	 LPVOID    lpvReserved)
+{
+  FcChar8 *p;
+
+  switch (fdwReason) {
+  case DLL_PROCESS_ATTACH:
+      if (!GetModuleFileName ((HMODULE) hinstDLL, fontconfig_path,
+			      sizeof (fontconfig_path)))
+	  break;
+
+      /* If the fontconfig DLL is in a "bin" or "lib" subfolder,
+       * assume it's a Unix-style installation tree, and use
+       * "etc/fonts" in there as FONTCONFIG_PATH. Otherwise use the
+       * folder where the DLL is as FONTCONFIG_PATH.
+       */
+      p = strrchr (fontconfig_path, '\\');
+      if (p)
+      {
+	  *p = '\0';
+	  p = strrchr (fontconfig_path, '\\');
+	  if (p && (FcStrCmpIgnoreCase (p + 1, "bin") == 0 ||
+		    FcStrCmpIgnoreCase (p + 1, "lib") == 0))
+	      *p = '\0';
+	  strcat (fontconfig_path, "\\etc\\fonts");
+      }
+      else
+          fontconfig_path[0] = '\0';
+      
+      break;
+  }
+
+  return TRUE;
+}
+
+#  endif /* !PIC */
+
+#undef FONTCONFIG_PATH
+#define FONTCONFIG_PATH fontconfig_path
+
+#endif /* !_WIN32 */
 
 #ifndef FONTCONFIG_FILE
 #define FONTCONFIG_FILE	"fonts.conf"
@@ -1271,15 +1622,25 @@ FcConfigFileExists (const FcChar8 *dir, const FcChar8 *file)
 	return 0;
 
     strcpy ((char *) path, (const char *) dir);
-    /* make sure there's a single separating / */
+    /* make sure there's a single separator */
+#ifdef _WIN32
+    if ((!path[0] || (path[strlen((char *) path)-1] != '/' &&
+		      path[strlen((char *) path)-1] != '\\')) &&
+	!(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] != '/')
 	strcat ((char *) path, "/");
+#endif
     strcat ((char *) path, (char *) file);
 
+    FcMemAlloc (FC_MEM_STRING, strlen ((char *) path) + 1);
     if (access ((char *) path, R_OK) == 0)
 	return path;
     
-    free (path);
+    FcStrFree (path);
     return 0;
 }
 
@@ -1299,7 +1660,7 @@ FcConfigGetPath (void)
 	e = env;
 	npath++;
 	while (*e)
-	    if (*e++ == ':')
+	    if (*e++ == FC_SEARCH_PATH_SEPARATOR)
 		npath++;
     }
     path = calloc (npath, sizeof (FcChar8 *));
@@ -1312,7 +1673,7 @@ FcConfigGetPath (void)
 	e = env;
 	while (*e) 
 	{
-	    colon = (FcChar8 *) strchr ((char *) e, ':');
+	    colon = (FcChar8 *) strchr ((char *) e, FC_SEARCH_PATH_SEPARATOR);
 	    if (!colon)
 		colon = e + strlen ((char *) e);
 	    path[i] = malloc (colon - e + 1);
@@ -1328,6 +1689,17 @@ FcConfigGetPath (void)
 	}
     }
     
+#ifdef _WIN32
+	if (fontconfig_path[0] == '\0')
+	{
+		char *p;
+		if(!GetModuleFileName(NULL, fontconfig_path, sizeof(fontconfig_path)))
+			goto bail1;
+		p = strrchr (fontconfig_path, '\\');
+		if (p) *p = '\0';
+		strcat (fontconfig_path, "\\fonts");
+	}
+#endif
     dir = (FcChar8 *) FONTCONFIG_PATH;
     path[i] = malloc (strlen ((char *) dir) + 1);
     if (!path[i])
@@ -1353,11 +1725,38 @@ FcConfigFreePath (FcChar8 **path)
     free (path);
 }
 
+static FcBool	_FcConfigHomeEnabled = FcTrue;
+
+FcChar8 *
+FcConfigHome (void)
+{
+    if (_FcConfigHomeEnabled)
+    {
+        char *home = getenv ("HOME");
+
+#ifdef _WIN32
+	if (home == NULL)
+	    home = getenv ("USERPROFILE");
+#endif
+
+	return (FcChar8 *) home;
+    }
+    return 0;
+}
+
+FcBool
+FcConfigEnableHome (FcBool enable)
+{
+    FcBool  prev = _FcConfigHomeEnabled;
+    _FcConfigHomeEnabled = enable;
+    return prev;
+}
+
 FcChar8 *
 FcConfigFilename (const FcChar8 *url)
 {
     FcChar8    *file, *dir, **path, **p;
-    
+
     if (!url || !*url)
     {
 	url = (FcChar8 *) getenv ("FONTCONFIG_FILE");
@@ -1365,14 +1764,26 @@ FcConfigFilename (const FcChar8 *url)
 	    url = (FcChar8 *) FONTCONFIG_FILE;
     }
     file = 0;
+
+#ifdef _WIN32
+    if (isalpha (*url) &&
+	url[1] == ':' &&
+	(url[2] == '/' || url[2] == '\\'))
+	goto absolute_path;
+#endif
+
     switch (*url) {
     case '~':
-	dir = (FcChar8 *) getenv ("HOME");
+	dir = FcConfigHome ();
 	if (dir)
 	    file = FcConfigFileExists (dir, url + 1);
 	else
 	    file = 0;
 	break;
+#ifdef _WIN32
+    case '\\':
+    absolute_path:
+#endif
     case '/':
 	file = FcConfigFileExists (0, url);
 	break;
@@ -1428,7 +1839,7 @@ FcConfigAppFontAddFile (FcConfig    *config,
 	FcConfigSetFonts (config, set, FcSetApplication);
     }
 	
-    if (!FcFileScan (set, subdirs, 0, config->blanks, file, FcFalse))
+    if (!FcFileScanConfig (set, subdirs, config->blanks, file, config))
     {
 	FcStrSetDestroy (subdirs);
 	return FcFalse;
@@ -1441,6 +1852,7 @@ FcConfigAppFontAddFile (FcConfig    *config,
 	}
 	FcStrListDone (sublist);
     }
+    FcStrSetDestroy (subdirs);
     return FcTrue;
 }
 
@@ -1449,9 +1861,7 @@ FcConfigAppFontAddDir (FcConfig	    *config,
 		       const FcChar8   *dir)
 {
     FcFontSet	*set;
-    FcStrSet	*subdirs;
-    FcStrList	*sublist;
-    FcChar8	*subdir;
+    FcStrSet	*dirs;
     
     if (!config)
     {
@@ -1459,8 +1869,9 @@ FcConfigAppFontAddDir (FcConfig	    *config,
 	if (!config)
 	    return FcFalse;
     }
-    subdirs = FcStrSetCreate ();
-    if (!subdirs)
+
+    dirs = FcStrSetCreate ();
+    if (!dirs)
 	return FcFalse;
     
     set = FcConfigGetFonts (config, FcSetApplication);
@@ -1469,30 +1880,145 @@ FcConfigAppFontAddDir (FcConfig	    *config,
 	set = FcFontSetCreate ();
 	if (!set)
 	{
-	    FcStrSetDestroy (subdirs);
+	    FcStrSetDestroy (dirs);
 	    return FcFalse;
 	}
 	FcConfigSetFonts (config, set, FcSetApplication);
     }
     
-    if (!FcDirScan (set, subdirs, 0, config->blanks, dir, FcFalse))
+    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;
 }
 
 void
 FcConfigAppFontClear (FcConfig	    *config)
 {
+    if (!config)
+    {
+	config = FcConfigGetCurrent ();
+	if (!config)
+	    return;
+    }
+
     FcConfigSetFonts (config, 0, FcSetApplication);
 }
+
+/*
+ * Manage filename-based font source selectors
+ */
+
+FcBool
+FcConfigGlobAdd (FcConfig	*config,
+		 const FcChar8  *glob,
+		 FcBool		accept)
+{
+    FcStrSet	*set = accept ? config->acceptGlobs : config->rejectGlobs;
+
+    return FcStrSetAdd (set, glob);
+}
+
+static FcBool
+FcConfigGlobMatch (const FcChar8    *glob,
+		   const FcChar8    *string)
+{
+    FcChar8	c;
+
+    while ((c = *glob++)) 
+    {
+	switch (c) {
+	case '*':
+	    /* short circuit common case */
+	    if (!*glob)
+		return FcTrue;
+	    /* short circuit another common case */
+	    if (strchr ((char *) glob, '*') == 0)
+		string += strlen ((char *) string) - strlen ((char *) glob);
+	    while (*string)
+	    {
+		if (FcConfigGlobMatch (glob, string))
+		    return FcTrue;
+		string++;
+	    }
+	    return FcFalse;
+	case '?':
+	    if (*string++ == '\0')
+		return FcFalse;
+	    break;
+	default:
+	    if (*string++ != c)
+		return FcFalse;
+	    break;
+	}
+    }
+    return *string == '\0';
+}
+
+static FcBool
+FcConfigGlobsMatch (const FcStrSet	*globs,
+		    const FcChar8	*string)
+{
+    int	i;
+
+    for (i = 0; i < globs->num; i++)
+	if (FcConfigGlobMatch (globs->strs[i], string))
+	    return FcTrue;
+    return FcFalse;
+}
+
+FcBool
+FcConfigAcceptFilename (FcConfig	*config,
+			const FcChar8	*filename)
+{
+    if (FcConfigGlobsMatch (config->acceptGlobs, filename))
+	return FcTrue;
+    if (FcConfigGlobsMatch (config->rejectGlobs, filename))
+	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__