diff --git a/configure.in b/configure.in
index e8e1062..8aac36e 100644
--- a/configure.in
+++ b/configure.in
@@ -38,11 +38,14 @@ AM_MAINTAINER_MODE
 
 dnl libtool versioning
 
-LT_CURRENT=1
-LT_REVISION=4
+dnl bump revision when fixing bugs
+dnl bump current and age, reset revision to zero when adding APIs
+dnl bump current, leave age, reset revision to zero when changing/removing APIS
+LT_CURRENT=2
+LT_REVISION=0
 AC_SUBST(LT_CURRENT)
 AC_SUBST(LT_REVISION)
-LT_AGE=0
+LT_AGE=1
 
 LT_VERSION_INFO="$LT_CURRENT:$LT_REVISION:$LT_AGE"
 AC_SUBST(LT_VERSION_INFO)
diff --git a/fc-cache/fc-cache.c b/fc-cache/fc-cache.c
index f20d3a7..de29351 100644
--- a/fc-cache/fc-cache.c
+++ b/fc-cache/fc-cache.c
@@ -31,7 +31,7 @@
 #define HAVE_GETOPT 1
 #endif
 
-#include "fcint.h"
+#include <fontconfig/fontconfig.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
@@ -130,15 +130,14 @@ nsubdirs (FcStrSet *set)
 static int
 scanDirs (FcStrList *list, FcConfig *config, FcBool force, FcBool really_force, FcBool verbose)
 {
-    int		ret = 0;
-    const FcChar8 *dir;
-    FcFontSet	*set;
-    FcStrSet	*subdirs;
-    FcStrList	*sublist;
-    FcCache	*cache;
-    struct stat	statb;
-    FcBool	was_valid;
-    int		i;
+    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
@@ -223,19 +222,17 @@ scanDirs (FcStrList *list, FcConfig *config, FcBool force, FcBool really_force,
 	    }
 	}
 
