#ifndef _FCINT_H_
#define _FCINT_H_
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
#include <stdlib.h>
#include <stdio.h>
+#ifdef HAVE_INTTYPES_H
+#include <inttypes.h>
+#elif defined(HAVE_STDINT_H)
#include <stdint.h>
+#else
+#error missing C99 integer data types
+#endif
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <fontconfig/fontconfig.h>
#include <fontconfig/fcprivate.h>
#include <fontconfig/fcfreetype.h>
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
#ifndef FC_CONFIG_PATH
#define FC_CONFIG_PATH "fonts.conf"
#define FC_FONT_FILE_INVALID ((FcChar8 *) ".")
#define FC_FONT_FILE_DIR ((FcChar8 *) ".dir")
+#define FC_GLOBAL_MAGIC_COOKIE "GLOBAL"
#ifdef _WIN32
#define FC_SEARCH_PATH_SEPARATOR ';'
#define FC_DBG_SCANV 256
#define FC_DBG_MEMORY 512
#define FC_DBG_CONFIG 1024
+#define FC_DBG_LANGSET 2048
#define FC_MEM_CHARSET 0
#define FC_MEM_CHARLEAF 1
#define FC_MEM_NUM 30
+#define FC_BANK_DYNAMIC 0
+#define FC_BANK_FIRST 1
#define FC_BANK_LANGS 0xfcfcfcfc
typedef enum _FcValueBinding {
FcValueBindingWeak, FcValueBindingStrong, FcValueBindingSame
} FcValueBinding;
-typedef struct _FcValueListPtr {
- int bank;
- union {
- int stat;
- struct _FcValueList *dyn;
- } u;
-} FcValueListPtr;
+/*
+ * Serialized data structures use only offsets instead of pointers
+ * A low bit of 1 indicates an offset.
+ */
+
+/* Is the provided pointer actually an offset? */
+#define FcIsEncodedOffset(p) ((((intptr_t) (p)) & 1) != 0)
-typedef struct _FcValueList {
- FcValueListPtr next;
+/* Encode offset in a pointer of type t */
+#define FcOffsetEncode(o,t) ((t *) ((o) | 1))
+
+/* Decode a pointer into an offset */
+#define FcOffsetDecode(p) (((intptr_t) (p)) & ~1)
+
+/* Compute pointer offset */
+#define FcPtrToOffset(b,p) ((intptr_t) (p) - (intptr_t) (b))
+
+/* Given base address, offset and type, return a pointer */
+#define FcOffsetToPtr(b,o,t) ((t *) ((intptr_t) (b) + (o)))
+
+/* Given base address, encoded offset and type, return a pointer */
+#define FcEncodedOffsetToPtr(b,p,t) FcOffsetToPtr(b,FcOffsetDecode(p),t)
+
+/* Given base address, pointer and type, return an encoded offset */
+#define FcPtrToEncodedOffset(b,p,t) FcOffsetEncode(FcPtrToOffset(b,p),t)
+
+/* Given a structure, offset member and type, return pointer */
+#define FcOffsetMember(s,m,t) FcOffsetToPtr(s,(s)->m,t)
+
+/* Given a structure, encoded offset member and type, return pointer to member */
+#define FcEncodedOffsetMember(s,m,t) FcOffsetToPtr(s,FcOffsetDecode((s)->m), t)
+
+/* Given a structure, member and type, convert the member to a pointer */
+#define FcPointerMember(s,m,t) (FcIsEncodedOffset((s)->m) ? \
+ FcEncodedOffsetMember (s,m,t) : \
+ (s)->m)
+
+/*
+ * Serialized values may hold strings, charsets and langsets as pointers,
+ * unfortunately FcValue is an exposed type so we can't just always use
+ * offsets
+ */
+#define FcValueString(v) FcPointerMember(v,u.s,FcChar8)
+#define FcValueCharSet(v) FcPointerMember(v,u.c,const FcCharSet)
+#define FcValueLangSet(v) FcPointerMember(v,u.l,const FcLangSet)
+
+typedef struct _FcValueList *FcValueListPtr;
- FcValue value;
- FcValueBinding binding;
+typedef struct _FcValueList {
+ struct _FcValueList *next;
+ FcValue value;
+ FcValueBinding binding;
} FcValueList;
-typedef int FcObjectPtr;
+#define FcValueListNext(vl) FcPointerMember(vl,next,FcValueList)
+
+typedef int FcObject;
-typedef struct _FcPatternEltPtr {
- int bank;
- union {
- int stat;
- struct _FcPatternElt *dyn;
- } u;
-} FcPatternEltPtr;
+typedef struct _FcPatternElt *FcPatternEltPtr;
+/*
+ * Pattern elts are stuck in a structure connected to the pattern,
+ * so they get moved around when the pattern is resized. Hence, the
+ * values field must be a pointer/offset instead of just an offset
+ */
typedef struct _FcPatternElt {
- FcObjectPtr object;
- FcValueListPtr values;
+ FcObject object;
+ FcValueList *values;
} FcPatternElt;
+#define FcPatternEltValues(pe) FcPointerMember(pe,values,FcValueList)
+
struct _FcPattern {
int num;
int size;
- FcPatternEltPtr elts;
+ intptr_t elts_offset;
int ref;
- int bank;
};
+#define FcPatternElts(p) FcOffsetMember(p,elts_offset,FcPatternElt)
+
+#define FcFontSetFonts(fs) FcPointerMember(fs,fonts,FcPattern *)
+/*
+#define FcFontSetFont(fs,i) (FcIsEncodedOffset((fs)->fonts) ? \
+ FcOffsetToPtr(FcFontSetFonts(fs), \
+ FcFontSetFonts(fs)[i]) : \
+ fs->fonts[i])*/
+
typedef enum _FcOp {
FcOpInteger, FcOpDouble, FcOpString, FcOpMatrix, FcOpBool, FcOpCharSet,
FcOpNil,
FcMatrix *mval;
FcBool bval;
FcCharSet *cval;
- char *field;
+ FcObject object;
FcChar8 *constant;
struct {
struct _FcExpr *left, *right;
struct _FcTest *next;
FcMatchKind kind;
FcQual qual;
- const char *field;
+ FcObject object;
FcOp op;
FcExpr *expr;
} FcTest;
typedef struct _FcEdit {
struct _FcEdit *next;
- const char *field;
+ FcObject object;
FcOp op;
FcExpr *expr;
FcValueBinding binding;
struct _FcCharSet {
int ref; /* reference count */
int num; /* size of leaves and numbers arrays */
- int bank;
- union {
- struct {
- FcCharLeaf **leaves;
- FcChar16 *numbers;
- } dyn;
- struct {
- int leafidx_offset;
- int numbers_offset;
- } stat;
- } u;
+ intptr_t leaves_offset;
+ intptr_t numbers_offset;
};
+#define FcCharSetLeaves(c) FcOffsetMember(c,leaves_offset,intptr_t)
+#define FcCharSetLeaf(c,i) (FcOffsetToPtr(FcCharSetLeaves(c), \
+ FcCharSetLeaves(c)[i], \
+ FcCharLeaf))
+#define FcCharSetNumbers(c) FcOffsetMember(c,numbers_offset,FcChar16)
+
struct _FcStrSet {
int ref; /* reference count */
int num;
} FcStrBuf;
typedef struct _FcCache {
- int magic; /* 0xFC02FC02 */
- int count; /* number of bytes of data in block */
- int bank; /* bank ID */
- int pattern_count; /* number of FcPatterns */
- int patternelt_count; /* number of FcPatternElts */
- int valuelist_count; /* number of FcValueLists */
- int str_count; /* size of strings appearing as FcValues */
- int langset_count; /* number of FcLangSets */
- int charset_count; /* number of FcCharSets */
- int charset_numbers_count;
- int charset_leaf_count;
- int charset_leaf_idx_count;
+ int magic; /* FC_CACHE_MAGIC */
+ off_t size; /* size of file */
+ intptr_t dir; /* offset to dir name */
+ 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)
+
+/*
+ * Used while constructing a directory cache object
+ */
+
+#define FC_SERIALIZE_HASH_SIZE 8191
+
+typedef struct _FcSerializeBucket {
+ struct _FcSerializeBucket *next;
+ const void *object;
+ intptr_t offset;
+} FcSerializeBucket;
+
+typedef struct _FcSerialize {
+ intptr_t size;
+ void *linear;
+ FcSerializeBucket *buckets[FC_SERIALIZE_HASH_SIZE];
+} FcSerialize;
+
/*
* To map adobe glyph names to unicode values, a precomputed hash
* table is used
#define FC_MAX_FILE_LEN 4096
-#define FC_STORAGE_STATIC 0x80
-#define fc_value_string(v) (((v)->type & FC_STORAGE_STATIC) ? ((FcChar8 *) v) + (v)->u.s_off : (v) -> u.s)
-#define fc_value_charset(v) (((v)->type & FC_STORAGE_STATIC) ? (const FcCharSet *)(((char *) v) + (v)->u.c_off) : (v) -> u.c)
-#define fc_value_langset(v) (((v)->type & FC_STORAGE_STATIC) ? (const FcLangSet *)(((char *) v) + (v)->u.l_off) : (v) -> u.l)
+/* XXX remove these when we're ready */
-/*
- * 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_value_string(v) FcValueString(v)
+#define fc_value_charset(v) FcValueCharSet(v)
+#define fc_value_langset(v) FcValueLangSet(v)
+#define fc_storage_type(v) ((v)->type)
-#define FC_CACHE_MAGIC 0xFC02FC02
+#define fc_alignof(type) offsetof (struct { char c; type member; }, member)
-typedef struct _FcGlobalCacheDir FcGlobalCacheDir;
-
-struct _FcGlobalCacheDir {
- struct _FcGlobalCacheDir *next;
- char *name;
- FcCache metadata;
- off_t offset;
- void *ent;
-};
-
-typedef struct _FcGlobalCache {
- FcGlobalCacheDir *dirs;
- FcBool updated;
- int fd;
-} FcGlobalCache;
+#define FC_CACHE_MAGIC 0xFC02FC04
+#define FC_CACHE_MAGIC_COPY 0xFC02FC05
struct _FcAtomic {
FcChar8 *file; /* original file name */
* of configured directories
*/
FcStrSet *fontDirs;
+ /*
+ * List of directories containing cache files.
+ */
+ FcStrSet *cacheDirs;
/*
* Names of all of the configuration files used
* to create this configuration
typedef struct _FcCharMap FcCharMap;
-#define ALIGN(v,type) ((__typeof__(v))(((uintptr_t)(v) + __alignof__(type) - 1) & ~(__alignof__(type) - 1)))
+/* watch out; assumes that v is void * -PL */
+#define ALIGN(v,type) ((void *)(((uintptr_t)(v) + fc_alignof(type) - 1) & ~(fc_alignof(type) - 1)))
/* fcblanks.c */
/* fccache.c */
-FcGlobalCache *
-FcGlobalCacheCreate (void);
-
-void
-FcGlobalCacheDestroy (FcGlobalCache *cache);
-
-FcBool
-FcGlobalCacheReadDir (FcFontSet *set,
- FcStrSet *dirs,
- FcGlobalCache *cache,
- const char *dir,
- FcConfig *config);
-
-void
-FcGlobalCacheLoad (FcGlobalCache *cache,
- FcStrSet *staleDirs,
- const FcChar8 *cache_file,
- FcConfig *config);
-
-FcBool
-FcGlobalCacheUpdate (FcGlobalCache *cache,
- const char *file,
- FcFontSet *set);
-
-FcBool
-FcGlobalCacheSave (FcGlobalCache *cache,
- const FcChar8 *cache_file);
-
FcFontSet *
-FcCacheRead (FcConfig *config, FcGlobalCache * cache);
+FcCacheRead (FcConfig *config);
FcBool
-FcDirCacheWrite (FcFontSet *set, FcStrSet * dirs, const FcChar8 *dir);
+FcDirCacheWrite (FcFontSet *set, FcStrSet * dirs, const FcChar8 *dir, FcConfig *config);
FcBool
-FcDirCacheRead (FcFontSet * set, FcStrSet * dirs, const FcChar8 *dir);
-
-int
-FcCacheBankToIndex (int bank);
-
-const char *
-FcCacheFindBankDir (int bank);
+FcDirCacheConsume (FILE *file, FcFontSet *set, FcStrSet *dirs,
+ const FcChar8 *dir, char *dirname);
+
+FcBool
+FcDirCacheRead (FcFontSet * set, FcStrSet * dirs, const FcChar8 *dir, FcConfig *config);
/* fccfg.c */
FcConfigAddDir (FcConfig *config,
const FcChar8 *d);
+FcBool
+FcConfigAddCacheDir (FcConfig *config,
+ const FcChar8 *d);
+
+FcStrList *
+FcConfigGetCacheDirs (FcConfig *config);
+
FcBool
FcConfigAddConfigFile (FcConfig *config,
const FcChar8 *f);
FcFileTime
FcConfigModifiedTime (FcConfig *config);
+intptr_t
+FcAlignSize (intptr_t size);
+
+FcSerialize *
+FcSerializeCreate (void);
+
+void
+FcSerializeDestroy (FcSerialize *serialize);
+
+FcBool
+FcSerializeAlloc (FcSerialize *serialize, const void *object, int size);
+
+intptr_t
+FcSerializeReserve (FcSerialize *serialize, int size);
+
+intptr_t
+FcSerializeOffset (FcSerialize *serialize, const void *object);
+
+void *
+FcSerializePtr (FcSerialize *serialize, const void *object);
+
+FcBool
+FcLangSetSerializeAlloc (FcSerialize *serialize, const FcLangSet *l);
+
+FcLangSet *
+FcLangSetSerialize(FcSerialize *serialize, const FcLangSet *l);
+
/* fccharset.c */
void
FcLangCharSetPopulate (void);
FcCharLeaf *
FcCharSetFindLeafCreate (FcCharSet *fcs, FcChar32 ucs4);
-void
-FcCharSetNewBank (void);
-
-int
-FcCharSetNeededBytes (const FcCharSet *c);
-
-int
-FcCharSetNeededBytesAlign (void);
-
-void *
-FcCharSetDistributeBytes (FcCache * metadata,
- void * block_ptr);
+FcBool
+FcCharSetSerializeAlloc(FcSerialize *serialize, const FcCharSet *cs);
FcCharSet *
-FcCharSetSerialize(int bank, FcCharSet *c);
-
-void *
-FcCharSetUnserialize (FcCache metadata, void *block_ptr);
-
-FcCharLeaf *
-FcCharSetGetLeaf(const FcCharSet *c, int i);
+FcCharSetSerialize(FcSerialize *serialize, const FcCharSet *cs);
FcChar16 *
FcCharSetGetNumbers(const FcCharSet *c);
void
FcSubstPrint (const FcSubst *subst);
-int
-FcDebug (void);
+void
+FcCharSetPrint (const FcCharSet *c);
+
+extern int FcDebugVal;
+
+static inline int
+FcDebug (void) { return FcDebugVal; }
+
+void
+FcInitDebug (void);
/* fcdefault.c */
FcChar8 *
FcBool
FcFileScanConfig (FcFontSet *set,
FcStrSet *dirs,
- FcFileCache *cache,
FcBlanks *blanks,
const FcChar8 *file,
FcBool force,
FcBool
FcDirScanConfig (FcFontSet *set,
FcStrSet *dirs,
- FcFileCache *cache,
FcBlanks *blanks,
const FcChar8 *dir,
FcBool force,
/* fcfs.c */
-void
-FcFontSetNewBank (void);
-
-int
-FcFontSetNeededBytes (FcFontSet *s);
-
-int
-FcFontSetNeededBytesAlign (void);
-
-void *
-FcFontSetDistributeBytes (FcCache * metadata, void * block_ptr);
-
-FcBool
-FcFontSetSerialize (int bank, FcFontSet * s);
-
FcBool
-FcFontSetUnserialize(FcCache metadata, FcFontSet * s, void * block_ptr);
+FcFontSetSerializeAlloc (FcSerialize *serialize, const FcFontSet *s);
+FcFontSet *
+FcFontSetSerialize (FcSerialize *serialize, const FcFontSet * s);
+
/* fcgram.y */
int
FcConfigparse (void);
FcBool
FcNameUnparseLangSet (FcStrBuf *buf, const FcLangSet *ls);
-void
-FcLangSetNewBank (void);
-
-int
-FcLangSetNeededBytes (const FcLangSet *l);
-
-int
-FcLangSetNeededBytesAlign (void);
-
-void *
-FcLangSetDistributeBytes (FcCache * metadata,
- void * block_ptr);
-
-FcLangSet *
-FcLangSetSerialize (int bank, FcLangSet *l);
-
-void *
-FcLangSetUnserialize (FcCache metadata, void *block_ptr);
-
/* fclist.c */
FcBool
/* fcname.c */
-FcBool
-FcNameBool (const FcChar8 *v, FcBool *result);
-
-void *
-FcObjectDistributeBytes (FcCache * metadata,
- void * block_ptr);
+/*
+ * NOTE -- this ordering is part of the cache file format.
+ * It must also match the ordering in fcname.c
+ */
-FcObjectPtr
-FcObjectToPtr (const char * si);
+#define FC_FAMILY_OBJECT 1
+#define FC_FAMILYLANG_OBJECT 2
+#define FC_STYLE_OBJECT 3
+#define FC_STYLELANG_OBJECT 4
+#define FC_FULLNAME_OBJECT 5
+#define FC_FULLNAMELANG_OBJECT 6
+#define FC_SLANT_OBJECT 7
+#define FC_WEIGHT_OBJECT 8
+#define FC_WIDTH_OBJECT 9
+#define FC_SIZE_OBJECT 10
+#define FC_ASPECT_OBJECT 11
+#define FC_PIXEL_SIZE_OBJECT 12
+#define FC_SPACING_OBJECT 13
+#define FC_FOUNDRY_OBJECT 14
+#define FC_ANTIALIAS_OBJECT 15
+#define FC_HINT_STYLE_OBJECT 16
+#define FC_HINTING_OBJECT 17
+#define FC_VERTICAL_LAYOUT_OBJECT 18
+#define FC_AUTOHINT_OBJECT 19
+#define FC_GLOBAL_ADVANCE_OBJECT 20
+#define FC_FILE_OBJECT 21
+#define FC_INDEX_OBJECT 22
+#define FC_RASTERIZER_OBJECT 23
+#define FC_OUTLINE_OBJECT 24
+#define FC_SCALABLE_OBJECT 25
+#define FC_DPI_OBJECT 26
+#define FC_RGBA_OBJECT 27
+#define FC_SCALE_OBJECT 28
+#define FC_MINSPACE_OBJECT 29
+#define FC_CHAR_WIDTH_OBJECT 30
+#define FC_CHAR_HEIGHT_OBJECT 31
+#define FC_MATRIX_OBJECT 32
+#define FC_CHARSET_OBJECT 33
+#define FC_LANG_OBJECT 34
+#define FC_FONTVERSION_OBJECT 35
+#define FC_CAPABILITY_OBJECT 36
+#define FC_FONTFORMAT_OBJECT 37
+#define FC_EMBOLDEN_OBJECT 38
+#define FC_EMBEDDED_BITMAP_OBJECT 39
-int
-FcObjectNeededBytes (void);
-
-int
-FcObjectNeededBytesAlign (void);
+FcBool
+FcNameBool (const FcChar8 *v, FcBool *result);
-void *
-FcObjectUnserialize (FcCache metadata, void *block_ptr);
+FcBool
+FcObjectValidType (FcObject object, FcType type);
-void
-FcObjectSerialize (void);
+FcObject
+FcObjectFromName (const char * name);
const char *
-FcObjectPtrU (FcObjectPtr p);
+FcObjectName (FcObject object);
-int
-FcObjectPtrCompare (FcObjectPtr a, FcObjectPtr b);
+#define FcObjectCompare(a, b) ((int) a - (int) b)
void
FcObjectStaticNameFini (void);
FcValueListDestroy (FcValueListPtr l);
FcPatternElt *
-FcPatternFindElt (const FcPattern *p, const char *object);
+FcPatternObjectFindElt (const FcPattern *p, FcObject object);
FcPatternElt *
-FcPatternInsertElt (FcPattern *p, const char *object);
+FcPatternObjectInsertElt (FcPattern *p, FcObject object);
FcBool
-FcPatternAddWithBinding (FcPattern *p,
- const char *object,
- FcValue value,
- FcValueBinding binding,
- FcBool append);
+FcPatternObjectAddWithBinding (FcPattern *p,
+ FcObject object,
+ FcValue value,
+ FcValueBinding binding,
+ FcBool append);
-FcPattern *
-FcPatternFreeze (FcPattern *p);
+FcBool
+FcPatternObjectAdd (FcPattern *p, FcObject object, FcValue value, FcBool append);
+
+FcBool
+FcPatternObjectAddWeak (FcPattern *p, FcObject object, FcValue value, FcBool append);
+
+FcResult
+FcPatternObjectGet (const FcPattern *p, FcObject object, int id, FcValue *v);
+
+FcBool
+FcPatternObjectDel (FcPattern *p, FcObject object);
-void
-FcPatternFini (void);
+FcBool
+FcPatternObjectRemove (FcPattern *p, FcObject object, int id);
FcBool
-FcPatternAppend (FcPattern *p, FcPattern *s);
+FcPatternObjectAddInteger (FcPattern *p, FcObject object, int i);
-void
-FcPatternAddFullFname (const FcPattern *p, const char *fname);
+FcBool
+FcPatternObjectAddDouble (FcPattern *p, FcObject object, double d);
-void
-FcPatternTransferFullFname (const FcPattern *new, const FcPattern *orig);
+FcBool
+FcPatternObjectAddString (FcPattern *p, FcObject object, const FcChar8 *s);
-const FcChar8 *
-FcStrStaticName (const FcChar8 *name);
+FcBool
+FcPatternObjectAddMatrix (FcPattern *p, FcObject object, const FcMatrix *s);
-FcChar32
-FcStringHash (const FcChar8 *s);
+FcBool
+FcPatternObjectAddCharSet (FcPattern *p, FcObject object, const FcCharSet *c);
-void
-FcPatternNewBank (void);
+FcBool
+FcPatternObjectAddBool (FcPattern *p, FcObject object, FcBool b);
-int
-FcPatternNeededBytes (FcPattern *p);
+FcBool
+FcPatternObjectAddLangSet (FcPattern *p, FcObject object, const FcLangSet *ls);
-int
-FcPatternNeededBytesAlign (void);
+FcResult
+FcPatternObjectGetInteger (const FcPattern *p, FcObject object, int n, int *i);
-void *
-FcPatternDistributeBytes (FcCache * metadata, void * block_ptr);
+FcResult
+FcPatternObjectGetDouble (const FcPattern *p, FcObject object, int n, double *d);
-FcValueList *
-FcValueListPtrU(FcValueListPtr p);
+FcResult
+FcPatternObjectGetString (const FcPattern *p, FcObject object, int n, FcChar8 ** s);
-FcPatternElt *
-FcPatternEltU (FcPatternEltPtr pei);
+FcResult
+FcPatternObjectGetMatrix (const FcPattern *p, FcObject object, int n, FcMatrix **s);
+
+FcResult
+FcPatternObjectGetCharSet (const FcPattern *p, FcObject object, int n, FcCharSet **c);
-FcValueListPtr
-FcValueListPtrCreateDynamic(FcValueList * p);
+FcResult
+FcPatternObjectGetBool (const FcPattern *p, FcObject object, int n, FcBool *b);
+
+FcResult
+FcPatternObjectGetLangSet (const FcPattern *p, FcObject object, int n, FcLangSet **ls);
+
+void
+FcPatternFini (void);
+
+FcBool
+FcPatternAppend (FcPattern *p, FcPattern *s);
+
+const FcChar8 *
+FcStrStaticName (const FcChar8 *name);
+
+FcChar32
+FcStringHash (const FcChar8 *s);
+
+FcBool
+FcPatternSerializeAlloc (FcSerialize *serialize, const FcPattern *pat);
FcPattern *
-FcPatternSerialize (int bank, FcPattern * p);
+FcPatternSerialize (FcSerialize *serialize, const FcPattern *pat);
-void *
-FcPatternUnserialize (FcCache metadata, void *block_ptr);
+FcBool
+FcValueListSerializeAlloc (FcSerialize *serialize, const FcValueList *pat);
+
+FcValueList *
+FcValueListSerialize (FcSerialize *serialize, const FcValueList *pat);
/* fcrender.c */
FcChar32
FcStrHashIgnoreCase (const FcChar8 *s);
+FcChar8 *
+FcStrCanonFilename (const FcChar8 *s);
+
+FcBool
+FcStrSerializeAlloc (FcSerialize *serialize, const FcChar8 *str);
+
+FcChar8 *
+FcStrSerialize (FcSerialize *serialize, const FcChar8 *str);
+
#endif /* _FC_INT_H_ */
git.wh0rd.org / fontconfig.git / blobdiff