 @@ -1,39 +1,37 @@
 /*
  * fontconfig/fc-cache/fc-cache.c
+ *
  * Copyright © 2002 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
  * the above copyright notice appear in all copies and that both that
  * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Keith Packard not be used in
+ * documentation, and that the name of the author(s) not be used in
  * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Keith Packard makes no
+ * specific, written prior permission.  The authors make no
  * representations about the suitability of this software for any purpose.  It
  * is provided "as is" without express or implied warranty.
+ *
  * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  * 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
  * PERFORMANCE OF THIS SOFTWARE.
  */
 #include "../fc-arch/fcarch.h"
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #else
 #ifdef linux
 #define HAVE_GETOPT_LONG 1
 #endif
 #define HAVE_GETOPT 1
 #endif
 #include <fontconfig/fontconfig.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 @@ -110,27 +108,27 @@ usage (char *program, int error)
     fprintf (file, "  -q         (quick)   don't sleep before exiting\n");
     fprintf (file, "  -r,   (really force) erase all existing caches, then rescan\n");
     fprintf (file, "  -s         (system)  scan system-wide directories only\n");
     fprintf (file, "  -v         (verbose) display status information while busy\n");
     fprintf (file, "  -V         (version) display font config version and exit\n");
     fprintf (file, "  -h         (help)    display this help and exit\n");
 #endif
     exit (error);
+}
 static FcStrSet *processed_dirs;
 static int
