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 e8e10622cabc425f93b37024efb66ca2e2083522..8aac36e4574534e8350d332aba31b85875f8aef4 100644 (file)
--- a/configure.in
+++ b/configure.in
@@ -38,11 +38,14 @@ AM_MAINTAINER_MODE
 
 dnl libtool versioning
 
 
 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)
 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)
 
 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 f20d3a7c07203903d0aa5336b27450c075252860..de29351d4dba90fa1e8711fab18fa690752ea769 100644 (file)
--- a/fc-cache/fc-cache.c
+++ b/fc-cache/fc-cache.c
@@ -31,7 +31,7 @@
 #define HAVE_GETOPT 1
 #endif
 
 #define HAVE_GETOPT 1
 #endif
 

-#include "fcint.h"
+#include <fontconfig/fontconfig.h>

 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.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)
 {
 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
     
     /*
      * 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",
        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", 
        }
        else
        {
            if (verbose)
                printf ("caching, %d fonts, %d dirs\n", 

-                       set->nfont, cache->dirs_count);
+                       FcCacheNumFont (cache), FcCacheNumSubdir (cache));

 
            if (!FcDirCacheValid (dir))
            {
 
            if (!FcDirCacheValid (dir))
            {


@@ -253,7 +250,7 @@ scanDirs (FcStrList *list, FcConfig *config, FcBool force, FcBool really_force,
            FcDirCacheUnload (cache);
            continue;
        }
            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);
            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++;
        {
            fprintf (stderr, "%s: Can't create subdir list\n", dir);
            ret++;

-           FcDirCacheUnload (cache);

            continue;
        }
        FcStrSetAdd (processed_dirs, dir);
            continue;
        }
        FcStrSetAdd (processed_dirs, dir);


@@ -311,7 +307,7 @@ cleanCacheDirectory (FcConfig *config, FcChar8 *dir, FcBool verbose)
     while ((ent = readdir (d)))
     {
        FcChar8 *file_name;
     while ((ent = readdir (d)))
     {
        FcChar8 *file_name;

-       FcChar8 *target_dir;
+       const FcChar8   *target_dir;

 
        if (ent->d_name[0] == '.')
            continue;
 
        if (ent->d_name[0] == '.')
            continue;

diff --git a/fc-cat/Makefile.am b/fc-cat/Makefile.am
index 91e5ad720baf69e46a3d7edd83b96b5aa2cfc52c..828f138b7481c968ded18eb2d85809f1f5dfb804 100644 (file)
--- 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
 
 
 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
 
 
 bin_PROGRAMS=fc-cat
 

diff --git a/fc-cat/fc-cat.c b/fc-cat/fc-cat.c
index bb804ab0271c1af7d8dfc2f59d976c138ddd9622..476798e49d1ba4c675a1c784a66f6501748efff3 100644 (file)
--- a/fc-cat/fc-cat.c
+++ b/fc-cat/fc-cat.c
@@ -31,10 +31,11 @@
 #define HAVE_GETOPT 1
 #endif
 
 #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 "../fc-arch/fcarch.h"
 #include <stdio.h>
 #include <stdlib.h>

+#include <string.h>

 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/stat.h>


@@ -173,20 +174,20 @@ usage (char *program)
  */
 
 static const FcChar8 *
  */
 
 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;
 }
 
        return file + cache_len + 1;
     return file;
 }
 

