X-Git-Url: https://git.wh0rd.org/?a=blobdiff_plain;f=src%2Ffcint.h;h=cb137d389615646d802285ad37a09437a53867d3;hb=af180c40376690b7ced5262156fbe13c9ebba1e2;hp=d9a870319fb22efe0dde8535d4cf32fe7edd8a5c;hpb=20ac65ab003c9b280e3fbd06215c5e3af16bea1f;p=fontconfig.git diff --git a/src/fcint.h b/src/fcint.h index d9a8703..cb137d3 100644 --- a/src/fcint.h +++ b/src/fcint.h @@ -1,7 +1,7 @@ /* - * $XFree86: xc/lib/fontconfig/src/fcint.h,v 1.10 2002/05/29 22:07:33 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 @@ -25,8 +25,19 @@ #ifndef _FCINT_H_ #define _FCINT_H_ +#ifdef HAVE_CONFIG_H +#include +#endif + #include #include +#ifdef HAVE_INTTYPES_H +#include +#elif defined(HAVE_STDINT_H) +#include +#else +#error missing C99 integer data types +#endif #include #include #include @@ -36,20 +47,7 @@ #include #include #include -#ifdef HAVE_CONFIG_H -#include -#endif - -typedef struct _FcMatcher { - char *object; - double (*compare) (char *object, FcValue value1, FcValue value2); - int priority; -} FcMatcher; - -typedef struct _FcSymbolic { - const char *name; - int value; -} FcSymbolic; +#include #ifndef FC_CONFIG_PATH #define FC_CONFIG_PATH "fonts.conf" @@ -57,6 +55,13 @@ typedef struct _FcSymbolic { #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 ';' +#else +#define FC_SEARCH_PATH_SEPARATOR ':' +#endif #define FC_DBG_MATCH 1 #define FC_DBG_MATCHV 2 @@ -66,10 +71,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 @@ -81,25 +88,70 @@ 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 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 + +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 { @@ -109,10 +161,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 { @@ -133,11 +187,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; @@ -149,6 +206,7 @@ typedef struct _FcEdit { const char *field; FcOp op; FcExpr *expr; + FcValueBinding binding; } FcEdit; typedef struct _FcSubst { @@ -161,12 +219,22 @@ typedef struct _FcCharLeaf { FcChar32 map[256/32]; } FcCharLeaf; +#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; + int bank; + union { + struct { + int leafidx_offset; + int numbers_offset; + } stat; + struct { + FcCharLeaf **leaves; + FcChar16 *numbers; + } dyn; + } u; }; struct _FcStrSet { @@ -189,24 +257,75 @@ 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; -}; +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 + */ + +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 + +#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 */ @@ -240,6 +359,10 @@ struct _FcConfig { * 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 @@ -253,6 +376,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, @@ -272,45 +402,46 @@ struct _FcConfig { extern FcConfig *_fcConfig; -/* fcblanks.c */ - -/* fccache.c */ +typedef struct _FcFileTime { + time_t time; + FcBool set; +} FcFileTime; -FcFileCache * -FcFileCacheCreate (void); +typedef struct _FcCharMap FcCharMap; -FcChar8 * -FcFileCacheFind (FcFileCache *cache, - const FcChar8 *file, - int id, - int *count); +/* watch out; assumes that v is void * -PL */ +#define ALIGN(v,type) ((void *)(((uintptr_t)(v) + fc_alignof(type) - 1) & ~(fc_alignof(type) - 1))) -void -FcFileCacheDestroy (FcFileCache *cache); +/* fcblanks.c */ -FcBool -FcFileCacheValid (const FcChar8 *cache_file); +/* fccache.c */ -void -FcFileCacheLoad (FcFileCache *cache, - const FcChar8 *cache_file); +FcFontSet * +FcCacheRead (FcConfig *config); FcBool -FcFileCacheUpdate (FcFileCache *cache, - const FcChar8 *file, - int id, - const FcChar8 *name); +FcDirCacheWrite (FcFontSet *set, FcStrSet * dirs, const FcChar8 *dir, FcConfig *config); FcBool -FcFileCacheSave (FcFileCache *cache, - const FcChar8 *cache_file); - +FcDirCacheConsume (FILE *file, FcFontSet *set, FcStrSet *dirs, + const FcChar8 *dir, char *dirname); + FcBool -FcFileCacheReadDir (FcFontSet *set, FcStrSet *dirs, const FcChar8 *cache_file); +FcDirCacheRead (FcFontSet * set, FcStrSet * dirs, const FcChar8 *dir, FcConfig *config); -FcBool -FcFileCacheWriteDir (FcFontSet *set, FcStrSet *dirs, const FcChar8 *cache_file); - +extern int *_fcBankId, *_fcBankIdx; +int +FcCacheBankToIndexMTF (int bank); + +static inline int +FcCacheBankToIndex (int bank) +{ + return (_fcBankId[*_fcBankIdx] == bank) ? *_fcBankIdx : FcCacheBankToIndexMTF(bank); +} + +const char * +FcCacheFindBankDir (int bank); + /* fccfg.c */ FcBool @@ -325,6 +456,13 @@ 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); @@ -349,46 +487,170 @@ FcConfigSetFonts (FcConfig *config, 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); FcCharSet * FcNameParseCharSet (FcChar8 *string); +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 (FcValueList *l); +FcValueListPrint (const FcValueListPtr l); + +void +FcLangSetPrint (const FcLangSet *ls); void FcOpPrint (FcOp op); void -FcTestPrint (FcTest *test); +FcTestPrint (const FcTest *test); void -FcExprPrint (FcExpr *expr); +FcExprPrint (const FcExpr *expr); void -FcEditPrint (FcEdit *edit); +FcEditPrint (const FcEdit *edit); void -FcSubstPrint (FcSubst *subst); +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); +/* 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 +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); @@ -402,9 +664,6 @@ FcConfigerror (char *fmt, ...); char * FcConfigSaveField (const char *field); -FcTest * -FcTestCreate (FcQual qual, const FcChar8 *field, FcOp compare, FcExpr *expr); - void FcTestDestroy (FcTest *test); @@ -438,9 +697,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); @@ -455,29 +711,179 @@ FcMemAlloc (int kind, int size); 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 +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 * -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); + +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 * +FcPatternSerialize (int bank, FcPattern * p); + +void * +FcPatternUnserialize (FcCache * metadata, void *block_ptr); /* fcrender.c */ /* fcmatrix.c */ + +extern const FcMatrix FcIdentityMatrix; + void FcMatrixFree (FcMatrix *mat); /* fcstr.c */ +void +FcStrSetSort (FcStrSet * set); + FcChar8 * FcStrPlus (const FcChar8 *s1, const FcChar8 *s2); @@ -502,4 +908,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_ */