/*
- * $XFree86: xc/lib/fontconfig/src/fcint.h,v 1.16 2002/07/06 23:47:44 keithp Exp $
+ * $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
#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
-
-typedef struct _FcSymbolic {
- const char *name;
- int value;
-} FcSymbolic;
#ifndef FC_CONFIG_PATH
#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_SCAN 128
#define FC_DBG_SCANV 256
#define FC_DBG_MEMORY 512
+#define FC_DBG_CONFIG 1024
+#define FC_DBG_LANGSET 2048
+#define FC_DBG_OBJTYPES 4096
#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 14
-#define FC_MEM_STRLIST 15
-#define FC_MEM_CONFIG 16
+#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
+
+#define FC_BANK_DYNAMIC 0
+#define FC_BANK_FIRST 1
+#define FC_BANK_LANGS 0xfcfcfcfc
+
+/* slim_internal.h */
+#if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)) && defined(__ELF__)
+#define FcPrivate __attribute__((__visibility__("hidden")))
+#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550)
+#define FcPrivate __hidden
+#else /* not gcc >= 3.3 and not Sun Studio >= 8 */
+#define FcPrivate
+#endif
typedef enum _FcValueBinding {
- FcValueBindingWeak, FcValueBindingStrong
+ FcValueBindingWeak, FcValueBindingStrong, FcValueBindingSame
} FcValueBinding;
+/*
+ * 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)
+
+/* 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;
+
typedef struct _FcValueList {
- struct _FcValueList *next;
- FcValue value;
- FcValueBinding binding;
+ struct _FcValueList *next;
+ FcValue value;
+ FcValueBinding binding;
} FcValueList;
+#define FcValueListNext(vl) FcPointerMember(vl,next,FcValueList)
+
+typedef int FcObject;
+
+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 {
- const char *object;
- FcValueList *values;
+ FcObject object;
+ FcValueList *values;
} FcPatternElt;
+#define FcPatternEltValues(pe) FcPointerMember(pe,values,FcValueList)
+
struct _FcPattern {
int num;
int size;
- FcPatternElt *elts;
+ intptr_t elts_offset;
int ref;
};
+#define FcPatternElts(p) FcOffsetMember(p,elts_offset,FcPatternElt)
+
+#define FcFontSetFonts(fs) FcPointerMember(fs,fonts,FcPattern *)
+
+#define FcFontSetFont(fs,i) (FcIsEncodedOffset((fs)->fonts) ? \
+ FcEncodedOffsetToPtr(fs, \
+ FcFontSetFonts(fs)[i], \
+ FcPattern) : \
+ fs->fonts[i])
+
typedef enum _FcOp {
FcOpInteger, FcOpDouble, FcOpString, FcOpMatrix, FcOpBool, FcOpCharSet,
FcOpNil,
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 {
FcMatrix *mval;
FcBool bval;
FcCharSet *cval;
- char *field;
+ FcObject object;
FcChar8 *constant;
struct {
struct _FcExpr *left, *right;
FcQualAny, FcQualAll, FcQualFirst, FcQualNotFirst
} FcQual;
+#define FcMatchDefault ((FcMatchKind) -1)
+
typedef struct _FcTest {
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;
} FcEdit;
typedef struct _FcSubst {
FcChar32 map[256/32];
} FcCharLeaf;
-typedef enum _FcLangResult {
- FcLangEqual, FcLangDifferentCountry, FcLangDifferentLang
-} FcLangResult;
+#define FC_REF_CONSTANT -1
struct _FcCharSet {
int ref; /* reference count */
- FcBool constant; /* in hash table constant */
int num; /* size of leaves and numbers arrays */
- FcCharLeaf **leaves;
- FcChar16 *numbers;
+ 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;
int size;
} FcStrBuf;
+struct _FcCache {
+ int magic; /* FC_CACHE_MAGIC_MMAP or FC_CACHE_ALLOC */
+ int version; /* FC_CACHE_CONTENT_VERSION */
+ intptr_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 */
+};
+
+#define FcCacheDir(c) FcOffsetMember(c,dir,FcChar8)
+#define FcCacheDirs(c) FcOffsetMember(c,dirs,intptr_t)
+#define FcCacheSet(c) FcOffsetMember(c,set,FcFontSet)
+#define FcCacheSubdir(c,i) FcOffsetToPtr (FcCacheDirs(c),\
+ FcCacheDirs(c)[i], \
+ FcChar8)
+
+/*
+ * 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 _FcCharSetFreezer FcCharSetFreezer;
+
+typedef struct _FcSerialize {
+ intptr_t size;
+ FcCharSetFreezer *cs_freezer;
+ void *linear;
+ FcSerializeBucket *buckets[FC_SERIALIZE_HASH_SIZE];
+} FcSerialize;
+
/*
- * The per-user ~/.fonts.cache 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
+ * To map adobe glyph names to unicode values, a precomputed hash
+ * table is used
*/
-#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 _FcGlobalCacheSubdir {
- struct _FcGlobalCacheSubdir *next;
- FcChar8 *file;
-} FcGlobalCacheSubdir;
-
-typedef struct _FcGlobalCacheDir {
- struct _FcGlobalCacheDir *next;
- FcGlobalCacheInfo info;
- int len;
- FcGlobalCacheFile *ents[FC_GLOBAL_CACHE_FILE_HASH_SIZE];
- FcGlobalCacheSubdir *subdirs;
-} FcGlobalCacheDir;
-
-typedef struct _FcGlobalCache {
- FcGlobalCacheDir *ents[FC_GLOBAL_CACHE_DIR_HASH_SIZE];
- FcBool updated;
- FcBool broken;
- int entries;
- int referenced;
-} FcGlobalCache;
+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
+
+/* XXX remove these when we're ready */
+
+#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_alignof(type) offsetof (struct { char c; type member; }, member)
+
+#define FC_CACHE_MAGIC_MMAP 0xFC02FC04
+#define FC_CACHE_MAGIC_ALLOC 0xFC02FC05
+#define FC_CACHE_CONTENT_VERSION 1
struct _FcAtomic {
FcChar8 *file; /* original file name */
* and those directives may occur in any order
*/
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
* 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
*/
FcSubst *substPattern; /* substitutions for patterns */
FcSubst *substFont; /* substitutions for fonts */
+ FcSubst *substScan; /* substitutions for scanned 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,
int rescanInterval; /* interval between scans */
};
-extern FcConfig *_fcConfig;
+extern FcPrivate FcConfig *_fcConfig;
+
+typedef struct _FcFileTime {
+ time_t time;
+ FcBool set;
+} FcFileTime;
typedef struct _FcCharMap FcCharMap;
+/* 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
-FcGlobalCacheCheckTime (FcGlobalCacheInfo *info);
-
-void
-FcGlobalCacheReferenced (FcGlobalCache *cache,
- FcGlobalCacheInfo *info);
-
-FcGlobalCacheDir *
-FcGlobalCacheDirGet (FcGlobalCache *cache,
- const FcChar8 *dir,
- int len,
- FcBool create_missing);
-
-FcBool
-FcGlobalCacheScanDir (FcFontSet *set,
- FcStrSet *dirs,
- FcGlobalCache *cache,
- const FcChar8 *dir);
-
-FcGlobalCacheFile *
-FcGlobalCacheFileGet (FcGlobalCache *cache,
- const FcChar8 *file,
- int id,
- int *count);
-
+FcPrivate FcCache *
+FcDirCacheScan (const FcChar8 *dir, FcConfig *config);
-void
-FcGlobalCacheLoad (FcGlobalCache *cache,
- const FcChar8 *cache_file);
+FcPrivate FcCache *
+FcDirCacheBuild (FcFontSet *set, const FcChar8 *dir, FcStrSet *dirs);
-FcBool
-FcGlobalCacheUpdate (FcGlobalCache *cache,
- const FcChar8 *file,
- int id,
- const FcChar8 *name);
-
-FcBool
-FcGlobalCacheSave (FcGlobalCache *cache,
- const FcChar8 *cache_file);
-
-FcBool
-FcDirCacheValid (const FcChar8 *cache_file);
+FcPrivate FcBool
+FcDirCacheWrite (FcCache *cache, FcConfig *config);
+
+FcPrivate void
+FcCacheObjectReference (void *object);
-FcBool
-FcDirCacheReadDir (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir);
+FcPrivate void
+FcCacheObjectDereference (void *object);
-FcBool
-FcDirCacheWriteDir (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir);
+FcPrivate void
+FcCacheFini (void);
/* fccfg.c */
-FcBool
+FcPrivate FcBool
FcConfigAddConfigDir (FcConfig *config,
const FcChar8 *d);
-FcBool
+FcPrivate FcBool
FcConfigAddFontDir (FcConfig *config,
const FcChar8 *d);
-FcBool
+FcPrivate FcBool
FcConfigAddDir (FcConfig *config,
const FcChar8 *d);
-FcBool
+FcPrivate FcBool
+FcConfigAddCacheDir (FcConfig *config,
+ const FcChar8 *d);
+
+FcPrivate FcBool
FcConfigAddConfigFile (FcConfig *config,
const FcChar8 *f);
-FcBool
-FcConfigSetCache (FcConfig *config,
- const FcChar8 *c);
-
-FcBool
+FcPrivate FcBool
FcConfigAddBlank (FcConfig *config,
FcChar32 blank);
-FcBool
+FcPrivate FcBool
FcConfigAddEdit (FcConfig *config,
FcTest *test,
FcEdit *edit,
FcMatchKind kind);
-void
+FcPrivate void
FcConfigSetFonts (FcConfig *config,
FcFontSet *fonts,
FcSetName set);
-FcBool
-FcConfigCompareValue (const FcValue m,
+FcPrivate FcBool
+FcConfigCompareValue (const FcValue *m,
FcOp op,
- const FcValue v);
+ const FcValue *v);
+
+FcPrivate FcBool
+FcConfigGlobAdd (FcConfig *config,
+ const FcChar8 *glob,
+ FcBool accept);
+
+FcPrivate FcBool
+FcConfigAcceptFilename (FcConfig *config,
+ const FcChar8 *filename);
+
+FcPrivate FcBool
+FcConfigPatternsAdd (FcConfig *config,
+ FcPattern *pattern,
+ FcBool accept);
+
+FcPrivate FcBool
+FcConfigAcceptFont (FcConfig *config,
+ const FcPattern *font);
+
+FcPrivate FcFileTime
+FcConfigModifiedTime (FcConfig *config);
+
+FcPrivate FcBool
+FcConfigAddCache (FcConfig *config, FcCache *cache);
+
+/* fcserialize.c */
+FcPrivate intptr_t
+FcAlignSize (intptr_t size);
+
+FcPrivate FcSerialize *
+FcSerializeCreate (void);
+
+FcPrivate void
+FcSerializeDestroy (FcSerialize *serialize);
+
+FcPrivate FcBool
+FcSerializeAlloc (FcSerialize *serialize, const void *object, int size);
+
+FcPrivate intptr_t
+FcSerializeReserve (FcSerialize *serialize, int size);
+
+FcPrivate intptr_t
+FcSerializeOffset (FcSerialize *serialize, const void *object);
+
+FcPrivate void *
+FcSerializePtr (FcSerialize *serialize, const void *object);
+
+FcPrivate FcBool
+FcLangSetSerializeAlloc (FcSerialize *serialize, const FcLangSet *l);
+
+FcPrivate FcLangSet *
+FcLangSetSerialize(FcSerialize *serialize, const FcLangSet *l);
/* fccharset.c */
-FcCharSet *
-FcCharSetFreeze (FcCharSet *cs);
+FcPrivate void
+FcLangCharSetPopulate (void);
+
+FcPrivate FcCharSetFreezer *
+FcCharSetFreezerCreate (void);
-FcBool
+FcPrivate const FcCharSet *
+FcCharSetFreeze (FcCharSetFreezer *freezer, const FcCharSet *fcs);
+
+FcPrivate void
+FcCharSetFreezerDestroy (FcCharSetFreezer *freezer);
+
+FcPrivate FcBool
FcNameUnparseCharSet (FcStrBuf *buf, const FcCharSet *c);
-FcCharSet *
+FcPrivate FcCharSet *
FcNameParseCharSet (FcChar8 *string);
-FcChar32
-FcFreeTypeUcs4ToPrivate (FcChar32 ucs4, const FcCharMap *map);
+FcPrivate FcCharLeaf *
+FcCharSetFindLeafCreate (FcCharSet *fcs, FcChar32 ucs4);
-FcChar32
-FcFreeTypePrivateToUcs4 (FcChar32 private, const FcCharMap *map);
+FcPrivate FcBool
+FcCharSetSerializeAlloc(FcSerialize *serialize, const FcCharSet *cs);
+
+FcPrivate FcCharSet *
+FcCharSetSerialize(FcSerialize *serialize, const FcCharSet *cs);
+
+FcPrivate FcChar16 *
+FcCharSetGetNumbers(const FcCharSet *c);
-const FcCharMap *
-FcFreeTypeGetPrivateMap (FT_Encoding encoding);
-
/* fcdbg.c */
-void
-FcValueListPrint (FcValueList *l);
+FcPrivate void
+FcValueListPrint (const FcValueListPtr l);
-void
+FcPrivate void
+FcLangSetPrint (const FcLangSet *ls);
+
+FcPrivate void
FcOpPrint (FcOp op);
-void
-FcTestPrint (FcTest *test);
+FcPrivate void
+FcTestPrint (const FcTest *test);
-void
-FcExprPrint (FcExpr *expr);
+FcPrivate void
+FcExprPrint (const FcExpr *expr);
-void
-FcEditPrint (FcEdit *edit);
+FcPrivate void
+FcEditPrint (const FcEdit *edit);
-void
-FcSubstPrint (FcSubst *subst);
+FcPrivate void
+FcSubstPrint (const FcSubst *subst);
-int
-FcDebug (void);
+FcPrivate void
+FcCharSetPrint (const FcCharSet *c);
+
+extern FcPrivate int FcDebugVal;
+
+#define FcDebug() (FcDebugVal)
+
+FcPrivate void
+FcInitDebug (void);
+
+/* fcdefault.c */
+FcPrivate FcChar8 *
+FcGetDefaultLang (void);
/* fcdir.c */
+FcPrivate FcBool
+FcFileScanConfig (FcFontSet *set,
+ FcStrSet *dirs,
+ FcBlanks *blanks,
+ const FcChar8 *file,
+ FcConfig *config);
+
+FcPrivate FcBool
+FcDirScanConfig (FcFontSet *set,
+ FcStrSet *dirs,
+ FcBlanks *blanks,
+ const FcChar8 *dir,
+ FcBool force,
+ FcConfig *config);
+
/* fcfont.c */
-int
+FcPrivate int
FcFontDebug (void);
/* fcfreetype.c */
-FcBool
+FcPrivate FcBool
FcFreeTypeIsExclusiveLang (const FcChar8 *lang);
-FcBool
+FcPrivate FcBool
FcFreeTypeHasLang (FcPattern *pattern, const FcChar8 *lang);
+FcPrivate FcChar32
+FcFreeTypeUcs4ToPrivate (FcChar32 ucs4, const FcCharMap *map);
+
+FcPrivate FcChar32
+FcFreeTypePrivateToUcs4 (FcChar32 private, const FcCharMap *map);
+
+FcPrivate const FcCharMap *
+FcFreeTypeGetPrivateMap (FT_Encoding encoding);
+
/* fcfs.c */
+
+FcPrivate FcBool
+FcFontSetSerializeAlloc (FcSerialize *serialize, const FcFontSet *s);
+
+FcPrivate FcFontSet *
+FcFontSetSerialize (FcSerialize *serialize, const FcFontSet * s);
+
/* fcgram.y */
-int
+FcPrivate int
FcConfigparse (void);
-int
+FcPrivate int
FcConfigwrap (void);
-void
+FcPrivate void
FcConfigerror (char *fmt, ...);
-char *
+FcPrivate char *
FcConfigSaveField (const char *field);
-FcTest *
-FcTestCreate (FcQual qual, const FcChar8 *field, FcOp compare, FcExpr *expr);
-
-void
+FcPrivate void
FcTestDestroy (FcTest *test);
-FcExpr *
+FcPrivate FcExpr *
FcExprCreateInteger (int i);
-FcExpr *
+FcPrivate FcExpr *
FcExprCreateDouble (double d);
-FcExpr *
+FcPrivate FcExpr *
FcExprCreateString (const FcChar8 *s);
-FcExpr *
+FcPrivate FcExpr *
FcExprCreateMatrix (const FcMatrix *m);
-FcExpr *
+FcPrivate FcExpr *
FcExprCreateBool (FcBool b);
-FcExpr *
+FcPrivate FcExpr *
FcExprCreateNil (void);
-FcExpr *
+FcPrivate FcExpr *
FcExprCreateField (const char *field);
-FcExpr *
+FcPrivate FcExpr *
FcExprCreateConst (const FcChar8 *constant);
-FcExpr *
+FcPrivate FcExpr *
FcExprCreateOp (FcExpr *left, FcOp op, FcExpr *right);
-void
+FcPrivate void
FcExprDestroy (FcExpr *e);
-FcEdit *
-FcEditCreate (const char *field, FcOp op, FcExpr *expr);
-
-void
+FcPrivate void
FcEditDestroy (FcEdit *e);
/* fcinit.c */
-void
+FcPrivate void
FcMemReport (void);
-void
+FcPrivate void
FcMemAlloc (int kind, int size);
-void
+FcPrivate void
FcMemFree (int kind, int size);
/* fclang.c */
-FcBool
-FcFreeTypeSetLang (FcPattern *pattern,
- FcCharSet *charset,
+FcPrivate FcLangSet *
+FcFreeTypeLangSet (const FcCharSet *charset,
const FcChar8 *exclusiveLang);
-FcLangResult
+FcPrivate FcLangResult
FcLangCompare (const FcChar8 *s1, const FcChar8 *s2);
-const FcCharSet *
+FcPrivate const FcCharSet *
FcCharSetForLang (const FcChar8 *lang);
+FcPrivate FcLangSet *
+FcLangSetPromote (const FcChar8 *lang);
+
+FcPrivate FcLangSet *
+FcNameParseLangSet (const FcChar8 *string);
+
+FcPrivate FcBool
+FcNameUnparseLangSet (FcStrBuf *buf, const FcLangSet *ls);
+
+FcPrivate FcChar8 *
+FcNameUnparseEscaped (FcPattern *pat, FcBool escape);
+
/* fclist.c */
+FcPrivate FcBool
+FcListPatternMatchAny (const FcPattern *p,
+ const FcPattern *font);
+
/* fcmatch.c */
/* fcname.c */
-FcBool
-FcNameBool (FcChar8 *v, FcBool *result);
+/*
+ * NOTE -- this ordering is part of the cache file format.
+ * It must also match the ordering in fcname.c
+ */
+
+#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
+#define FC_DECORATIVE_OBJECT 40
+
+FcPrivate FcBool
+FcNameBool (const FcChar8 *v, FcBool *result);
+
+FcPrivate FcBool
+FcObjectValidType (FcObject object, FcType type);
+
+FcPrivate FcObject
+FcObjectFromName (const char * name);
+
+FcPrivate const char *
+FcObjectName (FcObject object);
+
+FcPrivate FcBool
+FcObjectInit (void);
+
+FcPrivate void
+FcObjectFini (void);
+
+#define FcObjectCompare(a, b) ((int) a - (int) b)
/* fcpat.c */
-void
-FcValueListDestroy (FcValueList *l);
+
+FcPrivate FcValue
+FcValueCanonicalize (const FcValue *v);
+
+FcPrivate void
+FcValueListDestroy (FcValueListPtr l);
+
+FcPrivate FcPatternElt *
+FcPatternObjectFindElt (const FcPattern *p, FcObject object);
+
+FcPrivate FcPatternElt *
+FcPatternObjectInsertElt (FcPattern *p, FcObject object);
+
+FcPrivate FcBool
+FcPatternObjectAddWithBinding (FcPattern *p,
+ FcObject object,
+ FcValue value,
+ FcValueBinding binding,
+ FcBool append);
+
+FcPrivate FcBool
+FcPatternObjectAdd (FcPattern *p, FcObject object, FcValue value, FcBool append);
+
+FcPrivate FcBool
+FcPatternObjectAddWeak (FcPattern *p, FcObject object, FcValue value, FcBool append);
+
+FcPrivate FcResult
+FcPatternObjectGet (const FcPattern *p, FcObject object, int id, FcValue *v);
-FcPatternElt *
-FcPatternFindElt (const FcPattern *p, const char *object);
+FcPrivate FcBool
+FcPatternObjectDel (FcPattern *p, FcObject object);
+
+FcPrivate FcBool
+FcPatternObjectRemove (FcPattern *p, FcObject object, int id);
+
+FcPrivate FcBool
+FcPatternObjectAddInteger (FcPattern *p, FcObject object, int i);
+
+FcPrivate FcBool
+FcPatternObjectAddDouble (FcPattern *p, FcObject object, double d);
+
+FcPrivate FcBool
+FcPatternObjectAddString (FcPattern *p, FcObject object, const FcChar8 *s);
+
+FcPrivate FcBool
+FcPatternObjectAddMatrix (FcPattern *p, FcObject object, const FcMatrix *s);
+
+FcPrivate FcBool
+FcPatternObjectAddCharSet (FcPattern *p, FcObject object, const FcCharSet *c);
+
+FcPrivate FcBool
+FcPatternObjectAddBool (FcPattern *p, FcObject object, FcBool b);
+
+FcPrivate FcBool
+FcPatternObjectAddLangSet (FcPattern *p, FcObject object, const FcLangSet *ls);
+
+FcPrivate FcResult
+FcPatternObjectGetInteger (const FcPattern *p, FcObject object, int n, int *i);
+
+FcPrivate FcResult
+FcPatternObjectGetDouble (const FcPattern *p, FcObject object, int n, double *d);
-FcPatternElt *
-FcPatternInsertElt (FcPattern *p, const char *object);
+FcPrivate FcResult
+FcPatternObjectGetString (const FcPattern *p, FcObject object, int n, FcChar8 ** s);
-FcBool
-FcPatternAddWithBinding (FcPattern *p,
- const char *object,
- FcValue value,
- FcValueBinding binding,
- FcBool append);
+FcPrivate FcResult
+FcPatternObjectGetMatrix (const FcPattern *p, FcObject object, int n, FcMatrix **s);
+
+FcPrivate FcResult
+FcPatternObjectGetCharSet (const FcPattern *p, FcObject object, int n, FcCharSet **c);
+
+FcPrivate FcResult
+FcPatternObjectGetBool (const FcPattern *p, FcObject object, int n, FcBool *b);
+
+FcPrivate FcResult
+FcPatternObjectGetLangSet (const FcPattern *p, FcObject object, int n, FcLangSet **ls);
+
+FcPrivate void
+FcPatternFini (void);
+
+FcPrivate FcBool
+FcPatternAppend (FcPattern *p, FcPattern *s);
+
+FcPrivate const FcChar8 *
+FcStrStaticName (const FcChar8 *name);
+
+FcPrivate FcChar32
+FcStringHash (const FcChar8 *s);
+
+FcPrivate FcBool
+FcPatternSerializeAlloc (FcSerialize *serialize, const FcPattern *pat);
+
+FcPrivate FcPattern *
+FcPatternSerialize (FcSerialize *serialize, const FcPattern *pat);
+
+FcPrivate FcBool
+FcValueListSerializeAlloc (FcSerialize *serialize, const FcValueList *pat);
+
+FcPrivate FcValueList *
+FcValueListSerialize (FcSerialize *serialize, const FcValueList *pat);
/* fcrender.c */
/* fcmatrix.c */
-extern const FcMatrix FcIdentityMatrix;
+extern FcPrivate const FcMatrix FcIdentityMatrix;
-void
+FcPrivate void
FcMatrixFree (FcMatrix *mat);
/* fcstr.c */
-FcChar8 *
-FcStrPlus (const FcChar8 *s1, const FcChar8 *s2);
-
-void
-FcStrFree (FcChar8 *s);
+FcPrivate void
+FcStrSetSort (FcStrSet * set);
-void
+FcPrivate void
FcStrBufInit (FcStrBuf *buf, FcChar8 *init, int size);
-void
+FcPrivate void
FcStrBufDestroy (FcStrBuf *buf);
-FcChar8 *
+FcPrivate FcChar8 *
FcStrBufDone (FcStrBuf *buf);
-FcBool
+FcPrivate FcBool
FcStrBufChar (FcStrBuf *buf, FcChar8 c);
-FcBool
+FcPrivate FcBool
FcStrBufString (FcStrBuf *buf, const FcChar8 *s);
-FcBool
+FcPrivate FcBool
FcStrBufData (FcStrBuf *buf, const FcChar8 *s, int len);
-int
+FcPrivate int
FcStrCmpIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2);
+FcPrivate const FcChar8 *
+FcStrContainsIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2);
+
+FcPrivate const FcChar8 *
+FcStrContainsIgnoreCase (const FcChar8 *s1, const FcChar8 *s2);
+
+FcPrivate FcBool
+FcStrUsesHome (const FcChar8 *s);
+
+FcPrivate FcChar8 *
+FcStrLastSlash (const FcChar8 *path);
+
+FcPrivate FcChar32
+FcStrHashIgnoreCase (const FcChar8 *s);
+
+FcPrivate FcChar8 *
+FcStrCanonFilename (const FcChar8 *s);
+
+FcPrivate FcBool
+FcStrSerializeAlloc (FcSerialize *serialize, const FcChar8 *str);
+
+FcPrivate FcChar8 *
+FcStrSerialize (FcSerialize *serialize, const FcChar8 *str);
+
#endif /* _FC_INT_H_ */
git.wh0rd.org / fontconfig.git / blobdiff