+#define FC_FONT_FILE_DIR       ((FcChar8 *) ".dir")
+

 static FcBool
 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;
     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++)
     {
     
     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;
 
        if (FcPatternGetString (font, FC_FILE, 0, (FcChar8 **) &file) != FcResultMatch)
            goto bail3;


@@ -321,7 +320,7 @@ main (int argc, char **argv)
     {
        for (; i < argc; i++)
        {
     {
        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;
            {
                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;
     while ((arg = FcStrListNext (arglist)))
     {
        int         j;

-       off_t       size;
-       intptr_t    *cache_dirs;

        FcChar8     *cache_file = NULL;
        struct stat file_stat;
        
        FcChar8     *cache_file = NULL;
        struct stat file_stat;
        


@@ -373,17 +370,12 @@ main (int argc, char **argv)
        }
        
        dirs = FcStrSetCreate ();
        }
        
        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)
            if (recurse)

-               FcStrSetAdd (args, FcOffsetToPtr (cache_dirs,
-                                             cache_dirs[j],
-                                             FcChar8));
+               FcStrSetAdd (args, FcCacheSubdir (cache, j));

        }
 
        if (verbose)
        }
 
        if (verbose)


@@ -398,6 +390,7 @@ main (int argc, char **argv)
 
        FcStrSetDestroy (dirs);
 
 
        FcStrSetDestroy (dirs);
 

+       FcFontSetDestroy (fs);

        FcDirCacheUnload (cache);
        if (cache_file)
            FcStrFree (cache_file);
        FcDirCacheUnload (cache);
        if (cache_file)
            FcStrFree (cache_file);

diff --git a/fontconfig/fcfreetype.h b/fontconfig/fcfreetype.h
index a6cf2e64c15876503ab05a615a6f023793cb65ac..0c2a81c45532cb67a827a0fdf4d5439a84cfb7b9 100644 (file)
--- a/fontconfig/fcfreetype.h
+++ b/fontconfig/fcfreetype.h
@@ -27,21 +27,25 @@
 #include <ft2build.h>
 #include FT_FREETYPE_H
 
 #include <ft2build.h>
 #include FT_FREETYPE_H
 

+#ifndef FcPublic
+#define FcPublic
+#endif
+

 _FCFUNCPROTOBEGIN
 
 _FCFUNCPROTOBEGIN
 

-FT_UInt
+FcPublic FT_UInt

 FcFreeTypeCharIndex (FT_Face face, FcChar32 ucs4);
 
 FcFreeTypeCharIndex (FT_Face face, FcChar32 ucs4);
 

-FcCharSet *
+FcPublic FcCharSet *

 FcFreeTypeCharSetAndSpacing (FT_Face face, FcBlanks *blanks, int *spacing);
     
 FcFreeTypeCharSetAndSpacing (FT_Face face, FcBlanks *blanks, int *spacing);
     

-FcCharSet *
+FcPublic FcCharSet *

 FcFreeTypeCharSet (FT_Face face, FcBlanks *blanks);
 
 FcFreeTypeCharSet (FT_Face face, FcBlanks *blanks);
 

-FcResult
+FcPublic FcResult

 FcPatternGetFTFace (const FcPattern *p, const char *object, int n, FT_Face *f);
 
 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
 FcPatternAddFTFace (FcPattern *p, const char *object, const FT_Face f);
 
 _FCFUNCPROTOEND

diff --git a/fontconfig/fontconfig.h b/fontconfig/fontconfig.h
index 6ca1cf4548773d5d9b0b227906c3a1ccffaefec3..92a6d0828311aaa9c28d335e84f1005445f93852 100644 (file)
--- a/fontconfig/fontconfig.h
+++ b/fontconfig/fontconfig.h
@@ -25,6 +25,9 @@
 #ifndef _FONTCONFIG_H_
 #define _FONTCONFIG_H_
 
 #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)
 #include <stdarg.h>
 
 #if defined(__GNUC__) && (__GNUC__ >= 4)


@@ -33,6 +36,10 @@
 #define FC_ATTRIBUTE_SENTINEL(x)
 #endif
 
 #define FC_ATTRIBUTE_SENTINEL(x)
 #endif
 

+#ifndef FcPublic
+#define FcPublic
+#endif
+

 typedef unsigned char  FcChar8;
 typedef unsigned short FcChar16;
 typedef unsigned int   FcChar32;
 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 _FcStrSet    FcStrSet;
 

-_FCFUNCPROTOBEGIN
+typedef struct _FcCache            FcCache;

 
 

-FcBool
-FcDirCacheValid (const FcChar8 *cache_file);
+_FCFUNCPROTOBEGIN

 
 /* fcblanks.c */
 
 /* fcblanks.c */

-FcBlanks *
+FcPublic FcBlanks *

 FcBlanksCreate (void);
 
 FcBlanksCreate (void);
 

-void
+FcPublic void

 FcBlanksDestroy (FcBlanks *b);
 
 FcBlanksDestroy (FcBlanks *b);
 

-FcBool
+FcPublic FcBool

 FcBlanksAdd (FcBlanks *b, FcChar32 ucs4);
 
 FcBlanksAdd (FcBlanks *b, FcChar32 ucs4);
 

-FcBool
+FcPublic FcBool

 FcBlanksIsMember (FcBlanks *b, FcChar32 ucs4);
 
 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 */
 /* fccfg.c */

-FcChar8 *
+FcPublic FcChar8 *

 FcConfigHome (void);
 
 FcConfigHome (void);
 

-FcBool
+FcPublic FcBool

 FcConfigEnableHome (FcBool enable);
 
 FcConfigEnableHome (FcBool enable);
 

-FcChar8 *
+FcPublic FcChar8 *

 FcConfigFilename (const FcChar8 *url);
     
 FcConfigFilename (const FcChar8 *url);
     

-FcConfig *
+FcPublic FcConfig *

 FcConfigCreate (void);
 
 FcConfigCreate (void);
 

-void
+FcPublic void

 FcConfigDestroy (FcConfig *config);
 
 FcConfigDestroy (FcConfig *config);
 

-FcBool
+FcPublic FcBool

 FcConfigSetCurrent (FcConfig *config);
 
 FcConfigSetCurrent (FcConfig *config);
 

-FcConfig *
+FcPublic FcConfig *

 FcConfigGetCurrent (void);
 
 FcConfigGetCurrent (void);
 

-FcBool
+FcPublic FcBool

 FcConfigUptoDate (FcConfig *config);
     
 FcConfigUptoDate (FcConfig *config);
     

-FcBool
+FcPublic FcBool

 FcConfigBuildFonts (FcConfig *config);
 
 FcConfigBuildFonts (FcConfig *config);
 

-FcStrList *
+FcPublic FcStrList *

 FcConfigGetFontDirs (FcConfig   *config);
 
 FcConfigGetFontDirs (FcConfig   *config);
 

-FcStrList *
+FcPublic FcStrList *

 FcConfigGetConfigDirs (FcConfig   *config);
 
 FcConfigGetConfigDirs (FcConfig   *config);
 

-FcStrList *
+FcPublic FcStrList *

 FcConfigGetConfigFiles (FcConfig    *config);
 
 FcChar8 *
 FcConfigGetConfigFiles (FcConfig    *config);
 
 FcChar8 *


@@ -332,108 +361,124 @@ FcConfigGetCache (FcConfig  *config);
 FcBlanks *
 FcConfigGetBlanks (FcConfig *config);
 
 FcBlanks *
 FcConfigGetBlanks (FcConfig *config);
 

-int
+FcPublic FcStrList *
+FcConfigGetCacheDirs (FcConfig *config);
+
+FcPublic int

 FcConfigGetRescanInverval (FcConfig *config);
 
 FcConfigGetRescanInverval (FcConfig *config);
 

-FcBool
+FcPublic FcBool

 FcConfigSetRescanInverval (FcConfig *config, int rescanInterval);
 
 FcConfigSetRescanInverval (FcConfig *config, int rescanInterval);
 

-FcFontSet *
+FcPublic FcFontSet *

 FcConfigGetFonts (FcConfig     *config,
                  FcSetName     set);
 
 FcConfigGetFonts (FcConfig     *config,
                  FcSetName     set);
 

-FcBool
+FcPublic FcBool

 FcConfigAppFontAddFile (FcConfig    *config,
                        const FcChar8  *file);
 
 FcConfigAppFontAddFile (FcConfig    *config,
                        const FcChar8  *file);
 

-FcBool
+FcPublic FcBool

 FcConfigAppFontAddDir (FcConfig            *config,
                       const FcChar8   *dir);
 
 FcConfigAppFontAddDir (FcConfig            *config,
                       const FcChar8   *dir);
 

-void
+FcPublic void

 FcConfigAppFontClear (FcConfig     *config);
 
 FcConfigAppFontClear (FcConfig     *config);
 

-FcBool
+FcPublic FcBool

 FcConfigSubstituteWithPat (FcConfig    *config,
                           FcPattern    *p,
                           FcPattern    *p_pat,
                           FcMatchKind  kind);
 
 FcConfigSubstituteWithPat (FcConfig    *config,
                           FcPattern    *p,
                           FcPattern    *p_pat,
                           FcMatchKind  kind);
 

-FcBool
+FcPublic FcBool

 FcConfigSubstitute (FcConfig   *config,
                    FcPattern   *p,
                    FcMatchKind kind);
 
 /* fccharset.c */
 FcConfigSubstitute (FcConfig   *config,
                    FcPattern   *p,
                    FcMatchKind kind);
 
 /* fccharset.c */

-FcCharSet *
+FcPublic FcCharSet*

 FcCharSetCreate (void);
 
 FcCharSetCreate (void);
 

-void
+/* deprecated alias for FcCharSetCreate */
+FcPublic FcCharSet *
+FcCharSetNew (void);
+    
+FcPublic void

 FcCharSetDestroy (FcCharSet *fcs);
 
 FcCharSetDestroy (FcCharSet *fcs);
 

-FcBool
+FcPublic FcBool

 FcCharSetAddChar (FcCharSet *fcs, FcChar32 ucs4);
 
 FcCharSetAddChar (FcCharSet *fcs, FcChar32 ucs4);
 

-FcCharSet *
+FcPublic FcCharSet*

 FcCharSetCopy (FcCharSet *src);
 
 FcCharSetCopy (FcCharSet *src);
 

-FcBool
+FcPublic FcBool

 FcCharSetEqual (const FcCharSet *a, const FcCharSet *b);
 
 FcCharSetEqual (const FcCharSet *a, const FcCharSet *b);
 

-FcCharSet *
+FcPublic FcCharSet*

 FcCharSetIntersect (const FcCharSet *a, const FcCharSet *b);
 
 FcCharSetIntersect (const FcCharSet *a, const FcCharSet *b);
 

-FcCharSet *
+FcPublic FcCharSet*

 FcCharSetUnion (const FcCharSet *a, const FcCharSet *b);
 
 FcCharSetUnion (const FcCharSet *a, const FcCharSet *b);
 

-FcCharSet *
+FcPublic FcCharSet*

 FcCharSetSubtract (const FcCharSet *a, const FcCharSet *b);
 
 FcCharSetSubtract (const FcCharSet *a, const FcCharSet *b);
 

-FcBool
+FcPublic FcBool

 FcCharSetHasChar (const FcCharSet *fcs, FcChar32 ucs4);
 
 FcCharSetHasChar (const FcCharSet *fcs, FcChar32 ucs4);
 

-FcChar32
+FcPublic FcChar32

 FcCharSetCount (const FcCharSet *a);
 
 FcCharSetCount (const FcCharSet *a);
 

-FcChar32
+FcPublic FcChar32

 FcCharSetIntersectCount (const FcCharSet *a, const FcCharSet *b);
 
 FcCharSetIntersectCount (const FcCharSet *a, const FcCharSet *b);
 

-FcChar32
+FcPublic FcChar32

 FcCharSetSubtractCount (const FcCharSet *a, const FcCharSet *b);
 
 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)
 
 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);
 
 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);
 
 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 */
 
 /* fcdbg.c */

-void
+FcPublic void

 FcValuePrint (const FcValue v);
 
 FcValuePrint (const FcValue v);
 

-void
+FcPublic void

 FcPatternPrint (const FcPattern *p);
 
 FcPatternPrint (const FcPattern *p);
 

-void
+FcPublic void

 FcFontSetPrint (const FcFontSet *s);
 
 /* fcdefault.c */
 FcFontSetPrint (const FcFontSet *s);
 
 /* fcdefault.c */

-void
+FcPublic void

 FcDefaultSubstitute (FcPattern *pattern);
 
 /* fcdir.c */
 FcDefaultSubstitute (FcPattern *pattern);
 
 /* fcdir.c */

