/*
- * $XFree86: $
+ * $RCSId: xc/lib/fontconfig/src/fcint.h,v 1.27 2002/08/31 22:17:32 keithp Exp $
*
- * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc.
+ * Copyright © 2000 Keith Packard
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
-#include <libxml/parserInternals.h>
+#include <time.h>
#include <fontconfig/fontconfig.h>
#include <fontconfig/fcprivate.h>
-#include <fontconfig/fcxml.h>
+#include <fontconfig/fcfreetype.h>
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
-typedef struct _FcMatcher {
- char *object;
- double (*compare) (char *object, FcValue value1, FcValue value2);
-} FcMatcher;
-
+/* unused */
typedef struct _FcSymbolic {
const char *name;
int value;
#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
+#define FC_SEARCH_PATH_SEPARATOR ':'
+#endif
+
#define FC_DBG_MATCH 1
#define FC_DBG_MATCHV 2
#define FC_DBG_EDIT 4
#define FC_DBG_CACHEV 32
#define FC_DBG_PARSE 64
#define FC_DBG_SCAN 128
+#define FC_DBG_SCANV 256
#define FC_DBG_MEMORY 512
+#define FC_DBG_CONFIG 1024
#define FC_MEM_CHARSET 0
-#define FC_MEM_CHARNODE 1
+#define FC_MEM_CHARLEAF 1
#define FC_MEM_FONTSET 2
#define FC_MEM_FONTPTR 3
#define FC_MEM_OBJECTSET 4
#define FC_MEM_SUBSTATE 10
#define FC_MEM_STRING 11
#define FC_MEM_LISTBUCK 12
-#define FC_MEM_NUM 13
+#define FC_MEM_STRSET 13
+#define FC_MEM_STRLIST 14
+#define FC_MEM_CONFIG 15
+#define FC_MEM_LANGSET 16
+#define FC_MEM_ATOMIC 17
+#define FC_MEM_BLANKS 18
+#define FC_MEM_CACHE 19
+#define FC_MEM_STRBUF 20
+#define FC_MEM_SUBST 21
+#define FC_MEM_OBJECTTYPE 22
+#define FC_MEM_CONSTANT 23
+#define FC_MEM_TEST 24
+#define FC_MEM_EXPR 25
+#define FC_MEM_VSTACK 26
+#define FC_MEM_ATTR 27
+#define FC_MEM_PSTACK 28
+#define FC_MEM_STATICSTR 29
+
+#define FC_MEM_NUM 30
+
+typedef enum _FcValueBinding {
+ FcValueBindingWeak, FcValueBindingStrong, FcValueBindingSame
+} FcValueBinding;
+
+typedef struct _FcStrSetPtr {
+ FcStorage storage;
+ union {
+ int stat;
+ struct _FcStrSet *dyn;
+ } u;
+} FcStrSetPtr;
+
+typedef struct _FcValueListPtr {
+ FcStorage storage;
+ union {
+ int stat;
+ struct _FcValueList *dyn;
+ } u;
+} FcValueListPtr;
typedef struct _FcValueList {
- struct _FcValueList *next;
+ FcValueListPtr next;
+
FcValue value;
+ FcValueBinding binding;
} FcValueList;
+typedef struct _FcPatternEltPtr {
+ FcStorage storage;
+ union {
+ int stat;
+ struct _FcPatternElt *dyn;
+ } u;
+} FcPatternEltPtr;
+
typedef struct _FcPatternElt {
- const char *object;
- FcValueList *values;
+ FcObjectPtr object;
+ FcValueListPtr values;
} FcPatternElt;
struct _FcPattern {
int num;
int size;
- FcPatternElt *elts;
+ FcPatternEltPtr elts;
+ int ref;
};
typedef enum _FcOp {
FcOpAssign, FcOpAssignReplace,
FcOpPrependFirst, FcOpPrepend, FcOpAppend, FcOpAppendLast,
FcOpQuest,
- FcOpOr, FcOpAnd, FcOpEqual, FcOpNotEqual, FcOpContains,
+ FcOpOr, FcOpAnd, FcOpEqual, FcOpNotEqual,
+ FcOpContains, FcOpListing, FcOpNotContains,
FcOpLess, FcOpLessEqual, FcOpMore, FcOpMoreEqual,
FcOpPlus, FcOpMinus, FcOpTimes, FcOpDivide,
- FcOpNot, FcOpComma, FcOpInvalid
+ FcOpNot, FcOpComma, FcOpFloor, FcOpCeil, FcOpRound, FcOpTrunc,
+ FcOpInvalid
} FcOp;
typedef struct _FcExpr {
union {
int ival;
double dval;
- char *sval;
+ FcChar8 *sval;
FcMatrix *mval;
FcBool bval;
FcCharSet *cval;
char *field;
- char *constant;
+ FcChar8 *constant;
struct {
struct _FcExpr *left, *right;
} tree;
} FcExpr;
typedef enum _FcQual {
- FcQualAny, FcQualAll
+ FcQualAny, FcQualAll, FcQualFirst, FcQualNotFirst
} FcQual;
+#define FcMatchDefault ((FcMatchKind) -1)
+
typedef struct _FcTest {
struct _FcTest *next;
+ FcMatchKind kind;
FcQual qual;
const char *field;
FcOp op;
const char *field;
FcOp op;
FcExpr *expr;
+ FcValueBinding binding;
} FcEdit;
typedef struct _FcSubst {
FcEdit *edit;
} FcSubst;
-typedef struct _FcCharLeaf FcCharLeaf;
-typedef struct _FcCharBranch FcCharBranch;
-typedef union _FcCharNode FcCharNode;
-
-struct _FcCharLeaf {
+typedef struct _FcCharLeaf {
FcChar32 map[256/32];
-};
+} FcCharLeaf;
-union _FcCharNode {
- FcCharBranch *branch;
- FcCharLeaf *leaf;
-};
+#define FC_REF_CONSTANT -1
-struct _FcCharBranch {
- FcCharNode nodes[256];
+struct _FcCharSet {
+ int ref; /* reference count */
+ int num; /* size of leaves and numbers arrays */
+ FcStorage storage;
+ union {
+ struct {
+ FcCharLeaf **leaves;
+ FcChar16 *numbers;
+ } dyn;
+ struct {
+ int leafidx_offset;
+ int numbers_offset;
+ } stat;
+ } u;
};
-struct _FcCharSet {
- int levels;
+struct _FcStrSet {
int ref; /* reference count */
- FcBool constant; /* shared constant */
- FcCharNode node;
+ int num;
+ int size;
+ FcStorage storage;
+ union {
+ FcChar8 **strs;
+ int stridx_offset;
+ } u;
+};
+
+struct _FcStrList {
+ FcStrSet *set;
+ int n;
};
-typedef struct _FcNameBuf {
+typedef struct _FcStrBuf {
FcChar8 *buf;
FcBool allocated;
FcBool failed;
int len;
int size;
-} FcNameBuf;
-
-typedef struct _FcFileCacheEnt {
- struct _FcFileCacheEnt *next;
- unsigned int hash;
- char *file;
- int id;
- time_t time;
- char *name;
- FcBool referenced;
-} FcFileCacheEnt;
-
-#define FC_FILE_CACHE_HASH_SIZE 509
-
-struct _FcFileCache {
- FcFileCacheEnt *ents[FC_FILE_CACHE_HASH_SIZE];
- FcBool updated;
- int entries;
- int referenced;
+} FcStrBuf;
+
+/*
+ * To map adobe glyph names to unicode values, a precomputed hash
+ * table is used
+ */
+
+typedef struct _FcGlyphName {
+ FcChar32 ucs; /* unicode value */
+ FcChar8 name[1]; /* name extends beyond struct */
+} FcGlyphName;
+
+/*
+ * To perform case-insensitive string comparisons, a table
+ * is used which holds three different kinds of folding data.
+ *
+ * The first is a range of upper case values mapping to a range
+ * of their lower case equivalents. Within each range, the offset
+ * between upper and lower case is constant.
+ *
+ * The second is a range of upper case values which are interleaved
+ * with their lower case equivalents.
+ *
+ * The third is a set of raw unicode values mapping to a list
+ * of unicode values for comparison purposes. This allows conversion
+ * of ß to "ss" so that SS, ss and ß all match. A separate array
+ * holds the list of unicode values for each entry.
+ *
+ * These are packed into a single table. Using a binary search,
+ * the appropriate entry can be located.
+ */
+
+#define FC_CASE_FOLD_RANGE 0
+#define FC_CASE_FOLD_EVEN_ODD 1
+#define FC_CASE_FOLD_FULL 2
+
+typedef struct _FcCaseFold {
+ FcChar32 upper;
+ FcChar16 method : 2;
+ FcChar16 count : 14;
+ short offset; /* lower - upper for RANGE, table id for FULL */
+} FcCaseFold;
+
+#define FC_MAX_FILE_LEN 4096
+
+/*
+ * The per-user ~/.fonts.cache-<version> file is loaded into
+ * this data structure. Each directory gets a substructure
+ * which is validated by comparing the directory timestamp with
+ * that saved in the cache. When valid, the entire directory cache
+ * can be immediately loaded without reading the directory. Otherwise,
+ * the files are checked individually; updated files are loaded into the
+ * cache which is then rewritten to the users home directory
+ */
+
+#define FC_GLOBAL_CACHE_DIR_HASH_SIZE 37
+#define FC_GLOBAL_CACHE_FILE_HASH_SIZE 67
+
+typedef struct _FcGlobalCacheInfo {
+ unsigned int hash;
+ FcChar8 *file;
+ time_t time;
+ FcBool referenced;
+} FcGlobalCacheInfo;
+
+typedef struct _FcGlobalCacheFile {
+ struct _FcGlobalCacheFile *next;
+ FcGlobalCacheInfo info;
+ int id;
+ FcChar8 *name;
+} FcGlobalCacheFile;
+
+typedef struct _FcGlobalCacheDir FcGlobalCacheDir;
+
+typedef struct _FcGlobalCacheSubdir {
+ struct _FcGlobalCacheSubdir *next;
+ FcGlobalCacheDir *ent;
+} FcGlobalCacheSubdir;
+
+struct _FcGlobalCacheDir {
+ struct _FcGlobalCacheDir *next;
+ FcGlobalCacheInfo info;
+ int len;
+ FcGlobalCacheFile *ents[FC_GLOBAL_CACHE_FILE_HASH_SIZE];
+ FcGlobalCacheSubdir *subdirs;
+};
+
+typedef struct _FcGlobalCache {
+ FcGlobalCacheDir *ents[FC_GLOBAL_CACHE_DIR_HASH_SIZE];
+ FcBool updated;
+ FcBool broken;
+ int entries;
+ int referenced;
+} FcGlobalCache;
+
+struct _FcAtomic {
+ FcChar8 *file; /* original file name */
+ FcChar8 *new; /* temp file name -- write data here */
+ FcChar8 *lck; /* lockfile name (used for locking) */
+ FcChar8 *tmp; /* tmpfile name (used for locking) */
};
struct _FcBlanks {
* cache file must be consulted before the directories are scanned,
* and those directives may occur in any order
*/
- char **dirs; /* directories containing fonts */
- char *cache; /* name of per-user cache file */
+ FcStrSet *configDirs; /* directories to scan for fonts */
+ FcChar8 *cache; /* name of per-user cache file */
/*
* Set of allowed blank chars -- used to
* trim fonts of bogus glyphs
*/
FcBlanks *blanks;
+ /*
+ * List of directories containing fonts,
+ * built by recursively scanning the set
+ * of configured directories
+ */
+ FcStrSet *fontDirs;
/*
* Names of all of the configuration files used
* to create this configuration
*/
- char **configFiles; /* config files loaded */
+ FcStrSet *configFiles; /* config files loaded */
/*
* Substitution instructions for patterns and fonts;
* maxObjects is used to allocate appropriate intermediate storage
FcSubst *substPattern; /* substitutions for patterns */
FcSubst *substFont; /* substitutions for fonts */
int maxObjects; /* maximum number of tests in all substs */
+ /*
+ * List of patterns used to control font file selection
+ */
+ FcStrSet *acceptGlobs;
+ FcStrSet *rejectGlobs;
+ FcFontSet *acceptPatterns;
+ FcFontSet *rejectPatterns;
/*
* The set of fonts loaded from the listed directories; the
* order within the set does not determine the font selection,
* match preferrentially
*/
FcFontSet *fonts[FcSetApplication + 1];
+ /*
+ * Fontconfig can periodically rescan the system configuration
+ * and font directories. This rescanning occurs when font
+ * listing requests are made, but no more often than rescanInterval
+ * seconds apart.
+ */
+ time_t rescanTime; /* last time information was scanned */
+ int rescanInterval; /* interval between scans */
};
+extern FcConfig *_fcConfig;
+
+typedef struct _FcCharMap FcCharMap;
+
/* fcblanks.c */
/* fccache.c */
-FcFileCache *
-FcFileCacheCreate (void);
+FcGlobalCache *
+FcGlobalCacheCreate (void);
-char *
-FcFileCacheFind (FcFileCache *cache,
- const char *file,
- int id,
- int *count);
+void
+FcGlobalCacheDestroy (FcGlobalCache *cache);
+
+FcBool
+FcGlobalCacheCheckTime (const FcChar8*file, FcGlobalCacheInfo *info);
void
-FcFileCacheDestroy (FcFileCache *cache);
+FcGlobalCacheReferenced (FcGlobalCache *cache,
+ FcGlobalCacheInfo *info);
+
+void
+FcGlobalCacheReferenceSubdir (FcGlobalCache *cache,
+ const FcChar8 *dir);
+
+FcGlobalCacheDir *
+FcGlobalCacheDirGet (FcGlobalCache *cache,
+ const FcChar8 *dir,
+ int len,
+ FcBool create_missing);
+
+FcBool
+FcGlobalCacheScanDir (FcFontSet *set,
+ FcStrSet *dirs,
+ FcGlobalCache *cache,
+ const FcChar8 *dir,
+ FcConfig *config);
+
+FcGlobalCacheFile *
+FcGlobalCacheFileGet (FcGlobalCache *cache,
+ const FcChar8 *file,
+ int id,
+ int *count);
+
void
-FcFileCacheLoad (FcFileCache *cache,
- const char *cache_file);
+FcGlobalCacheLoad (FcGlobalCache *cache,
+ const FcChar8 *cache_file);
FcBool
-FcFileCacheUpdate (FcFileCache *cache,
- const char *file,
- int id,
- const char *name);
+FcGlobalCacheUpdate (FcGlobalCache *cache,
+ const FcChar8 *file,
+ int id,
+ const FcChar8 *name);
FcBool
-FcFileCacheSave (FcFileCache *cache,
- const char *cache_file);
+FcGlobalCacheSave (FcGlobalCache *cache,
+ const FcChar8 *cache_file);
FcBool
-FcFileCacheReadDir (FcFontSet *set, const char *cache_file);
+FcDirCacheReadDir (FcFontSet *set,
+ FcStrSet *dirs,
+ const FcChar8 *dir,
+ FcConfig *config);
FcBool
-FcFileCacheWriteDir (FcFontSet *set, const char *cache_file);
+FcDirCacheWriteDir (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir);
/* fccfg.c */
FcBool
-FcConfigAddDir (FcConfig *config,
- const char *d);
+FcConfigAddConfigDir (FcConfig *config,
+ const FcChar8 *d);
FcBool
-FcConfigAddConfigFile (FcConfig *config,
- const char *f);
+FcConfigAddFontDir (FcConfig *config,
+ const FcChar8 *d);
+
+FcBool
+FcConfigAddDir (FcConfig *config,
+ const FcChar8 *d);
+
+FcBool
+FcConfigAddConfigFile (FcConfig *config,
+ const FcChar8 *f);
FcBool
FcConfigSetCache (FcConfig *config,
- const char *c);
+ const FcChar8 *c);
FcBool
FcConfigAddBlank (FcConfig *config,
FcOp op,
const FcValue v);
+FcBool
+FcConfigGlobAdd (FcConfig *config,
+ const FcChar8 *glob,
+ FcBool accept);
+
+FcBool
+FcConfigAcceptFilename (FcConfig *config,
+ const FcChar8 *filename);
+
+FcBool
+FcConfigPatternsAdd (FcConfig *config,
+ FcPattern *pattern,
+ FcBool accept);
+
+FcBool
+FcConfigAcceptFont (FcConfig *config,
+ const FcPattern *font);
+
/* fccharset.c */
+FcCharSet *
+FcCharSetFreeze (FcCharSet *cs);
+
+void
+FcCharSetThawAll (void);
+
FcBool
-FcNameUnparseCharSet (FcNameBuf *buf, const FcCharSet *c);
+FcNameUnparseCharSet (FcStrBuf *buf, const FcCharSet *c);
FcCharSet *
FcNameParseCharSet (FcChar8 *string);
-/* fcdbg.c */
+FcCharLeaf *
+FcCharSetFindLeafCreate (FcCharSet *fcs, FcChar32 ucs4);
+
void
-FcValuePrint (FcValue v);
+FcCharSetPtrDestroy (FcCharSetPtr fcs);
void
-FcValueListPrint (FcValueList *l);
+FcCharSetClearStatic(void);
+
+FcBool
+FcCharSetPrepareSerialize(FcCharSet *c);
+FcCharSetPtr
+FcCharSetSerialize(FcCharSet *c);
+
+FcCharSetPtr
+FcCharSetPtrCreateDynamic(FcCharSet *c);
+
+FcCharLeaf *
+FcCharSetGetLeaf(const FcCharSet *c, int i);
+
+FcChar16 *
+FcCharSetGetNumbers(const FcCharSet *c);
+
+/* fcdbg.c */
void
-FcPatternPrint (FcPattern *p);
+FcValueListPrint (const FcValueListPtr l);
void
-FcOpPrint (FcOp op);
+FcLangSetPrint (const FcLangSet *ls);
void
-FcTestPrint (FcTest *test);
+FcOpPrint (FcOp op);
void
-FcExprPrint (FcExpr *expr);
+FcTestPrint (const FcTest *test);
void
-FcEditPrint (FcEdit *edit);
+FcExprPrint (const FcExpr *expr);
void
-FcSubstPrint (FcSubst *subst);
+FcEditPrint (const FcEdit *edit);
void
-FcFontSetPrint (FcFontSet *s);
+FcSubstPrint (const FcSubst *subst);
int
FcDebug (void);
+FcCharSet *
+FcCharSetPtrU (FcCharSetPtr mi);
+
/* fcdir.c */
+
FcBool
-FcFileScan (FcFontSet *set,
- FcFileCache *cache,
- FcBlanks *blanks,
- const char *file,
- FcBool force);
+FcFileIsDir (const FcChar8 *file);
FcBool
-FcDirScan (FcFontSet *set,
- FcFileCache *cache,
- FcBlanks *blanks,
- const char *dir,
- FcBool force);
+FcFileScanConfig (FcFontSet *set,
+ FcStrSet *dirs,
+ FcFileCache *cache,
+ FcBlanks *blanks,
+ const FcChar8 *file,
+ FcBool force,
+ FcConfig *config);
FcBool
-FcDirSave (FcFontSet *set, const char *dir);
+FcDirScanConfig (FcFontSet *set,
+ FcStrSet *dirs,
+ FcFileCache *cache,
+ FcBlanks *blanks,
+ const FcChar8 *dir,
+ FcBool force,
+ FcConfig *config);
/* fcfont.c */
int
FcFontDebug (void);
+/* fcfreetype.c */
+FcBool
+FcFreeTypeIsExclusiveLang (const FcChar8 *lang);
+
+FcBool
+FcFreeTypeHasLang (FcPattern *pattern, const FcChar8 *lang);
+
+FcChar32
+FcFreeTypeUcs4ToPrivate (FcChar32 ucs4, const FcCharMap *map);
+
+FcChar32
+FcFreeTypePrivateToUcs4 (FcChar32 private, const FcCharMap *map);
+
+const FcCharMap *
+FcFreeTypeGetPrivateMap (FT_Encoding encoding);
+
/* fcfs.c */
+
+void
+FcFontSetClearStatic (void);
+
+FcBool
+FcFontSetPrepareSerialize (FcFontSet * s);
+
+FcBool
+FcFontSetSerialize (FcFontSet * s);
+
/* fcgram.y */
int
FcConfigparse (void);
char *
FcConfigSaveField (const char *field);
-FcTest *
-FcTestCreate (FcQual qual, const char *field, FcOp compare, FcExpr *expr);
-
void
FcTestDestroy (FcTest *test);
FcExprCreateDouble (double d);
FcExpr *
-FcExprCreateString (const char *s);
+FcExprCreateString (const FcChar8 *s);
FcExpr *
FcExprCreateMatrix (const FcMatrix *m);
FcExprCreateField (const char *field);
FcExpr *
-FcExprCreateConst (const char *constant);
+FcExprCreateConst (const FcChar8 *constant);
FcExpr *
FcExprCreateOp (FcExpr *left, FcOp op, FcExpr *right);
void
FcExprDestroy (FcExpr *e);
-FcEdit *
-FcEditCreate (const char *field, FcOp op, FcExpr *expr);
-
void
FcEditDestroy (FcEdit *e);
void
FcMemFree (int kind, int size);
+/* fclang.c */
+FcLangSet *
+FcFreeTypeLangSet (const FcCharSet *charset,
+ const FcChar8 *exclusiveLang);
+
+FcLangResult
+FcLangCompare (const FcChar8 *s1, const FcChar8 *s2);
+
+const FcCharSet *
+FcCharSetForLang (const FcChar8 *lang);
+
+FcLangSet *
+FcLangSetPromote (const FcChar8 *lang);
+
+FcLangSet *
+FcNameParseLangSet (const FcChar8 *string);
+
+FcBool
+FcNameUnparseLangSet (FcStrBuf *buf, const FcLangSet *ls);
+
+void
+FcLangSetClearStatic (void);
+
+FcBool
+FcLangSetPrepareSerialize (FcLangSet *l);
+
+FcLangSetPtr
+FcLangSetSerialize (FcLangSet *l);
+
+FcLangSet *
+FcLangSetPtrU (FcLangSetPtr li);
+
+FcLangSetPtr
+FcLangSetPtrCreateDynamic (FcLangSet *l);
+
+void
+FcLangSetPtrDestroy (FcLangSetPtr li);
+
/* fclist.c */
+FcBool
+FcListPatternMatchAny (const FcPattern *p,
+ const FcPattern *font);
+
/* fcmatch.c */
+/* fcmmap.c */
+
+void
+FcCacheClearStatic(void);
+
+FcBool
+FcCachePrepareSerialize(FcConfig * config);
+
+FcBool
+FcCacheSerialize (FcConfig * config);
+
+
/* fcname.c */
+
FcBool
-FcNameConstant (char *string, int *result);
+FcNameBool (const FcChar8 *v, FcBool *result);
+
+/* fcpat.c */
+void
+FcValueListDestroy (FcValueListPtr l);
+
+FcPatternElt *
+FcPatternFindElt (const FcPattern *p, const char *object);
+
+FcPatternElt *
+FcPatternInsertElt (FcPattern *p, const char *object);
FcBool
-FcNameBool (char *v, FcBool *result);
+FcPatternAddWithBinding (FcPattern *p,
+ const char *object,
+ FcValue value,
+ FcValueBinding binding,
+ FcBool append);
+
+FcPattern *
+FcPatternFreeze (FcPattern *p);
+
+void
+FcPatternFini (void);
FcBool
-FcNameBufChar (FcNameBuf *buf, FcChar8 c);
+FcPatternAppend (FcPattern *p, FcPattern *s);
+
+void
+FcObjectClearStatic(void);
+
+FcObjectPtr
+FcObjectStaticName (const char *name);
FcBool
-FcNameBufString (FcNameBuf *buf, const FcChar8 *s);
+FcObjectPrepareSerialize (FcObjectPtr si);
+
+const char *
+FcObjectPtrU (FcObjectPtr p);
+
+int
+FcObjectPtrCompare (FcObjectPtr a, FcObjectPtr b);
+
+FcObjectPtr
+FcObjectPtrCreateDynamic (const char * s);
-/* fcpat.c */
void
-FcValueListDestroy (FcValueList *l);
-
+FcObjectPtrDestroy (FcObjectPtr p);
+
+FcBool
+FcPatternPrepareSerialize (FcPattern *p);
+
+void
+FcValueListClearStatic (void);
+
+void
+FcPatternClearStatic (void);
+
+FcValueList *
+FcValueListPtrU(FcValueListPtr p);
+
FcPatternElt *
-FcPatternFind (FcPattern *p, const char *object, FcBool insert);
+FcPatternEltU (FcPatternEltPtr pei);
+
+FcValueListPtr
+FcValueListPtrCreateDynamic(FcValueList * p);
+
+FcBool
+FcValueListPrepareSerialize (FcValueList *p);
+
+FcValueListPtr
+FcValueListSerialize(FcValueList *pi);
+
+FcPattern *
+FcPatternSerialize (FcPattern * p);
/* fcrender.c */
/* fcmatrix.c */
+
+extern const FcMatrixPtr FcIdentityMatrix;
+
void
FcMatrixFree (FcMatrix *mat);
+void
+FcMatrixPtrDestroy (FcMatrixPtr mi);
+
+FcBool
+FcMatrixPrepareSerialize(FcMatrix *m);
+
+FcMatrixPtr
+FcMatrixSerialize(FcMatrix *m);
+
+FcMatrix *
+FcMatrixPtrU (FcMatrixPtr mi);
+
+FcMatrixPtr
+FcMatrixPtrCreateDynamic (FcMatrix *m);
+
+void
+FcMatrixClearStatic (void);
+
/* fcstr.c */
-char *
-FcStrPlus (const char *s1, const char *s2);
+FcStrSet *
+FcStrSetPtrU (const FcStrSetPtr set);
+
+FcStrSetPtr
+FcStrSetPtrCreateDynamic (const FcStrSet * set);
+
+void
+FcStrSetClearStatic (void);
+
+FcBool
+FcStrSetPrepareSerialize (const FcStrSet *set);
+
+void
+FcStrSetSort (FcStrSet * set);
+
+FcChar8 *
+FcStrSetGet (const FcStrSet *set, int i);
+
+FcChar8 *
+FcStrPlus (const FcChar8 *s1, const FcChar8 *s2);
void
-FcStrFree (char *s);
+FcStrFree (FcChar8 *s);
+
+void
+FcStrBufInit (FcStrBuf *buf, FcChar8 *init, int size);
+
+void
+FcStrBufDestroy (FcStrBuf *buf);
+
+FcChar8 *
+FcStrBufDone (FcStrBuf *buf);
+
+FcBool
+FcStrBufChar (FcStrBuf *buf, FcChar8 c);
+
+FcBool
+FcStrBufString (FcStrBuf *buf, const FcChar8 *s);
+
+FcBool
+FcStrBufData (FcStrBuf *buf, const FcChar8 *s, int len);
+
+FcStrSetPtr
+FcStrSetSerialize (FcStrSet *set);
+
+int
+FcStrCmpIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2);
+
+const FcChar8 *
+FcStrContainsIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2);
+
+const FcChar8 *
+FcStrContainsIgnoreCase (const FcChar8 *s1, const FcChar8 *s2);
+
+FcBool
+FcStrUsesHome (const FcChar8 *s);
+
+FcChar8 *
+FcStrLastSlash (const FcChar8 *path);
+
+FcChar32
+FcStrHashIgnoreCase (const FcChar8 *s);
#endif /* _FC_INT_H_ */