X-Git-Url: https://git.wh0rd.org/?a=blobdiff_plain;f=src%2Ffcint.h;h=24bf246a5e45824784a41ee85f15b7cba97da631;hb=87c887464a6fc20310998146b8558179ebe18923;hp=dfdca441f3fafbd96536de1af1cd41c0bf834f22;hpb=c2e7c611cbef33e9f93fbb110cd8df61abec67d7;p=fontconfig.git diff --git a/src/fcint.h b/src/fcint.h index dfdca44..24bf246 100644 --- a/src/fcint.h +++ b/src/fcint.h @@ -1,7 +1,7 @@ /* - * $XFree86: xc/lib/fontconfig/src/fcint.h,v 1.2 2002/02/15 06:01:28 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 @@ -33,17 +33,14 @@ #include #include #include +#include #include #include +#include #ifdef HAVE_CONFIG_H #include #endif -typedef struct _FcMatcher { - char *object; - double (*compare) (char *object, FcValue value1, FcValue value2); -} FcMatcher; - typedef struct _FcSymbolic { const char *name; int value; @@ -53,6 +50,15 @@ typedef struct _FcSymbolic { #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 @@ -61,10 +67,12 @@ typedef struct _FcSymbolic { #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 @@ -76,22 +84,47 @@ typedef struct _FcSymbolic { #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 _FcValueList { struct _FcValueList *next; FcValue value; + FcValueBinding binding; } FcValueList; typedef struct _FcPatternElt { const char *object; - FcValueList *values; + FcValueList *values; } FcPatternElt; + struct _FcPattern { int num; int size; - FcPatternElt *elts; + FcPatternElt *elts; + int ref; }; typedef enum _FcOp { @@ -101,10 +134,12 @@ 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 { @@ -125,11 +160,14 @@ typedef struct _FcExpr { } 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; @@ -141,6 +179,7 @@ typedef struct _FcEdit { const char *field; FcOp op; FcExpr *expr; + FcValueBinding binding; } FcEdit; typedef struct _FcSubst { @@ -149,28 +188,29 @@ 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 */ + FcCharLeaf **leaves; + FcChar16 *numbers; }; -struct _FcCharSet { - int levels; +struct _FcStrSet { int ref; /* reference count */ - FcBool constant; /* shared constant */ - FcCharNode node; + int num; + int size; + FcChar8 **strs; +}; + +struct _FcStrList { + FcStrSet *set; + int n; }; typedef struct _FcStrBuf { @@ -181,23 +221,104 @@ typedef struct _FcStrBuf { int size; } FcStrBuf; -typedef struct _FcFileCacheEnt { - struct _FcFileCacheEnt *next; - unsigned int hash; - FcChar8 *file; - int id; - time_t time; - FcChar8 *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; +/* + * 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- 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 { @@ -212,18 +333,24 @@ struct _FcConfig { * cache file must be consulted before the directories are scanned, * and those directives may occur in any order */ - FcChar8 **dirs; /* directories containing fonts */ + 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 */ - FcChar8 **configFiles; /* config files loaded */ + FcStrSet *configFiles; /* config files loaded */ /* * Substitution instructions for patterns and fonts; * maxObjects is used to allocate appropriate intermediate storage @@ -232,6 +359,13 @@ struct _FcConfig { 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, @@ -239,46 +373,94 @@ struct _FcConfig { * 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); -FcChar8 * -FcFileCacheFind (FcFileCache *cache, - const FcChar8 *file, - int id, - int *count); +void +FcGlobalCacheDestroy (FcGlobalCache *cache); + +FcBool +FcGlobalCacheCheckTime (const FcChar8*file, FcGlobalCacheInfo *info); + +void +FcGlobalCacheReferenced (FcGlobalCache *cache, + FcGlobalCacheInfo *info); void -FcFileCacheDestroy (FcFileCache *cache); +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 FcChar8 *cache_file); +FcGlobalCacheLoad (FcGlobalCache *cache, + const FcChar8 *cache_file); FcBool -FcFileCacheUpdate (FcFileCache *cache, - const FcChar8 *file, - int id, - const FcChar8 *name); +FcGlobalCacheUpdate (FcGlobalCache *cache, + const FcChar8 *file, + int id, + const FcChar8 *name); FcBool -FcFileCacheSave (FcFileCache *cache, - const FcChar8 *cache_file); +FcGlobalCacheSave (FcGlobalCache *cache, + const FcChar8 *cache_file); FcBool -FcFileCacheReadDir (FcFontSet *set, const FcChar8 *cache_file); +FcDirCacheReadDir (FcFontSet *set, + FcStrSet *dirs, + const FcChar8 *dir, + FcConfig *config); FcBool -FcFileCacheWriteDir (FcFontSet *set, const FcChar8 *cache_file); +FcDirCacheWriteDir (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir); /* fccfg.c */ +FcBool +FcConfigAddConfigDir (FcConfig *config, + const FcChar8 *d); + +FcBool +FcConfigAddFontDir (FcConfig *config, + const FcChar8 *d); + FcBool FcConfigAddDir (FcConfig *config, const FcChar8 *d); @@ -311,50 +493,108 @@ FcConfigCompareValue (const FcValue m, 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 (FcStrBuf *buf, const FcCharSet *c); FcCharSet * FcNameParseCharSet (FcChar8 *string); -/* fcdbg.c */ -void -FcValuePrint (FcValue v); +FcCharLeaf * +FcCharSetFindLeafCreate (FcCharSet *fcs, FcChar32 ucs4); +/* fcdbg.c */ void -FcValueListPrint (FcValueList *l); +FcValueListPrint (const FcValueList *l); void -FcPatternPrint (FcPattern *p); +FcLangSetPrint (const FcLangSet *ls); void FcOpPrint (FcOp op); void -FcTestPrint (FcTest *test); - -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); /* fcdir.c */ +FcBool +FcFileIsDir (const FcChar8 *file); + +FcBool +FcFileScanConfig (FcFontSet *set, + FcStrSet *dirs, + FcFileCache *cache, + FcBlanks *blanks, + const FcChar8 *file, + FcBool force, + FcConfig *config); + +FcBool +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 */ /* fcgram.y */ int @@ -369,9 +609,6 @@ FcConfigerror (char *fmt, ...); char * FcConfigSaveField (const char *field); -FcTest * -FcTestCreate (FcQual qual, const FcChar8 *field, FcOp compare, FcExpr *expr); - void FcTestDestroy (FcTest *test); @@ -405,9 +642,6 @@ FcExprCreateOp (FcExpr *left, FcOp op, FcExpr *right); void FcExprDestroy (FcExpr *e); -FcEdit * -FcEditCreate (const char *field, FcOp op, FcExpr *expr); - void FcEditDestroy (FcEdit *e); @@ -422,31 +656,74 @@ FcMemAlloc (int kind, int size); void FcMemFree (int kind, int size); -/* fclist.c */ +/* fclang.c */ +FcLangSet * +FcFreeTypeLangSet (const FcCharSet *charset, + const FcChar8 *exclusiveLang); -/* fcmatch.c */ +FcLangResult +FcLangCompare (const FcChar8 *s1, const FcChar8 *s2); + +const FcCharSet * +FcCharSetForLang (const FcChar8 *lang); -/* fcname.c */ +FcLangSet * +FcLangSetPromote (const FcChar8 *lang); + +FcLangSet * +FcNameParseLangSet (const FcChar8 *string); FcBool -FcNameBool (FcChar8 *v, FcBool *result); +FcNameUnparseLangSet (FcStrBuf *buf, const FcLangSet *ls); + +/* fclist.c */ FcBool -FcStrBufChar (FcStrBuf *buf, FcChar8 c); +FcListPatternMatchAny (const FcPattern *p, + const FcPattern *font); + +/* fcmatch.c */ + +/* fcname.c */ FcBool -FcStrBufString (FcStrBuf *buf, const FcChar8 *s); +FcNameBool (const FcChar8 *v, FcBool *result); /* fcpat.c */ void FcValueListDestroy (FcValueList *l); FcPatternElt * -FcPatternFind (FcPattern *p, const char *object, FcBool insert); +FcPatternFindElt (const FcPattern *p, const char *object); + +FcPatternElt * +FcPatternInsertElt (FcPattern *p, const char *object); + +FcBool +FcPatternAddWithBinding (FcPattern *p, + const char *object, + FcValue value, + FcValueBinding binding, + FcBool append); + +FcPattern * +FcPatternFreeze (FcPattern *p); + +void +FcPatternThawAll (void); + +FcBool +FcPatternAppend (FcPattern *p, FcPattern *s); + +const char * +FcObjectStaticName (const char *name); /* fcrender.c */ /* fcmatrix.c */ + +extern const FcMatrix FcIdentityMatrix; + void FcMatrixFree (FcMatrix *mat); @@ -475,4 +752,22 @@ FcStrBufString (FcStrBuf *buf, const FcChar8 *s); FcBool FcStrBufData (FcStrBuf *buf, const FcChar8 *s, int len); +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_ */