-FcBool
+FcPublic FcBool
+FcFileIsDir (const FcChar8 *file);
+
+FcPublic FcBool

 FcFileScan (FcFontSet      *set,
            FcStrSet        *dirs,
            FcFileCache     *cache,
 FcFileScan (FcFontSet      *set,
            FcStrSet        *dirs,
            FcFileCache     *cache,


@@ -441,7 +486,7 @@ FcFileScan (FcFontSet           *set,
            const FcChar8   *file,
            FcBool          force);
 
            const FcChar8   *file,
            FcBool          force);
 

-FcBool
+FcPublic FcBool

 FcDirScan (FcFontSet       *set,
           FcStrSet         *dirs,
           FcFileCache      *cache,
 FcDirScan (FcFontSet       *set,
           FcStrSet         *dirs,
           FcFileCache      *cache,


@@ -449,147 +494,159 @@ FcDirScan (FcFontSet        *set,
           const FcChar8    *dir,
           FcBool           force);
 
           const FcChar8    *dir,
           FcBool           force);
 

-FcBool
+FcPublic FcBool

 FcDirSave (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir);
 
 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 */
 /* fcfreetype.c */

-FcPattern *
+FcPublic FcPattern *

 FcFreeTypeQuery (const FcChar8 *file, int id, FcBlanks *blanks, int *count);
 
 /* fcfs.c */
 
 FcFreeTypeQuery (const FcChar8 *file, int id, FcBlanks *blanks, int *count);
 
 /* fcfs.c */
 

-FcFontSet *
+FcPublic FcFontSet *

 FcFontSetCreate (void);
 
 FcFontSetCreate (void);
 

-void
+FcPublic void

 FcFontSetDestroy (FcFontSet *s);
 
 FcFontSetDestroy (FcFontSet *s);
 

-FcBool
+FcPublic FcBool

 FcFontSetAdd (FcFontSet *s, FcPattern *font);
 
 /* fcinit.c */
 FcFontSetAdd (FcFontSet *s, FcPattern *font);
 
 /* fcinit.c */

-FcConfig *
+FcPublic FcConfig *

 FcInitLoadConfig (void);
 
 FcInitLoadConfig (void);
 

-FcConfig *
+FcPublic FcConfig *

 FcInitLoadConfigAndFonts (void);
 
 FcInitLoadConfigAndFonts (void);
 

-FcBool
+FcPublic FcBool

 FcInit (void);
 
 FcInit (void);
 

-void
+FcPublic void

 FcFini (void);
 
 FcFini (void);
 

-int
+FcPublic int

 FcGetVersion (void);
 
 FcGetVersion (void);
 

-FcBool
+FcPublic FcBool

 FcInitReinitialize (void);
 
 FcInitReinitialize (void);
 

-FcBool
+FcPublic FcBool

 FcInitBringUptoDate (void);
 
 /* fclang.c */
 FcInitBringUptoDate (void);
 
 /* fclang.c */

-FcLangSet *
+FcPublic FcLangSet*

 FcLangSetCreate (void);
 
 FcLangSetCreate (void);
 

-void
+FcPublic void

 FcLangSetDestroy (FcLangSet *ls);
 
 FcLangSetDestroy (FcLangSet *ls);
 

-FcLangSet *
+FcPublic FcLangSet*

 FcLangSetCopy (const FcLangSet *ls);
 
 FcLangSetCopy (const FcLangSet *ls);
 

-FcBool
+FcPublic FcBool

 FcLangSetAdd (FcLangSet *ls, const FcChar8 *lang);
 
 FcLangSetAdd (FcLangSet *ls, const FcChar8 *lang);
 

-FcLangResult
+FcPublic FcLangResult

 FcLangSetHasLang (const FcLangSet *ls, const FcChar8 *lang);
 
 FcLangSetHasLang (const FcLangSet *ls, const FcChar8 *lang);
 

-FcLangResult
+FcPublic FcLangResult

 FcLangSetCompare (const FcLangSet *lsa, const FcLangSet *lsb);
 
 FcLangSetCompare (const FcLangSet *lsa, const FcLangSet *lsb);
 

-FcBool
+FcPublic FcBool

 FcLangSetContains (const FcLangSet *lsa, const FcLangSet *lsb);
 
 FcLangSetContains (const FcLangSet *lsa, const FcLangSet *lsb);
 

-FcBool
+FcPublic FcBool

 FcLangSetEqual (const FcLangSet *lsa, const FcLangSet *lsb);
 
 FcLangSetEqual (const FcLangSet *lsa, const FcLangSet *lsb);
 

-FcChar32
+FcPublic FcChar32

 FcLangSetHash (const FcLangSet *ls);
 
 /* fclist.c */
 FcLangSetHash (const FcLangSet *ls);
 
 /* fclist.c */

-FcObjectSet *
+FcPublic FcObjectSet *

 FcObjectSetCreate (void);
 
 FcObjectSetCreate (void);
 

-FcBool
+FcPublic FcBool

 FcObjectSetAdd (FcObjectSet *os, const char *object);
 
 FcObjectSetAdd (FcObjectSet *os, const char *object);
 

-void
+FcPublic void

 FcObjectSetDestroy (FcObjectSet *os);
 
 FcObjectSetDestroy (FcObjectSet *os);
 

-FcObjectSet *
+FcPublic FcObjectSet *

 FcObjectSetVaBuild (const char *first, va_list va);
 
 FcObjectSetVaBuild (const char *first, va_list va);
 

-FcObjectSet *
+FcPublic FcObjectSet *

 FcObjectSetBuild (const char *first, ...) FC_ATTRIBUTE_SENTINEL(0);
 
 FcObjectSetBuild (const char *first, ...) FC_ATTRIBUTE_SENTINEL(0);
 

-FcFontSet *
+FcPublic FcFontSet *

 FcFontSetList (FcConfig            *config,
               FcFontSet    **sets,
               int          nsets,
               FcPattern    *p,
               FcObjectSet  *os);
 
 FcFontSetList (FcConfig            *config,
               FcFontSet    **sets,
               int          nsets,
               FcPattern    *p,
               FcObjectSet  *os);
 

-FcFontSet *
+FcPublic FcFontSet *

 FcFontList (FcConfig   *config,
            FcPattern   *p,
            FcObjectSet *os);
 
 /* fcatomic.c */
 
 FcFontList (FcConfig   *config,
            FcPattern   *p,
            FcObjectSet *os);
 
 /* fcatomic.c */
 

-FcAtomic *
+FcPublic FcAtomic *

 FcAtomicCreate (const FcChar8   *file);
 
 FcAtomicCreate (const FcChar8   *file);
 

-FcBool
+FcPublic FcBool

 FcAtomicLock (FcAtomic *atomic);
 
 FcAtomicLock (FcAtomic *atomic);
 

-FcChar8 *
+FcPublic FcChar8 *

 FcAtomicNewFile (FcAtomic *atomic);
 
 FcAtomicNewFile (FcAtomic *atomic);
 

-FcChar8 *
+FcPublic FcChar8 *

 FcAtomicOrigFile (FcAtomic *atomic);
 
 FcAtomicOrigFile (FcAtomic *atomic);
 

-FcBool
+FcPublic FcBool

 FcAtomicReplaceOrig (FcAtomic *atomic);
 
 FcAtomicReplaceOrig (FcAtomic *atomic);
 

-void
+FcPublic void

 FcAtomicDeleteNew (FcAtomic *atomic);
 
 FcAtomicDeleteNew (FcAtomic *atomic);
 

-void
+FcPublic void

 FcAtomicUnlock (FcAtomic *atomic);
 
 FcAtomicUnlock (FcAtomic *atomic);
 

-void
+FcPublic void

 FcAtomicDestroy (FcAtomic *atomic);
 
 /* fcmatch.c */
 FcAtomicDestroy (FcAtomic *atomic);
 
 /* fcmatch.c */

-FcPattern *
+FcPublic FcPattern *

 FcFontSetMatch (FcConfig    *config,
                FcFontSet   **sets,
                int         nsets,
                FcPattern   *p,
                FcResult    *result);
 
 FcFontSetMatch (FcConfig    *config,
                FcFontSet   **sets,
                int         nsets,
                FcPattern   *p,
                FcResult    *result);
 

-FcPattern *
+FcPublic FcPattern *

 FcFontMatch (FcConfig  *config,
             FcPattern  *p, 
             FcResult   *result);
 
 FcFontMatch (FcConfig  *config,
             FcPattern  *p, 
             FcResult   *result);
 

-FcPattern *
+FcPublic FcPattern *

 FcFontRenderPrepare (FcConfig      *config,
                     FcPattern      *pat,
                     FcPattern      *font);
 
 FcFontRenderPrepare (FcConfig      *config,
                     FcPattern      *pat,
                     FcPattern      *font);
 

-FcFontSet *
+FcPublic FcFontSet *

 FcFontSetSort (FcConfig            *config,
               FcFontSet    **sets,
               int          nsets,
 FcFontSetSort (FcConfig            *config,
               FcFontSet    **sets,
               int          nsets,


@@ -598,192 +655,198 @@ FcFontSetSort (FcConfig     *config,
               FcCharSet    **csp,
               FcResult     *result);
 
               FcCharSet    **csp,
               FcResult     *result);
 

-FcFontSet *
+FcPublic FcFontSet *

 FcFontSort (FcConfig    *config,
            FcPattern    *p,
            FcBool       trim,
            FcCharSet    **csp,
            FcResult     *result);
 
 FcFontSort (FcConfig    *config,
            FcPattern    *p,
            FcBool       trim,
            FcCharSet    **csp,
            FcResult     *result);
 

-void
+FcPublic void

 FcFontSetSortDestroy (FcFontSet *fs);
 
 /* fcmatrix.c */
 FcFontSetSortDestroy (FcFontSet *fs);
 
 /* fcmatrix.c */

-FcMatrix *
+FcPublic FcMatrix *

 FcMatrixCopy (const FcMatrix *mat);
 
 FcMatrixCopy (const FcMatrix *mat);
 

-FcBool
+FcPublic FcBool

 FcMatrixEqual (const FcMatrix *mat1, const FcMatrix *mat2);
 
 FcMatrixEqual (const FcMatrix *mat1, const FcMatrix *mat2);
 

-void
+FcPublic void

 FcMatrixMultiply (FcMatrix *result, const FcMatrix *a, const FcMatrix *b);
 
 FcMatrixMultiply (FcMatrix *result, const FcMatrix *a, const FcMatrix *b);
 

-void
+FcPublic void

 FcMatrixRotate (FcMatrix *m, double c, double s);
 
 FcMatrixRotate (FcMatrix *m, double c, double s);
 

-void
+FcPublic void

 FcMatrixScale (FcMatrix *m, double sx, double sy);
 
 FcMatrixScale (FcMatrix *m, double sx, double sy);
 

-void
+FcPublic void

 FcMatrixShear (FcMatrix *m, double sh, double sv);
 
 /* fcname.c */
 
 FcMatrixShear (FcMatrix *m, double sh, double sv);
 
 /* fcname.c */
 

-FcBool
+FcPublic FcBool

 FcNameRegisterObjectTypes (const FcObjectType *types, int ntype);
 
 FcNameRegisterObjectTypes (const FcObjectType *types, int ntype);
 

-FcBool
+FcPublic FcBool

 FcNameUnregisterObjectTypes (const FcObjectType *types, int ntype);
     
 FcNameUnregisterObjectTypes (const FcObjectType *types, int ntype);
     

-const FcObjectType *
+FcPublic const FcObjectType *

 FcNameGetObjectType (const char *object);
 
 FcNameGetObjectType (const char *object);
 

-FcBool
+FcPublic FcBool

 FcNameRegisterConstants (const FcConstant *consts, int nconsts);
 
 FcNameRegisterConstants (const FcConstant *consts, int nconsts);
 

-FcBool
+FcPublic FcBool

 FcNameUnregisterConstants (const FcConstant *consts, int nconsts);
     
 FcNameUnregisterConstants (const FcConstant *consts, int nconsts);
     

-const FcConstant *
+FcPublic const FcConstant *

 FcNameGetConstant (FcChar8 *string);
 
 FcNameGetConstant (FcChar8 *string);
 

-FcBool
+FcPublic FcBool

 FcNameConstant (FcChar8 *string, int *result);
 
 FcNameConstant (FcChar8 *string, int *result);
 

-FcPattern *
+FcPublic FcPattern *

 FcNameParse (const FcChar8 *name);
 
 FcNameParse (const FcChar8 *name);
 

-FcChar8 *
+FcPublic FcChar8 *

 FcNameUnparse (FcPattern *pat);
 
 /* fcpat.c */
 FcNameUnparse (FcPattern *pat);
 
 /* fcpat.c */

-FcPattern *
+FcPublic FcPattern *

 FcPatternCreate (void);
 
 FcPatternCreate (void);
 

-FcPattern *
+FcPublic FcPattern *

 FcPatternDuplicate (const FcPattern *p);
 
 FcPatternDuplicate (const FcPattern *p);
 

-void
+FcPublic void

 FcPatternReference (FcPattern *p);
 
 FcPatternReference (FcPattern *p);
 

-void
+FcPublic void

 FcValueDestroy (FcValue v);
 
 FcValueDestroy (FcValue v);
 

-FcBool
+FcPublic FcBool

 FcValueEqual (FcValue va, FcValue vb);
 
 FcValueEqual (FcValue va, FcValue vb);
 

-FcValue
+FcPublic FcValue

 FcValueSave (FcValue v);
 
 FcValueSave (FcValue v);
 

-void
+FcPublic void

 FcPatternDestroy (FcPattern *p);
 
 FcPatternDestroy (FcPattern *p);
 

-FcBool
+FcPublic FcBool

 FcPatternEqual (const FcPattern *pa, const FcPattern *pb);
 
 FcPatternEqual (const FcPattern *pa, const FcPattern *pb);
 

-FcBool
+FcPublic FcBool

 FcPatternEqualSubset (const FcPattern *pa, const FcPattern *pb, const FcObjectSet *os);
 
 FcPatternEqualSubset (const FcPattern *pa, const FcPattern *pb, const FcObjectSet *os);
 

-FcChar32
+FcPublic FcChar32

 FcPatternHash (const FcPattern *p);
 
 FcPatternHash (const FcPattern *p);
 

-FcBool
+FcPublic FcBool

 FcPatternAdd (FcPattern *p, const char *object, FcValue value, FcBool append);
     
 FcPatternAdd (FcPattern *p, const char *object, FcValue value, FcBool append);
     

-FcBool
+FcPublic FcBool

 FcPatternAddWeak (FcPattern *p, const char *object, FcValue value, FcBool append);
     
 FcPatternAddWeak (FcPattern *p, const char *object, FcValue value, FcBool append);
     

-FcResult
+FcPublic FcResult

 FcPatternGet (const FcPattern *p, const char *object, int id, FcValue *v);
     
 FcPatternGet (const FcPattern *p, const char *object, int id, FcValue *v);
     

-FcBool
+FcPublic FcBool

 FcPatternDel (FcPattern *p, const char *object);
 
 FcPatternDel (FcPattern *p, const char *object);
 

-FcBool
+FcPublic FcBool

 FcPatternRemove (FcPattern *p, const char *object, int id);
 
 FcPatternRemove (FcPattern *p, const char *object, int id);
 

-FcBool
+FcPublic FcBool

 FcPatternAddInteger (FcPattern *p, const char *object, int i);
 
 FcPatternAddInteger (FcPattern *p, const char *object, int i);
 

-FcBool
+FcPublic FcBool

 FcPatternAddDouble (FcPattern *p, const char *object, double d);
 
 FcPatternAddDouble (FcPattern *p, const char *object, double d);
 

-FcBool
+FcPublic FcBool

 FcPatternAddString (FcPattern *p, const char *object, const FcChar8 *s);
 
 FcPatternAddString (FcPattern *p, const char *object, const FcChar8 *s);
 

-FcBool
+FcPublic FcBool

 FcPatternAddMatrix (FcPattern *p, const char *object, const FcMatrix *s);
 
 FcPatternAddMatrix (FcPattern *p, const char *object, const FcMatrix *s);
 

-FcBool
+FcPublic FcBool

 FcPatternAddCharSet (FcPattern *p, const char *object, const FcCharSet *c);
 
 FcPatternAddCharSet (FcPattern *p, const char *object, const FcCharSet *c);
 

-FcBool
+FcPublic FcBool

 FcPatternAddBool (FcPattern *p, const char *object, FcBool b);
 
 FcPatternAddBool (FcPattern *p, const char *object, FcBool b);
 

-FcBool
+FcPublic FcBool

 FcPatternAddLangSet (FcPattern *p, const char *object, const FcLangSet *ls);
 
 FcPatternAddLangSet (FcPattern *p, const char *object, const FcLangSet *ls);
 

-FcResult
+FcPublic FcResult

 FcPatternGetInteger (const FcPattern *p, const char *object, int n, int *i);
 
 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);
 
 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);
 
 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);
 
 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);
 
 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);
 
 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);
 
 FcPatternGetLangSet (const FcPattern *p, const char *object, int n, FcLangSet **ls);
 

