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.
This commit is contained in:
Keith Packard 2006-09-04 00:47:07 -07:00
parent 34227592c2
commit 4984242e36
9 changed files with 481 additions and 404 deletions

View File

@ -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)

View File

@ -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>
@ -132,7 +132,6 @@ scanDirs (FcStrList *list, FcConfig *config, FcBool force, FcBool really_force,
{
int ret = 0;
const FcChar8 *dir;
FcFontSet *set;
FcStrSet *subdirs;
FcStrList *sublist;
FcCache *cache;
@ -223,19 +222,17 @@ scanDirs (FcStrList *list, FcConfig *config, FcBool force, FcBool really_force,
}
}
set = FcCacheSet (cache);
if (was_valid)
{
if (verbose)
printf ("skipping, %d fonts, %d dirs\n",
set->nfont, cache->dirs_count);
FcCacheNumFont (cache), FcCacheNumSubdir (cache));
}
else
{
if (verbose)
printf ("caching, %d fonts, %d dirs\n",
set->nfont, cache->dirs_count);
FcCacheNumFont (cache), FcCacheNumSubdir (cache));
if (!FcDirCacheValid (dir))
{
@ -253,7 +250,7 @@ scanDirs (FcStrList *list, FcConfig *config, FcBool force, FcBool really_force,
FcDirCacheUnload (cache);
continue;
}
for (i = 0; i < cache->dirs_count; i++)
for (i = 0; i < FcCacheNumSubdir (cache); i++)
FcStrSetAdd (subdirs, FcCacheSubdir (cache, i));
FcDirCacheUnload (cache);
@ -264,7 +261,6 @@ scanDirs (FcStrList *list, FcConfig *config, FcBool force, FcBool really_force,
{
fprintf (stderr, "%s: Can't create subdir list\n", dir);
ret++;
FcDirCacheUnload (cache);
continue;
}
FcStrSetAdd (processed_dirs, dir);
@ -311,7 +307,7 @@ cleanCacheDirectory (FcConfig *config, FcChar8 *dir, FcBool verbose)
while ((ent = readdir (d)))
{
FcChar8 *file_name;
FcChar8 *target_dir;
const FcChar8 *target_dir;
if (ent->d_name[0] == '.')
continue;

View File

@ -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

View File

@ -31,10 +31,11 @@
#define HAVE_GETOPT 1
#endif
#include "../src/fccache.c"
#include <fontconfig/fontconfig.h>
#include "../fc-arch/fcarch.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
@ -173,20 +174,20 @@ usage (char *program)
*/
static const FcChar8 *
file_base_name (const char *cache, const FcChar8 *file)
file_base_name (const FcChar8 *cache, const FcChar8 *file)
{
const FcChar8 *cache_slash;
int cache_len = strlen (cache);
int cache_len = strlen ((char *) cache);
if (!strncmp (cache, file, cache_len) && file[cache_len] == '/')
if (!strncmp ((char *) cache, (char *) file, cache_len) && file[cache_len] == '/')
return file + cache_len + 1;
return file;
}
#define FC_FONT_FILE_DIR ((FcChar8 *) ".dir")
static FcBool
cache_print_set (FcFontSet *set, FcStrSet *dirs, char *base_name, FcBool verbose)
cache_print_set (FcFontSet *set, FcStrSet *dirs, const FcChar8 *base_name, FcBool verbose)
{
FcPattern *font;
FcChar8 *name, *dir;
const FcChar8 *file, *base;
int ret;
@ -219,9 +220,7 @@ cache_print_set (FcFontSet *set, FcStrSet *dirs, char *base_name, FcBool verbose
for (n = 0; n < set->nfont; n++)
{
FcPattern **fonts = FcFontSetFonts (set);
FcPattern *encoded_font = fonts[n];
FcPattern *font = FcEncodedOffsetToPtr (set, encoded_font, FcPattern);
FcPattern *font = set->fonts[n];
if (FcPatternGetString (font, FC_FILE, 0, (FcChar8 **) &file) != FcResultMatch)
goto bail3;
@ -321,7 +320,7 @@ main (int argc, char **argv)
{
for (; i < argc; i++)
{
if (!FcStrSetAddFilename (args, argv[i]))
if (!FcStrSetAddFilename (args, (const FcChar8 *) argv[i]))
{
fprintf (stderr, "%s: malloc failure\n", argv[0]);
return 1;
@ -356,8 +355,6 @@ main (int argc, char **argv)
while ((arg = FcStrListNext (arglist)))
{
int j;
off_t size;
intptr_t *cache_dirs;
FcChar8 *cache_file = NULL;
struct stat file_stat;
@ -373,17 +370,12 @@ main (int argc, char **argv)
}
dirs = FcStrSetCreate ();
fs = FcCacheSet (cache);
cache_dirs = FcCacheDirs (cache);
for (j = 0; j < cache->dirs_count; j++)
fs = FcCacheCopySet (cache);
for (j = 0; j < FcCacheNumSubdir (cache); j++)
{
FcStrSetAdd (dirs, FcOffsetToPtr (cache_dirs,
cache_dirs[j],
FcChar8));
FcStrSetAdd (dirs, FcCacheSubdir (cache, j));
if (recurse)
FcStrSetAdd (args, FcOffsetToPtr (cache_dirs,
cache_dirs[j],
FcChar8));
FcStrSetAdd (args, FcCacheSubdir (cache, j));
}
if (verbose)
@ -398,6 +390,7 @@ main (int argc, char **argv)
FcStrSetDestroy (dirs);
FcFontSetDestroy (fs);
FcDirCacheUnload (cache);
if (cache_file)
FcStrFree (cache_file);

View File

@ -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

View File

@ -25,6 +25,9 @@
#ifndef _FONTCONFIG_H_
#define _FONTCONFIG_H_
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdarg.h>
#if defined(__GNUC__) && (__GNUC__ >= 4)
@ -33,6 +36,10 @@
#define FC_ATTRIBUTE_SENTINEL(x)
#endif
#ifndef FcPublic
#define FcPublic
#endif
typedef unsigned char FcChar8;
typedef unsigned short FcChar16;
typedef unsigned int FcChar32;
@ -271,59 +278,81 @@ typedef struct _FcStrList FcStrList;
typedef struct _FcStrSet FcStrSet;
typedef struct _FcCache FcCache;
_FCFUNCPROTOBEGIN
FcBool
FcDirCacheValid (const FcChar8 *cache_file);
/* fcblanks.c */
FcBlanks *
FcPublic FcBlanks *
FcBlanksCreate (void);
void
FcPublic void
FcBlanksDestroy (FcBlanks *b);
FcBool
FcPublic FcBool
FcBlanksAdd (FcBlanks *b, FcChar32 ucs4);
FcBool
FcPublic FcBool
FcBlanksIsMember (FcBlanks *b, FcChar32 ucs4);
/* fccache.c */
FcPublic const FcChar8 *
FcCacheDir(const FcCache *c);
FcPublic FcFontSet *
FcCacheCopySet(const FcCache *c);
FcPublic const FcChar8 *
FcCacheSubdir (const FcCache *c, int i);
FcPublic int
FcCacheNumSubdir (const FcCache *c);
FcPublic int
FcCacheNumFont (const FcCache *c);
FcBool
FcDirCacheUnlink (const FcChar8 *dir, FcConfig *config);
FcPublic FcBool
FcDirCacheValid (const FcChar8 *cache_file);
/* fccfg.c */
FcChar8 *
FcPublic FcChar8 *
FcConfigHome (void);
FcBool
FcPublic FcBool
FcConfigEnableHome (FcBool enable);
FcChar8 *
FcPublic FcChar8 *
FcConfigFilename (const FcChar8 *url);
FcConfig *
FcPublic FcConfig *
FcConfigCreate (void);
void
FcPublic void
FcConfigDestroy (FcConfig *config);
FcBool
FcPublic FcBool
FcConfigSetCurrent (FcConfig *config);
FcConfig *
FcPublic FcConfig *
FcConfigGetCurrent (void);
FcBool
FcPublic FcBool
FcConfigUptoDate (FcConfig *config);
FcBool
FcPublic FcBool
FcConfigBuildFonts (FcConfig *config);
FcStrList *
FcPublic FcStrList *
FcConfigGetFontDirs (FcConfig *config);
FcStrList *
FcPublic FcStrList *
FcConfigGetConfigDirs (FcConfig *config);
FcStrList *
FcPublic FcStrList *
FcConfigGetConfigFiles (FcConfig *config);
FcChar8 *
@ -332,108 +361,124 @@ FcConfigGetCache (FcConfig *config);
FcBlanks *
FcConfigGetBlanks (FcConfig *config);
int
FcPublic FcStrList *
FcConfigGetCacheDirs (FcConfig *config);
FcPublic int
FcConfigGetRescanInverval (FcConfig *config);
FcBool
FcPublic FcBool
FcConfigSetRescanInverval (FcConfig *config, int rescanInterval);
FcFontSet *
FcPublic FcFontSet *
FcConfigGetFonts (FcConfig *config,
FcSetName set);
FcBool
FcPublic FcBool
FcConfigAppFontAddFile (FcConfig *config,
const FcChar8 *file);
FcBool
FcPublic FcBool
FcConfigAppFontAddDir (FcConfig *config,
const FcChar8 *dir);
void
FcPublic void
FcConfigAppFontClear (FcConfig *config);
FcBool
FcPublic FcBool
FcConfigSubstituteWithPat (FcConfig *config,
FcPattern *p,
FcPattern *p_pat,
FcMatchKind kind);
FcBool
FcPublic FcBool
FcConfigSubstitute (FcConfig *config,
FcPattern *p,
FcMatchKind kind);
/* fccharset.c */
FcCharSet *
FcPublic FcCharSet*
FcCharSetCreate (void);
void
/* deprecated alias for FcCharSetCreate */
FcPublic FcCharSet *
FcCharSetNew (void);
FcPublic void
FcCharSetDestroy (FcCharSet *fcs);
FcBool
FcPublic FcBool
FcCharSetAddChar (FcCharSet *fcs, FcChar32 ucs4);
FcCharSet *
FcPublic FcCharSet*
FcCharSetCopy (FcCharSet *src);
FcBool
FcPublic FcBool
FcCharSetEqual (const FcCharSet *a, const FcCharSet *b);
FcCharSet *
FcPublic FcCharSet*
FcCharSetIntersect (const FcCharSet *a, const FcCharSet *b);
FcCharSet *
FcPublic FcCharSet*
FcCharSetUnion (const FcCharSet *a, const FcCharSet *b);
FcCharSet *
FcPublic FcCharSet*
FcCharSetSubtract (const FcCharSet *a, const FcCharSet *b);
FcBool
FcPublic FcBool
FcCharSetHasChar (const FcCharSet *fcs, FcChar32 ucs4);
FcChar32
FcPublic FcChar32
FcCharSetCount (const FcCharSet *a);
FcChar32
FcPublic FcChar32
FcCharSetIntersectCount (const FcCharSet *a, const FcCharSet *b);
FcChar32
FcPublic FcChar32
FcCharSetSubtractCount (const FcCharSet *a, const FcCharSet *b);
FcBool
FcPublic FcBool
FcCharSetIsSubset (const FcCharSet *a, const FcCharSet *b);
#define FC_CHARSET_MAP_SIZE (256/32)
#define FC_CHARSET_DONE ((FcChar32) -1)
FcChar32
FcPublic FcChar32
FcCharSetFirstPage (const FcCharSet *a,
FcChar32 map[FC_CHARSET_MAP_SIZE],
FcChar32 *next);
FcChar32
FcPublic FcChar32
FcCharSetNextPage (const FcCharSet *a,
FcChar32 map[FC_CHARSET_MAP_SIZE],
FcChar32 *next);
/*
* old coverage API, rather hard to use correctly
*/
FcPublic FcChar32
FcCharSetCoverage (const FcCharSet *a, FcChar32 page, FcChar32 *result);
/* fcdbg.c */
void
FcPublic void
FcValuePrint (const FcValue v);
void
FcPublic void
FcPatternPrint (const FcPattern *p);
void
FcPublic void
FcFontSetPrint (const FcFontSet *s);
/* fcdefault.c */
void
FcPublic void
FcDefaultSubstitute (FcPattern *pattern);
/* fcdir.c */
FcBool
FcPublic FcBool
FcFileIsDir (const FcChar8 *file);
FcPublic FcBool
FcFileScan (FcFontSet *set,
FcStrSet *dirs,
FcFileCache *cache,
@ -441,7 +486,7 @@ FcFileScan (FcFontSet *set,
const FcChar8 *file,
FcBool force);
FcBool
FcPublic FcBool
FcDirScan (FcFontSet *set,
FcStrSet *dirs,
FcFileCache *cache,
@ -449,147 +494,159 @@ FcDirScan (FcFontSet *set,
const FcChar8 *dir,
FcBool force);
FcBool
FcPublic FcBool
FcDirSave (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir);
FcPublic FcCache *
FcDirCacheLoad (const FcChar8 *dir, FcConfig *config, FcChar8 **cache_file);
FcPublic FcCache *
FcDirCacheRead (const FcChar8 *dir, FcBool force, FcConfig *config);
FcPublic FcCache *
FcDirCacheLoadFile (const FcChar8 *cache_file, struct stat *file_stat);
FcPublic void
FcDirCacheUnload (FcCache *cache);
/* fcfreetype.c */
FcPattern *
FcPublic FcPattern *
FcFreeTypeQuery (const FcChar8 *file, int id, FcBlanks *blanks, int *count);
/* fcfs.c */
FcFontSet *
FcPublic FcFontSet *
FcFontSetCreate (void);
void
FcPublic void
FcFontSetDestroy (FcFontSet *s);
FcBool
FcPublic FcBool
FcFontSetAdd (FcFontSet *s, FcPattern *font);
/* fcinit.c */
FcConfig *
FcPublic FcConfig *
FcInitLoadConfig (void);
FcConfig *
FcPublic FcConfig *
FcInitLoadConfigAndFonts (void);
FcBool
FcPublic FcBool
FcInit (void);
void
FcPublic void
FcFini (void);
int
FcPublic int
FcGetVersion (void);
FcBool
FcPublic FcBool
FcInitReinitialize (void);
FcBool
FcPublic FcBool
FcInitBringUptoDate (void);
/* fclang.c */
FcLangSet *
FcPublic FcLangSet*
FcLangSetCreate (void);
void
FcPublic void
FcLangSetDestroy (FcLangSet *ls);
FcLangSet *
FcPublic FcLangSet*
FcLangSetCopy (const FcLangSet *ls);
FcBool
FcPublic FcBool
FcLangSetAdd (FcLangSet *ls, const FcChar8 *lang);
FcLangResult
FcPublic FcLangResult
FcLangSetHasLang (const FcLangSet *ls, const FcChar8 *lang);
FcLangResult
FcPublic FcLangResult
FcLangSetCompare (const FcLangSet *lsa, const FcLangSet *lsb);
FcBool
FcPublic FcBool
FcLangSetContains (const FcLangSet *lsa, const FcLangSet *lsb);
FcBool
FcPublic FcBool
FcLangSetEqual (const FcLangSet *lsa, const FcLangSet *lsb);
FcChar32
FcPublic FcChar32
FcLangSetHash (const FcLangSet *ls);
/* fclist.c */
FcObjectSet *
FcPublic FcObjectSet *
FcObjectSetCreate (void);
FcBool
FcPublic FcBool
FcObjectSetAdd (FcObjectSet *os, const char *object);
void
FcPublic void
FcObjectSetDestroy (FcObjectSet *os);
FcObjectSet *
FcPublic FcObjectSet *
FcObjectSetVaBuild (const char *first, va_list va);
FcObjectSet *
FcPublic FcObjectSet *
FcObjectSetBuild (const char *first, ...) FC_ATTRIBUTE_SENTINEL(0);
FcFontSet *
FcPublic FcFontSet *
FcFontSetList (FcConfig *config,
FcFontSet **sets,
int nsets,
FcPattern *p,
FcObjectSet *os);
FcFontSet *
FcPublic FcFontSet *
FcFontList (FcConfig *config,
FcPattern *p,
FcObjectSet *os);
/* fcatomic.c */
FcAtomic *
FcPublic FcAtomic *
FcAtomicCreate (const FcChar8 *file);
FcBool
FcPublic FcBool
FcAtomicLock (FcAtomic *atomic);
FcChar8 *
FcPublic FcChar8 *
FcAtomicNewFile (FcAtomic *atomic);
FcChar8 *
FcPublic FcChar8 *
FcAtomicOrigFile (FcAtomic *atomic);
FcBool
FcPublic FcBool
FcAtomicReplaceOrig (FcAtomic *atomic);
void
FcPublic void
FcAtomicDeleteNew (FcAtomic *atomic);
void
FcPublic void
FcAtomicUnlock (FcAtomic *atomic);
void
FcPublic void
FcAtomicDestroy (FcAtomic *atomic);
/* fcmatch.c */
FcPattern *
FcPublic FcPattern *
FcFontSetMatch (FcConfig *config,
FcFontSet **sets,
int nsets,
FcPattern *p,
FcResult *result);
FcPattern *
FcPublic FcPattern *
FcFontMatch (FcConfig *config,
FcPattern *p,
FcResult *result);
FcPattern *
FcPublic FcPattern *
FcFontRenderPrepare (FcConfig *config,
FcPattern *pat,
FcPattern *font);
FcFontSet *
FcPublic FcFontSet *
FcFontSetSort (FcConfig *config,
FcFontSet **sets,
int nsets,
@ -598,192 +655,198 @@ FcFontSetSort (FcConfig *config,
FcCharSet **csp,
FcResult *result);
FcFontSet *
FcPublic FcFontSet *
FcFontSort (FcConfig *config,
FcPattern *p,
FcBool trim,
FcCharSet **csp,
FcResult *result);
void
FcPublic void
FcFontSetSortDestroy (FcFontSet *fs);
/* fcmatrix.c */
FcMatrix *
FcPublic FcMatrix *
FcMatrixCopy (const FcMatrix *mat);
FcBool
FcPublic FcBool
FcMatrixEqual (const FcMatrix *mat1, const FcMatrix *mat2);
void
FcPublic void
FcMatrixMultiply (FcMatrix *result, const FcMatrix *a, const FcMatrix *b);
void
FcPublic void
FcMatrixRotate (FcMatrix *m, double c, double s);
void
FcPublic void
FcMatrixScale (FcMatrix *m, double sx, double sy);
void
FcPublic void
FcMatrixShear (FcMatrix *m, double sh, double sv);
/* fcname.c */
FcBool
FcPublic FcBool
FcNameRegisterObjectTypes (const FcObjectType *types, int ntype);
FcBool
FcPublic FcBool
FcNameUnregisterObjectTypes (const FcObjectType *types, int ntype);
const FcObjectType *
FcPublic const FcObjectType *
FcNameGetObjectType (const char *object);
FcBool
FcPublic FcBool
FcNameRegisterConstants (const FcConstant *consts, int nconsts);
FcBool
FcPublic FcBool
FcNameUnregisterConstants (const FcConstant *consts, int nconsts);
const FcConstant *
FcPublic const FcConstant *
FcNameGetConstant (FcChar8 *string);
FcBool
FcPublic FcBool
FcNameConstant (FcChar8 *string, int *result);
FcPattern *
FcPublic FcPattern *
FcNameParse (const FcChar8 *name);
FcChar8 *
FcPublic FcChar8 *
FcNameUnparse (FcPattern *pat);
/* fcpat.c */
FcPattern *
FcPublic FcPattern *
FcPatternCreate (void);
FcPattern *
FcPublic FcPattern *
FcPatternDuplicate (const FcPattern *p);
void
FcPublic void
FcPatternReference (FcPattern *p);
void
FcPublic void
FcValueDestroy (FcValue v);
FcBool
FcPublic FcBool
FcValueEqual (FcValue va, FcValue vb);
FcValue
FcPublic FcValue
FcValueSave (FcValue v);
void
FcPublic void
FcPatternDestroy (FcPattern *p);
FcBool
FcPublic FcBool
FcPatternEqual (const FcPattern *pa, const FcPattern *pb);
FcBool
FcPublic FcBool
FcPatternEqualSubset (const FcPattern *pa, const FcPattern *pb, const FcObjectSet *os);
FcChar32
FcPublic FcChar32
FcPatternHash (const FcPattern *p);
FcBool
FcPublic FcBool
FcPatternAdd (FcPattern *p, const char *object, FcValue value, FcBool append);
FcBool
FcPublic FcBool
FcPatternAddWeak (FcPattern *p, const char *object, FcValue value, FcBool append);
FcResult
FcPublic FcResult
FcPatternGet (const FcPattern *p, const char *object, int id, FcValue *v);
FcBool
FcPublic FcBool
FcPatternDel (FcPattern *p, const char *object);
FcBool
FcPublic FcBool
FcPatternRemove (FcPattern *p, const char *object, int id);
FcBool
FcPublic FcBool
FcPatternAddInteger (FcPattern *p, const char *object, int i);
FcBool
FcPublic FcBool
FcPatternAddDouble (FcPattern *p, const char *object, double d);
FcBool
FcPublic FcBool
FcPatternAddString (FcPattern *p, const char *object, const FcChar8 *s);
FcBool
FcPublic FcBool
FcPatternAddMatrix (FcPattern *p, const char *object, const FcMatrix *s);
FcBool
FcPublic FcBool
FcPatternAddCharSet (FcPattern *p, const char *object, const FcCharSet *c);
FcBool
FcPublic FcBool
FcPatternAddBool (FcPattern *p, const char *object, FcBool b);
FcBool
FcPublic FcBool
FcPatternAddLangSet (FcPattern *p, const char *object, const FcLangSet *ls);
FcResult
FcPublic FcResult
FcPatternGetInteger (const FcPattern *p, const char *object, int n, int *i);
FcResult
FcPublic FcResult
FcPatternGetDouble (const FcPattern *p, const char *object, int n, double *d);
FcResult
FcPublic FcResult
FcPatternGetString (const FcPattern *p, const char *object, int n, FcChar8 ** s);
FcResult
FcPublic FcResult
FcPatternGetMatrix (const FcPattern *p, const char *object, int n, FcMatrix **s);
FcResult
FcPublic FcResult
FcPatternGetCharSet (const FcPattern *p, const char *object, int n, FcCharSet **c);
FcResult
FcPublic FcResult
FcPatternGetBool (const FcPattern *p, const char *object, int n, FcBool *b);
FcResult
FcPublic FcResult
FcPatternGetLangSet (const FcPattern *p, const char *object, int n, FcLangSet **ls);
FcPattern *
FcPublic FcPattern *
FcPatternVaBuild (FcPattern *orig, va_list va);
FcPattern *
FcPublic FcPattern *
FcPatternBuild (FcPattern *orig, ...) FC_ATTRIBUTE_SENTINEL(0);
/* fcstr.c */
FcChar8 *
FcPublic FcChar8 *
FcStrCopy (const FcChar8 *s);
FcChar8 *
FcPublic FcChar8 *
FcStrCopyFilename (const FcChar8 *s);
FcPublic FcChar8 *
FcStrPlus (const FcChar8 *s1, const FcChar8 *s2);
FcPublic void
FcStrFree (FcChar8 *s);
/* These are ASCII only, suitable only for pattern element names */
#define FcIsUpper(c) ((0101 <= (c) && (c) <= 0132))
#define FcIsLower(c) ((0141 <= (c) && (c) <= 0172))
#define FcToLower(c) (FcIsUpper(c) ? (c) - 0101 + 0141 : (c))
FcChar8 *
FcPublic FcChar8 *
FcStrDowncase (const FcChar8 *s);
int
FcPublic int
FcStrCmpIgnoreCase (const FcChar8 *s1, const FcChar8 *s2);
int
FcPublic int
FcStrCmp (const FcChar8 *s1, const FcChar8 *s2);
const FcChar8 *
FcPublic const FcChar8 *
FcStrStrIgnoreCase (const FcChar8 *s1, const FcChar8 *s2);
const FcChar8 *
FcPublic const FcChar8 *
FcStrStr (const FcChar8 *s1, const FcChar8 *s2);
int
FcPublic int
FcUtf8ToUcs4 (const FcChar8 *src_orig,
FcChar32 *dst,
int len);
FcBool
FcPublic FcBool
FcUtf8Len (const FcChar8 *string,
int len,
int *nchar,
@ -791,61 +854,61 @@ FcUtf8Len (const FcChar8 *string,
#define FC_UTF8_MAX_LEN 6
int
FcPublic int
FcUcs4ToUtf8 (FcChar32 ucs4,
FcChar8 dest[FC_UTF8_MAX_LEN]);
int
FcPublic int
FcUtf16ToUcs4 (const FcChar8 *src_orig,
FcEndian endian,
FcChar32 *dst,
int len); /* in bytes */
FcBool
FcPublic FcBool
FcUtf16Len (const FcChar8 *string,
FcEndian endian,
int len, /* in bytes */
int *nchar,
int *wchar);
FcChar8 *
FcPublic FcChar8 *
FcStrDirname (const FcChar8 *file);
FcChar8 *
FcPublic FcChar8 *
FcStrBasename (const FcChar8 *file);
FcStrSet *
FcPublic FcStrSet *
FcStrSetCreate (void);
FcBool
FcStrSetMember (FcStrSet *set, const FcChar8 *s);
FcPublic FcBool
FcStrSetMember (FcPublic FcStrSet *set, const FcChar8 *s);
FcBool
FcStrSetEqual (FcStrSet *sa, FcStrSet *sb);
FcPublic FcBool
FcStrSetEqual (FcPublic FcStrSet *sa, FcPublic FcStrSet *sb);
FcBool
FcStrSetAdd (FcStrSet *set, const FcChar8 *s);
FcPublic FcBool
FcStrSetAdd (FcPublic FcStrSet *set, const FcChar8 *s);
FcBool
FcStrSetAddFilename (FcStrSet *set, const FcChar8 *s);
FcPublic FcBool
FcStrSetAddFilename (FcPublic FcStrSet *set, const FcChar8 *s);
FcBool
FcStrSetDel (FcStrSet *set, const FcChar8 *s);
FcPublic FcBool
FcStrSetDel (FcPublic FcStrSet *set, const FcChar8 *s);
void
FcStrSetDestroy (FcStrSet *set);
FcPublic void
FcStrSetDestroy (FcPublic FcStrSet *set);
FcStrList *
FcStrListCreate (FcStrSet *set);
FcPublic FcStrList *
FcPublic FcStrListCreate (FcPublic FcStrSet *set);
FcChar8 *
FcStrListNext (FcStrList *list);
FcPublic FcChar8 *
FcPublic FcStrListNext (FcStrList *list);
void
FcStrListDone (FcStrList *list);
FcPublic void
FcPublic FcStrListDone (FcStrList *list);
/* fcxml.c */
FcBool
FcPublic FcBool
FcConfigParseAndLoad (FcConfig *config, const FcChar8 *file, FcBool complain);
_FCFUNCPROTOEND

View File

@ -575,6 +575,54 @@ FcDirCacheWrite (FcCache *cache, FcConfig *config)
return FcFalse;
}
/*
* Hokey little macro trick to permit the definitions of C functions
* with the same name as CPP macros
*/
#define args(x...) (x)
const FcChar8 *
FcCacheDir args(const FcCache *c)
{
return FcCacheDir (c);
}
FcFontSet *
FcCacheCopySet args(const FcCache *c)
{
FcFontSet *old = FcCacheSet (c);
FcFontSet *new = FcFontSetCreate ();
int i;
if (!new)
return NULL;
for (i = 0; i < old->nfont; i++)
if (!FcFontSetAdd (new, FcFontSetFont (old, i)))
{
FcFontSetDestroy (new);
return NULL;
}
return new;
}
const FcChar8 *
FcCacheSubdir args(const FcCache *c, int i)
{
return FcCacheSubdir (c, i);
}
int
FcCacheNumSubdir args(const FcCache *c)
{
return c->dirs_count;
}
int
FcCacheNumFont args(const FcCache *c)
{
return FcCacheSet(c)->nfont;
}
/*
* This code implements the MD5 message-digest algorithm.
* The algorithm is due to Ron Rivest. This code was

View File

@ -43,9 +43,6 @@ FcCharSetCreate (void)
return fcs;
}
FcCharSet *
FcCharSetNew (void);
FcCharSet *
FcCharSetNew (void)
{
@ -693,8 +690,6 @@ FcCharSetFirstPage (const FcCharSet *a,
/*
* old coverage API, rather hard to use correctly
*/
FcChar32
FcCharSetCoverage (const FcCharSet *a, FcChar32 page, FcChar32 *result);
FcChar32
FcCharSetCoverage (const FcCharSet *a, FcChar32 page, FcChar32 *result)

View File

@ -53,9 +53,6 @@
#define FC_CONFIG_PATH "fonts.conf"
#endif
#define FC_FONT_FILE_INVALID ((FcChar8 *) ".")
#define FC_FONT_FILE_DIR ((FcChar8 *) ".dir")
#ifdef _WIN32
#define FC_SEARCH_PATH_SEPARATOR ';'
#else
@ -113,6 +110,15 @@
#define FC_BANK_FIRST 1
#define FC_BANK_LANGS 0xfcfcfcfc
/* slim_internal.h */
#if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)) && defined(__ELF__)
#define FcPrivate __attribute__((__visibility__("hidden")))
#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550)
#define FcPrivate __hidden
#else /* not gcc >= 3.3 and not Sun Studio >= 8 */
#define FcPrivate
#endif
typedef enum _FcValueBinding {
FcValueBindingWeak, FcValueBindingStrong, FcValueBindingSame
} FcValueBinding;
@ -306,7 +312,7 @@ typedef struct _FcStrBuf {
int size;
} FcStrBuf;
typedef struct _FcCache {
struct _FcCache {
int magic; /* FC_CACHE_MAGIC_MMAP or FC_CACHE_ALLOC */
int version; /* FC_CACHE_CONTENT_VERSION */
intptr_t size; /* size of file */
@ -314,13 +320,13 @@ typedef struct _FcCache {
intptr_t dirs; /* offset to subdirs */
int dirs_count; /* number of subdir strings */
intptr_t set; /* offset to font set */
} FcCache;
};
#define FcCacheDir(c) FcOffsetMember(c,dir,FcChar8)
#define FcCacheDirs(c) FcOffsetMember(c,dirs,intptr_t)
#define FcCacheSet(c) FcOffsetMember(c,set,FcFontSet)
#define FcCacheSubdir(c,i) FcOffsetToPtr (FcCacheDirs(cache),\
FcCacheDirs(cache)[i], \
#define FcCacheSubdir(c,i) FcOffsetToPtr (FcCacheDirs(c),\
FcCacheDirs(c)[i], \
FcChar8)
/*
@ -483,7 +489,7 @@ struct _FcConfig {
int rescanInterval; /* interval between scans */
};
extern FcConfig *_fcConfig;
extern FcPrivate FcConfig *_fcConfig;
typedef struct _FcFileTime {
time_t time;
@ -499,208 +505,186 @@ typedef struct _FcCharMap FcCharMap;
/* fccache.c */
FcBool
FcDirCacheUnlink (const FcChar8 *dir, FcConfig *config);
void
FcDirCacheUnload (FcCache *cache);
FcCache *
FcPrivate FcCache *
FcDirCacheScan (const FcChar8 *dir, FcConfig *config);
FcCache *
FcDirCacheLoad (const FcChar8 *dir, FcConfig *config, FcChar8 **cache_file);
FcCache *
FcDirCacheLoadFile (const FcChar8 *cache_file, struct stat *file_stat);
FcBool
FcDirCacheValid (const FcChar8 *dir);
FcCache *
FcPrivate FcCache *
FcDirCacheBuild (FcFontSet *set, const FcChar8 *dir, FcStrSet *dirs);
FcBool
FcPrivate FcBool
FcDirCacheWrite (FcCache *cache, FcConfig *config);
/* fccfg.c */
FcBool
FcPrivate FcBool
FcConfigAddConfigDir (FcConfig *config,
const FcChar8 *d);
FcBool
FcPrivate FcBool
FcConfigAddFontDir (FcConfig *config,
const FcChar8 *d);
FcBool
FcPrivate FcBool
FcConfigAddDir (FcConfig *config,
const FcChar8 *d);
FcBool
FcPrivate FcBool
FcConfigAddCacheDir (FcConfig *config,
const FcChar8 *d);
FcStrList *
FcConfigGetCacheDirs (FcConfig *config);
FcBool
FcPrivate FcBool
FcConfigAddConfigFile (FcConfig *config,
const FcChar8 *f);
FcBool
FcPrivate FcBool
FcConfigAddBlank (FcConfig *config,
FcChar32 blank);
FcBool
FcPrivate FcBool
FcConfigAddEdit (FcConfig *config,
FcTest *test,
FcEdit *edit,
FcMatchKind kind);
void
FcPrivate void
FcConfigSetFonts (FcConfig *config,
FcFontSet *fonts,
FcSetName set);
FcBool
FcPrivate FcBool
FcConfigCompareValue (const FcValue *m,
FcOp op,
const FcValue *v);
FcBool
FcPrivate FcBool
FcConfigGlobAdd (FcConfig *config,
const FcChar8 *glob,
FcBool accept);
FcBool
FcPrivate FcBool
FcConfigAcceptFilename (FcConfig *config,
const FcChar8 *filename);
FcBool
FcPrivate FcBool
FcConfigPatternsAdd (FcConfig *config,
FcPattern *pattern,
FcBool accept);
FcBool
FcPrivate FcBool
FcConfigAcceptFont (FcConfig *config,
const FcPattern *font);
FcFileTime
FcPrivate FcFileTime
FcConfigModifiedTime (FcConfig *config);
FcBool
FcPrivate FcBool
FcConfigAddCache (FcConfig *config, FcCache *cache);
/* fcserialize.c */
intptr_t
FcPrivate intptr_t
FcAlignSize (intptr_t size);
FcSerialize *
FcPrivate FcSerialize *
FcSerializeCreate (void);
void
FcPrivate void
FcSerializeDestroy (FcSerialize *serialize);
FcBool
FcPrivate FcBool
FcSerializeAlloc (FcSerialize *serialize, const void *object, int size);
intptr_t
FcPrivate intptr_t
FcSerializeReserve (FcSerialize *serialize, int size);
intptr_t
FcPrivate intptr_t
FcSerializeOffset (FcSerialize *serialize, const void *object);
void *
FcPrivate void *
FcSerializePtr (FcSerialize *serialize, const void *object);
FcBool
FcPrivate FcBool
FcLangSetSerializeAlloc (FcSerialize *serialize, const FcLangSet *l);
FcLangSet *
FcPrivate FcLangSet *
FcLangSetSerialize(FcSerialize *serialize, const FcLangSet *l);
/* fccharset.c */
void
FcPrivate void
FcLangCharSetPopulate (void);
FcCharSetFreezer *
FcPrivate FcCharSetFreezer *
FcCharSetFreezerCreate (void);
const FcCharSet *
FcPrivate const FcCharSet *
FcCharSetFreeze (FcCharSetFreezer *freezer, const FcCharSet *fcs);
void
FcPrivate void
FcCharSetFreezerDestroy (FcCharSetFreezer *freezer);
FcBool
FcPrivate FcBool
FcNameUnparseCharSet (FcStrBuf *buf, const FcCharSet *c);
FcCharSet *
FcPrivate FcCharSet *
FcNameParseCharSet (FcChar8 *string);
FcCharLeaf *
FcPrivate FcCharLeaf *
FcCharSetFindLeafCreate (FcCharSet *fcs, FcChar32 ucs4);
FcBool
FcPrivate FcBool
FcCharSetSerializeAlloc(FcSerialize *serialize, const FcCharSet *cs);
FcCharSet *
FcPrivate FcCharSet *
FcCharSetSerialize(FcSerialize *serialize, const FcCharSet *cs);
FcChar16 *
FcPrivate FcChar16 *
FcCharSetGetNumbers(const FcCharSet *c);
/* fcdbg.c */
void
FcPrivate void
FcValueListPrint (const FcValueListPtr l);
void
FcPrivate void
FcLangSetPrint (const FcLangSet *ls);
void
FcPrivate void
FcOpPrint (FcOp op);
void
FcPrivate void
FcTestPrint (const FcTest *test);
void
FcPrivate void
FcExprPrint (const FcExpr *expr);
void
FcPrivate void
FcEditPrint (const FcEdit *edit);
void
FcPrivate void
FcSubstPrint (const FcSubst *subst);
void
FcPrivate void
FcCharSetPrint (const FcCharSet *c);
extern int FcDebugVal;
extern FcPrivate int FcDebugVal;
static inline int
FcDebug (void) { return FcDebugVal; }
#define FcDebug() (FcDebugVal)
void
FcPrivate void
FcInitDebug (void);
/* fcdefault.c */
FcChar8 *
FcPrivate FcChar8 *
FcGetDefaultLang (void);
/* fcdir.c */
FcBool
FcFileIsDir (const FcChar8 *file);
FcBool
FcPrivate FcBool
FcFileScanConfig (FcFontSet *set,
FcStrSet *dirs,
FcBlanks *blanks,
const FcChar8 *file,
FcConfig *config);
FcBool
FcPrivate FcBool
FcDirScanConfig (FcFontSet *set,
FcStrSet *dirs,
FcBlanks *blanks,
@ -708,123 +692,120 @@ FcDirScanConfig (FcFontSet *set,
FcBool force,
FcConfig *config);
FcCache *
FcDirCacheRead (const FcChar8 *dir, FcBool force, FcConfig *config);
/* fcfont.c */
int
FcPrivate int
FcFontDebug (void);
/* fcfreetype.c */
FcBool
FcPrivate FcBool
FcFreeTypeIsExclusiveLang (const FcChar8 *lang);
FcBool
FcPrivate FcBool
FcFreeTypeHasLang (FcPattern *pattern, const FcChar8 *lang);
FcChar32
FcPrivate FcChar32
FcFreeTypeUcs4ToPrivate (FcChar32 ucs4, const FcCharMap *map);
FcChar32
FcPrivate FcChar32
FcFreeTypePrivateToUcs4 (FcChar32 private, const FcCharMap *map);
const FcCharMap *
FcPrivate const FcCharMap *
FcFreeTypeGetPrivateMap (FT_Encoding encoding);
/* fcfs.c */
FcBool
FcPrivate FcBool
FcFontSetSerializeAlloc (FcSerialize *serialize, const FcFontSet *s);
FcFontSet *
FcPrivate FcFontSet *
FcFontSetSerialize (FcSerialize *serialize, const FcFontSet * s);
/* fcgram.y */
int
FcPrivate int
FcConfigparse (void);
int
FcPrivate int
FcConfigwrap (void);
void
FcPrivate void
FcConfigerror (char *fmt, ...);
char *
FcPrivate char *
FcConfigSaveField (const char *field);
void
FcPrivate void
FcTestDestroy (FcTest *test);
FcExpr *
FcPrivate FcExpr *
FcExprCreateInteger (int i);
FcExpr *
FcPrivate FcExpr *
FcExprCreateDouble (double d);
FcExpr *
FcPrivate FcExpr *
FcExprCreateString (const FcChar8 *s);
FcExpr *
FcPrivate FcExpr *
FcExprCreateMatrix (const FcMatrix *m);
FcExpr *
FcPrivate FcExpr *
FcExprCreateBool (FcBool b);
FcExpr *
FcPrivate FcExpr *
FcExprCreateNil (void);
FcExpr *
FcPrivate FcExpr *
FcExprCreateField (const char *field);
FcExpr *
FcPrivate FcExpr *
FcExprCreateConst (const FcChar8 *constant);
FcExpr *
FcPrivate FcExpr *
FcExprCreateOp (FcExpr *left, FcOp op, FcExpr *right);
void
FcPrivate void
FcExprDestroy (FcExpr *e);
void
FcPrivate void
FcEditDestroy (FcEdit *e);
/* fcinit.c */
void
FcPrivate void
FcMemReport (void);
void
FcPrivate void
FcMemAlloc (int kind, int size);
void
FcPrivate void
FcMemFree (int kind, int size);
/* fclang.c */
FcLangSet *
FcPrivate FcLangSet *
FcFreeTypeLangSet (const FcCharSet *charset,
const FcChar8 *exclusiveLang);
FcLangResult
FcPrivate FcLangResult
FcLangCompare (const FcChar8 *s1, const FcChar8 *s2);
const FcCharSet *
FcPrivate const FcCharSet *
FcCharSetForLang (const FcChar8 *lang);
FcLangSet *
FcPrivate FcLangSet *
FcLangSetPromote (const FcChar8 *lang);
FcLangSet *
FcPrivate FcLangSet *
FcNameParseLangSet (const FcChar8 *string);
FcBool
FcPrivate FcBool
FcNameUnparseLangSet (FcStrBuf *buf, const FcLangSet *ls);
FcChar8 *
FcPrivate FcChar8 *
FcNameUnparseEscaped (FcPattern *pat, FcBool escape);
/* fclist.c */
FcBool
FcPrivate FcBool
FcListPatternMatchAny (const FcPattern *p,
const FcPattern *font);
@ -878,190 +859,184 @@ FcListPatternMatchAny (const FcPattern *p,
#define FC_EMBEDDED_BITMAP_OBJECT 39
#define FC_DECORATIVE_OBJECT 40
FcBool
FcPrivate FcBool
FcNameBool (const FcChar8 *v, FcBool *result);
FcBool
FcPrivate FcBool
FcObjectValidType (FcObject object, FcType type);
FcObject
FcPrivate FcObject
FcObjectFromName (const char * name);
const char *
FcPrivate const char *
FcObjectName (FcObject object);
FcBool
FcPrivate FcBool
FcObjectInit (void);
void
FcPrivate void
FcObjectFini (void);
#define FcObjectCompare(a, b) ((int) a - (int) b)
/* fcpat.c */
FcValue
FcPrivate FcValue
FcValueCanonicalize (const FcValue *v);
void
FcPrivate void
FcValueListDestroy (FcValueListPtr l);
FcPatternElt *
FcPrivate FcPatternElt *
FcPatternObjectFindElt (const FcPattern *p, FcObject object);
FcPatternElt *
FcPrivate FcPatternElt *
FcPatternObjectInsertElt (FcPattern *p, FcObject object);
FcBool
FcPrivate FcBool
FcPatternObjectAddWithBinding (FcPattern *p,
FcObject object,
FcValue value,
FcValueBinding binding,
FcBool append);
FcBool
FcPrivate FcBool
FcPatternObjectAdd (FcPattern *p, FcObject object, FcValue value, FcBool append);
FcBool
FcPrivate FcBool
FcPatternObjectAddWeak (FcPattern *p, FcObject object, FcValue value, FcBool append);
FcResult
FcPrivate FcResult
FcPatternObjectGet (const FcPattern *p, FcObject object, int id, FcValue *v);
FcBool
FcPrivate FcBool
FcPatternObjectDel (FcPattern *p, FcObject object);
FcBool
FcPrivate FcBool
FcPatternObjectRemove (FcPattern *p, FcObject object, int id);
FcBool
FcPrivate FcBool
FcPatternObjectAddInteger (FcPattern *p, FcObject object, int i);
FcBool
FcPrivate FcBool
FcPatternObjectAddDouble (FcPattern *p, FcObject object, double d);
FcBool
FcPrivate FcBool
FcPatternObjectAddString (FcPattern *p, FcObject object, const FcChar8 *s);
FcBool
FcPrivate FcBool
FcPatternObjectAddMatrix (FcPattern *p, FcObject object, const FcMatrix *s);
FcBool
FcPrivate FcBool
FcPatternObjectAddCharSet (FcPattern *p, FcObject object, const FcCharSet *c);
FcBool
FcPrivate FcBool
FcPatternObjectAddBool (FcPattern *p, FcObject object, FcBool b);
FcBool
FcPrivate FcBool
FcPatternObjectAddLangSet (FcPattern *p, FcObject object, const FcLangSet *ls);
FcResult
FcPrivate FcResult
FcPatternObjectGetInteger (const FcPattern *p, FcObject object, int n, int *i);
FcResult
FcPrivate FcResult
FcPatternObjectGetDouble (const FcPattern *p, FcObject object, int n, double *d);
FcResult
FcPrivate FcResult
FcPatternObjectGetString (const FcPattern *p, FcObject object, int n, FcChar8 ** s);
FcResult
FcPrivate FcResult
FcPatternObjectGetMatrix (const FcPattern *p, FcObject object, int n, FcMatrix **s);
FcResult
FcPrivate FcResult
FcPatternObjectGetCharSet (const FcPattern *p, FcObject object, int n, FcCharSet **c);
FcResult
FcPrivate FcResult
FcPatternObjectGetBool (const FcPattern *p, FcObject object, int n, FcBool *b);
FcResult
FcPrivate FcResult
FcPatternObjectGetLangSet (const FcPattern *p, FcObject object, int n, FcLangSet **ls);
void
FcPrivate void
FcPatternFini (void);
FcBool
FcPrivate FcBool
FcPatternAppend (FcPattern *p, FcPattern *s);
const FcChar8 *
FcPrivate const FcChar8 *
FcStrStaticName (const FcChar8 *name);
FcChar32
FcPrivate FcChar32
FcStringHash (const FcChar8 *s);
FcBool
FcPrivate FcBool
FcPatternSerializeAlloc (FcSerialize *serialize, const FcPattern *pat);
FcPattern *
FcPrivate FcPattern *
FcPatternSerialize (FcSerialize *serialize, const FcPattern *pat);
FcBool
FcPrivate FcBool
FcValueListSerializeAlloc (FcSerialize *serialize, const FcValueList *pat);
FcValueList *
FcPrivate FcValueList *
FcValueListSerialize (FcSerialize *serialize, const FcValueList *pat);
/* fcrender.c */
/* fcmatrix.c */
extern const FcMatrix FcIdentityMatrix;
extern FcPrivate const FcMatrix FcIdentityMatrix;
void
FcPrivate void
FcMatrixFree (FcMatrix *mat);
/* fcstr.c */
void
FcPrivate void
FcStrSetSort (FcStrSet * set);
FcChar8 *
FcStrPlus (const FcChar8 *s1, const FcChar8 *s2);
void
FcStrFree (FcChar8 *s);
void
FcPrivate void
FcStrBufInit (FcStrBuf *buf, FcChar8 *init, int size);
void
FcPrivate void
FcStrBufDestroy (FcStrBuf *buf);
FcChar8 *
FcPrivate FcChar8 *
FcStrBufDone (FcStrBuf *buf);
FcBool
FcPrivate FcBool
FcStrBufChar (FcStrBuf *buf, FcChar8 c);
FcBool
FcPrivate FcBool
FcStrBufString (FcStrBuf *buf, const FcChar8 *s);
FcBool
FcPrivate FcBool
FcStrBufData (FcStrBuf *buf, const FcChar8 *s, int len);
int
FcPrivate int
FcStrCmpIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2);
const FcChar8 *
FcPrivate const FcChar8 *
FcStrContainsIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2);
const FcChar8 *
FcPrivate const FcChar8 *
FcStrContainsIgnoreCase (const FcChar8 *s1, const FcChar8 *s2);
FcBool
FcPrivate FcBool
FcStrUsesHome (const FcChar8 *s);
FcChar8 *
FcPrivate FcChar8 *
FcStrLastSlash (const FcChar8 *path);
FcChar32
FcPrivate FcChar32
FcStrHashIgnoreCase (const FcChar8 *s);
FcChar8 *
FcPrivate FcChar8 *
FcStrCanonFilename (const FcChar8 *s);
FcBool
FcPrivate FcBool
FcStrSerializeAlloc (FcSerialize *serialize, const FcChar8 *str);
FcChar8 *
FcPrivate FcChar8 *
FcStrSerialize (FcSerialize *serialize, const FcChar8 *str);
#endif /* _FC_INT_H_ */