X-Git-Url: https://git.wh0rd.org/?p=fontconfig.git;a=blobdiff_plain;f=src%2Ffcint.h;h=83a7a435be4984b27e3de80cc5599e602cca966f;hp=6d8ae5ddb1b2b789bcf6dbc0f28aa35cc4b4981f;hb=HEAD;hpb=529291bef436384a06db246fda30e08d5812de14 diff --git a/src/fcint.h b/src/fcint.h index 6d8ae5d..83a7a43 100644 --- a/src/fcint.h +++ b/src/fcint.h @@ -1,5 +1,5 @@ /* - * $RCSId: xc/lib/fontconfig/src/fcint.h,v 1.27 2002/08/31 22:17:32 keithp Exp $ + * fontconfig/src/fcint.h * * Copyright © 2000 Keith Packard * @@ -7,15 +7,15 @@ * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting - * documentation, and that the name of Keith Packard not be used in + * documentation, and that the name of the author(s) not be used in * advertising or publicity pertaining to distribution of the software without - * specific, written prior permission. Keith Packard makes no + * specific, written prior permission. The authors make no * representations about the suitability of this software for any purpose. It * is provided "as is" without express or implied warranty. * - * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO - * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR @@ -42,21 +42,18 @@ #include #include #include +#include #include #include #include #include #include -#include +#include "fcdeprecate.h" #ifndef FC_CONFIG_PATH #define FC_CONFIG_PATH "fonts.conf" #endif -#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 @@ -74,6 +71,8 @@ #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_CHARLEAF 1 @@ -108,60 +107,126 @@ #define FC_MEM_NUM 30 -#define FC_BANK_DYNAMIC 0 -#define FC_BANK_FIRST 1 -#define FC_BANK_LANGS 0xfcfcfcfc +#define _FC_ASSERT_STATIC1(_line, _cond) typedef int _static_assert_on_line_##_line##_failed[(_cond)?1:-1] +#define _FC_ASSERT_STATIC0(_line, _cond) _FC_ASSERT_STATIC1 (_line, (_cond)) +#define FC_ASSERT_STATIC(_cond) _FC_ASSERT_STATIC0 (__LINE__, (_cond)) + +#define FC_MIN(a,b) ((a) < (b) ? (a) : (b)) +#define FC_MAX(a,b) ((a) > (b) ? (a) : (b)) +#define FC_ABS(a) ((a) < 0 ? -(a) : (a)) + +/* slim_internal.h */ +#if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)) && defined(__ELF__) && !defined(__sun) +#define FcPrivate __attribute__((__visibility__("hidden"))) +#define HAVE_GNUC_ATTRIBUTE 1 +#include "fcalias.h" +#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, 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. + */ -typedef struct _FcValueList { - FcValueListPtr next; +/* 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) - FcValue value; - FcValueBinding binding; +typedef struct _FcValueList *FcValueListPtr; + +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) ? \ + FcEncodedOffsetToPtr(fs, \ + FcFontSetFonts(fs)[i], \ + FcPattern) : \ + fs->fonts[i]) + typedef enum _FcOp { - FcOpInteger, FcOpDouble, FcOpString, FcOpMatrix, FcOpBool, FcOpCharSet, + FcOpInteger, FcOpDouble, FcOpString, FcOpMatrix, FcOpRange, FcOpBool, FcOpCharSet, FcOpLangSet, FcOpNil, FcOpField, FcOpConst, - FcOpAssign, FcOpAssignReplace, + FcOpAssign, FcOpAssignReplace, FcOpPrependFirst, FcOpPrepend, FcOpAppend, FcOpAppendLast, FcOpQuest, - FcOpOr, FcOpAnd, FcOpEqual, FcOpNotEqual, + FcOpOr, FcOpAnd, FcOpEqual, FcOpNotEqual, FcOpContains, FcOpListing, FcOpNotContains, FcOpLess, FcOpLessEqual, FcOpMore, FcOpMoreEqual, FcOpPlus, FcOpMinus, FcOpTimes, FcOpDivide, @@ -174,18 +239,28 @@ typedef struct _FcExpr { union { int ival; double dval; - FcChar8 *sval; + const FcChar8 *sval; FcMatrix *mval; FcBool bval; FcCharSet *cval; - char *field; - FcChar8 *constant; + FcLangSet *lval; + FcObject object; + const FcChar8 *constant; struct { struct _FcExpr *left, *right; } tree; } u; } FcExpr; +typedef struct _FcExprPage FcExprPage; + +struct _FcExprPage { + FcExprPage *next_page; + FcExpr *next; + FcExpr exprs[(1024 - 2/* two pointers */ - 2/* malloc overhead */) * sizeof (void *) / sizeof (FcExpr)]; + FcExpr end[]; +}; + typedef enum _FcQual { FcQualAny, FcQualAll, FcQualFirst, FcQualNotFirst } FcQual; @@ -196,14 +271,14 @@ 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; @@ -224,19 +299,16 @@ typedef struct _FcCharLeaf { struct _FcCharSet { int ref; /* reference count */ int num; /* size of leaves and numbers arrays */ - int bank; - union { - struct { - int leafidx_offset; - int numbers_offset; - } stat; - struct { - FcCharLeaf **leaves; - FcChar16 *numbers; - } dyn; - } 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; @@ -255,22 +327,57 @@ typedef struct _FcStrBuf { FcBool failed; int len; int size; + FcChar8 buf_static[16 * sizeof (void *)]; } FcStrBuf; -typedef struct _FcCache { - int magic; /* FC_CACHE_MAGIC */ - 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; -} FcCache; +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 */ + int mtime; /* low bits of directory mtime */ +}; + +#undef FcCacheDir +#undef FcCacheSubdir +#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 union _FcAlign { + double d; + int i; + intptr_t ip; + FcBool b; + void *p; +} FcAlign; + +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; /* * To map adobe glyph names to unicode values, a precomputed hash @@ -285,14 +392,14 @@ typedef 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 @@ -315,46 +422,9 @@ typedef struct _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) - -/* - * 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_CACHE_MAGIC 0xFC02FC04 - -typedef struct _FcGlobalCacheDir FcGlobalCacheDir; - -enum FcGCDirState { - FcGCDirDisabled, FcGCDirFileRead, FcGCDirConsumed, FcGCDirUpdated -}; -struct _FcGlobalCacheDir { - struct _FcGlobalCacheDir *next; - char *name; - FcCache metadata; - off_t offset; - FcStrSet *subdirs; - void *ent; - enum FcGCDirState state; -}; - -typedef struct _FcGlobalCache { - FcGlobalCacheDir *dirs; - FcBool updated; - int fd; -} FcGlobalCache; +#define FC_CACHE_MAGIC_MMAP 0xFC02FC04 +#define FC_CACHE_MAGIC_ALLOC 0xFC02FC05 +#define FC_CACHE_CONTENT_VERSION 3 /* also check FC_CACHE_VERSION */ struct _FcAtomic { FcChar8 *file; /* original file name */ @@ -376,7 +446,6 @@ struct _FcConfig { * 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 @@ -384,10 +453,14 @@ struct _FcConfig { FcBlanks *blanks; /* * List of directories containing fonts, - * built by recursively scanning the set + * built by recursively scanning the set * 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 @@ -400,6 +473,7 @@ struct _FcConfig { */ 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 @@ -423,9 +497,13 @@ struct _FcConfig { */ time_t rescanTime; /* last time information was scanned */ int rescanInterval; /* interval between scans */ + + int ref; /* reference count */ + + FcExprPage *expr_pool; /* pool of FcExpr's */ }; - -extern FcConfig *_fcConfig; + +extern FcPrivate FcConfig *_fcConfig; typedef struct _FcFileTime { time_t time; @@ -434,372 +512,286 @@ typedef struct _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))) +typedef struct _FcRange FcRange; + +struct _FcRange { + FcChar32 begin; + FcChar32 end; +}; /* 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, - FcStrSet *dirs, - const char *file, - FcFontSet *set, - FcConfig *config); - -FcBool -FcGlobalCacheSave (FcGlobalCache *cache, - const FcChar8 *cache_file, - FcConfig *config); - -FcFontSet * -FcCacheRead (FcConfig *config, FcGlobalCache * cache); - -FcBool -FcDirCacheWrite (FcFontSet *set, FcStrSet * dirs, const FcChar8 *dir); - -FcBool -FcDirCacheRead (FcFontSet * set, FcStrSet * dirs, const FcChar8 *dir, FcConfig *config); - -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); - +FcPrivate FcCache * +FcDirCacheScan (const FcChar8 *dir, FcConfig *config); + +FcPrivate FcCache * +FcDirCacheBuild (FcFontSet *set, const FcChar8 *dir, struct stat *dir_stat, FcStrSet *dirs); + +FcPrivate FcBool +FcDirCacheWrite (FcCache *cache, FcConfig *config); + +FcPrivate void +FcCacheObjectReference (void *object); + +FcPrivate void +FcCacheObjectDereference (void *object); + +FcPrivate void +FcCacheFini (void); + +FcPrivate void +FcDirCacheReference (FcCache *cache, int nref); + +FcPrivate int +FcStat (const char *file, struct stat *statb); + /* fccfg.c */ -FcBool +FcPrivate FcExpr * +FcConfigAllocExpr (FcConfig *config); + +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 +FcPrivate FcBool FcConfigCompareValue (const FcValue *m, FcOp op, const FcValue *v); -FcBool +FcPrivate FcBool FcConfigGlobAdd (FcConfig *config, const FcChar8 *glob, FcBool accept); -FcBool +FcPrivate FcBool FcConfigAcceptFilename (FcConfig *config, const FcChar8 *filename); -FcBool +FcPrivate FcBool FcConfigPatternsAdd (FcConfig *config, FcPattern *pattern, FcBool accept); -FcBool +FcPrivate FcBool FcConfigAcceptFont (FcConfig *config, const FcPattern *font); -FcFileTime +FcPrivate FcFileTime FcConfigModifiedTime (FcConfig *config); +FcPrivate FcBool +FcConfigAddCache (FcConfig *config, FcCache *cache, + FcSetName set, FcStrSet *dirSet); + +/* 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 */ -void +FcPrivate void FcLangCharSetPopulate (void); -FcCharSet * -FcCharSetFreeze (FcCharSet *cs); +FcPrivate FcCharSetFreezer * +FcCharSetFreezerCreate (void); + +FcPrivate const FcCharSet * +FcCharSetFreeze (FcCharSetFreezer *freezer, const FcCharSet *fcs); -void -FcCharSetThawAll (void); +FcPrivate void +FcCharSetFreezerDestroy (FcCharSetFreezer *freezer); -FcBool +FcPrivate FcBool FcNameUnparseCharSet (FcStrBuf *buf, const FcCharSet *c); -FcCharSet * +FcPrivate FcCharSet * FcNameParseCharSet (FcChar8 *string); -FcCharLeaf * -FcCharSetFindLeafCreate (FcCharSet *fcs, FcChar32 ucs4); - -void -FcCharSetNewBank (void); +FcPrivate FcBool +FcNameUnparseValue (FcStrBuf *buf, + FcValue *v0, + FcChar8 *escape); -int -FcCharSetNeededBytes (const FcCharSet *c); +FcPrivate FcBool +FcNameUnparseValueList (FcStrBuf *buf, + FcValueListPtr v, + FcChar8 *escape); -int -FcCharSetNeededBytesAlign (void); - -void * -FcCharSetDistributeBytes (FcCache * metadata, - void * block_ptr); - -FcCharSet * -FcCharSetSerialize(int bank, FcCharSet *c); +FcPrivate FcCharLeaf * +FcCharSetFindLeafCreate (FcCharSet *fcs, FcChar32 ucs4); -void * -FcCharSetUnserialize (FcCache * metadata, void *block_ptr); +FcPrivate FcBool +FcCharSetSerializeAlloc(FcSerialize *serialize, const FcCharSet *cs); -FcCharLeaf * -FcCharSetGetLeaf(const FcCharSet *c, int i); +FcPrivate FcCharSet * +FcCharSetSerialize(FcSerialize *serialize, const FcCharSet *cs); -FcChar16 * +FcPrivate FcChar16 * FcCharSetGetNumbers(const FcCharSet *c); /* fcdbg.c */ -void +FcPrivate void FcValueListPrint (const FcValueListPtr l); -void +FcPrivate void FcLangSetPrint (const FcLangSet *ls); -void +FcPrivate void FcOpPrint (FcOp op); -void +FcPrivate void FcTestPrint (const FcTest *test); -void +FcPrivate void FcExprPrint (const FcExpr *expr); -void +FcPrivate void FcEditPrint (const FcEdit *edit); -void +FcPrivate void FcSubstPrint (const FcSubst *subst); -extern int FcDebugVal; +FcPrivate void +FcCharSetPrint (const FcCharSet *c); + +extern FcPrivate int FcDebugVal; -static inline int -FcDebug (void) { return FcDebugVal; } +#define FcDebug() (FcDebugVal) -void +FcPrivate void FcInitDebug (void); /* fcdefault.c */ -FcChar8 * +FcPrivate FcChar8 * FcGetDefaultLang (void); /* fcdir.c */ -FcBool -FcFileIsDir (const FcChar8 *file); - -FcBool +FcPrivate FcBool FcFileScanConfig (FcFontSet *set, FcStrSet *dirs, - FcFileCache *cache, FcBlanks *blanks, const FcChar8 *file, - FcBool force, FcConfig *config); -FcBool +FcPrivate FcBool FcDirScanConfig (FcFontSet *set, FcStrSet *dirs, - FcFileCache *cache, FcBlanks *blanks, - const FcChar8 *dir, + const FcChar8 *dir, FcBool force, FcConfig *config); /* fcfont.c */ -int +FcPrivate 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); +FcPrivate FcBool +FcFontSetSerializeAlloc (FcSerialize *serialize, const FcFontSet *s); -/* fcgram.y */ -int -FcConfigparse (void); +FcPrivate FcFontSet * +FcFontSetSerialize (FcSerialize *serialize, const FcFontSet * s); -int -FcConfigwrap (void); - -void -FcConfigerror (char *fmt, ...); - -char * -FcConfigSaveField (const char *field); - -void +/* fcxml.c */ +FcPrivate void FcTestDestroy (FcTest *test); -FcExpr * -FcExprCreateInteger (int i); - -FcExpr * -FcExprCreateDouble (double d); - -FcExpr * -FcExprCreateString (const FcChar8 *s); - -FcExpr * -FcExprCreateMatrix (const FcMatrix *m); - -FcExpr * -FcExprCreateBool (FcBool b); - -FcExpr * -FcExprCreateNil (void); - -FcExpr * -FcExprCreateField (const char *field); - -FcExpr * -FcExprCreateConst (const FcChar8 *constant); - -FcExpr * -FcExprCreateOp (FcExpr *left, FcOp op, FcExpr *right); - -void -FcExprDestroy (FcExpr *e); - -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 */ -FcLangSet * -FcFreeTypeLangSet (const FcCharSet *charset, +FcPrivate FcLangSet * +FcFreeTypeLangSet (const FcCharSet *charset, const FcChar8 *exclusiveLang); -FcLangResult +FcPrivate FcLangResult FcLangCompare (const FcChar8 *s1, const FcChar8 *s2); - -const FcCharSet * -FcCharSetForLang (const FcChar8 *lang); -FcLangSet * +FcPrivate FcLangSet * FcLangSetPromote (const FcChar8 *lang); -FcLangSet * +FcPrivate FcLangSet * FcNameParseLangSet (const FcChar8 *string); -FcBool +FcPrivate 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); +FcPrivate FcChar8 * +FcNameUnparseEscaped (FcPattern *pat, FcBool escape); /* fclist.c */ -FcBool +FcPrivate FcBool FcListPatternMatchAny (const FcPattern *p, const FcPattern *font); @@ -807,170 +799,241 @@ FcListPatternMatchAny (const FcPattern *p, /* 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 +#define FC_DECORATIVE_OBJECT 40 +#define FC_LCD_FILTER_OBJECT 41 +#define FC_MAX_BASE_OBJECT FC_LCD_FILTER_OBJECT + +FcPrivate FcBool +FcNameBool (const FcChar8 *v, FcBool *result); -int -FcObjectNeededBytes (void); +FcPrivate FcBool +FcObjectValidType (FcObject object, FcType type); -int -FcObjectNeededBytesAlign (void); +FcPrivate FcObject +FcObjectFromName (const char * name); -void * -FcObjectUnserialize (FcCache * metadata, void *block_ptr); +FcPrivate const char * +FcObjectName (FcObject object); -void -FcObjectSerialize (void); +FcPrivate FcObjectSet * +FcObjectGetSet (void); -const char * -FcObjectPtrU (FcObjectPtr p); +FcPrivate FcBool +FcObjectInit (void); -static inline int -FcObjectPtrCompare (const FcObjectPtr a, const FcObjectPtr b) -{ - return a - b; -} +FcPrivate void +FcObjectFini (void); -void -FcObjectStaticNameFini (void); +#define FcObjectCompare(a, b) ((int) a - (int) b) /* fcpat.c */ -FcValue +FcPrivate FcValue FcValueCanonicalize (const FcValue *v); -void +FcPrivate void FcValueListDestroy (FcValueListPtr l); -FcPatternElt * -FcPatternFindElt (const FcPattern *p, const char *object); +FcPrivate FcPatternElt * +FcPatternObjectFindElt (const FcPattern *p, FcObject object); -FcPatternElt * -FcPatternInsertElt (FcPattern *p, const char *object); +FcPrivate FcPatternElt * +FcPatternObjectInsertElt (FcPattern *p, FcObject object); -FcBool -FcPatternAddWithBinding (FcPattern *p, - const char *object, - FcValue value, - FcValueBinding binding, - FcBool append); +FcPrivate FcBool +FcPatternObjectAddWithBinding (FcPattern *p, + FcObject object, + FcValue value, + FcValueBinding binding, + FcBool append); -void -FcPatternFini (void); +FcPrivate FcBool +FcPatternObjectAdd (FcPattern *p, FcObject object, FcValue value, FcBool append); -FcBool -FcPatternAppend (FcPattern *p, FcPattern *s); +FcPrivate FcBool +FcPatternObjectAddWeak (FcPattern *p, FcObject object, FcValue value, FcBool append); -const FcChar8 * -FcStrStaticName (const FcChar8 *name); +FcPrivate FcResult +FcPatternObjectGet (const FcPattern *p, FcObject object, int id, FcValue *v); -FcChar32 -FcStringHash (const FcChar8 *s); +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); -void -FcPatternNewBank (void); +FcPrivate FcBool +FcPatternObjectAddString (FcPattern *p, FcObject object, const FcChar8 *s); -int -FcPatternNeededBytes (FcPattern *p); +FcPrivate FcBool +FcPatternObjectAddMatrix (FcPattern *p, FcObject object, const FcMatrix *s); -int -FcPatternNeededBytesAlign (void); +FcPrivate FcBool +FcPatternObjectAddCharSet (FcPattern *p, FcObject object, const FcCharSet *c); -void * -FcPatternDistributeBytes (FcCache * metadata, void * block_ptr); +FcPrivate FcBool +FcPatternObjectAddBool (FcPattern *p, FcObject object, FcBool b); -/* please don't access these outside of fcpat.c! only visible so that - * *PtrU can be inlined. */ -extern FcValueList ** _fcValueLists; -extern FcPatternElt ** _fcPatternElts; +FcPrivate FcBool +FcPatternObjectAddLangSet (FcPattern *p, FcObject object, const FcLangSet *ls); -static inline FcValueList * -FcValueListPtrU (FcValueListPtr pi) -{ - if (pi.bank == FC_BANK_DYNAMIC) - return pi.u.dyn; +FcPrivate FcResult +FcPatternObjectGetInteger (const FcPattern *p, FcObject object, int n, int *i); - return &_fcValueLists[FcCacheBankToIndex(pi.bank)][pi.u.stat]; -} +FcPrivate FcResult +FcPatternObjectGetDouble (const FcPattern *p, FcObject object, int n, double *d); -static inline FcPatternElt * -FcPatternEltU (FcPatternEltPtr pei) -{ - if (pei.bank == FC_BANK_DYNAMIC) - return pei.u.dyn; +FcPrivate FcResult +FcPatternObjectGetString (const FcPattern *p, FcObject object, int n, FcChar8 ** s); - return &_fcPatternElts[FcCacheBankToIndex(pei.bank)][pei.u.stat]; -} +FcPrivate FcResult +FcPatternObjectGetMatrix (const FcPattern *p, FcObject object, int n, FcMatrix **s); -FcValueListPtr -FcValueListPtrCreateDynamic(FcValueList * p); +FcPrivate FcResult +FcPatternObjectGetCharSet (const FcPattern *p, FcObject object, int n, FcCharSet **c); -FcPattern * -FcPatternSerialize (int bank, FcPattern * p); +FcPrivate FcResult +FcPatternObjectGetBool (const FcPattern *p, FcObject object, int n, FcBool *b); -void * -FcPatternUnserialize (FcCache * metadata, void *block_ptr); +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 */ -void +FcPrivate void FcStrSetSort (FcStrSet * set); -FcChar8 * -FcStrPlus (const FcChar8 *s1, const FcChar8 *s2); - -void -FcStrFree (FcChar8 *s); - -void +FcPrivate void FcStrBufInit (FcStrBuf *buf, FcChar8 *init, int size); -void +FcPrivate void FcStrBufDestroy (FcStrBuf *buf); -FcChar8 * +FcPrivate FcChar8 * FcStrBufDone (FcStrBuf *buf); -FcBool +FcPrivate FcChar8 * +FcStrBufDoneStatic (FcStrBuf *buf); + +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); -const FcChar8 * +FcPrivate const FcChar8 * FcStrContainsIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2); -const FcChar8 * +FcPrivate const FcChar8 * FcStrContainsIgnoreCase (const FcChar8 *s1, const FcChar8 *s2); -FcBool +FcPrivate const FcChar8 * +FcStrContainsWord (const FcChar8 *s1, const FcChar8 *s2); + +FcPrivate FcBool FcStrUsesHome (const FcChar8 *s); -FcChar8 * +FcPrivate FcChar8 * FcStrLastSlash (const FcChar8 *path); -FcChar32 +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_ */