-FcPattern *
+FcPublic FcPattern *

 FcPatternVaBuild (FcPattern *orig, va_list va);
     
 FcPatternVaBuild (FcPattern *orig, va_list va);
     

-FcPattern *
+FcPublic FcPattern *

 FcPatternBuild (FcPattern *orig, ...) FC_ATTRIBUTE_SENTINEL(0);
 
 /* fcstr.c */
 
 FcPatternBuild (FcPattern *orig, ...) FC_ATTRIBUTE_SENTINEL(0);
 
 /* fcstr.c */
 

-FcChar8 *
+FcPublic FcChar8 *

 FcStrCopy (const FcChar8 *s);
 
 FcStrCopy (const FcChar8 *s);
 

-FcChar8 *
+FcPublic FcChar8 *

 FcStrCopyFilename (const FcChar8 *s);
     
 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))
 
 /* 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);
 
 FcStrDowncase (const FcChar8 *s);
 

-int
+FcPublic int

 FcStrCmpIgnoreCase (const FcChar8 *s1, const FcChar8 *s2);
 
 FcStrCmpIgnoreCase (const FcChar8 *s1, const FcChar8 *s2);
 

-int
+FcPublic int

 FcStrCmp (const FcChar8 *s1, const FcChar8 *s2);
 
 FcStrCmp (const FcChar8 *s1, const FcChar8 *s2);
 

-const FcChar8 *
+FcPublic const FcChar8 *

 FcStrStrIgnoreCase (const FcChar8 *s1, const FcChar8 *s2);
 
 FcStrStrIgnoreCase (const FcChar8 *s1, const FcChar8 *s2);
 

-const FcChar8 *
+FcPublic const FcChar8 *

 FcStrStr (const FcChar8 *s1, const FcChar8 *s2);
 
 FcStrStr (const FcChar8 *s1, const FcChar8 *s2);
 

-int
+FcPublic int

 FcUtf8ToUcs4 (const FcChar8 *src_orig,
              FcChar32      *dst,
              int           len);
 
 FcUtf8ToUcs4 (const FcChar8 *src_orig,
              FcChar32      *dst,
              int           len);
 

-FcBool
+FcPublic FcBool

 FcUtf8Len (const FcChar8    *string,
           int              len,
           int              *nchar,
 FcUtf8Len (const FcChar8    *string,
           int              len,
           int              *nchar,


@@ -791,61 +854,61 @@ FcUtf8Len (const FcChar8    *string,
 
 #define FC_UTF8_MAX_LEN        6
 
 
 #define FC_UTF8_MAX_LEN        6
 

-int
+FcPublic int

 FcUcs4ToUtf8 (FcChar32 ucs4,
              FcChar8   dest[FC_UTF8_MAX_LEN]);
 
 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 */
 
 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);
 
 FcUtf16Len (const FcChar8   *string,
            FcEndian        endian,
            int             len,            /* in bytes */
            int             *nchar,
            int             *wchar);
 

