fontconfig: Branch 'master'

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

 



 configure.in            |    9 -
 fc-cache/fc-cache.c     |   30 +--
 fc-cat/Makefile.am      |    2 
 fc-cat/fc-cat.c         |   37 +---
 fontconfig/fcfreetype.h |   14 +
 fontconfig/fontconfig.h |  403 +++++++++++++++++++++++++++---------------------
 src/fccache.c           |   48 +++++
 src/fccharset.c         |    5 
 src/fcint.h             |  337 ++++++++++++++++++----------------------
 9 files changed, 481 insertions(+), 404 deletions(-)

New commits:
diff-tree 4984242e3681a50a9c19f352783f145f91ecb868 (from 34227592c23db4d462d36773532cef67731e2831)
Author: Keith Packard <keithp@xxxxxxxxxxxxxxx>
Date:   Mon Sep 4 00:47:07 2006 -0700

    Hide private functions in shared library. Export functionality for utilities.
    
    Borrowing header stuff written for cairo, fontconfig now exposes in the
    shared library only the symbols which are included in the public header
    files. All private symbols are hidden using suitable compiler directives.
    
    A few new public functions were required for the fontconfig utility programs
    (fc-cat and fc-cache) so those were added, bumping the .so minor version number
    in the process.

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 *con
 	    }
 	}
 
-	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 *con
 	    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 *con
 	{
 	    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, F
     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, FcStrSe
     
     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;
 
-_FCFUNCPROTOBEGIN
+typedef struct _FcCache	    FcCache;
 
-FcBool
-FcDirCacheValid (const FcChar8 *cache_file);
+_FCFUNCPROTOBEGIN
 
 /* 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
@@ -576,6 +576,54 @@ FcDirCacheWrite (FcCache *cache, FcConfi
 }
 
 /*
+ * 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
  * written by Colin Plumb in 1993, no copyright is claimed.
diff --git a/src/fccharset.c b/src/fccharset.c
index 3dac4ce..fdff91f 100644
--- a/src/fccharset.c
+++ b/src/fccharset.c
@@ -44,9 +44,6 @@ FcCharSetCreate (void)
 }
 
 FcCharSet *
-FcCharSetNew (void);
-    
-FcCharSet *
 FcCharSetNew (void)
 {
     return FcCharSetCreate ();
@@ -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 *
 #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_ */
_______________________________________________
Fontconfig mailing list
Fontconfig@xxxxxxxxxxxxxxxxxxxxx
http://lists.freedesktop.org/mailman/listinfo/fontconfig

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

  Powered by Linux