-	set = FcCacheSet (cache);
-
 	if (was_valid)
 	{
 	    if (verbose)
 		printf ("skipping, %d fonts, %d dirs\n",
-			set->nfont, cache->dirs_count);
+			FcCacheNumFont (cache), FcCacheNumSubdir (cache));
 	}
 	else
 	{
 	    if (verbose)
 		printf ("caching, %d fonts, %d dirs\n", 
-			set->nfont, cache->dirs_count);
+			FcCacheNumFont (cache), FcCacheNumSubdir (cache));
 
 	    if (!FcDirCacheValid (dir))
 	    {
@@ -253,7 +250,7 @@ scanDirs (FcStrList *list, FcConfig *config, FcBool force, FcBool really_force,
 	    FcDirCacheUnload (cache);
 	    continue;
 	}
-	for (i = 0; i < cache->dirs_count; i++)
+	for (i = 0; i < FcCacheNumSubdir (cache); i++)
 	    FcStrSetAdd (subdirs, FcCacheSubdir (cache, i));
 	
 	FcDirCacheUnload (cache);
@@ -264,7 +261,6 @@ scanDirs (FcStrList *list, FcConfig *config, FcBool force, FcBool really_force,
 	{
 	    fprintf (stderr, "%s: Can't create subdir list\n", dir);
 	    ret++;
-	    FcDirCacheUnload (cache);
 	    continue;
 	}
 	FcStrSetAdd (processed_dirs, dir);
@@ -311,7 +307,7 @@ cleanCacheDirectory (FcConfig *config, FcChar8 *dir, FcBool verbose)
     while ((ent = readdir (d)))
     {
 	FcChar8	*file_name;
-	FcChar8	*target_dir;
+	const FcChar8	*target_dir;
 
 	if (ent->d_name[0] == '.')
 	    continue;
diff --git a/fc-cat/Makefile.am b/fc-cat/Makefile.am
index 91e5ad7..828f138 100644
--- a/fc-cat/Makefile.am
+++ b/fc-cat/Makefile.am
@@ -27,7 +27,7 @@ FC_CAT_SRC=${top_srcdir}/fc-cat
 
 SGML = ${FC_CAT_SRC}/fc-cat.sgml
 
-INCLUDES=-I${top_srcdir} $(FREETYPE_CFLAGS)
+INCLUDES=-I${top_srcdir} $(FREETYPE_CFLAGS) $(WARN_CFLAGS)
 
 bin_PROGRAMS=fc-cat
 
diff --git a/fc-cat/fc-cat.c b/fc-cat/fc-cat.c
index bb804ab..476798e 100644
--- a/fc-cat/fc-cat.c
+++ b/fc-cat/fc-cat.c
@@ -31,10 +31,11 @@
 #define HAVE_GETOPT 1
 #endif
 
-#include "../src/fccache.c"
+#include <fontconfig/fontconfig.h>
 #include "../fc-arch/fcarch.h"
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -173,20 +174,20 @@ usage (char *program)
  */
 
 static const FcChar8 *
-file_base_name (const char *cache, const FcChar8 *file)
+file_base_name (const FcChar8 *cache, const FcChar8 *file)
 {
-    const FcChar8   *cache_slash;
-    int		    cache_len = strlen (cache);
+    int		    cache_len = strlen ((char *) cache);
 
-    if (!strncmp (cache, file, cache_len) && file[cache_len] == '/')
+    if (!strncmp ((char *) cache, (char *) file, cache_len) && file[cache_len] == '/')
 	return file + cache_len + 1;
     return file;
 }
 
+#define FC_FONT_FILE_DIR	((FcChar8 *) ".dir")
+
 static FcBool
-cache_print_set (FcFontSet *set, FcStrSet *dirs, char *base_name, FcBool verbose)
+cache_print_set (FcFontSet *set, FcStrSet *dirs, const FcChar8 *base_name, FcBool verbose)
 {
-    FcPattern	    *font;
     FcChar8	    *name, *dir;
     const FcChar8   *file, *base;
     int		    ret;
@@ -219,9 +220,7 @@ cache_print_set (FcFontSet *set, FcStrSet *dirs, char *base_name, FcBool verbose
     
     for (n = 0; n < set->nfont; n++)
     {
-	FcPattern   **fonts = FcFontSetFonts (set);
-	FcPattern   *encoded_font = fonts[n];
-	FcPattern   *font = FcEncodedOffsetToPtr (set, encoded_font, FcPattern);
+	FcPattern   *font = set->fonts[n];
 
 	if (FcPatternGetString (font, FC_FILE, 0, (FcChar8 **) &file) != FcResultMatch)
 	    goto bail3;
@@ -321,7 +320,7 @@ main (int argc, char **argv)
     {
 	for (; i < argc; i++)
 	{
-	    if (!FcStrSetAddFilename (args, argv[i]))
+	    if (!FcStrSetAddFilename (args, (const FcChar8 *) argv[i]))
 	    {
 		fprintf (stderr, "%s: malloc failure\n", argv[0]);
 		return 1;
@@ -356,8 +355,6 @@ main (int argc, char **argv)
     while ((arg = FcStrListNext (arglist)))
     {
 	int	    j;
-	off_t	    size;
-	intptr_t    *cache_dirs;
 	FcChar8	    *cache_file = NULL;
 	struct stat file_stat;
 	
@@ -373,17 +370,12 @@ main (int argc, char **argv)
 	}
 	
 	dirs = FcStrSetCreate ();
-	fs = FcCacheSet (cache);
-	cache_dirs = FcCacheDirs (cache);
-	for (j = 0; j < cache->dirs_count; j++) 
+	fs = FcCacheCopySet (cache);
+	for (j = 0; j < FcCacheNumSubdir (cache); j++) 
 	{
-	    FcStrSetAdd (dirs, FcOffsetToPtr (cache_dirs,
-					      cache_dirs[j],
-					      FcChar8));
+	    FcStrSetAdd (dirs, FcCacheSubdir (cache, j));
 	    if (recurse)
-		FcStrSetAdd (args, FcOffsetToPtr (cache_dirs,
-					      cache_dirs[j],
-					      FcChar8));
+		FcStrSetAdd (args, FcCacheSubdir (cache, j));
 	}
 
 	if (verbose)
@@ -398,6 +390,7 @@ main (int argc, char **argv)
 
 	FcStrSetDestroy (dirs);
 
+	FcFontSetDestroy (fs);
 	FcDirCacheUnload (cache);
 	if (cache_file)
 	    FcStrFree (cache_file);
diff --git a/fontconfig/fcfreetype.h b/fontconfig/fcfreetype.h
index a6cf2e6..0c2a81c 100644
--- a/fontconfig/fcfreetype.h
+++ b/fontconfig/fcfreetype.h
@@ -27,21 +27,25 @@
 #include <ft2build.h>
 #include FT_FREETYPE_H
 
+#ifndef FcPublic
+#define FcPublic
+#endif
+
 _FCFUNCPROTOBEGIN
 
-FT_UInt
+FcPublic FT_UInt
 FcFreeTypeCharIndex (FT_Face face, FcChar32 ucs4);
 
-FcCharSet *
+FcPublic FcCharSet *
 FcFreeTypeCharSetAndSpacing (FT_Face face, FcBlanks *blanks, int *spacing);
     
-FcCharSet *
+FcPublic FcCharSet *
 FcFreeTypeCharSet (FT_Face face, FcBlanks *blanks);
 
-FcResult
+FcPublic FcResult
 FcPatternGetFTFace (const FcPattern *p, const char *object, int n, FT_Face *f);
 
-FcBool
+FcPublic FcBool
 FcPatternAddFTFace (FcPattern *p, const char *object, const FT_Face f);
 
 _FCFUNCPROTOEND
diff --git a/fontconfig/fontconfig.h b/fontconfig/fontconfig.h
index 6ca1cf4..92a6d08 100644
--- a/fontconfig/fontconfig.h
+++ b/fontconfig/fontconfig.h
@@ -25,6 +25,9 @@
 #ifndef _FONTCONFIG_H_
 #define _FONTCONFIG_H_
 
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
 #include <stdarg.h>
 
 #if defined(__GNUC__) && (__GNUC__ >= 4)
@@ -33,6 +36,10 @@
 #define FC_ATTRIBUTE_SENTINEL(x)
 #endif
 
+#ifndef FcPublic
+#define FcPublic
+#endif
+
 typedef unsigned char	FcChar8;
 typedef unsigned short	FcChar16;
 typedef unsigned int	FcChar32;
@@ -271,59 +278,81 @@ typedef struct _FcStrList   FcStrList;
 
 typedef struct _FcStrSet    FcStrSet;
 
+typedef struct _FcCache	    FcCache;
+
 _FCFUNCPROTOBEGIN
 
-FcBool
-FcDirCacheValid (const FcChar8 *cache_file);
-
 /* fcblanks.c */
-FcBlanks *
+FcPublic FcBlanks *
 FcBlanksCreate (void);
 
-void
+FcPublic void
 FcBlanksDestroy (FcBlanks *b);
 
-FcBool
+FcPublic FcBool
 FcBlanksAdd (FcBlanks *b, FcChar32 ucs4);
 
-FcBool
+FcPublic FcBool
 FcBlanksIsMember (FcBlanks *b, FcChar32 ucs4);
 
+/* fccache.c */
+
+FcPublic const FcChar8 *
+FcCacheDir(const FcCache *c);
+
+FcPublic FcFontSet *
+FcCacheCopySet(const FcCache *c);
+
+FcPublic const FcChar8 *
+FcCacheSubdir (const FcCache *c, int i);
+
+FcPublic int
+FcCacheNumSubdir (const FcCache *c);
+
+FcPublic int
+FcCacheNumFont (const FcCache *c);
+
+FcBool
+FcDirCacheUnlink (const FcChar8 *dir, FcConfig *config);
+
+FcPublic FcBool
+FcDirCacheValid (const FcChar8 *cache_file);
+
 /* fccfg.c */
-FcChar8 *
+FcPublic FcChar8 *
 FcConfigHome (void);
 
-FcBool
+FcPublic FcBool
 FcConfigEnableHome (FcBool enable);
 
-FcChar8 *
+FcPublic FcChar8 *
 FcConfigFilename (const FcChar8 *url);
     
-FcConfig *
+FcPublic FcConfig *
 FcConfigCreate (void);
 
-void
+FcPublic void
 FcConfigDestroy (FcConfig *config);
 
-FcBool
+FcPublic FcBool
 FcConfigSetCurrent (FcConfig *config);
 
-FcConfig *
+FcPublic FcConfig *
 FcConfigGetCurrent (void);
 
-FcBool
+FcPublic FcBool
 FcConfigUptoDate (FcConfig *config);
     
-FcBool
+FcPublic FcBool
 FcConfigBuildFonts (FcConfig *config);
 
-FcStrList *
+FcPublic FcStrList *
 FcConfigGetFontDirs (FcConfig   *config);
 
-FcStrList *
+FcPublic FcStrList *
 FcConfigGetConfigDirs (FcConfig   *config);
 
-FcStrList *
+FcPublic FcStrList *
 FcConfigGetConfigFiles (FcConfig    *config);
 
 FcChar8 *
@@ -332,108 +361,124 @@ FcConfigGetCache (FcConfig  *config);
 FcBlanks *
 FcConfigGetBlanks (FcConfig *config);
 
-int
+FcPublic FcStrList *
+FcConfigGetCacheDirs (FcConfig	*config);
+
+FcPublic int
 FcConfigGetRescanInverval (FcConfig *config);
 
-FcBool
+FcPublic FcBool
 FcConfigSetRescanInverval (FcConfig *config, int rescanInterval);
 
-FcFontSet *
+FcPublic FcFontSet *
 FcConfigGetFonts (FcConfig	*config,
 		  FcSetName	set);
 
-FcBool
+FcPublic FcBool
 FcConfigAppFontAddFile (FcConfig    *config,
 			const FcChar8  *file);
 
-FcBool
+FcPublic FcBool
 FcConfigAppFontAddDir (FcConfig	    *config,
 		       const FcChar8   *dir);
 
-void
+FcPublic void
 FcConfigAppFontClear (FcConfig	    *config);
 
-FcBool
+FcPublic FcBool
 FcConfigSubstituteWithPat (FcConfig	*config,
 			   FcPattern	*p,
 			   FcPattern	*p_pat,
 			   FcMatchKind	kind);
 
-FcBool
+FcPublic FcBool
 FcConfigSubstitute (FcConfig	*config,
 		    FcPattern	*p,
 		    FcMatchKind	kind);
 
 /* fccharset.c */
-FcCharSet *
+FcPublic FcCharSet*
 FcCharSetCreate (void);
 
-void
+/* deprecated alias for FcCharSetCreate */
+FcPublic FcCharSet *
+FcCharSetNew (void);
+    
+FcPublic void
 FcCharSetDestroy (FcCharSet *fcs);
 
-FcBool
+FcPublic FcBool
 FcCharSetAddChar (FcCharSet *fcs, FcChar32 ucs4);
 
-FcCharSet *
+FcPublic FcCharSet*
 FcCharSetCopy (FcCharSet *src);
 
-FcBool
+FcPublic FcBool
 FcCharSetEqual (const FcCharSet *a, const FcCharSet *b);
 
-FcCharSet *
+FcPublic FcCharSet*
 FcCharSetIntersect (const FcCharSet *a, const FcCharSet *b);
 
-FcCharSet *
+FcPublic FcCharSet*
 FcCharSetUnion (const FcCharSet *a, const FcCharSet *b);
 
-FcCharSet *
+FcPublic FcCharSet*
 FcCharSetSubtract (const FcCharSet *a, const FcCharSet *b);
 
-FcBool
+FcPublic FcBool
 FcCharSetHasChar (const FcCharSet *fcs, FcChar32 ucs4);
 
-FcChar32
+FcPublic FcChar32
 FcCharSetCount (const FcCharSet *a);
 
-FcChar32
+FcPublic FcChar32
 FcCharSetIntersectCount (const FcCharSet *a, const FcCharSet *b);
 
-FcChar32
+FcPublic FcChar32
 FcCharSetSubtractCount (const FcCharSet *a, const FcCharSet *b);
 
-FcBool
+FcPublic FcBool
 FcCharSetIsSubset (const FcCharSet *a, const FcCharSet *b);
 
 #define FC_CHARSET_MAP_SIZE (256/32)
 #define FC_CHARSET_DONE	((FcChar32) -1)
 
-FcChar32
+FcPublic FcChar32
 FcCharSetFirstPage (const FcCharSet *a, 
 		    FcChar32	    map[FC_CHARSET_MAP_SIZE],
 		    FcChar32	    *next);
 
-FcChar32
+FcPublic FcChar32
 FcCharSetNextPage (const FcCharSet  *a, 
 		   FcChar32	    map[FC_CHARSET_MAP_SIZE],
 		   FcChar32	    *next);
 
+/*
+ * old coverage API, rather hard to use correctly
+ */
+
+FcPublic FcChar32
+FcCharSetCoverage (const FcCharSet *a, FcChar32 page, FcChar32 *result);
 
 /* fcdbg.c */
-void
+FcPublic void
 FcValuePrint (const FcValue v);
 
-void
+FcPublic void
 FcPatternPrint (const FcPattern *p);
 
-void
+FcPublic void
 FcFontSetPrint (const FcFontSet *s);
 
 /* fcdefault.c */
-void
+FcPublic void
 FcDefaultSubstitute (FcPattern *pattern);
 
 /* fcdir.c */
-FcBool
+FcPublic FcBool
+FcFileIsDir (const FcChar8 *file);
+
+FcPublic FcBool
 FcFileScan (FcFontSet	    *set,
 	    FcStrSet	    *dirs,
 	    FcFileCache	    *cache,
@@ -441,7 +486,7 @@ FcFileScan (FcFontSet	    *set,
 	    const FcChar8   *file,
 	    FcBool	    force);
 
-FcBool
+FcPublic FcBool
 FcDirScan (FcFontSet	    *set,
 	   FcStrSet	    *dirs,
 	   FcFileCache	    *cache,
@@ -449,147 +494,159 @@ FcDirScan (FcFontSet	    *set,
 	   const FcChar8    *dir,
 	   FcBool	    force);
 
-FcBool
+FcPublic FcBool
 FcDirSave (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir);
 
+FcPublic FcCache *
+FcDirCacheLoad (const FcChar8 *dir, FcConfig *config, FcChar8 **cache_file);
+    
+FcPublic FcCache *
+FcDirCacheRead (const FcChar8 *dir, FcBool force, FcConfig *config);
+
+FcPublic FcCache *
+FcDirCacheLoadFile (const FcChar8 *cache_file, struct stat *file_stat);
+
+FcPublic void
+FcDirCacheUnload (FcCache *cache);
+
 /* fcfreetype.c */
-FcPattern *
+FcPublic FcPattern *
 FcFreeTypeQuery (const FcChar8 *file, int id, FcBlanks *blanks, int *count);
 
 /* fcfs.c */
 
-FcFontSet *
+FcPublic FcFontSet *
 FcFontSetCreate (void);
 
-void
+FcPublic void
 FcFontSetDestroy (FcFontSet *s);
 
-FcBool
+FcPublic FcBool
 FcFontSetAdd (FcFontSet *s, FcPattern *font);
 
 /* fcinit.c */
-FcConfig *
+FcPublic FcConfig *
 FcInitLoadConfig (void);
 
-FcConfig *
+FcPublic FcConfig *
 FcInitLoadConfigAndFonts (void);
 
-FcBool
+FcPublic FcBool
 FcInit (void);
 
-void
+FcPublic void
 FcFini (void);
 
-int
+FcPublic int
 FcGetVersion (void);
 
-FcBool
+FcPublic FcBool
 FcInitReinitialize (void);
 
-FcBool
+FcPublic FcBool
 FcInitBringUptoDate (void);
 
 /* fclang.c */
-FcLangSet *
+FcPublic FcLangSet*
 FcLangSetCreate (void);
 
-void
+FcPublic void
 FcLangSetDestroy (FcLangSet *ls);
 
-FcLangSet *
+FcPublic FcLangSet*
 FcLangSetCopy (const FcLangSet *ls);
 
-FcBool
+FcPublic FcBool
 FcLangSetAdd (FcLangSet *ls, const FcChar8 *lang);
 
-FcLangResult
+FcPublic FcLangResult
 FcLangSetHasLang (const FcLangSet *ls, const FcChar8 *lang);
 
-FcLangResult
+FcPublic FcLangResult
 FcLangSetCompare (const FcLangSet *lsa, const FcLangSet *lsb);
 
-FcBool
+FcPublic FcBool
 FcLangSetContains (const FcLangSet *lsa, const FcLangSet *lsb);
 
-FcBool
+FcPublic FcBool
 FcLangSetEqual (const FcLangSet *lsa, const FcLangSet *lsb);
 
-FcChar32
+FcPublic FcChar32
 FcLangSetHash (const FcLangSet *ls);
 
 /* fclist.c */
-FcObjectSet *
+FcPublic FcObjectSet *
 FcObjectSetCreate (void);
 
-FcBool
+FcPublic FcBool
 FcObjectSetAdd (FcObjectSet *os, const char *object);
 
-void
+FcPublic void
 FcObjectSetDestroy (FcObjectSet *os);
 
-FcObjectSet *
+FcPublic FcObjectSet *
 FcObjectSetVaBuild (const char *first, va_list va);
 
-FcObjectSet *
+FcPublic FcObjectSet *
 FcObjectSetBuild (const char *first, ...) FC_ATTRIBUTE_SENTINEL(0);
 
-FcFontSet *
+FcPublic FcFontSet *
 FcFontSetList (FcConfig	    *config,
 	       FcFontSet    **sets,
 	       int	    nsets,
 	       FcPattern    *p,
 	       FcObjectSet  *os);
 
-FcFontSet *
+FcPublic FcFontSet *
 FcFontList (FcConfig	*config,
 	    FcPattern	*p,
 	    FcObjectSet *os);
 
 /* fcatomic.c */
 
-FcAtomic *
+FcPublic FcAtomic *
 FcAtomicCreate (const FcChar8   *file);
 
-FcBool
+FcPublic FcBool
 FcAtomicLock (FcAtomic *atomic);
 
-FcChar8 *
+FcPublic FcChar8 *
 FcAtomicNewFile (FcAtomic *atomic);
 
-FcChar8 *
+FcPublic FcChar8 *
 FcAtomicOrigFile (FcAtomic *atomic);
 
-FcBool
+FcPublic FcBool
 FcAtomicReplaceOrig (FcAtomic *atomic);
 
-void
+FcPublic void
 FcAtomicDeleteNew (FcAtomic *atomic);
 
-void
+FcPublic void
 FcAtomicUnlock (FcAtomic *atomic);
 
-void
+FcPublic void
 FcAtomicDestroy (FcAtomic *atomic);
 
 /* fcmatch.c */
-FcPattern *
+FcPublic FcPattern *
 FcFontSetMatch (FcConfig    *config,
 		FcFontSet   **sets,
 		int	    nsets,
 		FcPattern   *p,
 		FcResult    *result);
 
-FcPattern *
+FcPublic FcPattern *
 FcFontMatch (FcConfig	*config,
 	     FcPattern	*p, 
 	     FcResult	*result);
 
-FcPattern *
+FcPublic FcPattern *
 FcFontRenderPrepare (FcConfig	    *config,
 		     FcPattern	    *pat,
 		     FcPattern	    *font);
 
-FcFontSet *
+FcPublic FcFontSet *
 FcFontSetSort (FcConfig	    *config,
 	       FcFontSet    **sets,
 	       int	    nsets,
@@ -598,192 +655,198 @@ FcFontSetSort (FcConfig	    *config,
 	       FcCharSet    **csp,
 	       FcResult	    *result);
 
-FcFontSet *
+FcPublic FcFontSet *
 FcFontSort (FcConfig	 *config,
 	    FcPattern    *p,
 	    FcBool	 trim,
 	    FcCharSet    **csp,
 	    FcResult	 *result);
 
-void
+FcPublic void
 FcFontSetSortDestroy (FcFontSet *fs);
 
 /* fcmatrix.c */
-FcMatrix *
+FcPublic FcMatrix *
 FcMatrixCopy (const FcMatrix *mat);
 
-FcBool
+FcPublic FcBool
 FcMatrixEqual (const FcMatrix *mat1, const FcMatrix *mat2);
 
-void
+FcPublic void
 FcMatrixMultiply (FcMatrix *result, const FcMatrix *a, const FcMatrix *b);
 
-void
+FcPublic void
 FcMatrixRotate (FcMatrix *m, double c, double s);
 
-void
+FcPublic void
 FcMatrixScale (FcMatrix *m, double sx, double sy);
 
-void
+FcPublic void
 FcMatrixShear (FcMatrix *m, double sh, double sv);
 
 /* fcname.c */
 
-FcBool
+FcPublic FcBool
 FcNameRegisterObjectTypes (const FcObjectType *types, int ntype);
 
-FcBool
+FcPublic FcBool
 FcNameUnregisterObjectTypes (const FcObjectType *types, int ntype);
     
-const FcObjectType *
+FcPublic const FcObjectType *
 FcNameGetObjectType (const char *object);
 
-FcBool
+FcPublic FcBool
 FcNameRegisterConstants (const FcConstant *consts, int nconsts);
 
-FcBool
+FcPublic FcBool
 FcNameUnregisterConstants (const FcConstant *consts, int nconsts);
     
-const FcConstant *
+FcPublic const FcConstant *
 FcNameGetConstant (FcChar8 *string);
 
-FcBool
+FcPublic FcBool
 FcNameConstant (FcChar8 *string, int *result);
 
-FcPattern *
+FcPublic FcPattern *
 FcNameParse (const FcChar8 *name);
 
-FcChar8 *
+FcPublic FcChar8 *
 FcNameUnparse (FcPattern *pat);
 
 /* fcpat.c */
-FcPattern *
+FcPublic FcPattern *
 FcPatternCreate (void);
 
-FcPattern *
+FcPublic FcPattern *
 FcPatternDuplicate (const FcPattern *p);
 
-void
+FcPublic void
 FcPatternReference (FcPattern *p);
 
-void
+FcPublic void
 FcValueDestroy (FcValue v);
 
-FcBool
+FcPublic FcBool
 FcValueEqual (FcValue va, FcValue vb);
 
-FcValue
+FcPublic FcValue
 FcValueSave (FcValue v);
 
-void
+FcPublic void
 FcPatternDestroy (FcPattern *p);
 
-FcBool
+FcPublic FcBool
 FcPatternEqual (const FcPattern *pa, const FcPattern *pb);
 
-FcBool
+FcPublic FcBool
 FcPatternEqualSubset (const FcPattern *pa, const FcPattern *pb, const FcObjectSet *os);
 
-FcChar32
+FcPublic FcChar32
 FcPatternHash (const FcPattern *p);
 
-FcBool
+FcPublic FcBool
 FcPatternAdd (FcPattern *p, const char *object, FcValue value, FcBool append);
     
-FcBool
+FcPublic FcBool
 FcPatternAddWeak (FcPattern *p, const char *object, FcValue value, FcBool append);
     
-FcResult
+FcPublic FcResult
 FcPatternGet (const FcPattern *p, const char *object, int id, FcValue *v);
     
-FcBool
+FcPublic FcBool
 FcPatternDel (FcPattern *p, const char *object);
 
-FcBool
+FcPublic FcBool
 FcPatternRemove (FcPattern *p, const char *object, int id);
 
-FcBool
+FcPublic FcBool
 FcPatternAddInteger (FcPattern *p, const char *object, int i);
 
-FcBool
+FcPublic FcBool
 FcPatternAddDouble (FcPattern *p, const char *object, double d);
 
-FcBool
+FcPublic FcBool
 FcPatternAddString (FcPattern *p, const char *object, const FcChar8 *s);
 
-FcBool
+FcPublic FcBool
 FcPatternAddMatrix (FcPattern *p, const char *object, const FcMatrix *s);
 
-FcBool
+FcPublic FcBool
 FcPatternAddCharSet (FcPattern *p, const char *object, const FcCharSet *c);
 
-FcBool
+FcPublic FcBool
 FcPatternAddBool (FcPattern *p, const char *object, FcBool b);
 
-FcBool
+FcPublic FcBool
 FcPatternAddLangSet (FcPattern *p, const char *object, const FcLangSet *ls);
 
-FcResult
+FcPublic FcResult
 FcPatternGetInteger (const FcPattern *p, const char *object, int n, int *i);
 
-FcResult
+FcPublic FcResult
 FcPatternGetDouble (const FcPattern *p, const char *object, int n, double *d);
 
-FcResult
+FcPublic FcResult
 FcPatternGetString (const FcPattern *p, const char *object, int n, FcChar8 ** s);
 
-FcResult
+FcPublic FcResult
 FcPatternGetMatrix (const FcPattern *p, const char *object, int n, FcMatrix **s);
 
-FcResult
+FcPublic FcResult
 FcPatternGetCharSet (const FcPattern *p, const char *object, int n, FcCharSet **c);
 
-FcResult
+FcPublic FcResult
 FcPatternGetBool (const FcPattern *p, const char *object, int n, FcBool *b);
 
-FcResult
+FcPublic FcResult
 FcPatternGetLangSet (const FcPattern *p, const char *object, int n, FcLangSet **ls);
 
-FcPattern *
+FcPublic FcPattern *
 FcPatternVaBuild (FcPattern *orig, va_list va);
     
-FcPattern *
+FcPublic FcPattern *
 FcPatternBuild (FcPattern *orig, ...) FC_ATTRIBUTE_SENTINEL(0);
 
 /* fcstr.c */
 
-FcChar8 *
+FcPublic FcChar8 *
 FcStrCopy (const FcChar8 *s);
 
-FcChar8 *
+FcPublic FcChar8 *
 FcStrCopyFilename (const FcChar8 *s);
     
+FcPublic FcChar8 *
+FcStrPlus (const FcChar8 *s1, const FcChar8 *s2);
+    
+FcPublic void
+FcStrFree (FcChar8 *s);
+
 /* These are ASCII only, suitable only for pattern element names */
 #define FcIsUpper(c)	((0101 <= (c) && (c) <= 0132))
 #define FcIsLower(c)	((0141 <= (c) && (c) <= 0172))
 #define FcToLower(c)	(FcIsUpper(c) ? (c) - 0101 + 0141 : (c))
 
-FcChar8 *
+FcPublic FcChar8 *
 FcStrDowncase (const FcChar8 *s);
 
-int
+FcPublic int
 FcStrCmpIgnoreCase (const FcChar8 *s1, const FcChar8 *s2);
 
-int
+FcPublic int
 FcStrCmp (const FcChar8 *s1, const FcChar8 *s2);
 
-const FcChar8 *
+FcPublic const FcChar8 *
 FcStrStrIgnoreCase (const FcChar8 *s1, const FcChar8 *s2);
 
-const FcChar8 *
+FcPublic const FcChar8 *
 FcStrStr (const FcChar8 *s1, const FcChar8 *s2);
 
-int
+FcPublic int
 FcUtf8ToUcs4 (const FcChar8 *src_orig,
 	      FcChar32	    *dst,
 	      int	    len);
 
-FcBool
+FcPublic FcBool
 FcUtf8Len (const FcChar8    *string,
 	   int		    len,
 	   int		    *nchar,
@@ -791,61 +854,61 @@ FcUtf8Len (const FcChar8    *string,
 
 #define FC_UTF8_MAX_LEN	6
 
-int
+FcPublic int
 FcUcs4ToUtf8 (FcChar32	ucs4,
 	      FcChar8	dest[FC_UTF8_MAX_LEN]);
 
-int
+FcPublic int
 FcUtf16ToUcs4 (const FcChar8	*src_orig,
 	       FcEndian		endian,
 	       FcChar32		*dst,
 	       int		len);	    /* in bytes */
 
-FcBool
+FcPublic FcBool
 FcUtf16Len (const FcChar8   *string,
 	    FcEndian	    endian,
 	    int		    len,	    /* in bytes */
 	    int		    *nchar,
 	    int		    *wchar);
 
-FcChar8 *
+FcPublic FcChar8 *
 FcStrDirname (const FcChar8 *file);
 
-FcChar8 *
+FcPublic FcChar8 *
 FcStrBasename (const FcChar8 *file);
 
-FcStrSet *
+FcPublic FcStrSet *
 FcStrSetCreate (void);
 
-FcBool
-FcStrSetMember (FcStrSet *set, const FcChar8 *s);
+FcPublic FcBool
+FcStrSetMember (FcPublic FcStrSet *set, const FcChar8 *s);
 
-FcBool
-FcStrSetEqual (FcStrSet *sa, FcStrSet *sb);
+FcPublic FcBool
+FcStrSetEqual (FcPublic FcStrSet *sa, FcPublic FcStrSet *sb);
 
-FcBool
-FcStrSetAdd (FcStrSet *set, const FcChar8 *s);
+FcPublic FcBool
+FcStrSetAdd (FcPublic FcStrSet *set, const FcChar8 *s);
 
-FcBool
-FcStrSetAddFilename (FcStrSet *set, const FcChar8 *s);
+FcPublic FcBool
+FcStrSetAddFilename (FcPublic FcStrSet *set, const FcChar8 *s);
 
-FcBool
-FcStrSetDel (FcStrSet *set, const FcChar8 *s);
+FcPublic FcBool
+FcStrSetDel (FcPublic FcStrSet *set, const FcChar8 *s);
 
-void
-FcStrSetDestroy (FcStrSet *set);
+FcPublic void
+FcStrSetDestroy (FcPublic FcStrSet *set);
 
-FcStrList *
-FcStrListCreate (FcStrSet *set);
+FcPublic FcStrList *
+FcPublic FcStrListCreate (FcPublic FcStrSet *set);
 
-FcChar8 *
-FcStrListNext (FcStrList *list);
+FcPublic FcChar8 *
+FcPublic FcStrListNext (FcStrList *list);
 
-void
-FcStrListDone (FcStrList *list);
+FcPublic void
+FcPublic FcStrListDone (FcStrList *list);
 
 /* fcxml.c */
-FcBool
+FcPublic FcBool
 FcConfigParseAndLoad (FcConfig *config, const FcChar8 *file, FcBool complain);
 
 _FCFUNCPROTOEND
diff --git a/src/fccache.c b/src/fccache.c
index 05dc7ee..aa03990 100644
--- a/src/fccache.c
+++ b/src/fccache.c
@@ -575,6 +575,54 @@ FcDirCacheWrite (FcCache *cache, FcConfig *config)
     return FcFalse;
 }
 
+/*
+ * Hokey little macro trick to permit the definitions of C functions
+ * with the same name as CPP macros
+ */
+#define args(x...)	    (x)
+
+const FcChar8 *
+FcCacheDir args(const FcCache *c)
+{
+    return FcCacheDir (c);
+}
+
+FcFontSet *
+FcCacheCopySet args(const FcCache *c)
+{
+    FcFontSet	*old = FcCacheSet (c);
+    FcFontSet	*new = FcFontSetCreate ();
+    int		i;
+    
+    if (!new)
+	return NULL;
+    for (i = 0; i < old->nfont; i++)
+	if (!FcFontSetAdd (new, FcFontSetFont (old, i)))
+	{
+	    FcFontSetDestroy (new);
+	    return NULL;
+	}
+    return new;
+}
+
+const FcChar8 *
+FcCacheSubdir args(const FcCache *c, int i)
+{
+    return FcCacheSubdir (c, i);
+}
+
+int
+FcCacheNumSubdir args(const FcCache *c)
+{
+    return c->dirs_count;
+}
+
+int
+FcCacheNumFont args(const FcCache *c)
+{
+    return FcCacheSet(c)->nfont;
+}
+
 /*
  * This code implements the MD5 message-digest algorithm.
  * The algorithm is due to Ron Rivest.	This code was
diff --git a/src/fccharset.c b/src/fccharset.c
index 3dac4ce..fdff91f 100644
--- a/src/fccharset.c
+++ b/src/fccharset.c
@@ -43,9 +43,6 @@ FcCharSetCreate (void)
     return fcs;
 }
 
-FcCharSet *
-FcCharSetNew (void);
-    
 FcCharSet *
 FcCharSetNew (void)
 {
@@ -693,8 +690,6 @@ FcCharSetFirstPage (const FcCharSet *a,
 /*
  * old coverage API, rather hard to use correctly
  */
-FcChar32
-FcCharSetCoverage (const FcCharSet *a, FcChar32 page, FcChar32 *result);
     
 FcChar32
 FcCharSetCoverage (const FcCharSet *a, FcChar32 page, FcChar32 *result)
diff --git a/src/fcint.h b/src/fcint.h
index 3b9f3c8..6cdb7cb 100644
--- a/src/fcint.h
+++ b/src/fcint.h
@@ -53,9 +53,6 @@
 #define FC_CONFIG_PATH "fonts.conf"
 #endif
 
-#define FC_FONT_FILE_INVALID	((FcChar8 *) ".")
-#define FC_FONT_FILE_DIR	((FcChar8 *) ".dir")
-
 #ifdef _WIN32
 #define FC_SEARCH_PATH_SEPARATOR ';'
 #else
@@ -113,6 +110,15 @@
 #define FC_BANK_FIRST 1
 #define FC_BANK_LANGS	    0xfcfcfcfc
 
+/* slim_internal.h */
+#if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)) && defined(__ELF__)
+#define FcPrivate		__attribute__((__visibility__("hidden")))
+#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;
@@ -306,7 +312,7 @@ typedef struct _FcStrBuf {
     int	    size;
 } FcStrBuf;
 
-typedef struct _FcCache {
+struct _FcCache {
     int		magic;              /* FC_CACHE_MAGIC_MMAP or FC_CACHE_ALLOC */
     int		version;	    /* FC_CACHE_CONTENT_VERSION */
     intptr_t	size;		    /* size of file */
@@ -314,13 +320,13 @@ typedef struct _FcCache {
     intptr_t	dirs;		    /* offset to subdirs */
     int		dirs_count;	    /* number of subdir strings */
     intptr_t	set;		    /* offset to font set */
-} FcCache;
+};
 
 #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(cache),\
-					   FcCacheDirs(cache)[i], \
+#define FcCacheSubdir(c,i)  FcOffsetToPtr (FcCacheDirs(c),\
+					   FcCacheDirs(c)[i], \
 					   FcChar8)
 
 /*
@@ -483,7 +489,7 @@ struct _FcConfig {
     int		rescanInterval;	    /* interval between scans */
 };
  
-extern FcConfig	*_fcConfig;
+extern FcPrivate FcConfig	*_fcConfig;
 
 typedef struct _FcFileTime {
     time_t  time;
@@ -499,208 +505,186 @@ typedef struct _FcCharMap FcCharMap;
 
 /* fccache.c */
 
-FcBool
-FcDirCacheUnlink (const FcChar8 *dir, FcConfig *config);
-
-void
-FcDirCacheUnload (FcCache *cache);
-
-FcCache *
+FcPrivate FcCache *
 FcDirCacheScan (const FcChar8 *dir, FcConfig *config);
 
-FcCache *
-FcDirCacheLoad (const FcChar8 *dir, FcConfig *config, FcChar8 **cache_file);
-    
-FcCache *
-FcDirCacheLoadFile (const FcChar8 *cache_file, struct stat *file_stat);
-
-FcBool
-FcDirCacheValid (const FcChar8 *dir);
-
-FcCache *
+FcPrivate FcCache *
 FcDirCacheBuild (FcFontSet *set, const FcChar8 *dir, FcStrSet *dirs);
 
-FcBool
+FcPrivate FcBool
 FcDirCacheWrite (FcCache *cache, FcConfig *config);
     
 /* fccfg.c */
 
-FcBool
+FcPrivate FcBool
 FcConfigAddConfigDir (FcConfig	    *config,
 		      const FcChar8 *d);
 
-FcBool
+FcPrivate FcBool
 FcConfigAddFontDir (FcConfig	    *config,
 		    const FcChar8   *d);
 
-FcBool
+FcPrivate FcBool
 FcConfigAddDir (FcConfig	*config,
 		const FcChar8	*d);
 
-FcBool
+FcPrivate FcBool
 FcConfigAddCacheDir (FcConfig	    *config,
 		     const FcChar8  *d);
 
-FcStrList *
-FcConfigGetCacheDirs (FcConfig	*config);
-
-FcBool
+FcPrivate FcBool
 FcConfigAddConfigFile (FcConfig		*config,
 		       const FcChar8	*f);
 
-FcBool
+FcPrivate FcBool
 FcConfigAddBlank (FcConfig	*config,
 		  FcChar32    	blank);
 
-FcBool
+FcPrivate FcBool
 FcConfigAddEdit (FcConfig	*config,
 		 FcTest		*test,
 		 FcEdit		*edit,
 		 FcMatchKind	kind);
 
-void
+FcPrivate void
 FcConfigSetFonts (FcConfig	*config,
 		  FcFontSet	*fonts,
 		  FcSetName	set);
 
-FcBool
+FcPrivate FcBool
 FcConfigCompareValue (const FcValue *m,
 		      FcOp	    op,
 		      const FcValue *v);
 
-FcBool
+FcPrivate FcBool
 FcConfigGlobAdd (FcConfig	*config,
 		 const FcChar8	*glob,
 		 FcBool		accept);
 
-FcBool
+FcPrivate FcBool
 FcConfigAcceptFilename (FcConfig	*config,
 			const FcChar8	*filename);
 
-FcBool
+FcPrivate FcBool
 FcConfigPatternsAdd (FcConfig	*config,
 		     FcPattern	*pattern,
 		     FcBool	accept);
 
-FcBool
+FcPrivate FcBool
 FcConfigAcceptFont (FcConfig	    *config,
 		    const FcPattern *font);
 
-FcFileTime
+FcPrivate FcFileTime
 FcConfigModifiedTime (FcConfig *config);
 
-FcBool
+FcPrivate FcBool
 FcConfigAddCache (FcConfig *config, FcCache *cache);
 
 /* fcserialize.c */
-intptr_t
+FcPrivate intptr_t
 FcAlignSize (intptr_t size);
     
-FcSerialize *
+FcPrivate FcSerialize *
 FcSerializeCreate (void);
 
-void
+FcPrivate void
 FcSerializeDestroy (FcSerialize *serialize);
 
-FcBool
+FcPrivate FcBool
 FcSerializeAlloc (FcSerialize *serialize, const void *object, int size);
 
-intptr_t
+FcPrivate intptr_t
 FcSerializeReserve (FcSerialize *serialize, int size);
 
-intptr_t
+FcPrivate intptr_t
 FcSerializeOffset (FcSerialize *serialize, const void *object);
 
-void *
+FcPrivate void *
 FcSerializePtr (FcSerialize *serialize, const void *object);
 
-FcBool
+FcPrivate FcBool
 FcLangSetSerializeAlloc (FcSerialize *serialize, const FcLangSet *l);
 
-FcLangSet *
+FcPrivate FcLangSet *
 FcLangSetSerialize(FcSerialize *serialize, const FcLangSet *l);
 
 /* fccharset.c */
-void
+FcPrivate void
 FcLangCharSetPopulate (void);
 
-FcCharSetFreezer *
+FcPrivate FcCharSetFreezer *
 FcCharSetFreezerCreate (void);
 
-const FcCharSet *
+FcPrivate const FcCharSet *
 FcCharSetFreeze (FcCharSetFreezer *freezer, const FcCharSet *fcs);
 
-void
+FcPrivate void
 FcCharSetFreezerDestroy (FcCharSetFreezer *freezer);
 
-FcBool
+FcPrivate FcBool
 FcNameUnparseCharSet (FcStrBuf *buf, const FcCharSet *c);
 
-FcCharSet *
+FcPrivate FcCharSet *
 FcNameParseCharSet (FcChar8 *string);
 
-FcCharLeaf *
+FcPrivate FcCharLeaf *
 FcCharSetFindLeafCreate (FcCharSet *fcs, FcChar32 ucs4);
 
-FcBool
+FcPrivate FcBool
 FcCharSetSerializeAlloc(FcSerialize *serialize, const FcCharSet *cs);
 
-FcCharSet *
+FcPrivate FcCharSet *
 FcCharSetSerialize(FcSerialize *serialize, const FcCharSet *cs);
 
-FcChar16 *
+FcPrivate FcChar16 *
 FcCharSetGetNumbers(const FcCharSet *c);
 
 /* fcdbg.c */
-void
+FcPrivate void
 FcValueListPrint (const FcValueListPtr l);
 
-void
+FcPrivate void
 FcLangSetPrint (const FcLangSet *ls);
 
-void
+FcPrivate void
 FcOpPrint (FcOp op);
 
-void
+FcPrivate void
 FcTestPrint (const FcTest *test);
 
-void
+FcPrivate void
 FcExprPrint (const FcExpr *expr);
 
-void
+FcPrivate void
 FcEditPrint (const FcEdit *edit);
 
-void
+FcPrivate void
 FcSubstPrint (const FcSubst *subst);
 
-void
+FcPrivate void
 FcCharSetPrint (const FcCharSet *c);
     
-extern int FcDebugVal;
+extern FcPrivate int FcDebugVal;
 
-static inline int
-FcDebug (void) { return FcDebugVal; }
+#define FcDebug() (FcDebugVal)
 
-void
+FcPrivate void
 FcInitDebug (void);
 
 /* fcdefault.c */
-FcChar8 *
+FcPrivate FcChar8 *
 FcGetDefaultLang (void);
 
 /* fcdir.c */
 
-FcBool
-FcFileIsDir (const FcChar8 *file);
-
-FcBool
+FcPrivate FcBool
 FcFileScanConfig (FcFontSet	*set,
 		  FcStrSet	*dirs,
 		  FcBlanks	*blanks,
 		  const FcChar8 *file,
 		  FcConfig	*config);
 
-FcBool
+FcPrivate FcBool
 FcDirScanConfig (FcFontSet	*set,
 		 FcStrSet	*dirs,
 		 FcBlanks	*blanks,
@@ -708,123 +692,120 @@ FcDirScanConfig (FcFontSet	*set,
 		 FcBool		force,
 		 FcConfig	*config);
 
-FcCache *
-FcDirCacheRead (const FcChar8 *dir, FcBool force, FcConfig *config);
-
 /* fcfont.c */
-int
+FcPrivate int
 FcFontDebug (void);
     
 /* fcfreetype.c */
-FcBool
+FcPrivate FcBool
 FcFreeTypeIsExclusiveLang (const FcChar8  *lang);
 
-FcBool
+FcPrivate FcBool
 FcFreeTypeHasLang (FcPattern *pattern, const FcChar8 *lang);
 
-FcChar32
+FcPrivate FcChar32
 FcFreeTypeUcs4ToPrivate (FcChar32 ucs4, const FcCharMap *map);
 
-FcChar32
+FcPrivate FcChar32
 FcFreeTypePrivateToUcs4 (FcChar32 private, const FcCharMap *map);
 
-const FcCharMap *
+FcPrivate const FcCharMap *
 FcFreeTypeGetPrivateMap (FT_Encoding encoding);
     
 /* fcfs.c */
 
-FcBool
+FcPrivate FcBool
 FcFontSetSerializeAlloc (FcSerialize *serialize, const FcFontSet *s);
 
-FcFontSet *
+FcPrivate FcFontSet *
 FcFontSetSerialize (FcSerialize *serialize, const FcFontSet * s);
     
 /* fcgram.y */
-int
+FcPrivate int
 FcConfigparse (void);
 
-int
+FcPrivate int
 FcConfigwrap (void);
     
-void
+FcPrivate void
 FcConfigerror (char *fmt, ...);
     
-char *
+FcPrivate char *
 FcConfigSaveField (const char *field);
 
-void
+FcPrivate void
 FcTestDestroy (FcTest *test);
 
-FcExpr *
+FcPrivate FcExpr *
 FcExprCreateInteger (int i);
 
-FcExpr *
+FcPrivate FcExpr *
 FcExprCreateDouble (double d);
 
-FcExpr *
+FcPrivate FcExpr *
 FcExprCreateString (const FcChar8 *s);
 
-FcExpr *
+FcPrivate FcExpr *
 FcExprCreateMatrix (const FcMatrix *m);
 
-FcExpr *
+FcPrivate FcExpr *
 FcExprCreateBool (FcBool b);
 
-FcExpr *
+FcPrivate FcExpr *
 FcExprCreateNil (void);
 
-FcExpr *
+FcPrivate FcExpr *
 FcExprCreateField (const char *field);
 
-FcExpr *
+FcPrivate FcExpr *
 FcExprCreateConst (const FcChar8 *constant);
 
-FcExpr *
+FcPrivate FcExpr *
 FcExprCreateOp (FcExpr *left, FcOp op, FcExpr *right);
 
-void
+FcPrivate void
 FcExprDestroy (FcExpr *e);
 
-void
+FcPrivate void
 FcEditDestroy (FcEdit *e);
 
 /* fcinit.c */
 
-void
+FcPrivate void
 FcMemReport (void);
 
-void
+FcPrivate void
 FcMemAlloc (int kind, int size);
 
-void
+FcPrivate void
 FcMemFree (int kind, int size);
 
 /* fclang.c */
-FcLangSet *
+FcPrivate FcLangSet *
 FcFreeTypeLangSet (const FcCharSet  *charset, 
 		   const FcChar8    *exclusiveLang);
 
-FcLangResult
+FcPrivate FcLangResult
 FcLangCompare (const FcChar8 *s1, const FcChar8 *s2);
     
-const FcCharSet *
+FcPrivate const FcCharSet *
 FcCharSetForLang (const FcChar8 *lang);
 
-FcLangSet *
+FcPrivate FcLangSet *
 FcLangSetPromote (const FcChar8 *lang);
 
-FcLangSet *
+FcPrivate FcLangSet *
 FcNameParseLangSet (const FcChar8 *string);
 
-FcBool
+FcPrivate FcBool
 FcNameUnparseLangSet (FcStrBuf *buf, const FcLangSet *ls);
 
-FcChar8 *
+FcPrivate FcChar8 *
 FcNameUnparseEscaped (FcPattern *pat, FcBool escape);
 
 /* fclist.c */
 
-FcBool
+FcPrivate FcBool
 FcListPatternMatchAny (const FcPattern *p,
 		       const FcPattern *font);
 
@@ -878,190 +859,184 @@ FcListPatternMatchAny (const FcPattern *p,
 #define FC_EMBEDDED_BITMAP_OBJECT	39
 #define FC_DECORATIVE_OBJECT	40
 
-FcBool
+FcPrivate FcBool
 FcNameBool (const FcChar8 *v, FcBool *result);
 
-FcBool
+FcPrivate FcBool
 FcObjectValidType (FcObject object, FcType type);
 
-FcObject
+FcPrivate FcObject
 FcObjectFromName (const char * name);
 
-const char *
+FcPrivate const char *
 FcObjectName (FcObject object);
 
-FcBool
+FcPrivate FcBool
 FcObjectInit (void);
 
-void
+FcPrivate void
 FcObjectFini (void);
 
 #define FcObjectCompare(a, b)	((int) a - (int) b)
 
 /* fcpat.c */
 
-FcValue
+FcPrivate FcValue
 FcValueCanonicalize (const FcValue *v);
 
-void
+FcPrivate void
 FcValueListDestroy (FcValueListPtr l);
 
-FcPatternElt *
+FcPrivate FcPatternElt *
 FcPatternObjectFindElt (const FcPattern *p, FcObject object);
 
-FcPatternElt *
+FcPrivate FcPatternElt *
 FcPatternObjectInsertElt (FcPattern *p, FcObject object);
 
-FcBool
+FcPrivate FcBool
 FcPatternObjectAddWithBinding  (FcPattern	*p,
 				FcObject	object,
 				FcValue		value,
 				FcValueBinding  binding,
 				FcBool		append);
 
-FcBool
+FcPrivate FcBool
 FcPatternObjectAdd (FcPattern *p, FcObject object, FcValue value, FcBool append);
     
-FcBool
+FcPrivate FcBool
 FcPatternObjectAddWeak (FcPattern *p, FcObject object, FcValue value, FcBool append);
     
-FcResult
+FcPrivate FcResult
 FcPatternObjectGet (const FcPattern *p, FcObject object, int id, FcValue *v);
     
-FcBool
+FcPrivate FcBool
 FcPatternObjectDel (FcPattern *p, FcObject object);
 
-FcBool
+FcPrivate FcBool
 FcPatternObjectRemove (FcPattern *p, FcObject object, int id);
 
-FcBool
+FcPrivate FcBool
 FcPatternObjectAddInteger (FcPattern *p, FcObject object, int i);
 
-FcBool
+FcPrivate FcBool
 FcPatternObjectAddDouble (FcPattern *p, FcObject object, double d);
 
-FcBool
+FcPrivate FcBool
 FcPatternObjectAddString (FcPattern *p, FcObject object, const FcChar8 *s);
 
-FcBool
+FcPrivate FcBool
 FcPatternObjectAddMatrix (FcPattern *p, FcObject object, const FcMatrix *s);
 
-FcBool
+FcPrivate FcBool
 FcPatternObjectAddCharSet (FcPattern *p, FcObject object, const FcCharSet *c);
 
-FcBool
+FcPrivate FcBool
 FcPatternObjectAddBool (FcPattern *p, FcObject object, FcBool b);
 
-FcBool
+FcPrivate FcBool
 FcPatternObjectAddLangSet (FcPattern *p, FcObject object, const FcLangSet *ls);
 
-FcResult
+FcPrivate FcResult
 FcPatternObjectGetInteger (const FcPattern *p, FcObject object, int n, int *i);
 
-FcResult
+FcPrivate FcResult
 FcPatternObjectGetDouble (const FcPattern *p, FcObject object, int n, double *d);
 
-FcResult
+FcPrivate FcResult
 FcPatternObjectGetString (const FcPattern *p, FcObject object, int n, FcChar8 ** s);
 
-FcResult
+FcPrivate FcResult
 FcPatternObjectGetMatrix (const FcPattern *p, FcObject object, int n, FcMatrix **s);
 
-FcResult
+FcPrivate FcResult
 FcPatternObjectGetCharSet (const FcPattern *p, FcObject object, int n, FcCharSet **c);
 
-FcResult
+FcPrivate FcResult
 FcPatternObjectGetBool (const FcPattern *p, FcObject object, int n, FcBool *b);
 
-FcResult
+FcPrivate FcResult
 FcPatternObjectGetLangSet (const FcPattern *p, FcObject object, int n, FcLangSet **ls);
 
-void
+FcPrivate void
 FcPatternFini (void);
 
-FcBool
+FcPrivate FcBool
 FcPatternAppend (FcPattern *p, FcPattern *s);
 
-const FcChar8 *
+FcPrivate const FcChar8 *
 FcStrStaticName (const FcChar8 *name);
 
-FcChar32
+FcPrivate FcChar32
 FcStringHash (const FcChar8 *s);
 
-FcBool
+FcPrivate FcBool
 FcPatternSerializeAlloc (FcSerialize *serialize, const FcPattern *pat);
 
-FcPattern *
+FcPrivate FcPattern *
 FcPatternSerialize (FcSerialize *serialize, const FcPattern *pat);
 
-FcBool
+FcPrivate FcBool
 FcValueListSerializeAlloc (FcSerialize *serialize, const FcValueList *pat);
 
-FcValueList *
+FcPrivate FcValueList *
 FcValueListSerialize (FcSerialize *serialize, const FcValueList *pat);
 
 /* fcrender.c */
 
 /* fcmatrix.c */
 
-extern const FcMatrix    FcIdentityMatrix;
+extern FcPrivate const FcMatrix    FcIdentityMatrix;
 
-void
+FcPrivate void
 FcMatrixFree (FcMatrix *mat);
 
 /* fcstr.c */
-void
+FcPrivate void
 FcStrSetSort (FcStrSet * set);
 
-FcChar8 *
-FcStrPlus (const FcChar8 *s1, const FcChar8 *s2);
-    
-void
-FcStrFree (FcChar8 *s);
-
-void
+FcPrivate void
 FcStrBufInit (FcStrBuf *buf, FcChar8 *init, int size);
 
-void
+FcPrivate void
 FcStrBufDestroy (FcStrBuf *buf);
 
-FcChar8 *
+FcPrivate FcChar8 *
 FcStrBufDone (FcStrBuf *buf);
 
-FcBool
+FcPrivate FcBool
 FcStrBufChar (FcStrBuf *buf, FcChar8 c);
 
-FcBool
+FcPrivate FcBool
 FcStrBufString (FcStrBuf *buf, const FcChar8 *s);
 
-FcBool
+FcPrivate FcBool
 FcStrBufData (FcStrBuf *buf, const FcChar8 *s, int len);
 
-int
+FcPrivate int
 FcStrCmpIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2);
 
-const FcChar8 *
+FcPrivate const FcChar8 *
 FcStrContainsIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2);
 
-const FcChar8 *
+FcPrivate const FcChar8 *
 FcStrContainsIgnoreCase (const FcChar8 *s1, const FcChar8 *s2);
 
-FcBool
+FcPrivate FcBool
 FcStrUsesHome (const FcChar8 *s);
 
-FcChar8 *
+FcPrivate FcChar8 *
 FcStrLastSlash (const FcChar8  *path);
 
-FcChar32
+FcPrivate FcChar32
 FcStrHashIgnoreCase (const FcChar8 *s);
 
-FcChar8 *
+FcPrivate FcChar8 *
 FcStrCanonFilename (const FcChar8 *s);
 
-FcBool
+FcPrivate FcBool
 FcStrSerializeAlloc (FcSerialize *serialize, const FcChar8 *str);
 
-FcChar8 *
+FcPrivate FcChar8 *
 FcStrSerialize (FcSerialize *serialize, const FcChar8 *str);
 
 #endif /* _FC_INT_H_ */