-FcChar8 *
+FcPublic FcChar8 *

 FcStrDirname (const FcChar8 *file);
 
 FcStrDirname (const FcChar8 *file);
 

-FcChar8 *
+FcPublic FcChar8 *

 FcStrBasename (const FcChar8 *file);
 
 FcStrBasename (const FcChar8 *file);
 

-FcStrSet *
+FcPublic FcStrSet *

 FcStrSetCreate (void);
 
 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 */
 
 /* fcxml.c */

-FcBool
+FcPublic FcBool

 FcConfigParseAndLoad (FcConfig *config, const FcChar8 *file, FcBool complain);
 
 _FCFUNCPROTOEND
 FcConfigParseAndLoad (FcConfig *config, const FcChar8 *file, FcBool complain);
 
 _FCFUNCPROTOEND

diff --git a/src/fccache.c b/src/fccache.c
index 05dc7eee6ad2f40d48e26eacb1f7ea4441cf002a..aa039900a39632d46b8ed122be79ba4d9d1d8dc4 100644 (file)
--- a/src/fccache.c
+++ b/src/fccache.c
@@ -575,6 +575,54 @@ FcDirCacheWrite (FcCache *cache, FcConfig *config)
     return FcFalse;
 }
 
     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
 /*
  * 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 3dac4ce6a378d627187245e36959c209778e2283..fdff91f810c081280f38b0fd072aa1d21a889b7f 100644 (file)
--- a/src/fccharset.c
+++ b/src/fccharset.c
@@ -43,9 +43,6 @@ FcCharSetCreate (void)
     return fcs;
 }
 
     return fcs;
 }
 

-FcCharSet *
-FcCharSetNew (void);
-    

 FcCharSet *
 FcCharSetNew (void)
 {
 FcCharSet *
 FcCharSetNew (void)
 {


@@ -693,8 +690,6 @@ FcCharSetFirstPage (const FcCharSet *a,
 /*
  * old coverage API, rather hard to use correctly
  */
 /*
  * 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)
     
 FcChar32
 FcCharSetCoverage (const FcCharSet *a, FcChar32 page, FcChar32 *result)

diff --git a/src/fcint.h b/src/fcint.h
index 3b9f3c852697c7259a00ce006a21cf8278a67028..6cdb7cb51903f40b35d893bacf0561b9527a92da 100644 (file)
--- a/src/fcint.h
+++ b/src/fcint.h
@@ -53,9 +53,6 @@
 #define FC_CONFIG_PATH "fonts.conf"
 #endif
 
 #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
 #ifdef _WIN32
 #define FC_SEARCH_PATH_SEPARATOR ';'
 #else


@@ -113,6 +110,15 @@
 #define FC_BANK_FIRST 1
 #define FC_BANK_LANGS      0xfcfcfcfc
 
 #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;
 typedef enum _FcValueBinding {
     FcValueBindingWeak, FcValueBindingStrong, FcValueBindingSame
 } FcValueBinding;


@@ -306,7 +312,7 @@ typedef struct _FcStrBuf {
     int            size;
 } 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 */
     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 */
     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 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)
 
 /*
                                           FcChar8)
 
 /*


@@ -483,7 +489,7 @@ struct _FcConfig {
     int                rescanInterval;     /* interval between scans */
 };
  
     int                rescanInterval;     /* interval between scans */
 };
  

