/*
* $RCSId: xc/lib/fontconfig/src/fcint.h,v 1.27 2002/08/31 22:17:32 keithp Exp $
*
- * Copyright © 2000 Keith Packard
+ * 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"
#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_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_CHARLEAF 1
#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_MEM_NUM 29
+#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;
+
typedef struct _FcValueList {
- struct _FcValueList *next;
+ FcValueListPtr next;
+
FcValue value;
FcValueBinding binding;
} FcValueList;
+typedef int FcObjectPtr;
+
+typedef struct _FcPatternEltPtr {
+ int bank;
+ 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;
+ int bank;
};
typedef enum _FcOp {
FcOpAssign, FcOpAssignReplace,
FcOpPrependFirst, FcOpPrepend, FcOpAppend, FcOpAppendLast,
FcOpQuest,
- FcOpOr, FcOpAnd, FcOpEqual, FcOpNotEqual, FcOpContains, FcOpNotContains,
+ FcOpOr, FcOpAnd, FcOpEqual, FcOpNotEqual,
+ FcOpContains, FcOpListing, FcOpNotContains,
FcOpLess, FcOpLessEqual, FcOpMore, FcOpMoreEqual,
FcOpPlus, FcOpMinus, FcOpTimes, FcOpDivide,
FcOpNot, FcOpComma, FcOpFloor, FcOpCeil, FcOpRound, FcOpTrunc,
struct _FcCharSet {
int ref; /* reference count */
int num; /* size of leaves and numbers arrays */
- FcCharLeaf **leaves;
- FcChar16 *numbers;
+ int bank;
+ union {
+ struct {
+ int leafidx_offset;
+ int numbers_offset;
+ } stat;
+ struct {
+ FcCharLeaf **leaves;
+ FcChar16 *numbers;
+ } dyn;
+ } u;
};
struct _FcStrSet {
int size;
} FcStrBuf;
+typedef struct _FcCache {
+ int magic; /* FC_CACHE_MAGIC */
+ int subdirs; /* number of subdir strings */
+ off_t pos; /* position of data block in file */
+ off_t 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;
+} FcCache;
+
/*
* To map adobe glyph names to unicode values, a precomputed hash
* table is used
} FcGlyphName;
/*
- * 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
+ * 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_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;
-};
+#define FC_CASE_FOLD_RANGE 0
+#define FC_CASE_FOLD_EVEN_ODD 1
+#define FC_CASE_FOLD_FULL 2
-typedef struct _FcGlobalCache {
- FcGlobalCacheDir *ents[FC_GLOBAL_CACHE_DIR_HASH_SIZE];
- FcBool updated;
- FcBool broken;
- int entries;
- int referenced;
-} FcGlobalCache;
+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
+
+#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)
+#define fc_storage_type(v) ((v)->type & ~FC_STORAGE_STATIC)
+
+#define fc_alignof(type) offsetof (struct { char c; type member; }, member)
+
+#define FC_CACHE_MAGIC 0xFC02FC04
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
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,
extern 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);
+FcFontSet *
+FcCacheRead (FcConfig *config);
FcBool
-FcGlobalCacheCheckTime (const FcChar8*file, FcGlobalCacheInfo *info);
-
-void
-FcGlobalCacheReferenced (FcGlobalCache *cache,
- FcGlobalCacheInfo *info);
-
-void
-FcGlobalCacheReferenceSubdir (FcGlobalCache *cache,
- const FcChar8 *dir);
-
-FcGlobalCacheDir *
-FcGlobalCacheDirGet (FcGlobalCache *cache,
- const FcChar8 *dir,
- int len,
- FcBool create_missing);
+FcDirCacheWrite (FcFontSet *set, FcStrSet * dirs, const FcChar8 *dir, FcConfig *config);
FcBool
-FcGlobalCacheScanDir (FcFontSet *set,
- FcStrSet *dirs,
- FcGlobalCache *cache,
- const FcChar8 *dir);
-
-FcGlobalCacheFile *
-FcGlobalCacheFileGet (FcGlobalCache *cache,
- const FcChar8 *file,
- int id,
- int *count);
-
-
-void
-FcGlobalCacheLoad (FcGlobalCache *cache,
- const FcChar8 *cache_file);
-
+FcDirCacheConsume (FILE *file, FcFontSet *set, FcStrSet *dirs,
+ const FcChar8 *dir, char *dirname);
+
FcBool
-FcGlobalCacheUpdate (FcGlobalCache *cache,
- const FcChar8 *file,
- int id,
- const FcChar8 *name);
+FcDirCacheRead (FcFontSet * set, FcStrSet * dirs, const FcChar8 *dir, FcConfig *config);
-FcBool
-FcGlobalCacheSave (FcGlobalCache *cache,
- const FcChar8 *cache_file);
+extern int *_fcBankId, *_fcBankIdx;
+int
+FcCacheBankToIndexMTF (int bank);
-FcBool
-FcDirCacheReadDir (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir);
+static inline int
+FcCacheBankToIndex (int bank)
+{
+ return (_fcBankId[*_fcBankIdx] == bank) ? *_fcBankIdx : FcCacheBankToIndexMTF(bank);
+}
-FcBool
-FcDirCacheWriteDir (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir);
-
+const char *
+FcCacheFindBankDir (int bank);
+
/* fccfg.c */
FcBool
FcConfigAddDir (FcConfig *config,
const FcChar8 *d);
+FcBool
+FcConfigAddCacheDir (FcConfig *config,
+ const FcChar8 *d);
+
+FcStrList *
+FcConfigGetCacheDirs (FcConfig *config);
+
FcBool
FcConfigAddConfigFile (FcConfig *config,
const FcChar8 *f);
FcSetName set);
FcBool
-FcConfigCompareValue (const FcValue m,
+FcConfigCompareValue (const FcValue *m,
FcOp op,
- const FcValue v);
+ 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);
+
+FcFileTime
+FcConfigModifiedTime (FcConfig *config);
/* fccharset.c */
+void
+FcLangCharSetPopulate (void);
+
FcCharSet *
FcCharSetFreeze (FcCharSet *cs);
+void
+FcCharSetThawAll (void);
+
FcBool
FcNameUnparseCharSet (FcStrBuf *buf, const FcCharSet *c);
FcCharLeaf *
FcCharSetFindLeafCreate (FcCharSet *fcs, FcChar32 ucs4);
+void
+FcCharSetNewBank (void);
+
+int
+FcCharSetNeededBytes (const FcCharSet *c);
+
+int
+FcCharSetNeededBytesAlign (void);
+
+void *
+FcCharSetDistributeBytes (FcCache * metadata,
+ void * block_ptr);
+
+FcCharSet *
+FcCharSetSerialize(int bank, FcCharSet *c);
+
+void *
+FcCharSetUnserialize (FcCache * metadata, void *block_ptr);
+
+FcCharLeaf *
+FcCharSetGetLeaf(const FcCharSet *c, int i);
+
+FcChar16 *
+FcCharSetGetNumbers(const FcCharSet *c);
+
/* fcdbg.c */
void
-FcValueListPrint (const FcValueList *l);
+FcValueListPrint (const FcValueListPtr l);
void
FcLangSetPrint (const FcLangSet *ls);
void
FcSubstPrint (const FcSubst *subst);
-int
-FcDebug (void);
+extern int FcDebugVal;
+
+static inline int
+FcDebug (void) { return FcDebugVal; }
+
+void
+FcInitDebug (void);
+
+/* fcdefault.c */
+FcChar8 *
+FcGetDefaultLang (void);
/* fcdir.c */
+FcBool
+FcFileIsDir (const FcChar8 *file);
+
+FcBool
+FcFileScanConfig (FcFontSet *set,
+ FcStrSet *dirs,
+ FcBlanks *blanks,
+ const FcChar8 *file,
+ FcBool force,
+ FcConfig *config);
+
+FcBool
+FcDirScanConfig (FcFontSet *set,
+ FcStrSet *dirs,
+ FcBlanks *blanks,
+ const FcChar8 *dir,
+ FcBool force,
+ FcConfig *config);
+
/* fcfont.c */
int
FcFontDebug (void);
FcFreeTypeGetPrivateMap (FT_Encoding encoding);
/* 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);
+
/* fcgram.y */
int
FcConfigparse (void);
char *
FcConfigSaveField (const char *field);
-FcTest *
-FcTestCreate (FcMatchKind kind,
- FcQual qual,
- const FcChar8 *field,
- FcOp compare,
- FcExpr *expr);
-
void
FcTestDestroy (FcTest *test);
void
FcExprDestroy (FcExpr *e);
-FcEdit *
-FcEditCreate (const char *field, FcOp op, FcExpr *expr, FcValueBinding binding);
-
void
FcEditDestroy (FcEdit *e);
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
+FcListPatternMatchAny (const FcPattern *p,
+ const FcPattern *font);
+
/* fcmatch.c */
/* fcname.c */
FcBool
-FcNameBool (FcChar8 *v, FcBool *result);
+FcNameBool (const FcChar8 *v, FcBool *result);
+
+void *
+FcObjectDistributeBytes (FcCache * metadata,
+ void * block_ptr);
+
+FcObjectPtr
+FcObjectToPtr (const char * si);
+
+int
+FcObjectNeededBytes (void);
+
+int
+FcObjectNeededBytesAlign (void);
+
+void *
+FcObjectUnserialize (FcCache * metadata, void *block_ptr);
+
+void
+FcObjectSerialize (void);
+
+const char *
+FcObjectPtrU (FcObjectPtr p);
+
+static inline int
+FcObjectPtrCompare (const FcObjectPtr a, const FcObjectPtr b)
+{
+ return a - b;
+}
+
+void
+FcObjectStaticNameFini (void);
/* fcpat.c */
+
+FcValue
+FcValueCanonicalize (const FcValue *v);
+
void
-FcValueListDestroy (FcValueList *l);
-
+FcValueListDestroy (FcValueListPtr l);
+
FcPatternElt *
FcPatternFindElt (const FcPattern *p, const char *object);
FcValueBinding binding,
FcBool append);
+void
+FcPatternFini (void);
+
+FcBool
+FcPatternAppend (FcPattern *p, FcPattern *s);
+
+const FcChar8 *
+FcStrStaticName (const FcChar8 *name);
+
+FcChar32
+FcStringHash (const FcChar8 *s);
+
+void
+FcPatternNewBank (void);
+
+int
+FcPatternNeededBytes (FcPattern *p);
+
+int
+FcPatternNeededBytesAlign (void);
+
+void *
+FcPatternDistributeBytes (FcCache * metadata, void * block_ptr);
+
+/* please don't access these outside of fcpat.c! only visible so that
+ * *PtrU can be inlined. */
+extern FcValueList ** _fcValueLists;
+extern FcPatternElt ** _fcPatternElts;
+
+static inline FcValueList *
+FcValueListPtrU (FcValueListPtr pi)
+{
+ if (pi.bank == FC_BANK_DYNAMIC)
+ return pi.u.dyn;
+
+ return &_fcValueLists[FcCacheBankToIndex(pi.bank)][pi.u.stat];
+}
+
+static inline FcPatternElt *
+FcPatternEltU (FcPatternEltPtr pei)
+{
+ if (pei.bank == FC_BANK_DYNAMIC)
+ return pei.u.dyn;
+
+ return &_fcPatternElts[FcCacheBankToIndex(pei.bank)][pei.u.stat];
+}
+
+FcValueListPtr
+FcValueListPtrCreateDynamic(FcValueList * p);
+
FcPattern *
-FcPatternFreeze (FcPattern *p);
+FcPatternSerialize (int bank, FcPattern * p);
+
+void *
+FcPatternUnserialize (FcCache * metadata, void *block_ptr);
/* fcrender.c */
FcMatrixFree (FcMatrix *mat);
/* fcstr.c */
+void
+FcStrSetSort (FcStrSet * set);
+
FcChar8 *
FcStrPlus (const FcChar8 *s1, const FcChar8 *s2);
FcChar8 *
FcStrLastSlash (const FcChar8 *path);
+FcChar32
+FcStrHashIgnoreCase (const FcChar8 *s);
+
+FcChar8 *
+FcStrCanonFilename (const FcChar8 *s);
+
#endif /* _FC_INT_H_ */
git.wh0rd.org / fontconfig.git / blobdiff