-scanDirs (FcStrList *list, FcConfig *config, FcBool force, FcBool really_force, FcBool verbose)
+scanDirs (FcStrList *list, FcConfig *config, FcBool force, FcBool really_force, FcBool verbose, int *changed)
+{
     int		    ret = 0;
     const FcChar8   *dir;
     FcStrSet	    *subdirs;
     FcStrList	    *sublist;
     FcCache	    *cache;
     struct stat	    statb;
     FcBool	    was_valid;
     int		    i;
     /*
      * Now scan all of the directories into separate databases
      * and write out the results
 @@ -183,26 +181,27 @@ scanDirs (FcStrList *list, FcConfig *con
 	if (really_force)
 	    FcDirCacheUnlink (dir, config);
 	cache = NULL;
 	was_valid = FcFalse;
 	if (!force) {
 	    cache = FcDirCacheLoad (dir, config, NULL);
 	    if (cache)
 		was_valid = FcTrue;
+	}
 	if (!cache)
+	{
 	    (*changed)++;
 	    cache = FcDirCacheRead (dir, FcTrue, config);
 	    if (!cache)
+	    {
 		fprintf (stderr, "%s: error scanning\n", dir);
 		ret++;
 		continue;
+	    }
+	}
 	if (was_valid)
+	{
 	    if (verbose)
 		printf ("skipping, existing cache is valid: %d fonts, %d dirs\n",
 @@ -234,155 +233,66 @@ scanDirs (FcStrList *list, FcConfig *con
 	    FcStrSetAdd (subdirs, FcCacheSubdir (cache, i));
 	FcDirCacheUnload (cache);
 	sublist = FcStrListCreate (subdirs);
 	FcStrSetDestroy (subdirs);
 	if (!sublist)
+	{
 	    fprintf (stderr, "%s: Can't create subdir list\n", dir);
 	    ret++;
 	    continue;
+	}
 	FcStrSetAdd (processed_dirs, dir);
-	ret += scanDirs (sublist, config, force, really_force, verbose);
+	ret += scanDirs (sublist, config, force, really_force, verbose, changed);
+    }
     FcStrListDone (list);
     return ret;
+}
 static FcBool
 cleanCacheDirectory (FcConfig *config, FcChar8 *dir, FcBool verbose)
     DIR		*d;
     struct dirent *ent;
     FcChar8	*dir_base;
     FcBool	ret = FcTrue;
     FcBool	remove;
     FcCache	*cache;
     struct stat	target_stat;
     dir_base = FcStrPlus (dir, (FcChar8 *) "/");
     if (!dir_base)
 	fprintf (stderr, "%s: out of memory\n", dir);
 	return FcFalse;
     if (access ((char *) dir, W_OK) != 0)
 	if (verbose)
 	    printf ("%s: not cleaning %s cache directory\n", dir,
 		    access ((char *) dir, F_OK) == 0 ? "unwritable" : "non-existent");
 	FcStrFree (dir_base);
 	return FcTrue;
     if (verbose)
 	printf ("%s: cleaning cache directory\n", dir);
     d = opendir ((char *) dir);
     if (!d)
 	perror ((char *) dir);
 	FcStrFree (dir_base);
 	return FcFalse;
     while ((ent = readdir (d)))
 	FcChar8	*file_name;
 	const FcChar8	*target_dir;
 	if (ent->d_name[0] == '.')
 	    continue;
 	/* skip cache files for different architectures and */
 	/* files which are not cache files at all */
 	if (strlen(ent->d_name) != 32 + strlen ("-" FC_ARCHITECTURE FC_CACHE_SUFFIX) ||
 	    strcmp(ent->d_name + 32, "-" FC_ARCHITECTURE FC_CACHE_SUFFIX))
 	    continue;
 	file_name = FcStrPlus (dir_base, (FcChar8 *) ent->d_name);
 	if (!file_name)
 	    fprintf (stderr, "%s: allocation failure\n", dir);
 	    ret = FcFalse;
 	    break;
 	remove = FcFalse;
 	cache = FcDirCacheLoadFile (file_name, NULL);
 	if (!cache)
 	    if (verbose)
 		printf ("%s: invalid cache file: %s\n", dir, ent->d_name);
 	    remove = FcTrue;
 	else
 	    target_dir = FcCacheDir (cache);
 	    if (stat ((char *) target_dir, &target_stat) < 0)
 		if (verbose)
 		    printf ("%s: %s: missing directory: %s \n",
 			    dir, ent->d_name, target_dir);
 		remove = FcTrue;
 	if (remove)
 	    if (unlink ((char *) file_name) < 0)
 		perror ((char *) file_name);
 		ret = FcFalse;
 	FcDirCacheUnload (cache);
         FcStrFree (file_name);
     closedir (d);
     FcStrFree (dir_base);
     return ret;
 static FcBool
 cleanCacheDirectories (FcConfig *config, FcBool verbose)
+{
     FcStrList	*cache_dirs = FcConfigGetCacheDirs (config);
     FcChar8	*cache_dir;
     FcBool	ret = FcTrue;
     if (!cache_dirs)
 	return FcFalse;
     while ((cache_dir = FcStrListNext (cache_dirs)))
+    {
-	if (!cleanCacheDirectory (config, cache_dir, verbose))
+	if (!FcDirCacheClean (cache_dir, verbose))
+	{
 	    ret = FcFalse;
 	    break;
+	}
+    }
     FcStrListDone (cache_dirs);
     return ret;
+}
 int
 main (int argc, char **argv)
+{
     FcStrSet	*dirs;
     FcStrList	*list;
     FcBool    	verbose = FcFalse;
     FcBool      quick = FcFalse;
     FcBool	force = FcFalse;
     FcBool	really_force = FcFalse;
     FcBool	systemOnly = FcFalse;
     FcConfig	*config;
     int		i;
     int		changed;
     int		ret;
 #if HAVE_GETOPT_LONG || HAVE_GETOPT
     int		c;
 #if HAVE_GETOPT_LONG
     while ((c = getopt_long (argc, argv, "fqrsVvh", longopts, NULL)) != -1)
 #else
     while ((c = getopt (argc, argv, "fqrsVvh")) != -1)
 #endif
+    {
 	switch (c) {
 	case 'r':
 	    really_force = FcTrue;
 @@ -443,34 +353,42 @@ main (int argc, char **argv)
 	    i++;
+	}
 	list = FcStrListCreate (dirs);
 	FcStrSetDestroy (dirs);
+    }
     else
 	list = FcConfigGetConfigDirs (config);
     if ((processed_dirs = FcStrSetCreate()) == NULL) {
 	fprintf(stderr, "Cannot malloc\n");
 	return 1;
+    }
-    ret = scanDirs (list, config, force, really_force, verbose);
+    changed = 0;
     ret = scanDirs (list, config, force, really_force, verbose, &changed);
     /*
      * Try to create CACHEDIR.TAG anyway.
      * This expects the fontconfig cache directory already exists.
      * If it doesn't, it won't be simply created.
      */
     FcCacheCreateTagFile (config);
     FcStrSetDestroy (processed_dirs);
     cleanCacheDirectories (config, verbose);
     /*
      * Now we need to sleep a second  (or two, to be extra sure), to make
      * sure that timestamps for changes after this run of fc-cache are later
      * then any timestamps we wrote.  We don't use gettimeofday() because
      * sleep(3) can't be interrupted by a signal here -- this isn't in the
      * library, and there aren't any signals flying around here.
      */
     FcConfigDestroy (config);
     FcFini ();
-    if (!quick)
+    if (!quick && changed)
-        sleep (2);
+	sleep (2);
     if (verbose)
 	printf ("%s: %s\n", argv[0], ret ? "failed" : "succeeded");
     return ret;
+}

 @@ -1,147 +1,95 @@
 /*
  * Copyright © 2000 Keith Packard
  * Copyright © 2005 Patrick Lam
+ *
  * Permission to use, copy, modify, distribute, and sell this software and its
  * documentation for any purpose is hereby granted without fee, provided that
  * the above copyright notice appear in all copies and that both that
  * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Keith Packard not be used in
+ * documentation, and that the name of the author(s) not be used in
  * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Keith Packard makes no
+ * specific, written prior permission.  The authors make no
  * representations about the suitability of this software for any purpose.  It
  * is provided "as is" without express or implied warranty.
+ *
  * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  * 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
  * PERFORMANCE OF THIS SOFTWARE.
  */
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 #include "fcint.h"
-#include "../fc-arch/fcarch.h"
+#include "fcarch.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <fcntl.h>
 #include <dirent.h>
 #include <string.h>
 #include <sys/types.h>
 #include <time.h>
 #include <assert.h>
 #if defined(HAVE_MMAP) || defined(__CYGWIN__)
 #  include <unistd.h>
 #  include <sys/mman.h>
 #elif defined(_WIN32)
 #  define _WIN32_WINNT 0x0500
 #  include <windows.h>
 #endif
 #ifndef O_BINARY
 #define O_BINARY 0
 #endif
 struct MD5Context {
         FcChar32 buf[4];
         FcChar32 bits[2];
         unsigned char in[64];
 };
 static void MD5Init(struct MD5Context *ctx);
 static void MD5Update(struct MD5Context *ctx, const unsigned char *buf, unsigned len);
 static void MD5Final(unsigned char digest[16], struct MD5Context *ctx);
 static void MD5Transform(FcChar32 buf[4], FcChar32 in[16]);
 #define CACHEBASE_LEN (1 + 32 + 1 + sizeof (FC_ARCHITECTURE) + sizeof (FC_CACHE_SUFFIX))
-#ifdef _WIN32
+static FcBool
 FcCacheIsMmapSafe (int fd)
 #include <windows.h>
 #ifdef __GNUC__
 typedef long long INT64;
 #define EPOCH_OFFSET 11644473600ll
 #else
 #define EPOCH_OFFSET 11644473600i64
 typedef __int64 INT64;
 #endif
 /* Workaround for problems in the stat() in the Microsoft C library:
  * 1) stat() uses FindFirstFile() to get the file
  * attributes. Unfortunately this API doesn't return correct values
  * for modification time of a directory until some time after a file
  * or subdirectory has been added to the directory. (This causes
  * run-test.sh to fail, for instance.) GetFileAttributesEx() is
  * better, it returns the updated timestamp right away.
  * 2) stat() does some strange things related to backward
  * compatibility with the local time timestamps on FAT volumes and
  * daylight saving time. This causes problems after the switches
  * to/from daylight saving time. See
  * http://bugzilla.gnome.org/show_bug.cgi?id=154968 , especially
  * comment #30, and http://www.codeproject.com/datetime/dstbugs.asp .
  * We don't need any of that, FAT and Win9x are as good as dead. So
  * just use the UTC timestamps from NTFS, converted to the Unix epoch.
  */
 int
 FcStat (const char *file, struct stat *statb)
+{
-    WIN32_FILE_ATTRIBUTE_DATA wfad;
+    static FcBool is_initialized = FcFalse;
-    char full_path_name[MAX_PATH];
+    static FcBool is_env_available = FcFalse;
-    char *basename;
+    static FcBool use_mmap = FcFalse;
     DWORD rc;
     if (!GetFileAttributesEx (file, GetFileExInfoStandard, &wfad))
 	return -1;
     statb->st_dev = 0;
-    /* Calculate a pseudo inode number as a hash of the full path name.
+    if (!is_initialized)
      * Call GetLongPathName() to get the spelling of the path name as it
-     * is on disk.
+	const char *env;
      */
     rc = GetFullPathName (file, sizeof (full_path_name), full_path_name, &basename);
     if (rc == 0 || rc > sizeof (full_path_name))
 	return -1;
-    rc = GetLongPathName (full_path_name, full_path_name, sizeof (full_path_name));
+	env = getenv ("FONTCONFIG_USE_MMAP");
-    statb->st_ino = FcStringHash (full_path_name);
+	if (env)
+	{
-    statb->st_mode = _S_IREAD | _S_IWRITE;
+	    if (FcNameBool ((const FcChar8 *)env, &use_mmap))
-    statb->st_mode |= (statb->st_mode >> 3) | (statb->st_mode >> 6);
+		is_env_available = FcTrue;
+	}
 	is_initialized = FcTrue;
+    }
     if (is_env_available)
 	return use_mmap;
-    if (wfad.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+    return FcIsFsMmapSafe (fd);
 	statb->st_mode |= _S_IFDIR;
     else
 	statb->st_mode |= _S_IFREG;
     statb->st_nlink = 1;
     statb->st_uid = statb->st_gid = 0;
     statb->st_rdev = 0;
     if (wfad.nFileSizeHigh > 0)
 	return -1;
     statb->st_size = wfad.nFileSizeLow;
     statb->st_atime = (*(INT64 *)&wfad.ftLastAccessTime)/10000000 - EPOCH_OFFSET;
     statb->st_mtime = (*(INT64 *)&wfad.ftLastWriteTime)/10000000 - EPOCH_OFFSET;
     statb->st_ctime = statb->st_mtime;
     return 0;
+}
 #endif
 static const char bin2hex[] = { '0', '1', '2', '3',
 				'4', '5', '6', '7',
 				'8', '9', 'a', 'b',
 				'c', 'd', 'e', 'f' };
 static FcChar8 *
 FcDirCacheBasename (const FcChar8 * dir, FcChar8 cache_base[CACHEBASE_LEN])
+{
     unsigned char 	hash[16];
     FcChar8		*hex_hash;
     int			cnt;
     struct MD5Context 	ctx;
 @@ -205,45 +153,45 @@ FcDirCacheOpenFile (const FcChar8 *cache
     fd = open((char *) cache_file, O_RDONLY | O_BINARY);
     if (fd < 0)
 	return fd;
 #ifndef _WIN32
     if (fstat (fd, file_stat) < 0)
+    {
 	close (fd);
 	return -1;
+    }
 #endif
     return fd;
+}
 /*
  * Look for a cache file for the specified dir. Attempt
  * to use each one we find, stopping when the callback
  * indicates success
  */
 static FcBool
 FcDirCacheProcess (FcConfig *config, const FcChar8 *dir,
 		   FcBool (*callback) (int fd, struct stat *fd_stat,
 				       struct stat *dir_stat, void *closure),
 		   void *closure, FcChar8 **cache_file_ret)
+{
     int		fd = -1;
     FcChar8	cache_base[CACHEBASE_LEN];
     FcStrList	*list;
     FcChar8	*cache_dir;
     struct stat file_stat, dir_stat;
     FcBool	ret = FcFalse;
-    if (FcStat ((char *) dir, &dir_stat) < 0)
+    if (FcStatChecksum (dir, &dir_stat) < 0)
         return FcFalse;
     FcDirCacheBasename (dir, cache_base);
     list = FcStrListCreate (config->cacheDirs);
     if (!list)
         return FcFalse;
     while ((cache_dir = FcStrListNext (list)))
+    {
         FcChar8	*cache_hashed = FcStrPlus (cache_dir, cache_base);
         if (!cache_hashed)
 	    break;
 @@ -253,27 +201,27 @@ FcDirCacheProcess (FcConfig *config, con
 	    close (fd);
 	    if (ret)
+	    {
 		if (cache_file_ret)
 		    *cache_file_ret = cache_hashed;
 		else
 		    FcStrFree (cache_hashed);
 		break;
+	    }
+	}
     	FcStrFree (cache_hashed);
+    }
     FcStrListDone (list);
     return ret;
+}
 #define FC_CACHE_MIN_MMAP   1024
 /*
  * Skip list element, make sure the 'next' pointer is the last thing
  * in the structure, it will be allocated large enough to hold all
  * of the necessary pointers
  */
 typedef struct _FcCacheSkip FcCacheSkip;
 @@ -287,37 +235,82 @@ struct _FcCacheSkip {
     FcCacheSkip	    *next[1];
 };
 /*
  * The head of the skip list; pointers for every possible level
  * in the skip list, plus the largest level in the list
  */
 #define FC_CACHE_MAX_LEVEL  16
 static FcCacheSkip	*fcCacheChains[FC_CACHE_MAX_LEVEL];
 static int		fcCacheMaxLevel;
 #if HAVE_RANDOM
-# define FcRandom()  random()
+static int32_t
 FcRandom(void)
+{
     int32_t result;
 #if HAVE_RANDOM_R
     static struct random_data fcrandbuf;
     static char statebuf[256];
     static FcBool initialized = FcFalse;
     if (initialized != FcTrue)
+    {
 	initstate_r(time(NULL), statebuf, 256, &fcrandbuf);
 	initialized = FcTrue;
+    }
     random_r(&fcrandbuf, &result);
 #elif HAVE_RANDOM
     static char statebuf[256];
     char *state;
     static FcBool initialized = FcFalse;
     if (initialized != FcTrue)
+    {
 	state = initstate(time(NULL), statebuf, 256);
 	initialized = FcTrue;
+    }
     else
 	state = setstate(statebuf);
     result = random();
     setstate(state);
 #elif HAVE_LRAND48
     result = lrand48();
 #elif HAVE_RAND_R
     static unsigned int seed = time(NULL);
     result = rand_r(&seed);
 #elif HAVE_RAND
     static FcBool initialized = FcFalse;
     if (initialized != FcTrue)
+    {
 	srand(time(NULL));
 	initialized = FcTrue;
+    }
     result = rand();
 #else
-# if HAVE_LRAND48
+# error no random number generator function available.
 #  define FcRandom()  lrand48()
 # else
 #  if HAVE_RAND
 #   define FcRandom()  rand()
 #  endif
 # endif
 #endif
     return result;
+}
 /*
  * Generate a random level number, distributed
  * so that each level is 1/4 as likely as the one before
+ *
  * Note that level numbers run 1 <= level <= MAX_LEVEL
  */
 static int
 random_level (void)
+{
     /* tricky bit -- each bit is '1' 75% of the time */
     long int	bits = FcRandom () | FcRandom ();
     int	level = 0;
 @@ -352,47 +345,47 @@ FcCacheInsert (FcCache *cache, struct st
         update[i] = &next[i];
+    }
     /*
      * Create new list element
      */
     level = random_level ();
     if (level > fcCacheMaxLevel)
+    {
 	level = fcCacheMaxLevel + 1;
 	update[fcCacheMaxLevel] = &fcCacheChains[fcCacheMaxLevel];
 	fcCacheMaxLevel = level;
+    }
     s = malloc (sizeof (FcCacheSkip) + (level - 1) * sizeof (FcCacheSkip *));
     if (!s)
 	return FcFalse;
     s->cache = cache;
     s->size = cache->size;
     s->ref = 1;
     if (cache_stat)
+    {
 	s->cache_dev = cache_stat->st_dev;
 	s->cache_ino = cache_stat->st_ino;
 	s->cache_mtime = cache_stat->st_mtime;
+    }
     else
+    {
 	s->cache_dev = 0;
 	s->cache_ino = 0;
 	s->cache_mtime = 0;
+    }
     /*
      * Insert into all fcCacheChains
      */
     for (i = 0; i < level; i++)
+    {
 	s->next[i] = *update[i];
 	*update[i] = s;
+    }
     return FcTrue;
+}
 static FcCacheSkip *
 FcCacheFindByAddr (void *object)
 @@ -505,96 +498,99 @@ FcCacheFini (void)
     for (i = 0; i < FC_CACHE_MAX_LEVEL; i++)
 	assert (fcCacheChains[i] == NULL);
     assert (fcCacheMaxLevel == 0);
+}
 static FcBool
 FcCacheTimeValid (FcCache *cache, struct stat *dir_stat)
+{
     struct stat	dir_static;
     if (!dir_stat)
+    {
-	if (FcStat ((const char *) FcCacheDir (cache), &dir_static) < 0)
+	if (FcStatChecksum (FcCacheDir (cache), &dir_static) < 0)
 	    return FcFalse;
 	dir_stat = &dir_static;
+    }
     if (FcDebug () & FC_DBG_CACHE)
-	printf ("FcCacheTimeValid dir \"%s\" cache time %d dir time %d\n",
+	printf ("FcCacheTimeValid dir \"%s\" cache checksum %d dir checksum %d\n",
-		FcCacheDir (cache), cache->mtime, (int) dir_stat->st_mtime);
+		FcCacheDir (cache), cache->checksum, (int) dir_stat->st_mtime);
-    return cache->mtime == (int) dir_stat->st_mtime;
+    return cache->checksum == (int) dir_stat->st_mtime;
+}
 /*
  * Map a cache file into memory
  */
 static FcCache *
 FcDirCacheMapFd (int fd, struct stat *fd_stat, struct stat *dir_stat)
+{
     FcCache	*cache;
     FcBool	allocated = FcFalse;
     if (fd_stat->st_size < sizeof (FcCache))
 	return NULL;
     cache = FcCacheFindByStat (fd_stat);
     if (cache)
+    {
 	if (FcCacheTimeValid (cache, dir_stat))
 	    return cache;
 	FcDirCacheUnload (cache);
 	cache = NULL;
+    }
     /*
-     * Lage cache files are mmap'ed, smaller cache files are read. This
+     * Large cache files are mmap'ed, smaller cache files are read. This
      * balances the system cost of mmap against per-process memory usage.
      */
-    if (fd_stat->st_size >= FC_CACHE_MIN_MMAP)
+    if (FcCacheIsMmapSafe (fd) && fd_stat->st_size >= FC_CACHE_MIN_MMAP)
+    {
 #if defined(HAVE_MMAP) || defined(__CYGWIN__)
 	cache = mmap (0, fd_stat->st_size, PROT_READ, MAP_SHARED, fd, 0);
 #ifdef HAVE_POSIX_FADVISE
 	posix_fadvise (fd, 0, fd_stat->st_size, POSIX_FADV_WILLNEED);
 #endif
 	if (cache == MAP_FAILED)
 	    cache = NULL;
 #elif defined(_WIN32)
+	{
 	    HANDLE hFileMap;
 	    cache = NULL;
 	    hFileMap = CreateFileMapping((HANDLE) _get_osfhandle(fd), NULL,
 					 PAGE_READONLY, 0, 0, NULL);
 	    if (hFileMap != NULL)
+	    {
 		cache = MapViewOfFile (hFileMap, FILE_MAP_READ, 0, 0,
 				       fd_stat->st_size);
 		CloseHandle (hFileMap);
+	    }
+	}
 #endif
+    }
     if (!cache)
+    {
 	cache = malloc (fd_stat->st_size);
 	if (!cache)
 	    return NULL;
 	if (read (fd, cache, fd_stat->st_size) != fd_stat->st_size)
+	{
 	    free (cache);
 	    return NULL;
+	}
 	allocated = FcTrue;
+    }
     if (cache->magic != FC_CACHE_MAGIC_MMAP ||
 	cache->version < FC_CACHE_CONTENT_VERSION ||
 	cache->size != fd_stat->st_size ||
 	!FcCacheTimeValid (cache, dir_stat) ||
 	!FcCacheInsert (cache, fd_stat))
+    {
 	if (allocated)
 	    free (cache);
 	else
+	{
 #if defined(HAVE_MMAP) || defined(__CYGWIN__)
 	    munmap (cache, fd_stat->st_size);
 #elif defined(_WIN32)
 	    UnmapViewOfFile (cache);
 @@ -664,173 +660,171 @@ FcDirCacheLoadFile (const FcChar8 *cache
     close (fd);
     return cache;
+}
 /*
  * Validate a cache file by reading the header and checking
  * the magic number and the size field
  */
 static FcBool
 FcDirCacheValidateHelper (int fd, struct stat *fd_stat, struct stat *dir_stat, void *closure)
+{
     FcBool  ret = FcTrue;
     FcCache	c;
     if (read (fd, &c, sizeof (FcCache)) != sizeof (FcCache))
 	ret = FcFalse;
     else if (c.magic != FC_CACHE_MAGIC_MMAP)
 	ret = FcFalse;
     else if (c.version < FC_CACHE_CONTENT_VERSION)
 	ret = FcFalse;
     else if (fd_stat->st_size != c.size)
 	ret = FcFalse;
-    else if (c.mtime != (int) dir_stat->st_mtime)
+    else if (c.checksum != (int) dir_stat->st_mtime)
 	ret = FcFalse;
     return ret;
+}
 static FcBool
 FcDirCacheValidConfig (const FcChar8 *dir, FcConfig *config)
+{
     return FcDirCacheProcess (config, dir,
 			      FcDirCacheValidateHelper,
 			      NULL, NULL);
+}
 FcBool
 FcDirCacheValid (const FcChar8 *dir)
+{
     FcConfig	*config;
     config = FcConfigGetCurrent ();
     if (!config)
         return FcFalse;
     return FcDirCacheValidConfig (dir, config);
+}
 /*
  * Build a cache structure from the given contents
  */
 FcCache *
 FcDirCacheBuild (FcFontSet *set, const FcChar8 *dir, struct stat *dir_stat, FcStrSet *dirs)
+{
     FcSerialize	*serialize = FcSerializeCreate ();
     FcCache *cache;
     int i;
     intptr_t	cache_offset;
     intptr_t	dirs_offset;
     FcChar8	*dir_serialize;
     intptr_t	*dirs_serialize;
     FcFontSet	*set_serialize;
     if (!serialize)
 	return NULL;
     /*
      * Space for cache structure
      */
-    cache_offset = FcSerializeReserve (serialize, sizeof (FcCache));
+    FcSerializeReserve (serialize, sizeof (FcCache));
     /*
      * Directory name
      */
     if (!FcStrSerializeAlloc (serialize, dir))
 	goto bail1;
     /*
      * Subdirs
      */
-    dirs_offset = FcSerializeAlloc (serialize, dirs, dirs->num * sizeof (FcChar8 *));
+    FcSerializeAlloc (serialize, dirs, dirs->num * sizeof (FcChar8 *));
     for (i = 0; i < dirs->num; i++)
 	if (!FcStrSerializeAlloc (serialize, dirs->strs[i]))
 	    goto bail1;
     /*
      * Patterns
      */
     if (!FcFontSetSerializeAlloc (serialize, set))
 	goto bail1;
     /* Serialize layout complete. Now allocate space and fill it */
     cache = malloc (serialize->size);
     if (!cache)
 	goto bail1;
     /* shut up valgrind */
     memset (cache, 0, serialize->size);
     serialize->linear = cache;
     cache->magic = FC_CACHE_MAGIC_ALLOC;
     cache->version = FC_CACHE_CONTENT_VERSION;
     cache->size = serialize->size;
-    cache->mtime = (int) dir_stat->st_mtime;
+    cache->checksum = (int) dir_stat->st_mtime;
     /*
      * Serialize directory name
      */
     dir_serialize = FcStrSerialize (serialize, dir);
     if (!dir_serialize)
 	goto bail2;
     cache->dir = FcPtrToOffset (cache, dir_serialize);
     /*
      * Serialize sub dirs
      */
     dirs_serialize = FcSerializePtr (serialize, dirs);
     if (!dirs_serialize)
 	goto bail2;
     cache->dirs = FcPtrToOffset (cache, dirs_serialize);
     cache->dirs_count = dirs->num;
     for (i = 0; i < dirs->num; i++)
+    {
 	FcChar8	*d_serialize = FcStrSerialize (serialize, dirs->strs[i]);
 	if (!d_serialize)
 	    goto bail2;
 	dirs_serialize[i] = FcPtrToOffset (dirs_serialize, d_serialize);
+    }
     /*
      * Serialize font set
      */
     set_serialize = FcFontSetSerialize (serialize, set);
     if (!set_serialize)
 	goto bail2;
     cache->set = FcPtrToOffset (cache, set_serialize);
     FcSerializeDestroy (serialize);
     FcCacheInsert (cache, NULL);
     return cache;
 bail2:
     free (cache);
 bail1:
     FcSerializeDestroy (serialize);
     return NULL;
+}
 #ifdef _WIN32
 #define mkdir(path,mode) _mkdir(path)
 #endif
 static FcBool
 FcMakeDirectory (const FcChar8 *dir)
+{
     FcChar8 *parent;
     FcBool  ret;
     if (strlen ((char *) dir) == 0)
 	return FcFalse;
     parent = FcStrDirname (dir);
     if (!parent)
 	return FcFalse;
     if (access ((char *) parent, F_OK) == 0)
 	ret = mkdir ((char *) dir, 0755) == 0 && chmod ((char *) dir, 0755) == 0;
     else if (access ((char *) parent, F_OK) == -1)
 	ret = FcMakeDirectory (parent) && (mkdir ((char *) dir, 0755) == 0) && chmod ((char *) dir, 0755) == 0;
     else
 	ret = FcFalse;
     FcStrFree (parent);
     return ret;
+}
 @@ -844,54 +838,58 @@ FcDirCacheWrite (FcCache *cache, FcConfi
     int 	    fd;
     FcAtomic 	    *atomic;
     FcStrList	    *list;
     FcChar8	    *cache_dir = NULL;
     FcChar8	    *test_dir;
     FcCacheSkip     *skip;
     struct stat     cache_stat;
     int		    magic;
     int		    written;
     /*
      * Write it to the first directory in the list which is writable
      */
     list = FcStrListCreate (config->cacheDirs);
     if (!list)
 	return FcFalse;
     while ((test_dir = FcStrListNext (list))) {
-	if (access ((char *) test_dir, W_OK|X_OK) == 0)
+	if (access ((char *) test_dir, W_OK) == 0)
+	{
 	    cache_dir = test_dir;
 	    break;
+	}
 	else
+	{
 	    /*
 	     * If the directory doesn't exist, try to create it
 	     */
 	    if (access ((char *) test_dir, F_OK) == -1) {
 		if (FcMakeDirectory (test_dir))
+		{
 		    cache_dir = test_dir;
 		    /* Create CACHEDIR.TAG */
 		    FcDirCacheCreateTagFile (cache_dir);
 		    break;
+		}
+	    }
 	    /*
 	     * Otherwise, try making it writable
 	     */
 	    else if (chmod ((char *) test_dir, 0755) == 0)
+	    {
 		cache_dir = test_dir;
 		/* Try to create CACHEDIR.TAG too */
 		FcDirCacheCreateTagFile (cache_dir);
 		break;
+	    }
+	}
+    }
     FcStrListDone (list);
     if (!cache_dir)
 	return FcFalse;
     FcDirCacheBasename (dir, cache_base);
     cache_hashed = FcStrPlus (cache_dir, cache_base);
     if (!cache_hashed)
         return FcFalse;
 @@ -899,41 +897,41 @@ FcDirCacheWrite (FcCache *cache, FcConfi
         printf ("FcDirCacheWriteDir dir \"%s\" file \"%s\"\n",
 		dir, cache_hashed);
     atomic = FcAtomicCreate ((FcChar8 *)cache_hashed);
     if (!atomic)
 	goto bail1;
     if (!FcAtomicLock (atomic))
 	goto bail3;
     fd = open((char *)FcAtomicNewFile (atomic), O_RDWR | O_CREAT | O_BINARY, 0666);
     if (fd == -1)
 	goto bail4;
     /* Temporarily switch magic to MMAP while writing to file */
     magic = cache->magic;
     if (magic != FC_CACHE_MAGIC_MMAP)
 	cache->magic = FC_CACHE_MAGIC_MMAP;
     /*
      * Write cache contents to file
      */
     written = write (fd, cache, cache->size);
     /* Switch magic back */
     if (magic != FC_CACHE_MAGIC_MMAP)
 	cache->magic = magic;
     if (written != cache->size)
+    {
 	perror ("write cache");
 	goto bail5;
+    }
     close(fd);
     if (!FcAtomicReplaceOrig(atomic))
         goto bail4;
     /* If the file is small, update the cache chain entry such that the
      * new cache file is not read again.  If it's large, we don't do that
      * such that we reload it, using mmap, which is shared across processes.
 @@ -953,46 +951,137 @@ FcDirCacheWrite (FcCache *cache, FcConfi
     return FcTrue;
  bail5:
     close (fd);
  bail4:
     FcAtomicUnlock (atomic);
  bail3:
     FcAtomicDestroy (atomic);
  bail1:
     FcStrFree (cache_hashed);
     return FcFalse;
+}
 FcBool
 FcDirCacheClean (const FcChar8 *cache_dir, FcBool verbose)
+{
     DIR		*d;
     struct dirent *ent;
     FcChar8	*dir_base;
     FcBool	ret = FcTrue;
     FcBool	remove;
     FcCache	*cache;
     struct stat	target_stat;
     dir_base = FcStrPlus (cache_dir, (FcChar8 *) FC_DIR_SEPARATOR_S);
     if (!dir_base)
+    {
 	fprintf (stderr, "Fontconfig error: %s: out of memory\n", cache_dir);
 	return FcFalse;
+    }
     if (access ((char *) cache_dir, W_OK) != 0)
+    {
 	if (verbose || FcDebug () & FC_DBG_CACHE)
 	    printf ("%s: not cleaning %s cache directory\n", cache_dir,
 		    access ((char *) cache_dir, F_OK) == 0 ? "unwritable" : "non-existent");
 	goto bail0;
+    }
     if (verbose || FcDebug () & FC_DBG_CACHE)
 	printf ("%s: cleaning cache directory\n", cache_dir);
     d = opendir ((char *) cache_dir);
     if (!d)
+    {
 	perror ((char *) cache_dir);
 	ret = FcFalse;
 	goto bail0;
+    }
     while ((ent = readdir (d)))
+    {
 	FcChar8	*file_name;
 	const FcChar8	*target_dir;
 	if (ent->d_name[0] == '.')
 	    continue;
 	/* skip cache files for different architectures and */
 	/* files which are not cache files at all */
 	if (strlen(ent->d_name) != 32 + strlen ("-" FC_ARCHITECTURE FC_CACHE_SUFFIX) ||
 	    strcmp(ent->d_name + 32, "-" FC_ARCHITECTURE FC_CACHE_SUFFIX))
 	    continue;
 	file_name = FcStrPlus (dir_base, (FcChar8 *) ent->d_name);
 	if (!file_name)
+	{
 	    fprintf (stderr, "Fontconfig error: %s: allocation failure\n", cache_dir);
 	    ret = FcFalse;
 	    break;
+	}
 	remove = FcFalse;
 	cache = FcDirCacheLoadFile (file_name, NULL);
 	if (!cache)
+	{
 	    if (verbose || FcDebug () & FC_DBG_CACHE)
 		printf ("%s: invalid cache file: %s\n", cache_dir, ent->d_name);
 	    remove = FcTrue;
+	}
 	else
+	{
 	    target_dir = FcCacheDir (cache);
 	    if (stat ((char *) target_dir, &target_stat) < 0)
+	    {
 		if (verbose || FcDebug () & FC_DBG_CACHE)
 		    printf ("%s: %s: missing directory: %s \n",
 			    cache_dir, ent->d_name, target_dir);
 		remove = FcTrue;
+	    }
+	}
 	if (remove)
+	{
 	    if (unlink ((char *) file_name) < 0)
+	    {
 		perror ((char *) file_name);
 		ret = FcFalse;
+	    }
+	}
 	FcDirCacheUnload (cache);
         FcStrFree (file_name);
+    }
     closedir (d);
   bail0:
     FcStrFree (dir_base);
     return ret;
+}
 /*
  * Hokey little macro trick to permit the definitions of C functions
  * with the same name as CPP macros
  */
 #define args1(x)	    (x)
 #define args2(x,y)	    (x,y)
 const FcChar8 *
 FcCacheDir args1(const FcCache *c)
+{
     return FcCacheDir (c);
+}
 FcFontSet *
 FcCacheCopySet args1(const FcCache *c)
+{
     FcFontSet	*old = FcCacheSet (c);
     FcFontSet	*new = FcFontSetCreate ();
     int		i;
     if (!new)
 	return NULL;
     for (i = 0; i < old->nfont; i++)
+    {
 	FcPattern   *font = FcFontSetFont (old, i);
 	FcPatternReference (font);
 	if (!FcFontSetAdd (new, font))
+	{
 	    FcFontSetDestroy (new);
 	    return NULL;
+	}
+    }
 @@ -1106,27 +1195,27 @@ static void MD5Update(struct MD5Context
 	memcpy(ctx->in, buf, 64);
 	byteReverse(ctx->in, 16);
 	MD5Transform(ctx->buf, (FcChar32 *) ctx->in);
 	buf += 64;
 	len -= 64;
+    }
     /* Handle any remaining bytes of data. */
     memcpy(ctx->in, buf, len);
+}
 /*
  * Final wrapup - pad to 64-byte boundary with the bit pattern
  * 1 0* (64-bit count of bits processed, MSB-first)
  */
 static void MD5Final(unsigned char digest[16], struct MD5Context *ctx)
+{
     unsigned count;
     unsigned char *p;
     /* Compute number of bytes mod 64 */
     count = (ctx->bits[0] >> 3) & 0x3F;
     /* Set the first char of padding to 0x80.  This is safe since there is
        always at least one byte free */
     p = ctx->in + count;
 @@ -1250,16 +1339,97 @@ static void MD5Transform(FcChar32 buf[4]
     MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
     MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
     MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
     MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
     MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
     MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
     MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
     buf[0] += a;
     buf[1] += b;
     buf[2] += c;
     buf[3] += d;
+}
 FcBool
 FcDirCacheCreateTagFile (const FcChar8 *cache_dir)
+{
     FcChar8		*cache_tag;
     int 		 fd;
     FILE		*fp;
     FcAtomic		*atomic;
     static const FcChar8 cache_tag_contents[] =
 	"Signature: 8a477f597d28d172789f06886806bc55\n"
 	"# This file is a cache directory tag created by fontconfig.\n"
 	"# For information about cache directory tags, see:\n"
 	"#       http://www.brynosaurus.com/cachedir/\n";
     static size_t	 cache_tag_contents_size = sizeof (cache_tag_contents) - 1;
     FcBool		 ret = FcFalse;
     if (!cache_dir)
 	return FcFalse;
     if (access ((char *) cache_dir, W_OK) == 0)
+    {
 	/* Create CACHEDIR.TAG */
 	cache_tag = FcStrPlus (cache_dir, (const FcChar8 *) FC_DIR_SEPARATOR_S "CACHEDIR.TAG");
 	if (!cache_tag)
 	    return FcFalse;
 	atomic = FcAtomicCreate ((FcChar8 *)cache_tag);
 	if (!atomic)
 	    goto bail1;
 	if (!FcAtomicLock (atomic))
 	    goto bail2;
 	fd = open((char *)FcAtomicNewFile (atomic), O_RDWR | O_CREAT, 0644);
 	if (fd == -1)
 	    goto bail3;
 	fp = fdopen(fd, "wb");
 	if (fp == NULL)
 	    goto bail3;
 	fwrite(cache_tag_contents, cache_tag_contents_size, sizeof (FcChar8), fp);
 	fclose(fp);
 	if (!FcAtomicReplaceOrig(atomic))
 	    goto bail3;
 	ret = FcTrue;
       bail3:
 	FcAtomicUnlock (atomic);
       bail2:
 	FcAtomicDestroy (atomic);
       bail1:
 	FcStrFree (cache_tag);
+    }
     if (FcDebug () & FC_DBG_CACHE)
+    {
 	if (ret)
 	    printf ("Created CACHEDIR.TAG at %s\n", cache_dir);
 	else
 	    printf ("Unable to create CACHEDIR.TAG at %s\n", cache_dir);
+    }
     return ret;
+}
 void
 FcCacheCreateTagFile (const FcConfig *config)
+{
     FcChar8   *cache_dir = NULL;
     FcStrList *list;
     list = FcConfigGetCacheDirs (config);
     if (!list)
 	return;
     while ((cache_dir = FcStrListNext (list)))
+    {
 	if (FcDirCacheCreateTagFile (cache_dir))
 	    break;
+    }
     FcStrListDone (list);
+}
 #define __fccache__
 #include "fcaliastail.h"
 #undef __fccache__

 @@ -1,48 +1,49 @@
 /*
  * fontconfig/src/fcmatch.c
+ *
  * 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
  * the above copyright notice appear in all copies and that both that
  * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Keith Packard not be used in
+ * documentation, and that the name of the author(s) not be used in
  * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Keith Packard makes no
+ * specific, written prior permission.  The authors make no
  * representations about the suitability of this software for any purpose.  It
  * is provided "as is" without express or implied warranty.
+ *
  * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  * 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
  * PERFORMANCE OF THIS SOFTWARE.
  */
 #include "fcint.h"
 #include <assert.h>
 #include <string.h>
 #include <ctype.h>
 #include <stdio.h>
 #include <float.h>
 static double
 FcCompareNumber (FcValue *value1, FcValue *value2)
+{
     double  v1, v2, v;
     switch (value1->type) {
     case FcTypeInteger:
 	v1 = (double) value1->u.i;
 	break;
     case FcTypeDouble:
 	v1 = value1->u.d;
 	break;
     default:
 	return -1.0;
+    }
     switch (value2->type) {
     case FcTypeInteger:
 	v2 = (double) value2->u.i;
 @@ -58,65 +59,65 @@ FcCompareNumber (FcValue *value1, FcValu
 	v = -v;
     return v;
+}
 static double
 FcCompareString (FcValue *v1, FcValue *v2)
+{
     return (double) FcStrCmpIgnoreCase (FcValueString(v1), FcValueString(v2)) != 0;
+}
 static double
 FcCompareFamily (FcValue *v1, FcValue *v2)
+{
-    /* rely on the guarantee in FcPatternAddWithBinding that
+    /* rely on the guarantee in FcPatternObjectAddWithBinding that
      * families are always FcTypeString. */
     const FcChar8* v1_string = FcValueString(v1);
     const FcChar8* v2_string = FcValueString(v2);
     if (FcToLower(*v1_string) != FcToLower(*v2_string) &&
 	*v1_string != ' ' && *v2_string != ' ')
        return 1.0;
     return (double) FcStrCmpIgnoreBlanksAndCase (v1_string, v2_string) != 0;
+}
 static double
 FcCompareLang (FcValue *v1, FcValue *v2)
+{
     FcLangResult    result;
     FcValue value1 = FcValueCanonicalize(v1), value2 = FcValueCanonicalize(v2);
     switch (value1.type) {
     case FcTypeLangSet:
 	switch (value2.type) {
 	case FcTypeLangSet:
 	    result = FcLangSetCompare (value1.u.l, value2.u.l);
 	    break;
 	case FcTypeString:
 	    result = FcLangSetHasLang (value1.u.l,
 				       value2.u.s);
 	    break;
 	default:
 	    return -1.0;
+	}
 	break;
     case FcTypeString:
 	switch (value2.type) {
 	case FcTypeLangSet:
 	    result = FcLangSetHasLang (value2.u.l, value1.u.s);
 	    break;
 	case FcTypeString:
 	    result = FcLangCompare (value1.u.s,
 				    value2.u.s);
 	    break;
 	default:
 	    return -1.0;
+	}
 	break;
     default:
 	return -1.0;
+    }
     switch (result) {
     case FcLangEqual:
 	return 0;
     case FcLangDifferentCountry:
 @@ -164,80 +165,101 @@ FcCompareSize (FcValue *value1, FcValue
 	v2 = value2->u.d;
 	break;
     default:
 	return -1;
+    }
     if (v2 == 0)
 	return 0;
     v = v2 - v1;
     if (v < 0)
 	v = -v;
     return v;
+}
 static double
 FcCompareFilename (FcValue *v1, FcValue *v2)
+{
 	const FcChar8 *s1 = FcValueString (v1), *s2 = FcValueString (v2);
 	if (FcStrCmp (s1, s2) == 0)
 	    return 0.0;
 	else if (FcStrCmpIgnoreCase (s1, s2) == 0)
 	    return 1.0;
 	else if (FcStrRegexCmp (s2, s1))
 	    return 2.0;
 	else if (FcStrRegexCmpIgnoreCase (s2, s1))
 	    return 3.0;
 	else
 	    return 4.0;
+}
 typedef struct _FcMatcher {
     FcObject	    object;
     double	    (*compare) (FcValue *value1, FcValue *value2);
     int		    strong, weak;
 } FcMatcher;
 /*
  * Order is significant, it defines the precedence of
  * each value, earlier values are more significant than
  * later values
  */
 static const FcMatcher _FcMatchers [] = {
-    { FC_FOUNDRY_OBJECT,	FcCompareString,	0, 0 },
+    { FC_FILE_OBJECT,		FcCompareFilename,	0, 0 },
-#define MATCH_FOUNDRY	    0
+#define MATCH_FILE	    0
-    { FC_CHARSET_OBJECT,	FcCompareCharSet,	1, 1 },
+    { FC_FOUNDRY_OBJECT,	FcCompareString,	1, 1 },
-#define MATCH_CHARSET	    1
+#define MATCH_FOUNDRY	    1
-    { FC_FAMILY_OBJECT,    	FcCompareFamily,	2, 4 },
+    { FC_CHARSET_OBJECT,	FcCompareCharSet,	2, 2 },
-#define MATCH_FAMILY	    2
+#define MATCH_CHARSET	    2
-    { FC_LANG_OBJECT,		FcCompareLang,	3, 3 },
+    { FC_FAMILY_OBJECT,    	FcCompareFamily,	3, 5 },
-#define MATCH_LANG	    3
+#define MATCH_FAMILY	    3
-#define MATCH_LANG_INDEX    3
+    { FC_LANG_OBJECT,		FcCompareLang,		4, 4 },
-    { FC_SPACING_OBJECT,	FcCompareNumber,	5, 5 },
+#define MATCH_LANG	    4
-#define MATCH_SPACING	    4
+#define MATCH_LANG_INDEX    4
-    { FC_PIXEL_SIZE_OBJECT,	FcCompareSize,	6, 6 },
+    { FC_SPACING_OBJECT,	FcCompareNumber,	6, 6 },
-#define MATCH_PIXEL_SIZE    5
+#define MATCH_SPACING	    5
-    { FC_STYLE_OBJECT,		FcCompareString,	7, 7 },
+    { FC_PIXEL_SIZE_OBJECT,	FcCompareSize,		7, 7 },
-#define MATCH_STYLE	    6
+#define MATCH_PIXEL_SIZE    6
-    { FC_SLANT_OBJECT,		FcCompareNumber,	8, 8 },
+    { FC_STYLE_OBJECT,		FcCompareString,	8, 8 },
-#define MATCH_SLANT	    7
+#define MATCH_STYLE	    7
-    { FC_WEIGHT_OBJECT,		FcCompareNumber,	9, 9 },
+    { FC_SLANT_OBJECT,		FcCompareNumber,	9, 9 },
-#define MATCH_WEIGHT	    8
+#define MATCH_SLANT	    8
-    { FC_WIDTH_OBJECT,		FcCompareNumber,	10, 10 },
+    { FC_WEIGHT_OBJECT,		FcCompareNumber,	10, 10 },
-#define MATCH_WIDTH	    9
+#define MATCH_WEIGHT	    9
-    { FC_DECORATIVE_OBJECT,	FcCompareBool,		11, 11 },
+    { FC_WIDTH_OBJECT,		FcCompareNumber,	11, 11 },
-#define MATCH_DECORATIVE	10
+#define MATCH_WIDTH	    10
-    { FC_ANTIALIAS_OBJECT,	FcCompareBool,		12, 12 },
+    { FC_DECORATIVE_OBJECT,	FcCompareBool,		12, 12 },
-#define MATCH_ANTIALIAS		    11
+#define MATCH_DECORATIVE	11
-    { FC_RASTERIZER_OBJECT,	FcCompareString,	13, 13 },
+    { FC_ANTIALIAS_OBJECT,	FcCompareBool,		13, 13 },
-#define MATCH_RASTERIZER	    12
+#define MATCH_ANTIALIAS		    12
-    { FC_OUTLINE_OBJECT,	FcCompareBool,		14, 14 },
+    { FC_RASTERIZER_OBJECT,	FcCompareString,	14, 14 },
-#define MATCH_OUTLINE		    13
+#define MATCH_RASTERIZER	    13
-    { FC_FONTVERSION_OBJECT,	FcCompareNumber,	15, 15 },
+    { FC_OUTLINE_OBJECT,	FcCompareBool,		15, 15 },
-#define MATCH_FONTVERSION	    14
+#define MATCH_OUTLINE		    14
     { FC_FONTVERSION_OBJECT,	FcCompareNumber,	16, 16 },
 #define MATCH_FONTVERSION	    15
 };
-#define NUM_MATCH_VALUES    16
+#define NUM_MATCH_VALUES    17
 static const FcMatcher*
-FcObjectToMatcher (FcObject object)
+FcObjectToMatcher (FcObject object,
 		   FcBool   include_lang)
+{
     int 	i;
     i = -1;
     switch (object) {
     case FC_FILE_OBJECT:
 	i = MATCH_FILE; break;
     case FC_FOUNDRY_OBJECT:
 	i = MATCH_FOUNDRY; break;
     case FC_FONTVERSION_OBJECT:
 	i = MATCH_FONTVERSION; break;
     case FC_FAMILY_OBJECT:
 	i = MATCH_FAMILY; break;
     case FC_CHARSET_OBJECT:
 	i = MATCH_CHARSET; break;
     case FC_ANTIALIAS_OBJECT:
 	i = MATCH_ANTIALIAS; break;
     case FC_LANG_OBJECT:
 	i = MATCH_LANG; break;
     case FC_SPACING_OBJECT:
 @@ -248,74 +270,88 @@ FcObjectToMatcher (FcObject object)
         i = MATCH_SLANT; break;
     case FC_PIXEL_SIZE_OBJECT:
 	i = MATCH_PIXEL_SIZE; break;
     case FC_WIDTH_OBJECT:
         i = MATCH_WIDTH; break;
     case FC_WEIGHT_OBJECT:
         i = MATCH_WEIGHT; break;
     case FC_RASTERIZER_OBJECT:
 	i = MATCH_RASTERIZER; break;
     case FC_OUTLINE_OBJECT:
 	i = MATCH_OUTLINE; break;
     case FC_DECORATIVE_OBJECT:
 	i = MATCH_DECORATIVE; break;
     default:
 	if (include_lang)
+	{
 	    switch (object) {
 	    case FC_FAMILYLANG_OBJECT:
 	    case FC_STYLELANG_OBJECT:
 	    case FC_FULLNAMELANG_OBJECT:
 		i = MATCH_LANG; break;
+	    }
+	}
+    }
     if (i < 0)
 	return NULL;
     return _FcMatchers+i;
+}
 static FcBool
-FcCompareValueList (FcObject	 object,
+FcCompareValueList (FcObject	     object,
-		    FcValueListPtr v1orig,	/* pattern */
+		    const FcMatcher *match,
-		    FcValueListPtr v2orig,	/* target */
+		    FcValueListPtr   v1orig,	/* pattern */
-		    FcValue	*bestValue,
+		    FcValueListPtr   v2orig,	/* target */
-		    double	*value,
+		    FcValue         *bestValue,
-		    FcResult	*result)
+		    double          *value,
 		    int             *n,
 		    FcResult        *result)
+{
     FcValueListPtr  v1, v2;
     double    	    v, best, bestStrong, bestWeak;
-    int		    j;
+    int		    j, k, pos = 0;
     const FcMatcher *match = FcObjectToMatcher(object);
     if (!match)
+    {
 	if (bestValue)
 	    *bestValue = FcValueCanonicalize(&v2orig->value);
 	if (n)
 	    *n = 0;
 	return FcTrue;
+    }
     best = DBL_MAX;
     bestStrong = DBL_MAX;
     bestWeak = DBL_MAX;
     j = 1;
     for (v1 = v1orig; v1; v1 = FcValueListNext(v1))
+    {
-	for (v2 = v2orig; v2; v2 = FcValueListNext(v2))
+	for (v2 = v2orig, k = 0; v2; v2 = FcValueListNext(v2), k++)
+	{
 	    v = (match->compare) (&v1->value, &v2->value);
 	    if (v < 0)
+	    {
 		*result = FcResultTypeMismatch;
 		return FcFalse;
+	    }
 	    v = v * 1000 + j;
 	    if (v < best)
+	    {
 		if (bestValue)
 		    *bestValue = FcValueCanonicalize(&v2->value);
 		best = v;
 		pos = k;
+	    }
 	    if (v1->binding == FcValueBindingStrong)
+	    {
 		if (v < bestStrong)
 		    bestStrong = v;
+	    }
 	    else
+	    {
 		if (v < bestWeak)
 		    bestWeak = v;
+	    }
+	}
 	j++;
 @@ -330,100 +366,196 @@ FcCompareValueList (FcObject	 object,
+    }
     if (value)
+    {
 	int weak    = match->weak;
 	int strong  = match->strong;
 	if (weak == strong)
 	    value[strong] += best;
 	else
+	{
 	    value[weak] += bestWeak;
 	    value[strong] += bestStrong;
+	}
+    }
     if (n)
 	*n = pos;
     return FcTrue;
+}
 /*
  * Return a value indicating the distance between the two lists of
  * values
  */
 static FcBool
 FcCompare (FcPattern	*pat,
 	   FcPattern	*fnt,
 	   double	*value,
 	   FcResult	*result)
+{
     int		    i, i1, i2;
     for (i = 0; i < NUM_MATCH_VALUES; i++)
 	value[i] = 0.0;
     i1 = 0;
     i2 = 0;
     while (i1 < pat->num && i2 < fnt->num)
+    {
 	FcPatternElt *elt_i1 = &FcPatternElts(pat)[i1];
 	FcPatternElt *elt_i2 = &FcPatternElts(fnt)[i2];
 	i = FcObjectCompare(elt_i1->object, elt_i2->object);
 	if (i > 0)
 	    i2++;
 	else if (i < 0)
 	    i1++;
 	else
+	{
-	    if (!FcCompareValueList (elt_i1->object,
+	    const FcMatcher *match = FcObjectToMatcher (elt_i1->object, FcFalse);
 	    if (!FcCompareValueList (elt_i1->object, match,
 				     FcPatternEltValues(elt_i1),
 				     FcPatternEltValues(elt_i2),
-, value, result))
+				     NULL, value, NULL, result))
 		return FcFalse;
 	    i1++;
 	    i2++;
+	}
+    }
     return FcTrue;
+}
 FcPattern *
 FcFontRenderPrepare (FcConfig	    *config,
 		     FcPattern	    *pat,
 		     FcPattern	    *font)
+{
     FcPattern	    *new;
     int		    i;
-    FcPatternElt    *fe, *pe;
+    FcPatternElt    *fe, *pe, *fel, *pel;
     FcValue	    v;
     FcResult	    result;
     assert (pat != NULL);
     assert (font != NULL);
     new = FcPatternCreate ();
     if (!new)
-	return 0;
+	return NULL;
     for (i = 0; i < font->num; i++)
+    {
 	fe = &FcPatternElts(font)[i];
 	if (fe->object == FC_FAMILYLANG_OBJECT ||
 	    fe->object == FC_STYLELANG_OBJECT ||
 	    fe->object == FC_FULLNAMELANG_OBJECT)
+	{
 	    /* ignore those objects. we need to deal with them
 	     * another way */
 	    continue;
+	}
 	if (fe->object == FC_FAMILY_OBJECT ||
 	    fe->object == FC_STYLE_OBJECT ||
 	    fe->object == FC_FULLNAME_OBJECT)
+	{
 	    FC_ASSERT_STATIC ((FC_FAMILY_OBJECT + 1) == FC_FAMILYLANG_OBJECT);
 	    FC_ASSERT_STATIC ((FC_STYLE_OBJECT + 1) == FC_STYLELANG_OBJECT);
 	    FC_ASSERT_STATIC ((FC_FULLNAME_OBJECT + 1) == FC_FULLNAMELANG_OBJECT);
 	    fel = FcPatternObjectFindElt (font, fe->object + 1);
 	    pel = FcPatternObjectFindElt (pat, fe->object + 1);
+	}
 	else
+	{
 	    fel = NULL;
 	    pel = NULL;
+	}
 	pe = FcPatternObjectFindElt (pat, fe->object);
 	if (pe)
+	{
-	    if (!FcCompareValueList (pe->object, FcPatternEltValues(pe),
+	    const FcMatcher *match = FcObjectToMatcher (pe->object, FcFalse);
 				     FcPatternEltValues(fe), &v, 0, &result))
 	    if (!FcCompareValueList (pe->object, match,
 				     FcPatternEltValues(pe),
 				     FcPatternEltValues(fe), &v, NULL, NULL, &result))
+	    {
 		FcPatternDestroy (new);
-		return 0;
+		return NULL;
+	    }
 	    if (fel && pel)
+	    {
 		int n = 1, j;
 		FcValueListPtr l1, l2, ln = NULL, ll = NULL;
 		match = FcObjectToMatcher (pel->object, FcTrue);
 		if (!FcCompareValueList (pel->object, match,
 					 FcPatternEltValues (pel),
 					 FcPatternEltValues (fel), NULL, NULL, &n, &result))
+		{
 		    FcPatternDestroy (new);
 		    return NULL;
+		}
 		for (j = 0, l1 = FcPatternEltValues (fe), l2 = FcPatternEltValues (fel);
 		     l1 != NULL || l2 != NULL;
 		     j++, l1 = l1 ? FcValueListNext (l1) : NULL, l2 = l2 ? FcValueListNext (l2) : NULL)
+		{
 		    if (j == n)
+		    {
 			if (l1)
 			    ln = FcValueListPrepend (ln,
 						     FcValueCanonicalize (&l1->value),
 						     FcValueBindingStrong);
 			if (l2)
 			    ll = FcValueListPrepend (ll,
 						     FcValueCanonicalize (&l2->value),
 						     FcValueBindingStrong);
+		    }
 		    else
+		    {
 			if (l1)
 			    ln = FcValueListAppend (ln,
 						    FcValueCanonicalize (&l1->value),
 						    FcValueBindingStrong);
 			if (l2)
 			    ll = FcValueListAppend (ll,
 						    FcValueCanonicalize (&l2->value),
 						    FcValueBindingStrong);
+		    }
+		}
 		FcPatternObjectListAdd (new, fe->object, ln, FcFalse);
 		FcPatternObjectListAdd (new, fel->object, ll, FcFalse);
 		continue;
+	    }
 	    else if (fel)
+	    {
 		FcValueListPtr l1, l2;
 	    copy_lang:
 		l1 = FcValueListDuplicate (FcPatternEltValues (fe));
 		l2 = FcValueListDuplicate (FcPatternEltValues (fel));
 		FcPatternObjectListAdd (new, fe->object, l1, FcFalse);
 		FcPatternObjectListAdd (new, fel->object, l2, FcFalse);
 		continue;
+	    }
+	}
 	else
+	{
 	    if (fel)
 		goto copy_lang;
 	    v = FcValueCanonicalize(&FcPatternEltValues (fe)->value);
+	}
 	FcPatternObjectAdd (new, fe->object, v, FcFalse);
+    }
     for (i = 0; i < pat->num; i++)
+    {
 	pe = &FcPatternElts(pat)[i];
 	fe = FcPatternObjectFindElt (font, pe->object);
 	if (!fe)
+	{
 	    v = FcValueCanonicalize(&FcPatternEltValues(pe)->value);
 	    FcPatternObjectAdd (new, pe->object, v, FcTrue);
+	}
+    }
 @@ -488,65 +620,76 @@ FcFontSetMatchInternal (FcConfig    *con
 		    break;
+		}
+	    }
+	}
+    }
     if (FcDebug () & FC_DBG_MATCH)
+    {
 	printf ("Best score");
 	for (i = 0; i < NUM_MATCH_VALUES; i++)
 	    printf (" %g", bestscore[i]);
 	printf ("\n");
 	FcPatternPrint (best);
+    }
-    if (!best)
+    /* assuming that 'result' is initialized with FcResultNoMatch
      * outside this function */
-	*result = FcResultNoMatch;
+    if (best)
-	return 0;
+	*result = FcResultMatch;
     return best;
+}
 FcPattern *
 FcFontSetMatch (FcConfig    *config,
 		FcFontSet   **sets,
 		int	    nsets,
 		FcPattern   *p,
 		FcResult    *result)
+{
     FcPattern	    *best;
     assert (sets != NULL);
     assert (p != NULL);
     assert (result != NULL);
     *result = FcResultNoMatch;
     if (!config)
+    {
 	config = FcConfigGetCurrent ();
 	if (!config)
 	    return 0;
+    }
     best = FcFontSetMatchInternal (config, sets, nsets, p, result);
     if (best)
 	return FcFontRenderPrepare (config, p, best);
     else
 	return NULL;
+}
 FcPattern *
 FcFontMatch (FcConfig	*config,
 	     FcPattern	*p,
 	     FcResult	*result)
+{
     FcFontSet	*sets[2];
     int		nsets;
     FcPattern   *best;
     assert (p != NULL);
     assert (result != NULL);
     *result = FcResultNoMatch;
     if (!config)
+    {
 	config = FcConfigGetCurrent ();
 	if (!config)
 	    return 0;
+    }
     nsets = 0;
     if (config->fonts[FcSetSystem])
 	sets[nsets++] = config->fonts[FcSetSystem];
     if (config->fonts[FcSetApplication])
 	sets[nsets++] = config->fonts[FcSetApplication];
     best = FcFontSetMatchInternal (config, sets, nsets, p, result);
 @@ -663,56 +806,69 @@ FcFontSetSort (FcConfig	    *config,
     FcFontSet	    *ret;
     FcFontSet	    *s;
     FcSortNode	    *nodes;
     FcSortNode	    **nodeps, **nodep;
     int		    nnodes;
     FcSortNode	    *new;
     int		    set;
     int		    f;
     int		    i;
     int		    nPatternLang;
     FcBool    	    *patternLangSat;
     FcValue	    patternLang;
     assert (sets != NULL);
     assert (p != NULL);
     assert (result != NULL);
     /* There are some implementation that relying on the result of
      * "result" to check if the return value of FcFontSetSort
      * is valid or not.
      * So we should initialize it to the conservative way since
      * this function doesn't return NULL anymore.
      */
     if (result)
 	*result = FcResultNoMatch;
     if (FcDebug () & FC_DBG_MATCH)
+    {
 	printf ("Sort ");
 	FcPatternPrint (p);
+    }
     nnodes = 0;
     for (set = 0; set < nsets; set++)
+    {
 	s = sets[set];
 	if (!s)
 	    continue;
 	nnodes += s->nfont;
+    }
     if (!nnodes)
-	goto bail0;
+	return FcFontSetCreate ();
     for (nPatternLang = 0;
 	 FcPatternGet (p, FC_LANG, nPatternLang, &patternLang) == FcResultMatch;
 	 nPatternLang++)
+	;
     /* freed below */
     nodes = malloc (nnodes * sizeof (FcSortNode) +
 		    nnodes * sizeof (FcSortNode *) +
 		    nPatternLang * sizeof (FcBool));
     if (!nodes)
 	goto bail0;
     nodeps = (FcSortNode **) (nodes + nnodes);
     patternLangSat = (FcBool *) (nodeps + nnodes);
     new = nodes;
     nodep = nodeps;
     for (set = 0; set < nsets; set++)
+    {
 	s = sets[set];
 	if (!s)
 	    continue;
 	for (f = 0; f < s->nfont; f++)
+	{
 	    if (FcDebug () & FC_DBG_MATCHV)
+	    {
 		printf ("Font %d ", f);
 		FcPatternPrint (s->fonts[f]);
 @@ -726,41 +882,41 @@ FcFontSetSort (FcConfig	    *config,
 		for (i = 0; i < NUM_MATCH_VALUES; i++)
+		{
 		    printf (" %g", new->score[i]);
+		}
 		printf ("\n");
+	    }
 	    *nodep = new;
 	    new++;
 	    nodep++;
+	}
+    }
     nnodes = new - nodes;
     qsort (nodeps, nnodes, sizeof (FcSortNode *),
 	   FcSortCompare);
     for (i = 0; i < nPatternLang; i++)
 	patternLangSat[i] = FcFalse;
     for (f = 0; f < nnodes; f++)
+    {
 	FcBool	satisfies = FcFalse;
 	/*
 	 * If this node matches any language, go check
 	 * which ones and satisfy those entries
 	 */
-	if (nodeps[f]->score[MATCH_LANG_INDEX] < 200)
+	if (nodeps[f]->score[MATCH_LANG_INDEX] < 2000)
+	{
 	    for (i = 0; i < nPatternLang; i++)
+	    {
 		FcValue	    nodeLang;
 		if (!patternLangSat[i] &&
 		    FcPatternGet (p, FC_LANG, i, &patternLang) == FcResultMatch &&
 		    FcPatternGet (nodeps[f]->pattern, FC_LANG, 0, &nodeLang) == FcResultMatch)
+		{
 		    double  compare = FcCompareLang (&patternLang, &nodeLang);
 		    if (compare >= 0 && compare < 2)
+		    {
 			if (FcDebug () & FC_DBG_MATCHV)
 @@ -793,46 +949,54 @@ FcFontSetSort (FcConfig	    *config,
     if (!ret)
 	goto bail1;
     if (!FcSortWalk (nodeps, nnodes, ret, csp, trim))
 	goto bail2;
     free (nodes);
     if (FcDebug() & FC_DBG_MATCH)
+    {
 	printf ("First font ");
 	FcPatternPrint (ret->fonts[0]);
+    }
     if (ret->nfont > 0)
 	*result = FcResultMatch;
     return ret;
 bail2:
     FcFontSetDestroy (ret);
 bail1:
     free (nodes);
 bail0:
     return 0;
+}
 FcFontSet *
 FcFontSort (FcConfig	*config,
 	    FcPattern	*p,
 	    FcBool	trim,
 	    FcCharSet	**csp,
 	    FcResult	*result)
+{
     FcFontSet	*sets[2];
     int		nsets;
     assert (p != NULL);
     assert (result != NULL);
     *result = FcResultNoMatch;
     if (!config)
+    {
 	config = FcConfigGetCurrent ();
 	if (!config)
 	    return 0;
+    }
     nsets = 0;
     if (config->fonts[FcSetSystem])
 	sets[nsets++] = config->fonts[FcSetSystem];
     if (config->fonts[FcSetApplication])
 	sets[nsets++] = config->fonts[FcSetApplication];
     return FcFontSetSort (config, sets, nsets, p, trim, csp, result);
+}

 @@ -1,91 +1,92 @@
 /*
  * fontconfig/src/fcname.c
+ *
  * 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
  * the above copyright notice appear in all copies and that both that
  * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Keith Packard not be used in
+ * documentation, and that the name of the author(s) not be used in
  * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Keith Packard makes no
+ * specific, written prior permission.  The authors make no
  * representations about the suitability of this software for any purpose.  It
  * is provided "as is" without express or implied warranty.
+ *
  * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  * 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
  * PERFORMANCE OF THIS SOFTWARE.
  */
 #include "fcint.h"
 #include <ctype.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 /*
  * Please do not change this list, it is used to initialize the object
  * list in this order to match the FC_foo_OBJECT constants. Those
  * constants are written into cache files.
  */
 static const FcObjectType _FcBaseObjectTypes[] = {
     { FC_FAMILY,	FcTypeString, },    /* 1 */
     { FC_FAMILYLANG,	FcTypeString, },
     { FC_STYLE,		FcTypeString, },
     { FC_STYLELANG,	FcTypeString, },
     { FC_FULLNAME,	FcTypeString, },
     { FC_FULLNAMELANG,	FcTypeString, },
     { FC_SLANT,		FcTypeInteger, },
     { FC_WEIGHT,	FcTypeInteger, },
     { FC_WIDTH,		FcTypeInteger, },
     { FC_SIZE,		FcTypeDouble, },
     { FC_ASPECT,	FcTypeDouble, },
     { FC_PIXEL_SIZE,	FcTypeDouble, },
     { FC_SPACING,	FcTypeInteger, },
     { FC_FOUNDRY,	FcTypeString, },
     { FC_ANTIALIAS,	FcTypeBool, },
     { FC_HINT_STYLE,    FcTypeInteger, },
     { FC_HINTING,	FcTypeBool, },
     { FC_VERTICAL_LAYOUT,   FcTypeBool, },
     { FC_AUTOHINT,	FcTypeBool, },
-    { FC_GLOBAL_ADVANCE,    FcTypeBool, },
+    { FC_GLOBAL_ADVANCE,    FcTypeBool, },	/* deprecated */
     { FC_FILE,		FcTypeString, },
     { FC_INDEX,		FcTypeInteger, },
     { FC_RASTERIZER,	FcTypeString, },
     { FC_OUTLINE,	FcTypeBool, },
     { FC_SCALABLE,	FcTypeBool, },
     { FC_DPI,		FcTypeDouble },
     { FC_RGBA,		FcTypeInteger, },
     { FC_SCALE,		FcTypeDouble, },
     { FC_MINSPACE,	FcTypeBool, },
     { FC_CHAR_WIDTH,	FcTypeInteger },
     { FC_CHAR_HEIGHT,	FcTypeInteger },
     { FC_MATRIX,	FcTypeMatrix },
     { FC_CHARSET,	FcTypeCharSet },
     { FC_LANG,		FcTypeLangSet },
     { FC_FONTVERSION,	FcTypeInteger },
     { FC_CAPABILITY,	FcTypeString },
     { FC_FONTFORMAT,	FcTypeString },
     { FC_EMBOLDEN,	FcTypeBool },
     { FC_EMBEDDED_BITMAP,   FcTypeBool },
     { FC_DECORATIVE,	FcTypeBool },
     { FC_LCD_FILTER,	FcTypeInteger }, /* 41 */
     { FC_NAMELANG,	FcTypeString }, /* 42 */
 };
 #define NUM_OBJECT_TYPES    (sizeof _FcBaseObjectTypes / sizeof _FcBaseObjectTypes[0])
 typedef struct _FcObjectTypeList    FcObjectTypeList;
 struct _FcObjectTypeList {
     const FcObjectTypeList  *next;
     const FcObjectType	    *types;
     int			    ntypes;
 };
 static const FcObjectTypeList _FcBaseObjectTypesList = {
 @@ -159,27 +160,27 @@ FcObjectFindByName (const char *object,
 	FcObjectInit ();
     for (p = &FcObjectBuckets[hash%OBJECT_HASH_SIZE]; (b = *p); p = &(b->next))
+    {
 	o = FcObjects + b->id - 1;
         if (b->hash == hash && !strcmp (object, (o->object)))
             return o;
+    }
     if (!insert)
 	return NULL;
     /*
      * Hook it into the hash chain
      */
     b = malloc (sizeof(FcObjectBucket));
     if (!b)
 	return NULL;
     object = (const char *) FcStrCopy ((FcChar8 *) object);
     if (!object) {
 	free (b);
 	return NULL;
+    }
     o = FcObjectInsert (object, -1);
     b->next = NULL;
     b->hash = hash;
     b->id = FcObjectId (o);
     *p = b;
     return o;
+}
 @@ -202,27 +203,27 @@ FcObjectHashInsert (const FcObjectType *
     if (!FcObjectsInited)
 	FcObjectInit ();
     for (p = &FcObjectBuckets[hash%OBJECT_HASH_SIZE]; (b = *p); p = &(b->next))
+    {
 	o = FcObjects + b->id - 1;
         if (b->hash == hash && !strcmp (object->object, o->object))
             return FcFalse;
+    }
     /*
      * Hook it into the hash chain
      */
     b = malloc (sizeof(FcObjectBucket));
     if (!b)
 	return FcFalse;
     if (copy)
+    {
 	o = FcObjectInsert (object->object, object->type);
 	if (!o)
+	{
 	    free (b);
 	    return FcFalse;
+	}
+    }
     else
 	o = (FcObjectType *) object;
     b->next = NULL;
 @@ -286,39 +287,37 @@ FcNameUnregisterObjectTypes (const FcObj
 const FcObjectType *
 FcNameGetObjectType (const char *object)
+{
     return FcObjectFindByName (object, FcFalse);
+}
 FcBool
 FcObjectValidType (FcObject object, FcType type)
+{
     FcObjectType    *t = FcObjectFindById (object);
     if (t) {
 	switch (t->type) {
 	case -1:
 	    return FcTrue;
 	case FcTypeDouble:
 	case FcTypeInteger:
 	    if (type == FcTypeDouble || type == FcTypeInteger)
 		return FcTrue;
 	    break;
 	case FcTypeLangSet:
 	    if (type == FcTypeLangSet || type == FcTypeString)
 		return FcTrue;
 	    break;
 	default:
-	    if (type == t->type)
+	    if (t->type == -1 || type == t->type)
 		return FcTrue;
 	    break;
+	}
 	return FcFalse;
+    }
     return FcTrue;
+}
 FcObject
 FcObjectFromName (const char * name)
+{
     FcObjectType    *o = FcObjectFindByName (name, FcTrue);
 @@ -411,49 +410,49 @@ static const FcConstant _FcBaseConstants
     { (FcChar8 *) "roman",	    "slant",    FC_SLANT_ROMAN, },
     { (FcChar8 *) "italic",	    "slant",    FC_SLANT_ITALIC, },
     { (FcChar8 *) "oblique",	    "slant",    FC_SLANT_OBLIQUE, },
     { (FcChar8 *) "ultracondensed", "width",	FC_WIDTH_ULTRACONDENSED },
     { (FcChar8 *) "extracondensed", "width",	FC_WIDTH_EXTRACONDENSED },
     { (FcChar8 *) "condensed",	    "width",	FC_WIDTH_CONDENSED },
     { (FcChar8 *) "semicondensed", "width",	FC_WIDTH_SEMICONDENSED },
     { (FcChar8 *) "normal",	    "width",	FC_WIDTH_NORMAL },
     { (FcChar8 *) "semiexpanded",   "width",	FC_WIDTH_SEMIEXPANDED },
     { (FcChar8 *) "expanded",	    "width",	FC_WIDTH_EXPANDED },
     { (FcChar8 *) "extraexpanded",  "width",	FC_WIDTH_EXTRAEXPANDED },
     { (FcChar8 *) "ultraexpanded",  "width",	FC_WIDTH_ULTRAEXPANDED },
     { (FcChar8 *) "proportional",   "spacing",  FC_PROPORTIONAL, },
     { (FcChar8 *) "dual",	    "spacing",  FC_DUAL, },
     { (FcChar8 *) "mono",	    "spacing",  FC_MONO, },
     { (FcChar8 *) "charcell",	    "spacing",  FC_CHARCELL, },
     { (FcChar8 *) "unknown",	    "rgba",	    FC_RGBA_UNKNOWN },
     { (FcChar8 *) "rgb",	    "rgba",	    FC_RGBA_RGB, },
     { (FcChar8 *) "bgr",	    "rgba",	    FC_RGBA_BGR, },
     { (FcChar8 *) "vrgb",	    "rgba",	    FC_RGBA_VRGB },
     { (FcChar8 *) "vbgr",	    "rgba",	    FC_RGBA_VBGR },
     { (FcChar8 *) "none",	    "rgba",	    FC_RGBA_NONE },
     { (FcChar8 *) "hintnone",	    "hintstyle",   FC_HINT_NONE },
     { (FcChar8 *) "hintslight",	    "hintstyle",   FC_HINT_SLIGHT },
     { (FcChar8 *) "hintmedium",	    "hintstyle",   FC_HINT_MEDIUM },
     { (FcChar8 *) "hintfull",	    "hintstyle",   FC_HINT_FULL },
     { (FcChar8 *) "antialias",	    "antialias",    FcTrue },
     { (FcChar8 *) "hinting",	    "hinting",	    FcTrue },
     { (FcChar8 *) "verticallayout", "verticallayout",	FcTrue },
     { (FcChar8 *) "autohint",	    "autohint",	    FcTrue },
-    { (FcChar8 *) "globaladvance",  "globaladvance",	FcTrue },
+    { (FcChar8 *) "globaladvance",  "globaladvance",	FcTrue }, /* deprecated */
     { (FcChar8 *) "outline",	    "outline",	    FcTrue },
     { (FcChar8 *) "scalable",	    "scalable",	    FcTrue },
     { (FcChar8 *) "minspace",	    "minspace",	    FcTrue },
     { (FcChar8 *) "embolden",	    "embolden",	    FcTrue },
     { (FcChar8 *) "embeddedbitmap", "embeddedbitmap",	FcTrue },
     { (FcChar8 *) "decorative",	    "decorative",   FcTrue },
     { (FcChar8 *) "lcdnone",	    "lcdfilter",    FC_LCD_NONE },
     { (FcChar8 *) "lcddefault",	    "lcdfilter",    FC_LCD_DEFAULT },
     { (FcChar8 *) "lcdlight",	    "lcdfilter",    FC_LCD_LIGHT },
     { (FcChar8 *) "lcdlegacy",	    "lcdfilter",    FC_LCD_LEGACY },
 };
 #define NUM_FC_CONSTANTS   (sizeof _FcBaseConstants/sizeof _FcBaseConstants[0])
 @@ -485,58 +484,58 @@ FcNameRegisterConstants (const FcConstan
     FcMemAlloc (FC_MEM_CONSTANT, sizeof (FcConstantList));
     l->consts = consts;
     l->nconsts = nconsts;
     l->next = _FcConstants;
     _FcConstants = l;
     return FcTrue;
+}
 FcBool
 FcNameUnregisterConstants (const FcConstant *consts, int nconsts)
+{
     const FcConstantList	*l, **prev;
     for (prev = &_FcConstants;
 	 (l = *prev);
 	 prev = (const FcConstantList **) &(l->next))
+    {
 	if (l->consts == consts && l->nconsts == nconsts)
+	{
 	    *prev = l->next;
 	    FcMemFree (FC_MEM_CONSTANT, sizeof (FcConstantList));
 	    free ((void *) l);
 	    return FcTrue;
+	}
+    }
     return FcFalse;
+}
 const FcConstant *
-FcNameGetConstant (FcChar8 *string)
+FcNameGetConstant (const FcChar8 *string)
+{
     const FcConstantList    *l;
     int			    i;
     for (l = _FcConstants; l; l = l->next)
+    {
 	for (i = 0; i < l->nconsts; i++)
 	    if (!FcStrCmpIgnoreCase (string, l->consts[i].name))
 		return &l->consts[i];
+    }
     return 0;
+}
 FcBool
-FcNameConstant (FcChar8 *string, int *result)
+FcNameConstant (const FcChar8 *string, int *result)
+{
     const FcConstant	*c;
     if ((c = FcNameGetConstant(string)))
+    {
 	*result = c->value;
 	return FcTrue;
+    }
     return FcFalse;
+}
 FcBool
 FcNameBool (const FcChar8 *v, FcBool *result)
 @@ -564,73 +563,74 @@ FcNameBool (const FcChar8 *v, FcBool *re
 	    *result = FcTrue;
 	    return FcTrue;
+	}
 	if (c1 == 'f')
+	{
 	    *result = FcFalse;
 	    return FcTrue;
+	}
+    }
     return FcFalse;
+}
 static FcValue
-FcNameConvert (FcType type, FcChar8 *string, FcMatrix *m)
+FcNameConvert (FcType type, FcChar8 *string)
+{
     FcValue	v;
     FcMatrix	m;
     v.type = type;
     switch (v.type) {
     case FcTypeInteger:
 	if (!FcNameConstant (string, &v.u.i))
 	    v.u.i = atoi ((char *) string);
 	break;
     case FcTypeString:
-	v.u.s = FcStrStaticName(string);
+	v.u.s = FcSharedStr (string);
 	if (!v.u.s)
 	    v.type = FcTypeVoid;
 	break;
     case FcTypeBool:
 	if (!FcNameBool (string, &v.u.b))
 	    v.u.b = FcFalse;
 	break;
     case FcTypeDouble:
 	v.u.d = strtod ((char *) string, 0);
 	break;
     case FcTypeMatrix:
-	v.u.m = m;
+	sscanf ((char *) string, "%lg %lg %lg %lg", &m.xx, &m.xy, &m.yx, &m.yy);
-	sscanf ((char *) string, "%lg %lg %lg %lg", &m->xx, &m->xy, &m->yx, &m->yy);
+	v.u.m = FcMatrixCopy (&m);
 	break;
     case FcTypeCharSet:
 	v.u.c = FcNameParseCharSet (string);
 	if (!v.u.c)
 	    v.type = FcTypeVoid;
 	break;
     case FcTypeLangSet:
 	v.u.l = FcNameParseLangSet (string);
 	if (!v.u.l)
 	    v.type = FcTypeVoid;
 	break;
     default:
 	break;
+    }
     return v;
+}
 static const FcChar8 *
 FcNameFindNext (const FcChar8 *cur, const char *delim, FcChar8 *save, FcChar8 *last)
+{
     FcChar8    c;
     while ((c = *cur))
+    {
 	if (c == '\\')
+	{
 	    ++cur;
 	    if (!(c = *cur))
 		break;
+	}
 	else if (strchr (delim, c))
 	    break;
 	++cur;
 	*save++ = c;
+    }
 @@ -640,27 +640,26 @@ FcNameFindNext (const FcChar8 *cur, cons
 	cur++;
     return cur;
+}
 FcPattern *
 FcNameParse (const FcChar8 *name)
+{
     FcChar8		*save;
     FcPattern		*pat;
     double		d;
     FcChar8		*e;
     FcChar8		delim;
     FcValue		v;
     FcMatrix		m;
     const FcObjectType	*t;
     const FcConstant	*c;
     /* freed below */
     save = malloc (strlen ((char *) name) + 1);
     if (!save)
 	goto bail0;
     pat = FcPatternCreate ();
     if (!pat)
 	goto bail1;
     for (;;)
+    {
 @@ -691,51 +690,33 @@ FcNameParse (const FcChar8 *name)
     while (delim == ':')
+    {
 	name = FcNameFindNext (name, "=_:", save, &delim);
 	if (save[0])
+	{
 	    if (delim == '=' || delim == '_')
+	    {
 		t = FcNameGetObjectType ((char *) save);
 		for (;;)
+		{
 		    name = FcNameFindNext (name, ":,", save, &delim);
 		    if (t)
+		    {
-			v = FcNameConvert (t->type, save, &m);
+			v = FcNameConvert (t->type, save);
 			if (!FcPatternAdd (pat, t->object, v, FcTrue))
+			{
-			    switch (v.type) {
+			    FcValueDestroy (v);
 			    case FcTypeCharSet:
 				FcCharSetDestroy ((FcCharSet *) v.u.c);
 				break;
 			    case FcTypeLangSet:
 				FcLangSetDestroy ((FcLangSet *) v.u.l);
 				break;
 			    default:
 				break;
 			    goto bail2;
+			}
-			switch (v.type) {
+			FcValueDestroy (v);
 			case FcTypeCharSet:
 			    FcCharSetDestroy ((FcCharSet *) v.u.c);
 			    break;
 			case FcTypeLangSet:
 			    FcLangSetDestroy ((FcLangSet *) v.u.l);
 			    break;
 			default:
 			    break;
+		    }
 		    if (delim != ',')
 			break;
+		}
+	    }
 	    else
+	    {
 		if ((c = FcNameGetConstant (save)))
+		{
 		    t = FcNameGetObjectType ((char *) c->object);
 		    switch (t->type) {
 		    case FcTypeInteger:
 		    case FcTypeDouble:
 @@ -755,67 +736,67 @@ FcNameParse (const FcChar8 *name)
+    }
     free (save);
     return pat;
 bail2:
     FcPatternDestroy (pat);
 bail1:
     free (save);
 bail0:
     return 0;
+}
 static FcBool
 FcNameUnparseString (FcStrBuf	    *buf,
 		     const FcChar8  *string,
 		     const FcChar8  *escape)
+{
     FcChar8 c;
     while ((c = *string++))
+    {
 	if (escape && strchr ((char *) escape, (char) c))
+	{
 	    if (!FcStrBufChar (buf, escape[0]))
 		return FcFalse;
+	}
 	if (!FcStrBufChar (buf, c))
 	    return FcFalse;
+    }
     return FcTrue;
+}
 FcBool
 FcNameUnparseValue (FcStrBuf	*buf,
 		    FcValue	*v0,
 		    FcChar8	*escape)
+{
     FcChar8	temp[1024];
     FcValue v = FcValueCanonicalize(v0);
     switch (v.type) {
     case FcTypeVoid:
 	return FcTrue;
     case FcTypeInteger:
 	sprintf ((char *) temp, "%d", v.u.i);
 	return FcNameUnparseString (buf, temp, 0);
     case FcTypeDouble:
 	sprintf ((char *) temp, "%g", v.u.d);
 	return FcNameUnparseString (buf, temp, 0);
     case FcTypeString:
 	return FcNameUnparseString (buf, v.u.s, escape);
     case FcTypeBool:
 	return FcNameUnparseString (buf, v.u.b ? (FcChar8 *) "True" : (FcChar8 *) "False", 0);
     case FcTypeMatrix:
 	sprintf ((char *) temp, "%g %g %g %g",
 		 v.u.m->xx, v.u.m->xy, v.u.m->yx, v.u.m->yy);
 	return FcNameUnparseString (buf, temp, 0);
     case FcTypeCharSet:
 	return FcNameUnparseCharSet (buf, v.u.c);
     case FcTypeLangSet:
 	return FcNameUnparseLangSet (buf, v.u.l);
     case FcTypeFTFace:
 	return FcTrue;
+    }
     return FcFalse;
+}
 FcBool
 @@ -863,41 +844,40 @@ FcNameUnparseEscaped (FcPattern *pat, Fc
     e = FcPatternObjectFindElt (pat, FC_SIZE_OBJECT);
     if (e)
+    {
 	if (!FcNameUnparseString (&buf, (FcChar8 *) "-", 0))
 	    goto bail0;
 	if (!FcNameUnparseValueList (&buf, FcPatternEltValues(e), escape ? (FcChar8 *) FC_ESCAPE_FIXED : 0))
 	    goto bail0;
+    }
     for (l = _FcObjectTypes; l; l = l->next)
+    {
 	for (i = 0; i < l->ntypes; i++)
+	{
 	    o = &l->types[i];
 	    if (!strcmp (o->object, FC_FAMILY) ||
-		!strcmp (o->object, FC_SIZE) ||
+		!strcmp (o->object, FC_SIZE))
 		!strcmp (o->object, FC_FILE))
 		continue;
 	    e = FcPatternObjectFindElt (pat, FcObjectFromName (o->object));
 	    if (e)
+	    {
 		if (!FcNameUnparseString (&buf, (FcChar8 *) ":", 0))
 		    goto bail0;
 		if (!FcNameUnparseString (&buf, (FcChar8 *) o->object, escape ? (FcChar8 *) FC_ESCAPE_VARIABLE : 0))
 		    goto bail0;
 		if (!FcNameUnparseString (&buf, (FcChar8 *) "=", 0))
 		    goto bail0;
 		if (!FcNameUnparseValueList (&buf, FcPatternEltValues(e), escape ?
 					     (FcChar8 *) FC_ESCAPE_VARIABLE : 0))
 		    goto bail0;
+	    }
+	}
+    }
     return FcStrBufDone (&buf);
 bail0:
     FcStrBufDestroy (&buf);
     return 0;
+}
 #define __fcname__
 #include "fcaliastail.h"
 #undef __fcname__

 @@ -1,25 +1,25 @@
 /*
  * fontconfig/src/fcint.h
+ *
  * 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
  * the above copyright notice appear in all copies and that both that
  * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Keith Packard not be used in
+ * documentation, and that the name of the author(s) not be used in
  * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Keith Packard makes no
+ * specific, written prior permission.  The authors make no
  * representations about the suitability of this software for any purpose.  It
  * is provided "as is" without express or implied warranty.
+ *
  * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  * 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
  * PERFORMANCE OF THIS SOFTWARE.
  */
 #ifndef _FCINT_H_
 @@ -60,29 +60,43 @@
 #include <stddef.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <time.h>
 #include <fontconfig/fontconfig.h>
 #include <fontconfig/fcprivate.h>
 #include "fcdeprecate.h"
 #ifndef FC_CONFIG_PATH
 #define FC_CONFIG_PATH "fonts.conf"
 #endif
 #ifdef _WIN32
-#define FC_SEARCH_PATH_SEPARATOR ';'
+#  ifndef _WIN32_WINNT
 #    define _WIN32_WINNT 0x0500
 #  endif
 #  define WIN32_LEAN_AND_MEAN
 #  define STRICT
 #  include <windows.h>
 typedef UINT (WINAPI *pfnGetSystemWindowsDirectory)(LPSTR, UINT);
 typedef HRESULT (WINAPI *pfnSHGetFolderPathA)(HWND, int, HANDLE, DWORD, LPSTR);
 extern pfnGetSystemWindowsDirectory pGetSystemWindowsDirectory;
 extern pfnSHGetFolderPathA pSHGetFolderPathA;
 #  define FC_SEARCH_PATH_SEPARATOR ';'
 #  define FC_DIR_SEPARATOR         '\\'
 #  define FC_DIR_SEPARATOR_S       "\\"
 #else
-#define FC_SEARCH_PATH_SEPARATOR ':'
+#  define FC_SEARCH_PATH_SEPARATOR ':'
 #  define FC_DIR_SEPARATOR         '/'
 #  define FC_DIR_SEPARATOR_S       "/"
 #endif
 #define FC_DBG_MATCH	1
 #define FC_DBG_MATCHV	2
 #define FC_DBG_EDIT	4
 #define FC_DBG_FONTSET	8
 #define FC_DBG_CACHE	16
 #define FC_DBG_CACHEV	32
 #define FC_DBG_PARSE	64
 #define FC_DBG_SCAN	128
 #define FC_DBG_SCANV	256
 #define FC_DBG_MEMORY	512
 #define FC_DBG_CONFIG	1024
 @@ -108,54 +122,58 @@
 #define FC_MEM_LANGSET	    16
 #define FC_MEM_ATOMIC	    17
 #define FC_MEM_BLANKS	    18
 #define FC_MEM_CACHE	    19
 #define FC_MEM_STRBUF	    20
 #define FC_MEM_SUBST	    21
 #define FC_MEM_OBJECTTYPE   22
 #define FC_MEM_CONSTANT	    23
 #define FC_MEM_TEST	    24
 #define FC_MEM_EXPR	    25
 #define FC_MEM_VSTACK	    26
 #define FC_MEM_ATTR	    27
 #define FC_MEM_PSTACK	    28
-#define FC_MEM_STATICSTR    29
+#define FC_MEM_SHAREDSTR    29
 #define FC_MEM_NUM	    30
 #define _FC_ASSERT_STATIC1(_line, _cond) typedef int _static_assert_on_line_##_line##_failed[(_cond)?1:-1]
 #define _FC_ASSERT_STATIC0(_line, _cond) _FC_ASSERT_STATIC1 (_line, (_cond))
 #define FC_ASSERT_STATIC(_cond) _FC_ASSERT_STATIC0 (__LINE__, (_cond))
 #define FC_MIN(a,b) ((a) < (b) ? (a) : (b))
 #define FC_MAX(a,b) ((a) > (b) ? (a) : (b))
 #define FC_ABS(a)   ((a) < 0 ? -(a) : (a))
 /* slim_internal.h */
 #if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)) && defined(__ELF__) && !defined(__sun)
 #define FcPrivate		__attribute__((__visibility__("hidden")))
 #define HAVE_GNUC_ATTRIBUTE 1
 #include "fcalias.h"
 #elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550)
 #define FcPrivate		__hidden
 #else /* not gcc >= 3.3 and not Sun Studio >= 8 */
 #define FcPrivate
 #endif
 typedef enum _FcValueBinding {
     FcValueBindingWeak, FcValueBindingStrong, FcValueBindingSame
 } FcValueBinding;
 /*
  * Serialized data structures use only offsets instead of pointers
  * A low bit of 1 indicates an offset.
  */
 /* Is the provided pointer actually an offset? */
 #define FcIsEncodedOffset(p)	((((intptr_t) (p)) & 1) != 0)
 /* Encode offset in a pointer of type t */
 #define FcOffsetEncode(o,t)	((t *) ((o) | 1))
 /* Decode a pointer into an offset */
 #define FcOffsetDecode(p)	(((intptr_t) (p)) & ~1)
 /* Compute pointer offset */
 #define FcPtrToOffset(b,p)	((intptr_t) (p) - (intptr_t) (b))
 /* Given base address, offset and type, return a pointer */
 @@ -186,33 +204,33 @@ typedef enum _FcValueBinding {
 #define FcValueString(v)	FcPointerMember(v,u.s,FcChar8)
 #define FcValueCharSet(v)	FcPointerMember(v,u.c,const FcCharSet)
 #define FcValueLangSet(v)	FcPointerMember(v,u.l,const FcLangSet)
 typedef struct _FcValueList *FcValueListPtr;
 typedef struct _FcValueList {
     struct _FcValueList	*next;
     FcValue		value;
     FcValueBinding	binding;
 } FcValueList;
 #define FcValueListNext(vl)	FcPointerMember(vl,next,FcValueList)
 typedef int FcObject;
 typedef struct _FcPatternElt *FcPatternEltPtr;
 /*
  * Pattern elts are stuck in a structure connected to the pattern,
  * so they get moved around when the pattern is resized. Hence, the
  * values field must be a pointer/offset instead of just an offset
  */
 typedef struct _FcPatternElt {
     FcObject		object;
     FcValueList		*values;
 } FcPatternElt;
 #define FcPatternEltValues(pe)	FcPointerMember(pe,values,FcValueList)
 struct _FcPattern {
     int		    num;
     int		    size;
 @@ -221,64 +239,73 @@ struct _FcPattern {
 };
 #define FcPatternElts(p)	FcOffsetMember(p,elts_offset,FcPatternElt)
 #define FcFontSetFonts(fs)	FcPointerMember(fs,fonts,FcPattern *)
 #define FcFontSetFont(fs,i)	(FcIsEncodedOffset((fs)->fonts) ? \
 				 FcEncodedOffsetToPtr(fs, \
 						      FcFontSetFonts(fs)[i], \
 						      FcPattern) : \
 				 fs->fonts[i])
 typedef enum _FcOp {
-    FcOpInteger, FcOpDouble, FcOpString, FcOpMatrix, FcOpBool, FcOpCharSet,
+    FcOpInteger, FcOpDouble, FcOpString, FcOpMatrix, FcOpRange, FcOpBool, FcOpCharSet, FcOpLangSet,
     FcOpNil,
     FcOpField, FcOpConst,
     FcOpAssign, FcOpAssignReplace,
     FcOpPrependFirst, FcOpPrepend, FcOpAppend, FcOpAppendLast,
     FcOpQuest,
     FcOpOr, FcOpAnd, FcOpEqual, FcOpNotEqual,
     FcOpContains, FcOpListing, FcOpNotContains,
     FcOpLess, FcOpLessEqual, FcOpMore, FcOpMoreEqual,
     FcOpPlus, FcOpMinus, FcOpTimes, FcOpDivide,
     FcOpNot, FcOpComma, FcOpFloor, FcOpCeil, FcOpRound, FcOpTrunc,
     FcOpInvalid
 } FcOp;
 typedef enum _FcOpFlags {
 	FcOpFlagIgnoreBlanks = 1 << 0
 } FcOpFlags;
 #define FC_OP_GET_OP(_x_)	((_x_) & 0xffff)
 #define FC_OP_GET_FLAGS(_x_)	(((_x_) & 0xffff0000) >> 16)
 #define FC_OP(_x_,_f_)		(FC_OP_GET_OP (_x_) | ((_f_) << 16))
 typedef struct _FcExpr {
     FcOp   op;
     union {
 	int	    ival;
 	double	    dval;
-	FcChar8	    *sval;
+	const FcChar8	    *sval;
 	FcMatrix    *mval;
 	FcBool	    bval;
 	FcCharSet   *cval;
 	FcLangSet   *lval;
 	FcObject    object;
-	FcChar8	    *constant;
+	const FcChar8	    *constant;
 	struct {
 	    struct _FcExpr *left, *right;
 	} tree;
     } u;
 } FcExpr;
 typedef struct _FcExprPage FcExprPage;
 struct _FcExprPage {
   FcExprPage *next_page;
   FcExpr *next;
   FcExpr exprs[(1024 - 2/* two pointers */ - 2/* malloc overhead */) * sizeof (void *) / sizeof (FcExpr)];
-  FcExpr end[0];
+  FcExpr end[FLEXIBLE_ARRAY_MEMBER];
 };
 typedef enum _FcQual {
     FcQualAny, FcQualAll, FcQualFirst, FcQualNotFirst
 } FcQual;
 #define FcMatchDefault	((FcMatchKind) -1)
 typedef struct _FcTest {
     struct _FcTest	*next;
     FcMatchKind		kind;
     FcQual		qual;
     FcObject		object;
 @@ -338,27 +365,27 @@ typedef struct _FcStrBuf {
     int	    len;
     int	    size;
     FcChar8 buf_static[16 * sizeof (void *)];
 } FcStrBuf;
 struct _FcCache {
     int		magic;              /* FC_CACHE_MAGIC_MMAP or FC_CACHE_ALLOC */
     int		version;	    /* FC_CACHE_CONTENT_VERSION */
     intptr_t	size;		    /* size of file */
     intptr_t	dir;		    /* offset to dir name */
     intptr_t	dirs;		    /* offset to subdirs */
     int		dirs_count;	    /* number of subdir strings */
     intptr_t	set;		    /* offset to font set */
-    int		mtime;		    /* low bits of directory mtime */
+    int		checksum;	    /* checksum of directory state */
 };
 #undef FcCacheDir
 #undef FcCacheSubdir
 #define FcCacheDir(c)	FcOffsetMember(c,dir,FcChar8)
 #define FcCacheDirs(c)	FcOffsetMember(c,dirs,intptr_t)
 #define FcCacheSet(c)	FcOffsetMember(c,set,FcFontSet)
 #define FcCacheSubdir(c,i)  FcOffsetToPtr (FcCacheDirs(c),\
 					   FcCacheDirs(c)[i], \
 					   FcChar8)
 /*
  * Used while constructing a directory cache object
 @@ -378,48 +405,48 @@ typedef struct _FcSerializeBucket {
     struct _FcSerializeBucket *next;
     const void	*object;
     intptr_t	offset;
 } FcSerializeBucket;
 typedef struct _FcCharSetFreezer FcCharSetFreezer;
 typedef struct _FcSerialize {
     intptr_t		size;
     FcCharSetFreezer	*cs_freezer;
     void		*linear;
     FcSerializeBucket	*buckets[FC_SERIALIZE_HASH_SIZE];
 } FcSerialize;
 /*
  * To map adobe glyph names to unicode values, a precomputed hash
  * table is used
  */
 typedef struct _FcGlyphName {
     FcChar32	ucs;		/* unicode value */
     FcChar8	name[1];	/* name extends beyond struct */
 } FcGlyphName;
 /*
  * To perform case-insensitive string comparisons, a table
  * is used which holds three different kinds of folding data.
+ *
  * The first is a range of upper case values mapping to a range
  * of their lower case equivalents.  Within each range, the offset
  * between upper and lower case is constant.
+ *
  * The second is a range of upper case values which are interleaved
  * with their lower case equivalents.
+ *
  * The third is a set of raw unicode values mapping to a list
  * of unicode values for comparison purposes.  This allows conversion
  * of ß to "ss" so that SS, ss and ß all match.  A separate array
  * holds the list of unicode values for each entry.
+ *
  * These are packed into a single table.  Using a binary search,
  * the appropriate entry can be located.
  */
 #define FC_CASE_FOLD_RANGE	    0
 #define FC_CASE_FOLD_EVEN_ODD	    1
 #define FC_CASE_FOLD_FULL	    2
 @@ -453,27 +480,27 @@ struct _FcConfig {
     /*
      * File names loaded from the configuration -- saved here as the
      * cache file must be consulted before the directories are scanned,
      * and those directives may occur in any order
      */
     FcStrSet	*configDirs;	    /* directories to scan for fonts */
     /*
      * Set of allowed blank chars -- used to
      * trim fonts of bogus glyphs
      */
     FcBlanks	*blanks;
     /*
      * List of directories containing fonts,
      * built by recursively scanning the set
      * of configured directories
      */
     FcStrSet	*fontDirs;
     /*
      * List of directories containing cache files.
      */
     FcStrSet	*cacheDirs;
     /*
      * Names of all of the configuration files used
      * to create this configuration
      */
     FcStrSet	*configFiles;	    /* config files loaded */
     /*
 @@ -502,70 +529,89 @@ struct _FcConfig {
     /*
      * Fontconfig can periodically rescan the system configuration
      * and font directories.  This rescanning occurs when font
      * listing requests are made, but no more often than rescanInterval
      * seconds apart.
      */
     time_t	rescanTime;	    /* last time information was scanned */
     int		rescanInterval;	    /* interval between scans */
     int		ref;                /* reference count */
     FcExprPage *expr_pool;	    /* pool of FcExpr's */
 };
 extern FcPrivate FcConfig	*_fcConfig;
 typedef struct _FcFileTime {
     time_t  time;
     FcBool  set;
 } FcFileTime;
 typedef struct _FcCharMap FcCharMap;
 typedef struct _FcRange	    FcRange;
 struct _FcRange {
     FcChar32 begin;
     FcChar32 end;
 };
 typedef struct _FcStatFS    FcStatFS;
 struct _FcStatFS {
     FcBool is_remote_fs;
     FcBool is_mtime_broken;
 };
 /* fcblanks.c */
 /* fccache.c */
 FcPrivate FcCache *
 FcDirCacheScan (const FcChar8 *dir, FcConfig *config);
 FcPrivate FcCache *
 FcDirCacheBuild (FcFontSet *set, const FcChar8 *dir, struct stat *dir_stat, FcStrSet *dirs);
 FcPrivate FcBool
 FcDirCacheWrite (FcCache *cache, FcConfig *config);
 FcPrivate FcBool
 FcDirCacheCreateTagFile (const FcChar8 *cache_dir);
 FcPrivate void
 FcCacheObjectReference (void *object);
 FcPrivate void
 FcCacheObjectDereference (void *object);
 FcPrivate void
 FcCacheFini (void);
 FcPrivate void
 FcDirCacheReference (FcCache *cache, int nref);
 #ifdef _WIN32
 FcPrivate int
 FcStat (const char *file, struct stat *statb);
 #else
 #define FcStat stat
 #endif
 /* fccfg.c */
 FcPrivate FcChar8 *
 FcConfigXdgCacheHome (void);
 FcPrivate FcChar8 *
 FcConfigXdgConfigHome (void);
 FcPrivate FcChar8 *
 FcConfigXdgDataHome (void);
 FcPrivate FcExpr *
 FcConfigAllocExpr (FcConfig *config);
 FcPrivate FcBool
 FcConfigAddConfigDir (FcConfig	    *config,
 		      const FcChar8 *d);
 FcPrivate FcBool
 FcConfigAddFontDir (FcConfig	    *config,
 		    const FcChar8   *d);
 FcPrivate FcBool
 FcConfigAddDir (FcConfig	*config,
 @@ -611,33 +657,33 @@ FcConfigAcceptFilename (FcConfig	*config
 FcPrivate FcBool
 FcConfigPatternsAdd (FcConfig	*config,
 		     FcPattern	*pattern,
 		     FcBool	accept);
 FcPrivate FcBool
 FcConfigAcceptFont (FcConfig	    *config,
 		    const FcPattern *font);
 FcPrivate FcFileTime
 FcConfigModifiedTime (FcConfig *config);
 FcPrivate FcBool
 FcConfigAddCache (FcConfig *config, FcCache *cache,
 		  FcSetName set, FcStrSet *dirSet);
 /* fcserialize.c */
 FcPrivate intptr_t
 FcAlignSize (intptr_t size);
 FcPrivate FcSerialize *
 FcSerializeCreate (void);
 FcPrivate void
 FcSerializeDestroy (FcSerialize *serialize);
 FcPrivate FcBool
 FcSerializeAlloc (FcSerialize *serialize, const void *object, int size);
 FcPrivate intptr_t
 FcSerializeReserve (FcSerialize *serialize, int size);
 FcPrivate intptr_t
 @@ -685,49 +731,55 @@ FcPrivate FcCharLeaf *
 FcCharSetFindLeafCreate (FcCharSet *fcs, FcChar32 ucs4);
 FcPrivate FcBool
 FcCharSetSerializeAlloc(FcSerialize *serialize, const FcCharSet *cs);
 FcPrivate FcCharSet *
 FcCharSetSerialize(FcSerialize *serialize, const FcCharSet *cs);
 FcPrivate FcChar16 *
 FcCharSetGetNumbers(const FcCharSet *c);
 /* fcdbg.c */
 FcPrivate void
-FcValueListPrint (const FcValueListPtr l);
+FcValuePrintWithPosition (const FcValue v, FcBool show_pos_mark);
 FcPrivate void
 FcValueListPrintWithPosition (FcValueListPtr l, const FcValueListPtr pos);
 FcPrivate void
 FcValueListPrint (FcValueListPtr l);
 FcPrivate void
 FcLangSetPrint (const FcLangSet *ls);
 FcPrivate void
 FcOpPrint (FcOp op);
 FcPrivate void
 FcTestPrint (const FcTest *test);
 FcPrivate void
 FcExprPrint (const FcExpr *expr);
 FcPrivate void
 FcEditPrint (const FcEdit *edit);
 FcPrivate void
 FcSubstPrint (const FcSubst *subst);
 FcPrivate void
 FcCharSetPrint (const FcCharSet *c);
 extern FcPrivate int FcDebugVal;
 #define FcDebug() (FcDebugVal)
 FcPrivate void
 FcInitDebug (void);
 /* fcdefault.c */
 FcPrivate FcChar8 *
 FcGetDefaultLang (void);
 /* fcdir.c */
 @@ -768,32 +820,35 @@ FcEditDestroy (FcEdit *e);
 /* fcinit.c */
 FcPrivate void
 FcMemReport (void);
 FcPrivate void
 FcMemAlloc (int kind, int size);
 FcPrivate void
 FcMemFree (int kind, int size);
 /* fclang.c */
 FcPrivate FcLangSet *
 FcFreeTypeLangSet (const FcCharSet  *charset,
 		   const FcChar8    *exclusiveLang);
 FcPrivate FcChar8 *
 FcLangNormalize (const FcChar8 *lang);
 FcPrivate FcLangResult
 FcLangCompare (const FcChar8 *s1, const FcChar8 *s2);
 FcPrivate FcLangSet *
 FcLangSetPromote (const FcChar8 *lang);
 FcPrivate FcLangSet *
 FcNameParseLangSet (const FcChar8 *string);
 FcPrivate FcBool
 FcNameUnparseLangSet (FcStrBuf *buf, const FcLangSet *ls);
 FcPrivate FcChar8 *
 FcNameUnparseEscaped (FcPattern *pat, FcBool escape);
 /* fclist.c */
 @@ -820,49 +875,50 @@ FcListPatternMatchAny (const FcPattern *
 #define FC_SLANT_OBJECT		7
 #define FC_WEIGHT_OBJECT	8
 #define FC_WIDTH_OBJECT		9
 #define FC_SIZE_OBJECT		10
 #define FC_ASPECT_OBJECT	11
 #define FC_PIXEL_SIZE_OBJECT	12
 #define FC_SPACING_OBJECT	13
 #define FC_FOUNDRY_OBJECT	14
 #define FC_ANTIALIAS_OBJECT	15
 #define FC_HINT_STYLE_OBJECT	16
 #define FC_HINTING_OBJECT	17
 #define FC_VERTICAL_LAYOUT_OBJECT	18
 #define FC_AUTOHINT_OBJECT	19
-#define FC_GLOBAL_ADVANCE_OBJECT	20
+#define FC_GLOBAL_ADVANCE_OBJECT	20	/* deprecated */
 #define FC_FILE_OBJECT		21
 #define FC_INDEX_OBJECT		22
 #define FC_RASTERIZER_OBJECT	23
 #define FC_OUTLINE_OBJECT	24
 #define FC_SCALABLE_OBJECT	25
 #define FC_DPI_OBJECT		26
 #define FC_RGBA_OBJECT		27
 #define FC_SCALE_OBJECT		28
 #define FC_MINSPACE_OBJECT	29
 #define FC_CHAR_WIDTH_OBJECT	30
 #define FC_CHAR_HEIGHT_OBJECT	31
 #define FC_MATRIX_OBJECT	32
 #define FC_CHARSET_OBJECT	33
 #define FC_LANG_OBJECT		34
 #define FC_FONTVERSION_OBJECT	35
 #define FC_CAPABILITY_OBJECT	36
 #define FC_FONTFORMAT_OBJECT	37
 #define FC_EMBOLDEN_OBJECT	38
 #define FC_EMBEDDED_BITMAP_OBJECT	39
 #define FC_DECORATIVE_OBJECT	40
 #define FC_LCD_FILTER_OBJECT	41
-#define FC_MAX_BASE_OBJECT	FC_LCD_FILTER_OBJECT
+#define FC_NAMELANG_OBJECT	42
 #define FC_MAX_BASE_OBJECT	FC_NAMELANG_OBJECT
 FcPrivate FcBool
 FcNameBool (const FcChar8 *v, FcBool *result);
 FcPrivate FcBool
 FcObjectValidType (FcObject object, FcType type);
 FcPrivate FcObject
 FcObjectFromName (const char * name);
 FcPrivate const char *
 FcObjectName (FcObject object);
 @@ -872,51 +928,73 @@ FcObjectGetSet (void);
 FcPrivate FcBool
 FcObjectInit (void);
 FcPrivate void
 FcObjectFini (void);
 #define FcObjectCompare(a, b)	((int) a - (int) b)
 /* fcpat.c */
 FcPrivate FcValue
 FcValueCanonicalize (const FcValue *v);
 FcPrivate FcValueListPtr
 FcValueListCreate (void);
 FcPrivate void
 FcValueListDestroy (FcValueListPtr l);
 FcPrivate FcValueListPtr
 FcValueListPrepend (FcValueListPtr vallist,
 		    FcValue        value,
 		    FcValueBinding binding);
 FcPrivate FcValueListPtr
 FcValueListAppend (FcValueListPtr vallist,
 		   FcValue        value,
 		   FcValueBinding binding);
 FcPrivate FcValueListPtr
 FcValueListDuplicate(FcValueListPtr orig);
 FcPrivate FcPatternElt *
 FcPatternObjectFindElt (const FcPattern *p, FcObject object);
 FcPrivate FcPatternElt *
 FcPatternObjectInsertElt (FcPattern *p, FcObject object);
 FcPrivate FcBool
 FcPatternObjectListAdd (FcPattern	*p,
 			FcObject	object,
 			FcValueListPtr	list,
 			FcBool		append);
 FcPrivate FcBool
 FcPatternObjectAddWithBinding  (FcPattern	*p,
 				FcObject	object,
 				FcValue		value,
 				FcValueBinding  binding,
 				FcBool		append);
 FcPrivate FcBool
 FcPatternObjectAdd (FcPattern *p, FcObject object, FcValue value, FcBool append);
 FcPrivate FcBool
 FcPatternObjectAddWeak (FcPattern *p, FcObject object, FcValue value, FcBool append);
 FcPrivate FcResult
 FcPatternObjectGet (const FcPattern *p, FcObject object, int id, FcValue *v);
 FcPrivate FcBool
 FcPatternObjectDel (FcPattern *p, FcObject object);
 FcPrivate FcBool
 FcPatternObjectRemove (FcPattern *p, FcObject object, int id);
 FcPrivate FcBool
 FcPatternObjectAddInteger (FcPattern *p, FcObject object, int i);
 FcPrivate FcBool
 FcPatternObjectAddDouble (FcPattern *p, FcObject object, double d);
 FcPrivate FcBool
 @@ -945,60 +1023,77 @@ FcPatternObjectGetString (const FcPatter
 FcPrivate FcResult
 FcPatternObjectGetMatrix (const FcPattern *p, FcObject object, int n, FcMatrix **s);
 FcPrivate FcResult
 FcPatternObjectGetCharSet (const FcPattern *p, FcObject object, int n, FcCharSet **c);
 FcPrivate FcResult
 FcPatternObjectGetBool (const FcPattern *p, FcObject object, int n, FcBool *b);
 FcPrivate FcResult
 FcPatternObjectGetLangSet (const FcPattern *p, FcObject object, int n, FcLangSet **ls);
 FcPrivate void
 FcPatternFini (void);
 FcPrivate FcBool
 FcPatternAppend (FcPattern *p, FcPattern *s);
 FcPrivate const FcChar8 *
-FcStrStaticName (const FcChar8 *name);
+FcSharedStr (const FcChar8 *name);
 FcPrivate FcBool
 FcSharedStrFree (const FcChar8 *name);
 FcPrivate FcChar32
 FcStringHash (const FcChar8 *s);
 FcPrivate FcBool
 FcPatternSerializeAlloc (FcSerialize *serialize, const FcPattern *pat);
 FcPrivate FcPattern *
 FcPatternSerialize (FcSerialize *serialize, const FcPattern *pat);
 FcPrivate FcBool
 FcValueListSerializeAlloc (FcSerialize *serialize, const FcValueList *pat);
 FcPrivate FcValueList *
 FcValueListSerialize (FcSerialize *serialize, const FcValueList *pat);
 /* fcrender.c */
 /* fcmatrix.c */
 extern FcPrivate const FcMatrix    FcIdentityMatrix;
 FcPrivate void
 FcMatrixFree (FcMatrix *mat);
 /* fcstat.c */
 FcPrivate int
 FcStat (const FcChar8 *file, struct stat *statb);
 FcPrivate int
 FcStatChecksum (const FcChar8 *file, struct stat *statb);
 FcPrivate FcBool
 FcIsFsMmapSafe (int fd);
 FcPrivate FcBool
 FcIsFsMtimeBroken (const FcChar8 *dir);
 /* fcstr.c */
 FcPrivate FcBool
 FcStrSetAddLangs (FcStrSet *strs, const char *languages);
 FcPrivate void
 FcStrSetSort (FcStrSet * set);
 FcPrivate void
 FcStrBufInit (FcStrBuf *buf, FcChar8 *init, int size);
 FcPrivate void
 FcStrBufDestroy (FcStrBuf *buf);
 FcPrivate FcChar8 *
 FcStrBufDone (FcStrBuf *buf);
 FcPrivate FcChar8 *
 @@ -1006,26 +1101,32 @@ FcStrBufDoneStatic (FcStrBuf *buf);
 FcPrivate FcBool
 FcStrBufChar (FcStrBuf *buf, FcChar8 c);
 FcPrivate FcBool
 FcStrBufString (FcStrBuf *buf, const FcChar8 *s);
 FcPrivate FcBool
 FcStrBufData (FcStrBuf *buf, const FcChar8 *s, int len);
 FcPrivate int
 FcStrCmpIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2);
 FcPrivate FcBool
 FcStrRegexCmp (const FcChar8 *s, const FcChar8 *regex);
 FcPrivate FcBool
 FcStrRegexCmpIgnoreCase (const FcChar8 *s, const FcChar8 *regex);
 FcPrivate const FcChar8 *
 FcStrContainsIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2);
 FcPrivate const FcChar8 *
 FcStrContainsIgnoreCase (const FcChar8 *s1, const FcChar8 *s2);
 FcPrivate const FcChar8 *
 FcStrContainsWord (const FcChar8 *s1, const FcChar8 *s2);
 FcPrivate FcBool
 FcStrUsesHome (const FcChar8 *s);
 FcPrivate FcChar8 *

 @@ -8,27 +8,27 @@
  * See ftglue.h for more information.
  */
 #include "ftglue.h"
 #if 0
 #include <stdio.h>
 #define  LOG(x)  ftglue_log x
 static void
 ftglue_log( const char*   format, ... )
+{
   va_list  ap;
   va_start( ap, format );
   vfprintf( stderr, format, ap );
   va_end( ap );
+}
 #else
 #define  LOG(x)  do {} while (0)
 #endif
 #undef read	/* XXX: SSP/FORTIFY */
 /* only used internally */
 static FT_Pointer
 @@ -74,35 +74,36 @@ FTGLUE_APIDEF( FT_Long )
 ftglue_stream_pos( FT_Stream   stream )
+{
   LOG(( "ftglue:stream:pos() -> %ld\n", stream->pos ));
   return stream->pos;
+}
 FTGLUE_APIDEF( FT_Error )
 ftglue_stream_seek( FT_Stream   stream,
                     FT_Long     pos )
+{
   FT_Error  error = 0;
   stream->pos = pos;
   if ( stream->read )
+  {
     if ( stream->read( stream, pos, 0, 0 ) )
       error = FT_Err_Invalid_Stream_Operation;
+  }
   else if ( pos > stream->size )
     error = FT_Err_Invalid_Stream_Operation;
   if ( !error )
     stream->pos = pos;
   LOG(( "ftglue:stream:seek(%ld) -> %d\n", pos, error ));
   return error;
+}
 FTGLUE_APIDEF( FT_Error )
 ftglue_stream_frame_enter( FT_Stream   stream,
                            FT_ULong    count )
+{
   FT_Error  error = FT_Err_Ok;
   FT_ULong  read_bytes;
   if ( stream->read )
 @@ -162,30 +163,30 @@ ftglue_stream_frame_exit( FT_Stream  str
   LOG(( "ftglue:stream:frame_exit()\n" ));
+}
 FTGLUE_APIDEF( FT_Error )
 ftglue_face_goto_table( FT_Face    face,
                         FT_ULong   the_tag,
                         FT_Stream  stream )
+{
   FT_Error  error;
   LOG(( "ftglue_face_goto_table( %p, %c%c%c%c, %p )\n",
                 face,
                 (int)((the_tag >> 24) & 0xFF),
                 (int)((the_tag >> 16) & 0xFF),
                 (int)((the_tag >> 8) & 0xFF),
                 (int)(the_tag & 0xFF),
                 stream ));
   if ( !FT_IS_SFNT(face) )
+  {
     LOG(( "not a SFNT face !!\n" ));
     error = FT_Err_Invalid_Face_Handle;
+  }
   else
+  {
    /* parse the directory table directly, without using
     * FreeType's built-in data structures
     */
 @@ -227,37 +228,37 @@ ftglue_face_goto_table( FT_Face    face,
     if ( FILE_Seek( offset+12 )   ||
          ACCESS_Frame( count*16 ) )
       goto Exit;
     for ( nn = 0; nn < count; nn++ )
+    {
       FT_ULong  tag      = GET_ULong();
       FT_ULong  checksum = GET_ULong();
       FT_ULong  start    = GET_ULong();
       FT_ULong  size     = GET_ULong();
       FT_UNUSED(checksum);
       FT_UNUSED(size);
       if ( tag == the_tag )
+      {
         LOG(( "TrueType table (start: %ld) (size: %ld)\n", start, size ));
         error = ftglue_stream_seek( stream, start );
         goto FoundIt;
+      }
+    }
     error = FT_Err_Table_Missing;
   FoundIt:
     FORGET_Frame();
+  }
 Exit:
   LOG(( "TrueType error=%d\n", error ));
   return error;
+}
 #undef QALLOC
 #define __ftglue__
 #include "fcaliastail.h"
 #undef __ftglue__