-extern FcConfig        *_fcConfig;
+extern FcPrivate FcConfig      *_fcConfig;

 
 typedef struct _FcFileTime {
     time_t  time;
 
 typedef struct _FcFileTime {
     time_t  time;


@@ -499,208 +505,186 @@ typedef struct _FcCharMap FcCharMap;
 
 /* fccache.c */
 
 
 /* fccache.c */
 

-FcBool
-FcDirCacheUnlink (const FcChar8 *dir, FcConfig *config);
-
-void
-FcDirCacheUnload (FcCache *cache);
-
-FcCache *
+FcPrivate FcCache *

 FcDirCacheScan (const FcChar8 *dir, FcConfig *config);
 
 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);
 
 FcDirCacheBuild (FcFontSet *set, const FcChar8 *dir, FcStrSet *dirs);
 

-FcBool
+FcPrivate FcBool

 FcDirCacheWrite (FcCache *cache, FcConfig *config);
     
 /* fccfg.c */
 
 FcDirCacheWrite (FcCache *cache, FcConfig *config);
     
 /* fccfg.c */
 

-FcBool
+FcPrivate FcBool

 FcConfigAddConfigDir (FcConfig     *config,
                      const FcChar8 *d);
 
 FcConfigAddConfigDir (FcConfig     *config,
                      const FcChar8 *d);
 

-FcBool
+FcPrivate FcBool

 FcConfigAddFontDir (FcConfig       *config,
                    const FcChar8   *d);
 
 FcConfigAddFontDir (FcConfig       *config,
                    const FcChar8   *d);
 

-FcBool
+FcPrivate FcBool

 FcConfigAddDir (FcConfig       *config,
                const FcChar8   *d);
 
 FcConfigAddDir (FcConfig       *config,
                const FcChar8   *d);
 

-FcBool
+FcPrivate FcBool

 FcConfigAddCacheDir (FcConfig      *config,
                     const FcChar8  *d);
 
 FcConfigAddCacheDir (FcConfig      *config,
                     const FcChar8  *d);
 

-FcStrList *
-FcConfigGetCacheDirs (FcConfig *config);
-
-FcBool
+FcPrivate FcBool

 FcConfigAddConfigFile (FcConfig                *config,
                       const FcChar8    *f);
 
 FcConfigAddConfigFile (FcConfig                *config,
                       const FcChar8    *f);
 

-FcBool
+FcPrivate FcBool

 FcConfigAddBlank (FcConfig     *config,
                  FcChar32      blank);
 
 FcConfigAddBlank (FcConfig     *config,
                  FcChar32      blank);
 

-FcBool
+FcPrivate FcBool

 FcConfigAddEdit (FcConfig      *config,
                 FcTest         *test,
                 FcEdit         *edit,
                 FcMatchKind    kind);
 
 FcConfigAddEdit (FcConfig      *config,
                 FcTest         *test,
                 FcEdit         *edit,
                 FcMatchKind    kind);
 

-void
+FcPrivate void

 FcConfigSetFonts (FcConfig     *config,
                  FcFontSet     *fonts,
                  FcSetName     set);
 
 FcConfigSetFonts (FcConfig     *config,
                  FcFontSet     *fonts,
                  FcSetName     set);
 

-FcBool
+FcPrivate FcBool

 FcConfigCompareValue (const FcValue *m,
                      FcOp          op,
                      const FcValue *v);
 
 FcConfigCompareValue (const FcValue *m,
                      FcOp          op,
                      const FcValue *v);
 

-FcBool
+FcPrivate FcBool

 FcConfigGlobAdd (FcConfig      *config,
                 const FcChar8  *glob,
                 FcBool         accept);
 
 FcConfigGlobAdd (FcConfig      *config,
                 const FcChar8  *glob,
                 FcBool         accept);
 

-FcBool
+FcPrivate FcBool

 FcConfigAcceptFilename (FcConfig       *config,
                        const FcChar8   *filename);
 
 FcConfigAcceptFilename (FcConfig       *config,
                        const FcChar8   *filename);
 

-FcBool
+FcPrivate FcBool

 FcConfigPatternsAdd (FcConfig  *config,
                     FcPattern  *pattern,
                     FcBool     accept);
 
 FcConfigPatternsAdd (FcConfig  *config,
                     FcPattern  *pattern,
                     FcBool     accept);
 

-FcBool
+FcPrivate FcBool

 FcConfigAcceptFont (FcConfig       *config,
                    const FcPattern *font);
 
 FcConfigAcceptFont (FcConfig       *config,
                    const FcPattern *font);
 

-FcFileTime
+FcPrivate FcFileTime

 FcConfigModifiedTime (FcConfig *config);
 
 FcConfigModifiedTime (FcConfig *config);
 

-FcBool
+FcPrivate FcBool

 FcConfigAddCache (FcConfig *config, FcCache *cache);
 
 /* fcserialize.c */
 FcConfigAddCache (FcConfig *config, FcCache *cache);
 
 /* fcserialize.c */

-intptr_t
+FcPrivate intptr_t

 FcAlignSize (intptr_t size);
     
 FcAlignSize (intptr_t size);
     

-FcSerialize *
+FcPrivate FcSerialize *

 FcSerializeCreate (void);
 
 FcSerializeCreate (void);
 

-void
+FcPrivate void

 FcSerializeDestroy (FcSerialize *serialize);
 
 FcSerializeDestroy (FcSerialize *serialize);
 

-FcBool
+FcPrivate FcBool

 FcSerializeAlloc (FcSerialize *serialize, const void *object, int size);
 
 FcSerializeAlloc (FcSerialize *serialize, const void *object, int size);
 

-intptr_t
+FcPrivate intptr_t

 FcSerializeReserve (FcSerialize *serialize, int size);
 
 FcSerializeReserve (FcSerialize *serialize, int size);
 

-intptr_t
+FcPrivate intptr_t

 FcSerializeOffset (FcSerialize *serialize, const void *object);
 
 FcSerializeOffset (FcSerialize *serialize, const void *object);
 

-void *
+FcPrivate void *

 FcSerializePtr (FcSerialize *serialize, const void *object);
 
 FcSerializePtr (FcSerialize *serialize, const void *object);
 

-FcBool
+FcPrivate FcBool

 FcLangSetSerializeAlloc (FcSerialize *serialize, const FcLangSet *l);
 
 FcLangSetSerializeAlloc (FcSerialize *serialize, const FcLangSet *l);
 

-FcLangSet *
+FcPrivate FcLangSet *

 FcLangSetSerialize(FcSerialize *serialize, const FcLangSet *l);
 
 /* fccharset.c */
 FcLangSetSerialize(FcSerialize *serialize, const FcLangSet *l);
 
 /* fccharset.c */

-void
+FcPrivate void

 FcLangCharSetPopulate (void);
 
 FcLangCharSetPopulate (void);
 

-FcCharSetFreezer *
+FcPrivate FcCharSetFreezer *

 FcCharSetFreezerCreate (void);
 
 FcCharSetFreezerCreate (void);
 

-const FcCharSet *
+FcPrivate const FcCharSet *

 FcCharSetFreeze (FcCharSetFreezer *freezer, const FcCharSet *fcs);
 
 FcCharSetFreeze (FcCharSetFreezer *freezer, const FcCharSet *fcs);
 

-void
+FcPrivate void

 FcCharSetFreezerDestroy (FcCharSetFreezer *freezer);
 
 FcCharSetFreezerDestroy (FcCharSetFreezer *freezer);
 

-FcBool
+FcPrivate FcBool

 FcNameUnparseCharSet (FcStrBuf *buf, const FcCharSet *c);
 
 FcNameUnparseCharSet (FcStrBuf *buf, const FcCharSet *c);
 

-FcCharSet *
+FcPrivate FcCharSet *

 FcNameParseCharSet (FcChar8 *string);
 
 FcNameParseCharSet (FcChar8 *string);
 

-FcCharLeaf *
+FcPrivate FcCharLeaf *

 FcCharSetFindLeafCreate (FcCharSet *fcs, FcChar32 ucs4);
 
 FcCharSetFindLeafCreate (FcCharSet *fcs, FcChar32 ucs4);
 

-FcBool
+FcPrivate FcBool

 FcCharSetSerializeAlloc(FcSerialize *serialize, const FcCharSet *cs);
 
 FcCharSetSerializeAlloc(FcSerialize *serialize, const FcCharSet *cs);
 

-FcCharSet *
+FcPrivate FcCharSet *

 FcCharSetSerialize(FcSerialize *serialize, const FcCharSet *cs);
 
 FcCharSetSerialize(FcSerialize *serialize, const FcCharSet *cs);
 

-FcChar16 *
+FcPrivate FcChar16 *

 FcCharSetGetNumbers(const FcCharSet *c);
 
 /* fcdbg.c */
 FcCharSetGetNumbers(const FcCharSet *c);
 
 /* fcdbg.c */

-void
+FcPrivate void

 FcValueListPrint (const FcValueListPtr l);
 
 FcValueListPrint (const FcValueListPtr l);
 

-void
+FcPrivate void

 FcLangSetPrint (const FcLangSet *ls);
 
 FcLangSetPrint (const FcLangSet *ls);
 

-void
+FcPrivate void

 FcOpPrint (FcOp op);
 
 FcOpPrint (FcOp op);
 

-void
+FcPrivate void

 FcTestPrint (const FcTest *test);
 
 FcTestPrint (const FcTest *test);
 

-void
+FcPrivate void

 FcExprPrint (const FcExpr *expr);
 
 FcExprPrint (const FcExpr *expr);
 

-void
+FcPrivate void

 FcEditPrint (const FcEdit *edit);
 
 FcEditPrint (const FcEdit *edit);
 

-void
+FcPrivate void

 FcSubstPrint (const FcSubst *subst);
 
 FcSubstPrint (const FcSubst *subst);
 

-void
+FcPrivate void

 FcCharSetPrint (const FcCharSet *c);
     
 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 */
 FcInitDebug (void);
 
 /* fcdefault.c */

-FcChar8 *
+FcPrivate FcChar8 *

 FcGetDefaultLang (void);
 
 /* fcdir.c */
 
 FcGetDefaultLang (void);
 
 /* fcdir.c */
 

-FcBool
-FcFileIsDir (const FcChar8 *file);
-
-FcBool
+FcPrivate FcBool

 FcFileScanConfig (FcFontSet    *set,
                  FcStrSet      *dirs,
                  FcBlanks      *blanks,
                  const FcChar8 *file,
                  FcConfig      *config);
 
 FcFileScanConfig (FcFontSet    *set,
                  FcStrSet      *dirs,
                  FcBlanks      *blanks,
                  const FcChar8 *file,
                  FcConfig      *config);
 

-FcBool
+FcPrivate FcBool

 FcDirScanConfig (FcFontSet     *set,
                 FcStrSet       *dirs,
                 FcBlanks       *blanks,
 FcDirScanConfig (FcFontSet     *set,
                 FcStrSet       *dirs,
                 FcBlanks       *blanks,


@@ -708,123 +692,120 @@ FcDirScanConfig (FcFontSet      *set,
                 FcBool         force,
                 FcConfig       *config);
 
                 FcBool         force,
                 FcConfig       *config);
 

-FcCache *
-FcDirCacheRead (const FcChar8 *dir, FcBool force, FcConfig *config);
-

 /* fcfont.c */
 /* fcfont.c */

-int
+FcPrivate int

 FcFontDebug (void);
     
 /* fcfreetype.c */
 FcFontDebug (void);
     
 /* fcfreetype.c */

-FcBool
+FcPrivate FcBool

 FcFreeTypeIsExclusiveLang (const FcChar8  *lang);
 
 FcFreeTypeIsExclusiveLang (const FcChar8  *lang);
 

-FcBool
+FcPrivate FcBool

 FcFreeTypeHasLang (FcPattern *pattern, const FcChar8 *lang);
 
 FcFreeTypeHasLang (FcPattern *pattern, const FcChar8 *lang);
 

-FcChar32
+FcPrivate FcChar32

 FcFreeTypeUcs4ToPrivate (FcChar32 ucs4, const FcCharMap *map);
 
 FcFreeTypeUcs4ToPrivate (FcChar32 ucs4, const FcCharMap *map);
 

-FcChar32
+FcPrivate FcChar32

 FcFreeTypePrivateToUcs4 (FcChar32 private, const FcCharMap *map);
 
 FcFreeTypePrivateToUcs4 (FcChar32 private, const FcCharMap *map);
 

-const FcCharMap *
+FcPrivate const FcCharMap *

 FcFreeTypeGetPrivateMap (FT_Encoding encoding);
     
 /* fcfs.c */
 
 FcFreeTypeGetPrivateMap (FT_Encoding encoding);
     
 /* fcfs.c */
 

-FcBool
+FcPrivate FcBool

 FcFontSetSerializeAlloc (FcSerialize *serialize, const FcFontSet *s);
 
 FcFontSetSerializeAlloc (FcSerialize *serialize, const FcFontSet *s);
 

-FcFontSet *
+FcPrivate FcFontSet *

 FcFontSetSerialize (FcSerialize *serialize, const FcFontSet * s);
     
 /* fcgram.y */
 FcFontSetSerialize (FcSerialize *serialize, const FcFontSet * s);
     
 /* fcgram.y */

-int
+FcPrivate int

 FcConfigparse (void);
 
 FcConfigparse (void);
 

-int
+FcPrivate int

 FcConfigwrap (void);
     
 FcConfigwrap (void);
     

-void
+FcPrivate void

 FcConfigerror (char *fmt, ...);
     
 FcConfigerror (char *fmt, ...);
     

-char *
+FcPrivate char *

 FcConfigSaveField (const char *field);
 
 FcConfigSaveField (const char *field);
 

-void
+FcPrivate void

 FcTestDestroy (FcTest *test);
 
 FcTestDestroy (FcTest *test);
 

-FcExpr *
+FcPrivate FcExpr *

 FcExprCreateInteger (int i);
 
 FcExprCreateInteger (int i);
 

-FcExpr *
+FcPrivate FcExpr *

 FcExprCreateDouble (double d);
 
 FcExprCreateDouble (double d);
 

-FcExpr *
+FcPrivate FcExpr *

 FcExprCreateString (const FcChar8 *s);
 
 FcExprCreateString (const FcChar8 *s);
 

-FcExpr *
+FcPrivate FcExpr *

 FcExprCreateMatrix (const FcMatrix *m);
 
 FcExprCreateMatrix (const FcMatrix *m);
 

-FcExpr *
+FcPrivate FcExpr *

 FcExprCreateBool (FcBool b);
 
 FcExprCreateBool (FcBool b);
 

-FcExpr *
+FcPrivate FcExpr *

 FcExprCreateNil (void);
 
 FcExprCreateNil (void);
 

-FcExpr *
+FcPrivate FcExpr *

 FcExprCreateField (const char *field);
 
 FcExprCreateField (const char *field);
 

-FcExpr *
+FcPrivate FcExpr *

 FcExprCreateConst (const FcChar8 *constant);
 
 FcExprCreateConst (const FcChar8 *constant);
 

-FcExpr *
+FcPrivate FcExpr *

 FcExprCreateOp (FcExpr *left, FcOp op, FcExpr *right);
 
 FcExprCreateOp (FcExpr *left, FcOp op, FcExpr *right);
 

-void
+FcPrivate void

 FcExprDestroy (FcExpr *e);
 
 FcExprDestroy (FcExpr *e);
 

-void
+FcPrivate void

 FcEditDestroy (FcEdit *e);
 
 /* fcinit.c */
 
 FcEditDestroy (FcEdit *e);
 
 /* fcinit.c */
 

-void
+FcPrivate void

 FcMemReport (void);
 
 FcMemReport (void);
 

-void
+FcPrivate void

 FcMemAlloc (int kind, int size);
 
 FcMemAlloc (int kind, int size);
 

-void
+FcPrivate void

 FcMemFree (int kind, int size);
 
 /* fclang.c */
 FcMemFree (int kind, int size);
 
 /* fclang.c */

-FcLangSet *
+FcPrivate FcLangSet *

 FcFreeTypeLangSet (const FcCharSet  *charset, 
                   const FcChar8    *exclusiveLang);
 
 FcFreeTypeLangSet (const FcCharSet  *charset, 
                   const FcChar8    *exclusiveLang);
 

-FcLangResult
+FcPrivate FcLangResult

 FcLangCompare (const FcChar8 *s1, const FcChar8 *s2);
     
 FcLangCompare (const FcChar8 *s1, const FcChar8 *s2);
     

-const FcCharSet *
+FcPrivate const FcCharSet *

 FcCharSetForLang (const FcChar8 *lang);
 
 FcCharSetForLang (const FcChar8 *lang);
 

-FcLangSet *
+FcPrivate FcLangSet *

 FcLangSetPromote (const FcChar8 *lang);
 
 FcLangSetPromote (const FcChar8 *lang);
 

-FcLangSet *
+FcPrivate FcLangSet *

 FcNameParseLangSet (const FcChar8 *string);
 
 FcNameParseLangSet (const FcChar8 *string);
 

-FcBool
+FcPrivate FcBool

 FcNameUnparseLangSet (FcStrBuf *buf, const FcLangSet *ls);
 
 FcNameUnparseLangSet (FcStrBuf *buf, const FcLangSet *ls);
 

-FcChar8 *
+FcPrivate FcChar8 *

 FcNameUnparseEscaped (FcPattern *pat, FcBool escape);
 
 /* fclist.c */
 
 FcNameUnparseEscaped (FcPattern *pat, FcBool escape);
 
 /* fclist.c */
 

-FcBool
+FcPrivate FcBool

 FcListPatternMatchAny (const FcPattern *p,
                       const FcPattern *font);
 
 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
 
 #define FC_EMBEDDED_BITMAP_OBJECT      39
 #define FC_DECORATIVE_OBJECT   40
 

-FcBool
+FcPrivate FcBool

 FcNameBool (const FcChar8 *v, FcBool *result);
 
 FcNameBool (const FcChar8 *v, FcBool *result);
 

-FcBool
+FcPrivate FcBool

 FcObjectValidType (FcObject object, FcType type);
 
 FcObjectValidType (FcObject object, FcType type);
 

-FcObject
+FcPrivate FcObject

 FcObjectFromName (const char * name);
 
 FcObjectFromName (const char * name);
 

-const char *
+FcPrivate const char *

 FcObjectName (FcObject object);
 
 FcObjectName (FcObject object);
 

-FcBool
+FcPrivate FcBool

 FcObjectInit (void);
 
 FcObjectInit (void);
 

-void
+FcPrivate void

 FcObjectFini (void);
 
 #define FcObjectCompare(a, b)  ((int) a - (int) b)
 
 /* fcpat.c */
 
 FcObjectFini (void);
 
 #define FcObjectCompare(a, b)  ((int) a - (int) b)
 
 /* fcpat.c */
 

-FcValue
+FcPrivate FcValue

 FcValueCanonicalize (const FcValue *v);
 
 FcValueCanonicalize (const FcValue *v);
 

-void
+FcPrivate void

 FcValueListDestroy (FcValueListPtr l);
 
 FcValueListDestroy (FcValueListPtr l);
 

-FcPatternElt *
+FcPrivate FcPatternElt *

 FcPatternObjectFindElt (const FcPattern *p, FcObject object);
 
 FcPatternObjectFindElt (const FcPattern *p, FcObject object);
 

-FcPatternElt *
+FcPrivate FcPatternElt *

 FcPatternObjectInsertElt (FcPattern *p, FcObject object);
 
 FcPatternObjectInsertElt (FcPattern *p, FcObject object);
 

-FcBool
+FcPrivate FcBool

 FcPatternObjectAddWithBinding  (FcPattern      *p,
                                FcObject        object,
                                FcValue         value,
                                FcValueBinding  binding,
                                FcBool          append);
 
 FcPatternObjectAddWithBinding  (FcPattern      *p,
                                FcObject        object,
                                FcValue         value,
                                FcValueBinding  binding,
                                FcBool          append);
 

-FcBool
+FcPrivate FcBool

 FcPatternObjectAdd (FcPattern *p, FcObject object, FcValue value, FcBool append);
     
 FcPatternObjectAdd (FcPattern *p, FcObject object, FcValue value, FcBool append);
     

-FcBool
+FcPrivate FcBool

 FcPatternObjectAddWeak (FcPattern *p, FcObject object, FcValue value, FcBool append);
     
 FcPatternObjectAddWeak (FcPattern *p, FcObject object, FcValue value, FcBool append);
     

-FcResult
+FcPrivate FcResult

 FcPatternObjectGet (const FcPattern *p, FcObject object, int id, FcValue *v);
     
 FcPatternObjectGet (const FcPattern *p, FcObject object, int id, FcValue *v);
     

-FcBool
+FcPrivate FcBool

 FcPatternObjectDel (FcPattern *p, FcObject object);
 
 FcPatternObjectDel (FcPattern *p, FcObject object);
 

-FcBool
+FcPrivate FcBool

 FcPatternObjectRemove (FcPattern *p, FcObject object, int id);
 
 FcPatternObjectRemove (FcPattern *p, FcObject object, int id);
 

-FcBool
+FcPrivate FcBool

 FcPatternObjectAddInteger (FcPattern *p, FcObject object, int i);
 
 FcPatternObjectAddInteger (FcPattern *p, FcObject object, int i);
 

-FcBool
+FcPrivate FcBool

 FcPatternObjectAddDouble (FcPattern *p, FcObject object, double d);
 
 FcPatternObjectAddDouble (FcPattern *p, FcObject object, double d);
 

-FcBool
+FcPrivate FcBool

 FcPatternObjectAddString (FcPattern *p, FcObject object, const FcChar8 *s);
 
 FcPatternObjectAddString (FcPattern *p, FcObject object, const FcChar8 *s);
 

-FcBool
+FcPrivate FcBool

 FcPatternObjectAddMatrix (FcPattern *p, FcObject object, const FcMatrix *s);
 
 FcPatternObjectAddMatrix (FcPattern *p, FcObject object, const FcMatrix *s);
 

-FcBool
+FcPrivate FcBool

 FcPatternObjectAddCharSet (FcPattern *p, FcObject object, const FcCharSet *c);
 
 FcPatternObjectAddCharSet (FcPattern *p, FcObject object, const FcCharSet *c);
 

-FcBool
+FcPrivate FcBool

 FcPatternObjectAddBool (FcPattern *p, FcObject object, FcBool b);
 
 FcPatternObjectAddBool (FcPattern *p, FcObject object, FcBool b);
 

-FcBool
+FcPrivate FcBool

 FcPatternObjectAddLangSet (FcPattern *p, FcObject object, const FcLangSet *ls);
 
 FcPatternObjectAddLangSet (FcPattern *p, FcObject object, const FcLangSet *ls);
 

-FcResult
+FcPrivate FcResult

 FcPatternObjectGetInteger (const FcPattern *p, FcObject object, int n, int *i);
 
 FcPatternObjectGetInteger (const FcPattern *p, FcObject object, int n, int *i);
 

-FcResult
+FcPrivate FcResult

 FcPatternObjectGetDouble (const FcPattern *p, FcObject object, int n, double *d);
 
 FcPatternObjectGetDouble (const FcPattern *p, FcObject object, int n, double *d);
 

-FcResult
+FcPrivate FcResult

 FcPatternObjectGetString (const FcPattern *p, FcObject object, int n, FcChar8 ** s);
 
 FcPatternObjectGetString (const FcPattern *p, FcObject object, int n, FcChar8 ** s);
 

-FcResult
+FcPrivate FcResult

 FcPatternObjectGetMatrix (const FcPattern *p, FcObject object, int n, FcMatrix **s);
 
 FcPatternObjectGetMatrix (const FcPattern *p, FcObject object, int n, FcMatrix **s);
 

-FcResult
+FcPrivate FcResult

 FcPatternObjectGetCharSet (const FcPattern *p, FcObject object, int n, FcCharSet **c);
 
 FcPatternObjectGetCharSet (const FcPattern *p, FcObject object, int n, FcCharSet **c);
 

-FcResult
+FcPrivate FcResult

 FcPatternObjectGetBool (const FcPattern *p, FcObject object, int n, FcBool *b);
 
 FcPatternObjectGetBool (const FcPattern *p, FcObject object, int n, FcBool *b);
 

-FcResult
+FcPrivate FcResult

 FcPatternObjectGetLangSet (const FcPattern *p, FcObject object, int n, FcLangSet **ls);
 
 FcPatternObjectGetLangSet (const FcPattern *p, FcObject object, int n, FcLangSet **ls);
 

-void
+FcPrivate void

 FcPatternFini (void);
 
 FcPatternFini (void);
 

-FcBool
+FcPrivate FcBool

 FcPatternAppend (FcPattern *p, FcPattern *s);
 
 FcPatternAppend (FcPattern *p, FcPattern *s);
 

-const FcChar8 *
+FcPrivate const FcChar8 *

 FcStrStaticName (const FcChar8 *name);
 
 FcStrStaticName (const FcChar8 *name);
 

-FcChar32
+FcPrivate FcChar32

 FcStringHash (const FcChar8 *s);
 
 FcStringHash (const FcChar8 *s);
 

-FcBool
+FcPrivate FcBool

 FcPatternSerializeAlloc (FcSerialize *serialize, const FcPattern *pat);
 
 FcPatternSerializeAlloc (FcSerialize *serialize, const FcPattern *pat);
 

-FcPattern *
+FcPrivate FcPattern *

 FcPatternSerialize (FcSerialize *serialize, const FcPattern *pat);
 
 FcPatternSerialize (FcSerialize *serialize, const FcPattern *pat);
 

-FcBool
+FcPrivate FcBool

 FcValueListSerializeAlloc (FcSerialize *serialize, const FcValueList *pat);
 
 FcValueListSerializeAlloc (FcSerialize *serialize, const FcValueList *pat);
 

-FcValueList *
+FcPrivate FcValueList *

 FcValueListSerialize (FcSerialize *serialize, const FcValueList *pat);
 
 /* fcrender.c */
 
 /* fcmatrix.c */
 
 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 */
 FcMatrixFree (FcMatrix *mat);
 
 /* fcstr.c */

-void
+FcPrivate void

 FcStrSetSort (FcStrSet * set);
 
 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);
 
 FcStrBufInit (FcStrBuf *buf, FcChar8 *init, int size);
 

-void
+FcPrivate void

 FcStrBufDestroy (FcStrBuf *buf);
 
 FcStrBufDestroy (FcStrBuf *buf);
 

-FcChar8 *
+FcPrivate FcChar8 *

 FcStrBufDone (FcStrBuf *buf);
 
 FcStrBufDone (FcStrBuf *buf);
 

-FcBool
+FcPrivate FcBool

 FcStrBufChar (FcStrBuf *buf, FcChar8 c);
 
 FcStrBufChar (FcStrBuf *buf, FcChar8 c);
 

-FcBool
+FcPrivate FcBool

 FcStrBufString (FcStrBuf *buf, const FcChar8 *s);
 
 FcStrBufString (FcStrBuf *buf, const FcChar8 *s);
 

-FcBool
+FcPrivate FcBool

 FcStrBufData (FcStrBuf *buf, const FcChar8 *s, int len);
 
 FcStrBufData (FcStrBuf *buf, const FcChar8 *s, int len);
 

-int
+FcPrivate int

 FcStrCmpIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2);
 
 FcStrCmpIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2);
 

