walkero
/
fontconfig
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
configure.in
View File

@ -38,11 +38,14 @@ AM_MAINTAINER_MODE
dnl libtool versioning dnl libtool versioning
LT_CURRENT=1 dnl bump revision when fixing bugs
LT_REVISION=4 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_CURRENT)
AC_SUBST(LT_REVISION) AC_SUBST(LT_REVISION)
LT_AGE=0 LT_AGE=1
LT_VERSION_INFO="$LT_CURRENT:$LT_REVISION:$LT_AGE" LT_VERSION_INFO="$LT_CURRENT:$LT_REVISION:$LT_AGE"
AC_SUBST(LT_VERSION_INFO) AC_SUBST(LT_VERSION_INFO)

30
fc-cache/fc-cache.c
View File

@ -31,7 +31,7 @@
#define HAVE_GETOPT 1 #define HAVE_GETOPT 1
#endif #endif
#include "fcint.h" #include <fontconfig/fontconfig.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h> #include <unistd.h>
@ -130,15 +130,14 @@ nsubdirs (FcStrSet *set)
static int static int
scanDirs (FcStrList *list, FcConfig *config, FcBool force, FcBool really_force, FcBool verbose) scanDirs (FcStrList *list, FcConfig *config, FcBool force, FcBool really_force, FcBool verbose)
{ {
int ret = 0; int ret = 0;
const FcChar8 *dir; const FcChar8 *dir;
FcFontSet *set; FcStrSet *subdirs;
FcStrSet *subdirs; FcStrList *sublist;
FcStrList *sublist; FcCache *cache;
FcCache *cache; struct stat statb;
struct stat statb; FcBool was_valid;
FcBool was_valid; int i;
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 (was_valid)
{ {
if (verbose) if (verbose)
printf ("skipping, %d fonts, %d dirs\n", printf ("skipping, %d fonts, %d dirs\n",
set->nfont, cache->dirs_count); FcCacheNumFont (cache), FcCacheNumSubdir (cache));
} }
else else
{ {
if (verbose) if (verbose)
printf ("caching, %d fonts, %d dirs\n", 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); FcDirCacheUnload (cache);
continue; continue;
} }
for (i = 0; i < cache->dirs_count; i++) for (i = 0; i < FcCacheNumSubdir (cache); i++)
FcStrSetAdd (subdirs, FcCacheSubdir (cache, i)); FcStrSetAdd (subdirs, FcCacheSubdir (cache, i));
FcDirCacheUnload (cache); 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); fprintf (stderr, "%s: Can't create subdir list\n", dir);
ret++; ret++;
FcDirCacheUnload (cache);
continue; continue;
} }
FcStrSetAdd (processed_dirs, dir); FcStrSetAdd (processed_dirs, dir);
@ -311,7 +307,7 @@ cleanCacheDirectory (FcConfig *config, FcChar8 *dir, FcBool verbose)
while ((ent = readdir (d))) while ((ent = readdir (d)))
{ {
FcChar8 *file_name; FcChar8 *file_name;
FcChar8 *target_dir; const FcChar8 *target_dir;
if (ent->d_name[0] == '.') if (ent->d_name[0] == '.')
continue; continue;

2
fc-cat/Makefile.am
View File

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

37
fc-cat/fc-cat.c
View File

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

14
fontconfig/fcfreetype.h
View File

@ -27,21 +27,25 @@
#include <ft2build.h> #include <ft2build.h>
#include FT_FREETYPE_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); FcPatternAddFTFace (FcPattern *p, const char *object, const FT_Face f);
_FCFUNCPROTOEND _FCFUNCPROTOEND

403
fontconfig/fontconfig.h
View File

@ -25,6 +25,9 @@
#ifndef _FONTCONFIG_H_ #ifndef _FONTCONFIG_H_
#define _FONTCONFIG_H_ #define _FONTCONFIG_H_
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdarg.h> #include <stdarg.h>
#if defined(__GNUC__) && (__GNUC__ >= 4) #if defined(__GNUC__) && (__GNUC__ >= 4)
@ -33,6 +36,10 @@
#define FC_ATTRIBUTE_SENTINEL(x) #define FC_ATTRIBUTE_SENTINEL(x)
#endif #endif
#ifndef FcPublic
#define FcPublic
#endif
typedef unsigned char FcChar8; typedef unsigned char FcChar8;
typedef unsigned short FcChar16; typedef unsigned short FcChar16;
typedef unsigned int FcChar32; typedef unsigned int FcChar32;
@ -271,59 +278,81 @@ typedef struct _FcStrList FcStrList;
typedef struct _FcStrSet FcStrSet; typedef struct _FcStrSet FcStrSet;
typedef struct _FcCache FcCache;
_FCFUNCPROTOBEGIN _FCFUNCPROTOBEGIN
FcBool
FcDirCacheValid (const FcChar8 *cache_file);
/* 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); FcConfigGetConfigFiles (FcConfig *config);
FcChar8 * FcChar8 *
@ -332,108 +361,124 @@ FcConfigGetCache (FcConfig *config);
FcBlanks * FcBlanks *
FcConfigGetBlanks (FcConfig *config); 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, FcConfigGetFonts (FcConfig *config,
FcSetName set); FcSetName set);
FcBool FcPublic FcBool
FcConfigAppFontAddFile (FcConfig *config, FcConfigAppFontAddFile (FcConfig *config,
const FcChar8 *file); const FcChar8 *file);
FcBool FcPublic FcBool
FcConfigAppFontAddDir (FcConfig *config, FcConfigAppFontAddDir (FcConfig *config,
const FcChar8 *dir); const FcChar8 *dir);
void FcPublic void
FcConfigAppFontClear (FcConfig *config); FcConfigAppFontClear (FcConfig *config);
FcBool FcPublic FcBool
FcConfigSubstituteWithPat (FcConfig *config, FcConfigSubstituteWithPat (FcConfig *config,
FcPattern *p, FcPattern *p,
FcPattern *p_pat, FcPattern *p_pat,
FcMatchKind kind); FcMatchKind kind);
FcBool FcPublic FcBool
FcConfigSubstitute (FcConfig *config, FcConfigSubstitute (FcConfig *config,
FcPattern *p, FcPattern *p,
FcMatchKind kind); FcMatchKind kind);
/* fccharset.c */ /* 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); FcCharSetIsSubset (const FcCharSet *a, const FcCharSet *b);
#define FC_CHARSET_MAP_SIZE (256/32) #define FC_CHARSET_MAP_SIZE (256/32)
#define FC_CHARSET_DONE ((FcChar32) -1) #define FC_CHARSET_DONE ((FcChar32) -1)
FcChar32 FcPublic FcChar32
FcCharSetFirstPage (const FcCharSet *a, FcCharSetFirstPage (const FcCharSet *a,
FcChar32 map[FC_CHARSET_MAP_SIZE], FcChar32 map[FC_CHARSET_MAP_SIZE],
FcChar32 *next); FcChar32 *next);
FcChar32 FcPublic FcChar32
FcCharSetNextPage (const FcCharSet *a, FcCharSetNextPage (const FcCharSet *a,
FcChar32 map[FC_CHARSET_MAP_SIZE], FcChar32 map[FC_CHARSET_MAP_SIZE],
FcChar32 *next); 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); FcFontSetPrint (const FcFontSet *s);
/* fcdefault.c */ /* fcdefault.c */
void FcPublic void
FcDefaultSubstitute (FcPattern *pattern); FcDefaultSubstitute (FcPattern *pattern);
/* fcdir.c */ /* fcdir.c */
FcBool FcPublic FcBool
FcFileIsDir (const FcChar8 *file);
FcPublic FcBool
FcFileScan (FcFontSet *set, FcFileScan (FcFontSet *set,
FcStrSet *dirs, FcStrSet *dirs,
FcFileCache *cache, FcFileCache *cache,
@ -441,7 +486,7 @@ FcFileScan (FcFontSet *set,
const FcChar8 *file, const FcChar8 *file,
FcBool force); FcBool force);
FcBool FcPublic FcBool
FcDirScan (FcFontSet *set, FcDirScan (FcFontSet *set,
FcStrSet *dirs, FcStrSet *dirs,
FcFileCache *cache, FcFileCache *cache,
@ -449,147 +494,159 @@ FcDirScan (FcFontSet *set,
const FcChar8 *dir, const FcChar8 *dir,
FcBool force); 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); FcFreeTypeQuery (const FcChar8 *file, int id, FcBlanks *blanks, int *count);
/* fcfs.c */ /* 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); FcFontSetAdd (FcFontSet *s, FcPattern *font);
/* fcinit.c */ /* 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); FcInitBringUptoDate (void);
/* fclang.c */ /* 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); FcLangSetHash (const FcLangSet *ls);
/* fclist.c */ /* 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, FcFontSetList (FcConfig *config,
FcFontSet **sets, FcFontSet **sets,
int nsets, int nsets,
FcPattern *p, FcPattern *p,
FcObjectSet *os); FcObjectSet *os);
FcFontSet * FcPublic FcFontSet *
FcFontList (FcConfig *config, FcFontList (FcConfig *config,
FcPattern *p, FcPattern *p,
FcObjectSet *os); FcObjectSet *os);
/* fcatomic.c */ /* 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); FcAtomicDestroy (FcAtomic *atomic);
/* fcmatch.c */ /* fcmatch.c */
FcPattern * FcPublic FcPattern *
FcFontSetMatch (FcConfig *config, FcFontSetMatch (FcConfig *config,
FcFontSet **sets, FcFontSet **sets,
int nsets, int nsets,
FcPattern *p, FcPattern *p,
FcResult *result); FcResult *result);
FcPattern * FcPublic FcPattern *
FcFontMatch (FcConfig *config, FcFontMatch (FcConfig *config,
FcPattern *p, FcPattern *p,
FcResult *result); FcResult *result);
FcPattern * FcPublic FcPattern *
FcFontRenderPrepare (FcConfig *config, FcFontRenderPrepare (FcConfig *config,
FcPattern *pat, FcPattern *pat,
FcPattern *font); FcPattern *font);
FcFontSet * FcPublic FcFontSet *
FcFontSetSort (FcConfig *config, FcFontSetSort (FcConfig *config,
FcFontSet **sets, FcFontSet **sets,
int nsets, int nsets,
@ -598,192 +655,198 @@ FcFontSetSort (FcConfig *config,
FcCharSet **csp, FcCharSet **csp,
FcResult *result); FcResult *result);
FcFontSet * FcPublic FcFontSet *
FcFontSort (FcConfig *config, FcFontSort (FcConfig *config,
FcPattern *p, FcPattern *p,
FcBool trim, FcBool trim,
FcCharSet **csp, FcCharSet **csp,
FcResult *result); FcResult *result);
void FcPublic void
FcFontSetSortDestroy (FcFontSet *fs); FcFontSetSortDestroy (FcFontSet *fs);
/* fcmatrix.c */ /* 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); FcMatrixShear (FcMatrix *m, double sh, double sv);
/* fcname.c */ /* 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); FcNameUnparse (FcPattern *pat);
/* fcpat.c */ /* 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); FcPatternBuild (FcPattern *orig, ...) FC_ATTRIBUTE_SENTINEL(0);
/* fcstr.c */ /* 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 */ /* These are ASCII only, suitable only for pattern element names */
#define FcIsUpper(c) ((0101 <= (c) && (c) <= 0132)) #define FcIsUpper(c) ((0101 <= (c) && (c) <= 0132))
#define FcIsLower(c) ((0141 <= (c) && (c) <= 0172)) #define FcIsLower(c) ((0141 <= (c) && (c) <= 0172))
#define FcToLower(c) (FcIsUpper(c) ? (c) - 0101 + 0141 : (c)) #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, FcUtf8ToUcs4 (const FcChar8 *src_orig,
FcChar32 *dst, FcChar32 *dst,
int len); int len);
FcBool FcPublic FcBool
FcUtf8Len (const FcChar8 *string, FcUtf8Len (const FcChar8 *string,
int len, int len,
int *nchar, 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, FcUcs4ToUtf8 (FcChar32 ucs4,
FcChar8 dest[FC_UTF8_MAX_LEN]); FcChar8 dest[FC_UTF8_MAX_LEN]);
int FcPublic int
FcUtf16ToUcs4 (const FcChar8 *src_orig, FcUtf16ToUcs4 (const FcChar8 *src_orig,
FcEndian endian, FcEndian endian,
FcChar32 *dst, FcChar32 *dst,
int len); /* in bytes */ int len); /* in bytes */
FcBool FcPublic FcBool
FcUtf16Len (const FcChar8 *string, FcUtf16Len (const FcChar8 *string,
FcEndian endian, FcEndian endian,
int len, /* in bytes */ int len, /* in bytes */
int *nchar, int *nchar,
int *wchar); 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 FcPublic FcBool
FcStrSetMember (FcStrSet *set, const FcChar8 *s); FcStrSetMember (FcPublic FcStrSet *set, const FcChar8 *s);
FcBool FcPublic FcBool
FcStrSetEqual (FcStrSet *sa, FcStrSet *sb); FcStrSetEqual (FcPublic FcStrSet *sa, FcPublic FcStrSet *sb);
FcBool FcPublic FcBool
FcStrSetAdd (FcStrSet *set, const FcChar8 *s); FcStrSetAdd (FcPublic FcStrSet *set, const FcChar8 *s);
FcBool FcPublic FcBool
FcStrSetAddFilename (FcStrSet *set, const FcChar8 *s); FcStrSetAddFilename (FcPublic FcStrSet *set, const FcChar8 *s);
FcBool FcPublic FcBool
FcStrSetDel (FcStrSet *set, const FcChar8 *s); FcStrSetDel (FcPublic FcStrSet *set, const FcChar8 *s);
void FcPublic void
FcStrSetDestroy (FcStrSet *set); FcStrSetDestroy (FcPublic FcStrSet *set);
FcStrList * FcPublic FcStrList *
FcStrListCreate (FcStrSet *set); FcPublic FcStrListCreate (FcPublic FcStrSet *set);
FcChar8 * FcPublic FcChar8 *
FcStrListNext (FcStrList *list); FcPublic FcStrListNext (FcStrList *list);
void FcPublic void
FcStrListDone (FcStrList *list); FcPublic FcStrListDone (FcStrList *list);
/* fcxml.c */ /* fcxml.c */
FcBool FcPublic FcBool
FcConfigParseAndLoad (FcConfig *config, const FcChar8 *file, FcBool complain); FcConfigParseAndLoad (FcConfig *config, const FcChar8 *file, FcBool complain);
_FCFUNCPROTOEND _FCFUNCPROTOEND

48
src/fccache.c
View File

@ -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. * This code implements the MD5 message-digest algorithm.
* The algorithm is due to Ron Rivest. This code was * The algorithm is due to Ron Rivest. This code was

5
src/fccharset.c
View File

@ -43,9 +43,6 @@ FcCharSetCreate (void)
return fcs; return fcs;
} }
FcCharSet *
FcCharSetNew (void);
FcCharSet * FcCharSet *
FcCharSetNew (void) 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 FcChar32
FcCharSetCoverage (const FcCharSet *a, FcChar32 page, FcChar32 *result) FcCharSetCoverage (const FcCharSet *a, FcChar32 page, FcChar32 *result)

337
src/fcint.h
View File

@ -53,9 +53,6 @@
#define FC_CONFIG_PATH "fonts.conf" #define FC_CONFIG_PATH "fonts.conf"
#endif #endif
#define FC_FONT_FILE_INVALID ((FcChar8 *) ".")
#define FC_FONT_FILE_DIR ((FcChar8 *) ".dir")
#ifdef _WIN32 #ifdef _WIN32
#define FC_SEARCH_PATH_SEPARATOR ';' #define FC_SEARCH_PATH_SEPARATOR ';'
#else #else
@ -113,6 +110,15 @@
#define FC_BANK_FIRST 1 #define FC_BANK_FIRST 1
#define FC_BANK_LANGS 0xfcfcfcfc #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 { typedef enum _FcValueBinding {
FcValueBindingWeak, FcValueBindingStrong, FcValueBindingSame FcValueBindingWeak, FcValueBindingStrong, FcValueBindingSame
} FcValueBinding; } FcValueBinding;
@ -306,7 +312,7 @@ typedef struct _FcStrBuf {
int size; int size;
} FcStrBuf; } FcStrBuf;
typedef struct _FcCache { struct _FcCache {
int magic; /* FC_CACHE_MAGIC_MMAP or FC_CACHE_ALLOC */ int magic; /* FC_CACHE_MAGIC_MMAP or FC_CACHE_ALLOC */
int version; /* FC_CACHE_CONTENT_VERSION */ int version; /* FC_CACHE_CONTENT_VERSION */
intptr_t size; /* size of file */ intptr_t size; /* size of file */
@ -314,13 +320,13 @@ typedef struct _FcCache {
intptr_t dirs; /* offset to subdirs */ intptr_t dirs; /* offset to subdirs */
int dirs_count; /* number of subdir strings */ int dirs_count; /* number of subdir strings */
intptr_t set; /* offset to font set */ intptr_t set; /* offset to font set */
} FcCache; };
#define FcCacheDir(c) FcOffsetMember(c,dir,FcChar8) #define FcCacheDir(c) FcOffsetMember(c,dir,FcChar8)
#define FcCacheDirs(c) FcOffsetMember(c,dirs,intptr_t) #define FcCacheDirs(c) FcOffsetMember(c,dirs,intptr_t)
#define FcCacheSet(c) FcOffsetMember(c,set,FcFontSet) #define FcCacheSet(c) FcOffsetMember(c,set,FcFontSet)
#define FcCacheSubdir(c,i) FcOffsetToPtr (FcCacheDirs(cache),\ #define FcCacheSubdir(c,i) FcOffsetToPtr (FcCacheDirs(c),\
FcCacheDirs(cache)[i], \ 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 { typedef struct _FcFileTime {
time_t time; time_t time;
@ -499,208 +505,186 @@ typedef struct _FcCharMap FcCharMap;
/* fccache.c */ /* fccache.c */
FcBool FcPrivate FcCache *
FcDirCacheUnlink (const FcChar8 *dir, FcConfig *config);
void
FcDirCacheUnload (FcCache *cache);
FcCache *
FcDirCacheScan (const FcChar8 *dir, FcConfig *config); FcDirCacheScan (const FcChar8 *dir, FcConfig *config);
FcCache * FcPrivate 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 *
FcDirCacheBuild (FcFontSet *set, const FcChar8 *dir, FcStrSet *dirs); FcDirCacheBuild (FcFontSet *set, const FcChar8 *dir, FcStrSet *dirs);
FcBool FcPrivate FcBool
FcDirCacheWrite (FcCache *cache, FcConfig *config); FcDirCacheWrite (FcCache *cache, FcConfig *config);
/* fccfg.c */ /* fccfg.c */
FcBool FcPrivate FcBool
FcConfigAddConfigDir (FcConfig *config, FcConfigAddConfigDir (FcConfig *config,
const FcChar8 *d); const FcChar8 *d);
FcBool FcPrivate FcBool
FcConfigAddFontDir (FcConfig *config, FcConfigAddFontDir (FcConfig *config,
const FcChar8 *d); const FcChar8 *d);
FcBool FcPrivate FcBool
FcConfigAddDir (FcConfig *config, FcConfigAddDir (FcConfig *config,
const FcChar8 *d); const FcChar8 *d);
FcBool FcPrivate FcBool
FcConfigAddCacheDir (FcConfig *config, FcConfigAddCacheDir (FcConfig *config,
const FcChar8 *d); const FcChar8 *d);
FcStrList * FcPrivate FcBool
FcConfigGetCacheDirs (FcConfig *config);
FcBool
FcConfigAddConfigFile (FcConfig *config, FcConfigAddConfigFile (FcConfig *config,
const FcChar8 *f); const FcChar8 *f);
FcBool FcPrivate FcBool
FcConfigAddBlank (FcConfig *config, FcConfigAddBlank (FcConfig *config,
FcChar32 blank); FcChar32 blank);
FcBool FcPrivate FcBool
FcConfigAddEdit (FcConfig *config, FcConfigAddEdit (FcConfig *config,
FcTest *test, FcTest *test,
FcEdit *edit, FcEdit *edit,
FcMatchKind kind); FcMatchKind kind);
void FcPrivate void
FcConfigSetFonts (FcConfig *config, FcConfigSetFonts (FcConfig *config,
FcFontSet *fonts, FcFontSet *fonts,
FcSetName set); FcSetName set);
FcBool FcPrivate FcBool
FcConfigCompareValue (const FcValue *m, FcConfigCompareValue (const FcValue *m,
FcOp op, FcOp op,
const FcValue *v); const FcValue *v);
FcBool FcPrivate FcBool
FcConfigGlobAdd (FcConfig *config, FcConfigGlobAdd (FcConfig *config,
const FcChar8 *glob, const FcChar8 *glob,
FcBool accept); FcBool accept);
FcBool FcPrivate FcBool
FcConfigAcceptFilename (FcConfig *config, FcConfigAcceptFilename (FcConfig *config,
const FcChar8 *filename); const FcChar8 *filename);
FcBool FcPrivate FcBool
FcConfigPatternsAdd (FcConfig *config, FcConfigPatternsAdd (FcConfig *config,
FcPattern *pattern, FcPattern *pattern,
FcBool accept); FcBool accept);
FcBool FcPrivate FcBool
FcConfigAcceptFont (FcConfig *config, FcConfigAcceptFont (FcConfig *config,
const FcPattern *font); const FcPattern *font);
FcFileTime FcPrivate FcFileTime
FcConfigModifiedTime (FcConfig *config); FcConfigModifiedTime (FcConfig *config);
FcBool FcPrivate FcBool
FcConfigAddCache (FcConfig *config, FcCache *cache); FcConfigAddCache (FcConfig *config, FcCache *cache);
/* fcserialize.c */ /* 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); FcLangSetSerialize(FcSerialize *serialize, const FcLangSet *l);
/* fccharset.c */ /* 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); FcCharSetGetNumbers(const FcCharSet *c);
/* fcdbg.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 #define FcDebug() (FcDebugVal)
FcDebug (void) { return FcDebugVal; }
void FcPrivate void
FcInitDebug (void); FcInitDebug (void);
/* fcdefault.c */ /* fcdefault.c */
FcChar8 * FcPrivate FcChar8 *
FcGetDefaultLang (void); FcGetDefaultLang (void);
/* fcdir.c */ /* fcdir.c */
FcBool FcPrivate FcBool
FcFileIsDir (const FcChar8 *file);
FcBool
FcFileScanConfig (FcFontSet *set, FcFileScanConfig (FcFontSet *set,
FcStrSet *dirs, FcStrSet *dirs,
FcBlanks *blanks, FcBlanks *blanks,
const FcChar8 *file, const FcChar8 *file,
FcConfig *config); FcConfig *config);
FcBool FcPrivate FcBool
FcDirScanConfig (FcFontSet *set, FcDirScanConfig (FcFontSet *set,
FcStrSet *dirs, FcStrSet *dirs,
FcBlanks *blanks, FcBlanks *blanks,
@ -708,123 +692,120 @@ FcDirScanConfig (FcFontSet *set,
FcBool force, FcBool force,
FcConfig *config); FcConfig *config);
FcCache *
FcDirCacheRead (const FcChar8 *dir, FcBool force, FcConfig *config);
/* fcfont.c */ /* fcfont.c */
int FcPrivate int
FcFontDebug (void); FcFontDebug (void);
/* fcfreetype.c */ /* 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); FcFreeTypeGetPrivateMap (FT_Encoding encoding);
/* fcfs.c */ /* 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); FcFontSetSerialize (FcSerialize *serialize, const FcFontSet * s);
/* fcgram.y */ /* 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); FcEditDestroy (FcEdit *e);
/* fcinit.c */ /* 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); FcMemFree (int kind, int size);
/* fclang.c */ /* fclang.c */
FcLangSet * FcPrivate FcLangSet *
FcFreeTypeLangSet (const FcCharSet *charset, FcFreeTypeLangSet (const FcCharSet *charset,
const FcChar8 *exclusiveLang); 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); FcNameUnparseEscaped (FcPattern *pat, FcBool escape);
/* fclist.c */ /* fclist.c */
FcBool FcPrivate FcBool
FcListPatternMatchAny (const FcPattern *p, FcListPatternMatchAny (const FcPattern *p,
const FcPattern *font); const FcPattern *font);
@ -878,190 +859,184 @@ FcListPatternMatchAny (const FcPattern *p,
#define FC_EMBEDDED_BITMAP_OBJECT 39 #define FC_EMBEDDED_BITMAP_OBJECT 39
#define FC_DECORATIVE_OBJECT 40 #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); FcObjectFini (void);
#define FcObjectCompare(a, b) ((int) a - (int) b) #define FcObjectCompare(a, b) ((int) a - (int) b)
/* fcpat.c */ /* 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, FcPatternObjectAddWithBinding (FcPattern *p,
FcObject object, FcObject object,
FcValue value, FcValue value,
FcValueBinding binding, FcValueBinding binding,
FcBool append); 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); FcValueListSerialize (FcSerialize *serialize, const FcValueList *pat);
/* fcrender.c */ /* fcrender.c */
/* fcmatrix.c */ /* fcmatrix.c */
extern const FcMatrix FcIdentityMatrix; extern FcPrivate const FcMatrix FcIdentityMatrix;
void FcPrivate void
FcMatrixFree (FcMatrix *mat); FcMatrixFree (FcMatrix *mat);
/* fcstr.c */ /* fcstr.c */
void FcPrivate void
FcStrSetSort (FcStrSet * set); FcStrSetSort (FcStrSet * set);
FcChar8 * FcPrivate void
FcStrPlus (const FcChar8 *s1, const FcChar8 *s2);
void
FcStrFree (FcChar8 *s);
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); FcStrSerialize (FcSerialize *serialize, const FcChar8 *str);
#endif /* _FC_INT_H_ */ #endif /* _FC_INT_H_ */