-const FcChar8 *
+FcPrivate const FcChar8 *

 FcStrContainsIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2);
 
 FcStrContainsIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2);
 

-const FcChar8 *
+FcPrivate const FcChar8 *

 FcStrContainsIgnoreCase (const FcChar8 *s1, const FcChar8 *s2);
 
 FcStrContainsIgnoreCase (const FcChar8 *s1, const FcChar8 *s2);
 

-FcBool
+FcPrivate FcBool

 FcStrUsesHome (const FcChar8 *s);
 
 FcStrUsesHome (const FcChar8 *s);
 

-FcChar8 *
+FcPrivate FcChar8 *

 FcStrLastSlash (const FcChar8  *path);
 
 FcStrLastSlash (const FcChar8  *path);
 

-FcChar32
+FcPrivate FcChar32

 FcStrHashIgnoreCase (const FcChar8 *s);
 
 FcStrHashIgnoreCase (const FcChar8 *s);
 

-FcChar8 *
+FcPrivate FcChar8 *

 FcStrCanonFilename (const FcChar8 *s);
 
 FcStrCanonFilename (const FcChar8 *s);
 

-FcBool
+FcPrivate FcBool

 FcStrSerializeAlloc (FcSerialize *serialize, const FcChar8 *str);
 
 FcStrSerializeAlloc (FcSerialize *serialize, const FcChar8 *str);
 

-FcChar8 *
+FcPrivate FcChar8 *

 FcStrSerialize (FcSerialize *serialize, const FcChar8 *str);
 
 #endif /* _FC_INT_H_ */
 FcStrSerialize (FcSerialize *serialize, const FcChar8 *str);
 
 #endif /* _FC_INT_H_ */