[fontconfig.git] / src / fcint.h

/*
 * $RCSId: xc/lib/fontconfig/src/fcint.h,v 1.27 2002/08/31 22:17:32 keithp Exp $
 *
 * 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
 * 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
 * advertising or publicity pertaining to distribution of the software without
 * specific, written prior permission.  Keith Packard makes 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,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
 * EVENT SHALL KEITH PACKARD 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
 * PERFORMANCE OF THIS SOFTWARE.
 */

#ifndef _FCINT_H_
#define _FCINT_H_

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <time.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_EDIT	4
#define FC_DBG_FONTSET	8
#define FC_DBG_CACHE	16
#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_CHARLEAF	    1
#define FC_MEM_FONTSET	    2
#define FC_MEM_FONTPTR	    3
#define FC_MEM_OBJECTSET    4
#define FC_MEM_OBJECTPTR    5
#define FC_MEM_MATRIX	    6
#define FC_MEM_PATTERN	    7
#define FC_MEM_PATELT	    8
#define FC_MEM_VALLIST	    9
#define FC_MEM_SUBSTATE	    10
#define FC_MEM_STRING	    11
#define FC_MEM_LISTBUCK	    12
#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_NUM	    29

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;
} FcPatternElt;


struct _FcPattern {
    int		    num;
    int		    size;
    FcPatternElt    *elts;
    int		    ref;
};

typedef enum _FcOp {
    FcOpInteger, FcOpDouble, FcOpString, FcOpMatrix, FcOpBool, FcOpCharSet, 
    FcOpNil,
    FcOpField, FcOpConst,
    FcOpAssign, FcOpAssignReplace, 
    FcOpPrependFirst, FcOpPrepend, FcOpAppend, FcOpAppendLast,
    FcOpQuest,
    FcOpOr, FcOpAnd, FcOpEqual, FcOpNotEqual, 
    FcOpContains, FcOpListing, FcOpNotContains,
    FcOpLess, FcOpLessEqual, FcOpMore, FcOpMoreEqual,
    FcOpPlus, FcOpMinus, FcOpTimes, FcOpDivide,
    FcOpNot, FcOpComma, FcOpFloor, FcOpCeil, FcOpRound, FcOpTrunc,
    FcOpInvalid
} FcOp;

typedef struct _FcExpr {
    FcOp   op;
    union {
	int	    ival;
	double	    dval;
	FcChar8	    *sval;
	FcMatrix    *mval;
	FcBool	    bval;
	FcCharSet   *cval;
	char	    *field;
	FcChar8	    *constant;
	struct {
	    struct _FcExpr *left, *right;
	} tree;
    } u;
} FcExpr;

typedef enum _FcQual {
    FcQualAny, FcQualAll, FcQualFirst, FcQualNotFirst
} FcQual;

#define FcMatchDefault	((FcMatchKind) -1)

typedef struct _FcTest {
    struct _FcTest	*next;
    FcMatchKind		kind;
    FcQual		qual;
    const char		*field;
    FcOp		op;
    FcExpr		*expr;
} FcTest;

typedef struct _FcEdit {
    struct _FcEdit *next;
    const char	    *field;
    FcOp	    op;
    FcExpr	    *expr;
    FcValueBinding  binding;
} FcEdit;

typedef struct _FcSubst {
    struct _FcSubst	*next;
    FcTest		*test;
    FcEdit		*edit;
} FcSubst;

typedef struct _FcCharLeaf {
    FcChar32	map[256/32];
} FcCharLeaf;

#define FC_REF_CONSTANT	    -1

struct _FcCharSet {
    int		    ref;	/* reference count */
    int		    num;	/* size of leaves and numbers arrays */
    FcCharLeaf	    **leaves;
    FcChar16	    *numbers;
};

struct _FcStrSet {
    int		    ref;	/* reference count */
    int		    num;
    int		    size;
    FcChar8	    **strs;
};

struct _FcStrList {
    FcStrSet	    *set;
    int		    n;
};

typedef struct _FcStrBuf {
    FcChar8 *buf;
    FcBool  allocated;
    FcBool  failed;
    int	    len;
    int	    size;
} FcStrBuf;

/*
 * 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;

#define FC_MAX_FILE_LEN	    4096

/*
 * 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
 */

#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 {
    int		nblank;
    int		sblank;
    FcChar32	*blanks;
};

struct _FcConfig {
    /*
     * File names loaded from the configuration -- saved here as the
     * cache file must be consulted before the directories are scanned,
     * 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
     */
    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
     */
    FcStrSet	*configFiles;	    /* config files loaded */
    /*
     * Substitution instructions for patterns and fonts;
     * maxObjects is used to allocate appropriate intermediate storage
     * while performing a whole set of substitutions
     */
    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,
     * except in the case of identical matches in which case earlier fonts
     * 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 */

FcGlobalCache *
FcGlobalCacheCreate (void);

void
FcGlobalCacheDestroy (FcGlobalCache *cache);

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);

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
FcGlobalCacheLoad (FcGlobalCache    *cache,
		   const FcChar8    *cache_file);

FcBool
FcGlobalCacheUpdate (FcGlobalCache  *cache,
		     const FcChar8  *file,
		     int	    id,
		     const FcChar8  *name);

FcBool
FcGlobalCacheSave (FcGlobalCache    *cache,
		   const FcChar8    *cache_file);

FcBool
FcDirCacheReadDir (FcFontSet	    *set, 
		   FcStrSet	    *dirs,
		   const FcChar8    *dir,
		   FcConfig	    *config);

FcBool
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);

FcBool
FcConfigAddConfigFile (FcConfig		*config,
		       const FcChar8	*f);

FcBool
FcConfigSetCache (FcConfig	*config,
		  const FcChar8	*c);

FcBool
FcConfigAddBlank (FcConfig	*config,
		  FcChar32    	blank);

FcBool
FcConfigAddEdit (FcConfig	*config,
		 FcTest		*test,
		 FcEdit		*edit,
		 FcMatchKind	kind);

void
FcConfigSetFonts (FcConfig	*config,
		  FcFontSet	*fonts,
		  FcSetName	set);

FcBool
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);

FcCharLeaf *
FcCharSetFindLeafCreate (FcCharSet *fcs, FcChar32 ucs4);

/* fcdbg.c */
void
FcValueListPrint (const FcValueList *l);

void
FcLangSetPrint (const FcLangSet *ls);

void
FcOpPrint (FcOp op);

void
FcTestPrint (const FcTest *test);

void
FcExprPrint (const FcExpr *expr);

void
FcEditPrint (const FcEdit *edit);

void
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
FcConfigparse (void);

int
FcConfigwrap (void);
    
void
FcConfigerror (char *fmt, ...);
    
char *
FcConfigSaveField (const char *field);

FcTest *
FcTestCreate (FcMatchKind   kind,
	      FcQual	    qual,
	      const FcChar8 *field,
	      FcOp	    compare,
	      FcExpr	    *expr);

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);

FcEdit *
FcEditCreate (const char *field, FcOp op, FcExpr *expr, FcValueBinding binding);

void
FcEditDestroy (FcEdit *e);

/* fcinit.c */

void
FcMemReport (void);

void
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);

/* fclist.c */

FcBool
FcListPatternMatchAny (const FcPattern *p,
		       const FcPattern *font);

/* fcmatch.c */

/* fcname.c */

FcBool
FcNameBool (FcChar8 *v, FcBool *result);

/* fcpat.c */
void
FcValueListDestroy (FcValueList *l);
    
FcPatternElt *
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);

/* fcstr.c */
FcChar8 *
FcStrPlus (const FcChar8 *s1, const FcChar8 *s2);
    
void
FcStrFree (FcChar8 *s);

void
FcStrBufInit (FcStrBuf *buf, FcChar8 *init, int size);

void
FcStrBufDestroy (FcStrBuf *buf);

FcChar8 *
FcStrBufDone (FcStrBuf *buf);

FcBool
FcStrBufChar (FcStrBuf *buf, FcChar8 c);

FcBool
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);

#endif /* _FC_INT_H_ */
Commit	Line	Data
	1	/*
	2	* $RCSId: xc/lib/fontconfig/src/fcint.h,v 1.27 2002/08/31 22:17:32 keithp Exp $
	3	*
	4	* Copyright © 2000 Keith Packard
	5	*
	6	* Permission to use, copy, modify, distribute, and sell this software and its
	7	* documentation for any purpose is hereby granted without fee, provided that
	8	* the above copyright notice appear in all copies and that both that
	9	* copyright notice and this permission notice appear in supporting
	10	* documentation, and that the name of Keith Packard not be used in
	11	* advertising or publicity pertaining to distribution of the software without
	12	* specific, written prior permission. Keith Packard makes no
	13	* representations about the suitability of this software for any purpose. It
	14	* is provided "as is" without express or implied warranty.
	15	*
	16	* KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
	17	* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
	18	* EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
	19	* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
	20	* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
	21	* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
	22	* PERFORMANCE OF THIS SOFTWARE.
	23	*/
	24
	25	#ifndef _FCINT_H_
	26	#define _FCINT_H_
	27
	28	#include <stdlib.h>
	29	#include <stdio.h>
	30	#include <string.h>
	31	#include <ctype.h>
	32	#include <errno.h>
	33	#include <unistd.h>
	34	#include <sys/types.h>
	35	#include <sys/stat.h>
	36	#include <time.h>
	37	#include <fontconfig/fontconfig.h>
	38	#include <fontconfig/fcprivate.h>
	39	#include <fontconfig/fcfreetype.h>
	40	#ifdef HAVE_CONFIG_H
	41	#include <config.h>
	42	#endif
	43
	44	typedef struct _FcSymbolic {
	45	const char *name;
	46	int value;
	47	} FcSymbolic;
	48
	49	#ifndef FC_CONFIG_PATH
	50	#define FC_CONFIG_PATH "fonts.conf"
	51	#endif
	52
	53	#define FC_FONT_FILE_INVALID ((FcChar8 *) ".")
	54	#define FC_FONT_FILE_DIR ((FcChar8 *) ".dir")
	55
	56	#ifdef _WIN32
	57	#define FC_SEARCH_PATH_SEPARATOR ';'
	58	#else
	59	#define FC_SEARCH_PATH_SEPARATOR ':'
	60	#endif
	61
	62	#define FC_DBG_MATCH 1
	63	#define FC_DBG_MATCHV 2
	64	#define FC_DBG_EDIT 4
	65	#define FC_DBG_FONTSET 8
	66	#define FC_DBG_CACHE 16
	67	#define FC_DBG_CACHEV 32
	68	#define FC_DBG_PARSE 64
	69	#define FC_DBG_SCAN 128
	70	#define FC_DBG_SCANV 256
	71	#define FC_DBG_MEMORY 512
	72	#define FC_DBG_CONFIG 1024
	73
	74	#define FC_MEM_CHARSET 0
	75	#define FC_MEM_CHARLEAF 1
	76	#define FC_MEM_FONTSET 2
	77	#define FC_MEM_FONTPTR 3
	78	#define FC_MEM_OBJECTSET 4
	79	#define FC_MEM_OBJECTPTR 5
	80	#define FC_MEM_MATRIX 6
	81	#define FC_MEM_PATTERN 7
	82	#define FC_MEM_PATELT 8
	83	#define FC_MEM_VALLIST 9
	84	#define FC_MEM_SUBSTATE 10
	85	#define FC_MEM_STRING 11
	86	#define FC_MEM_LISTBUCK 12
	87	#define FC_MEM_STRSET 13
	88	#define FC_MEM_STRLIST 14
	89	#define FC_MEM_CONFIG 15
	90	#define FC_MEM_LANGSET 16
	91	#define FC_MEM_ATOMIC 17
	92	#define FC_MEM_BLANKS 18
	93	#define FC_MEM_CACHE 19
	94	#define FC_MEM_STRBUF 20
	95	#define FC_MEM_SUBST 21
	96	#define FC_MEM_OBJECTTYPE 22
	97	#define FC_MEM_CONSTANT 23
	98	#define FC_MEM_TEST 24
	99	#define FC_MEM_EXPR 25
	100	#define FC_MEM_VSTACK 26
	101	#define FC_MEM_ATTR 27
	102	#define FC_MEM_PSTACK 28
	103
	104	#define FC_MEM_NUM 29
	105
	106	typedef enum _FcValueBinding {
	107	FcValueBindingWeak, FcValueBindingStrong, FcValueBindingSame
	108	} FcValueBinding;
	109
	110	typedef struct _FcValueList {
	111	struct _FcValueList *next;
	112	FcValue value;
	113	FcValueBinding binding;
	114	} FcValueList;
	115
	116	typedef struct _FcPatternElt {
	117	const char *object;
	118	FcValueList *values;
	119	} FcPatternElt;
	120
	121
	122	struct _FcPattern {
	123	int num;
	124	int size;
	125	FcPatternElt *elts;
	126	int ref;
	127	};
	128
	129	typedef enum _FcOp {
	130	FcOpInteger, FcOpDouble, FcOpString, FcOpMatrix, FcOpBool, FcOpCharSet,
	131	FcOpNil,
	132	FcOpField, FcOpConst,
	133	FcOpAssign, FcOpAssignReplace,
	134	FcOpPrependFirst, FcOpPrepend, FcOpAppend, FcOpAppendLast,
	135	FcOpQuest,
	136	FcOpOr, FcOpAnd, FcOpEqual, FcOpNotEqual,
	137	FcOpContains, FcOpListing, FcOpNotContains,
	138	FcOpLess, FcOpLessEqual, FcOpMore, FcOpMoreEqual,
	139	FcOpPlus, FcOpMinus, FcOpTimes, FcOpDivide,
	140	FcOpNot, FcOpComma, FcOpFloor, FcOpCeil, FcOpRound, FcOpTrunc,
	141	FcOpInvalid
	142	} FcOp;
	143
	144	typedef struct _FcExpr {
	145	FcOp op;
	146	union {
	147	int ival;
	148	double dval;
	149	FcChar8 *sval;
	150	FcMatrix *mval;
	151	FcBool bval;
	152	FcCharSet *cval;
	153	char *field;
	154	FcChar8 *constant;
	155	struct {
	156	struct _FcExpr left, right;
	157	} tree;
	158	} u;
	159	} FcExpr;
	160
	161	typedef enum _FcQual {
	162	FcQualAny, FcQualAll, FcQualFirst, FcQualNotFirst
	163	} FcQual;
	164
	165	#define FcMatchDefault ((FcMatchKind) -1)
	166
	167	typedef struct _FcTest {
	168	struct _FcTest *next;
	169	FcMatchKind kind;
	170	FcQual qual;
	171	const char *field;
	172	FcOp op;
	173	FcExpr *expr;
	174	} FcTest;
	175
	176	typedef struct _FcEdit {
	177	struct _FcEdit *next;
	178	const char *field;
	179	FcOp op;
	180	FcExpr *expr;
	181	FcValueBinding binding;
	182	} FcEdit;
	183
	184	typedef struct _FcSubst {
	185	struct _FcSubst *next;
	186	FcTest *test;
	187	FcEdit *edit;
	188	} FcSubst;
	189
	190	typedef struct _FcCharLeaf {
	191	FcChar32 map[256/32];
	192	} FcCharLeaf;
	193
	194	#define FC_REF_CONSTANT -1
	195
	196	struct _FcCharSet {
	197	int ref; /* reference count */
	198	int num; /* size of leaves and numbers arrays */
	199	FcCharLeaf **leaves;
	200	FcChar16 *numbers;
	201	};
	202
	203	struct _FcStrSet {
	204	int ref; /* reference count */
	205	int num;
	206	int size;
	207	FcChar8 **strs;
	208	};
	209
	210	struct _FcStrList {
	211	FcStrSet *set;
	212	int n;
	213	};
	214
	215	typedef struct _FcStrBuf {
	216	FcChar8 *buf;
	217	FcBool allocated;
	218	FcBool failed;
	219	int len;
	220	int size;
	221	} FcStrBuf;
	222
	223	/*
	224	* To map adobe glyph names to unicode values, a precomputed hash
	225	* table is used
	226	*/
	227
	228	typedef struct _FcGlyphName {
	229	FcChar32 ucs; /* unicode value */
	230	FcChar8 name[1]; /* name extends beyond struct */
	231	} FcGlyphName;
	232
	233	#define FC_MAX_FILE_LEN 4096
	234
	235	/*
	236	* The per-user ~/.fonts.cache-<version> file is loaded into
	237	* this data structure. Each directory gets a substructure
	238	* which is validated by comparing the directory timestamp with
	239	* that saved in the cache. When valid, the entire directory cache
	240	* can be immediately loaded without reading the directory. Otherwise,
	241	* the files are checked individually; updated files are loaded into the
	242	* cache which is then rewritten to the users home directory
	243	*/
	244
	245	#define FC_GLOBAL_CACHE_DIR_HASH_SIZE 37
	246	#define FC_GLOBAL_CACHE_FILE_HASH_SIZE 67
	247
	248	typedef struct _FcGlobalCacheInfo {
	249	unsigned int hash;
	250	FcChar8 *file;
	251	time_t time;
	252	FcBool referenced;
	253	} FcGlobalCacheInfo;
	254
	255	typedef struct _FcGlobalCacheFile {
	256	struct _FcGlobalCacheFile *next;
	257	FcGlobalCacheInfo info;
	258	int id;
	259	FcChar8 *name;
	260	} FcGlobalCacheFile;
	261
	262	typedef struct _FcGlobalCacheDir FcGlobalCacheDir;
	263
	264	typedef struct _FcGlobalCacheSubdir {
	265	struct _FcGlobalCacheSubdir *next;
	266	FcGlobalCacheDir *ent;
	267	} FcGlobalCacheSubdir;
	268
	269	struct _FcGlobalCacheDir {
	270	struct _FcGlobalCacheDir *next;
	271	FcGlobalCacheInfo info;
	272	int len;
	273	FcGlobalCacheFile *ents[FC_GLOBAL_CACHE_FILE_HASH_SIZE];
	274	FcGlobalCacheSubdir *subdirs;
	275	};
	276
	277	typedef struct _FcGlobalCache {
	278	FcGlobalCacheDir *ents[FC_GLOBAL_CACHE_DIR_HASH_SIZE];
	279	FcBool updated;
	280	FcBool broken;
	281	int entries;
	282	int referenced;
	283	} FcGlobalCache;
	284
	285	struct _FcAtomic {
	286	FcChar8 file; / original file name */
	287	FcChar8 new; / temp file name -- write data here */
	288	FcChar8 lck; / lockfile name (used for locking) */
	289	FcChar8 tmp; / tmpfile name (used for locking) */
	290	};
	291
	292	struct _FcBlanks {
	293	int nblank;
	294	int sblank;
	295	FcChar32 *blanks;
	296	};
	297
	298	struct _FcConfig {
	299	/*
	300	* File names loaded from the configuration -- saved here as the
	301	* cache file must be consulted before the directories are scanned,
	302	* and those directives may occur in any order
	303	*/
	304	FcStrSet configDirs; / directories to scan for fonts */
	305	FcChar8 cache; / name of per-user cache file */
	306	/*
	307	* Set of allowed blank chars -- used to
	308	* trim fonts of bogus glyphs
	309	*/
	310	FcBlanks *blanks;
	311	/*
	312	* List of directories containing fonts,
	313	* built by recursively scanning the set
	314	* of configured directories
	315	*/
	316	FcStrSet *fontDirs;
	317	/*
	318	* Names of all of the configuration files used
	319	* to create this configuration
	320	*/
	321	FcStrSet configFiles; / config files loaded */
	322	/*
	323	* Substitution instructions for patterns and fonts;
	324	* maxObjects is used to allocate appropriate intermediate storage
	325	* while performing a whole set of substitutions
	326	*/
	327	FcSubst substPattern; / substitutions for patterns */
	328	FcSubst substFont; / substitutions for fonts */
	329	int maxObjects; /* maximum number of tests in all substs */
	330	/*
	331	* List of patterns used to control font file selection
	332	*/
	333	FcStrSet *acceptGlobs;
	334	FcStrSet *rejectGlobs;
	335	FcFontSet *acceptPatterns;
	336	FcFontSet *rejectPatterns;
	337	/*
	338	* The set of fonts loaded from the listed directories; the
	339	* order within the set does not determine the font selection,
	340	* except in the case of identical matches in which case earlier fonts
	341	* match preferrentially
	342	*/
	343	FcFontSet *fonts[FcSetApplication + 1];
	344	/*
	345	* Fontconfig can periodically rescan the system configuration
	346	* and font directories. This rescanning occurs when font
	347	* listing requests are made, but no more often than rescanInterval
	348	* seconds apart.
	349	*/
	350	time_t rescanTime; /* last time information was scanned */
	351	int rescanInterval; /* interval between scans */
	352	};
	353
	354	extern FcConfig *_fcConfig;
	355
	356	typedef struct _FcCharMap FcCharMap;
	357
	358	/* fcblanks.c */
	359
	360	/* fccache.c */
	361
	362	FcGlobalCache *
	363	FcGlobalCacheCreate (void);
	364
	365	void
	366	FcGlobalCacheDestroy (FcGlobalCache *cache);
	367
	368	FcBool
	369	FcGlobalCacheCheckTime (const FcChar8file, FcGlobalCacheInfo info);
	370
	371	void
	372	FcGlobalCacheReferenced (FcGlobalCache *cache,
	373	FcGlobalCacheInfo *info);
	374
	375	void
	376	FcGlobalCacheReferenceSubdir (FcGlobalCache *cache,
	377	const FcChar8 *dir);
	378
	379	FcGlobalCacheDir *
	380	FcGlobalCacheDirGet (FcGlobalCache *cache,
	381	const FcChar8 *dir,
	382	int len,
	383	FcBool create_missing);
	384
	385	FcBool
	386	FcGlobalCacheScanDir (FcFontSet *set,
	387	FcStrSet *dirs,
	388	FcGlobalCache *cache,
	389	const FcChar8 *dir,
	390	FcConfig *config);
	391
	392	FcGlobalCacheFile *
	393	FcGlobalCacheFileGet (FcGlobalCache *cache,
	394	const FcChar8 *file,
	395	int id,
	396	int *count);
	397
	398
	399	void
	400	FcGlobalCacheLoad (FcGlobalCache *cache,
	401	const FcChar8 *cache_file);
	402
	403	FcBool
	404	FcGlobalCacheUpdate (FcGlobalCache *cache,
	405	const FcChar8 *file,
	406	int id,
	407	const FcChar8 *name);
	408
	409	FcBool
	410	FcGlobalCacheSave (FcGlobalCache *cache,
	411	const FcChar8 *cache_file);
	412
	413	FcBool
	414	FcDirCacheReadDir (FcFontSet *set,
	415	FcStrSet *dirs,
	416	const FcChar8 *dir,
	417	FcConfig *config);
	418
	419	FcBool
	420	FcDirCacheWriteDir (FcFontSet set, FcStrSet dirs, const FcChar8 *dir);
	421
	422	/* fccfg.c */
	423
	424	FcBool
	425	FcConfigAddConfigDir (FcConfig *config,
	426	const FcChar8 *d);
	427
	428	FcBool
	429	FcConfigAddFontDir (FcConfig *config,
	430	const FcChar8 *d);
	431
	432	FcBool
	433	FcConfigAddDir (FcConfig *config,
	434	const FcChar8 *d);
	435
	436	FcBool
	437	FcConfigAddConfigFile (FcConfig *config,
	438	const FcChar8 *f);
	439
	440	FcBool
	441	FcConfigSetCache (FcConfig *config,
	442	const FcChar8 *c);
	443
	444	FcBool
	445	FcConfigAddBlank (FcConfig *config,
	446	FcChar32 blank);
	447
	448	FcBool
	449	FcConfigAddEdit (FcConfig *config,
	450	FcTest *test,
	451	FcEdit *edit,
	452	FcMatchKind kind);
	453
	454	void
	455	FcConfigSetFonts (FcConfig *config,
	456	FcFontSet *fonts,
	457	FcSetName set);
	458
	459	FcBool
	460	FcConfigCompareValue (const FcValue m,
	461	FcOp op,
	462	const FcValue v);
	463
	464	FcBool
	465	FcConfigGlobAdd (FcConfig *config,
	466	const FcChar8 *glob,
	467	FcBool accept);
	468
	469	FcBool
	470	FcConfigAcceptFilename (FcConfig *config,
	471	const FcChar8 *filename);
	472
	473	FcBool
	474	FcConfigPatternsAdd (FcConfig *config,
	475	FcPattern *pattern,
	476	FcBool accept);
	477
	478	FcBool
	479	FcConfigAcceptFont (FcConfig *config,
	480	const FcPattern *font);
	481
	482	/* fccharset.c */
	483	FcCharSet *
	484	FcCharSetFreeze (FcCharSet *cs);
	485
	486	void
	487	FcCharSetThawAll (void);
	488
	489	FcBool
	490	FcNameUnparseCharSet (FcStrBuf buf, const FcCharSet c);
	491
	492	FcCharSet *
	493	FcNameParseCharSet (FcChar8 *string);
	494
	495	FcCharLeaf *
	496	FcCharSetFindLeafCreate (FcCharSet *fcs, FcChar32 ucs4);
	497
	498	/* fcdbg.c */
	499	void
	500	FcValueListPrint (const FcValueList *l);
	501
	502	void
	503	FcLangSetPrint (const FcLangSet *ls);
	504
	505	void
	506	FcOpPrint (FcOp op);
	507
	508	void
	509	FcTestPrint (const FcTest *test);
	510
	511	void
	512	FcExprPrint (const FcExpr *expr);
	513
	514	void
	515	FcEditPrint (const FcEdit *edit);
	516
	517	void
	518	FcSubstPrint (const FcSubst *subst);
	519
	520	int
	521	FcDebug (void);
	522
	523	/* fcdir.c */
	524
	525	FcBool
	526	FcFileIsDir (const FcChar8 *file);
	527
	528	FcBool
	529	FcFileScanConfig (FcFontSet *set,
	530	FcStrSet *dirs,
	531	FcFileCache *cache,
	532	FcBlanks *blanks,
	533	const FcChar8 *file,
	534	FcBool force,
	535	FcConfig *config);
	536
	537	FcBool
	538	FcDirScanConfig (FcFontSet *set,
	539	FcStrSet *dirs,
	540	FcFileCache *cache,
	541	FcBlanks *blanks,
	542	const FcChar8 *dir,
	543	FcBool force,
	544	FcConfig *config);
	545
	546	/* fcfont.c */
	547	int
	548	FcFontDebug (void);
	549
	550	/* fcfreetype.c */
	551	FcBool
	552	FcFreeTypeIsExclusiveLang (const FcChar8 *lang);
	553
	554	FcBool
	555	FcFreeTypeHasLang (FcPattern pattern, const FcChar8 lang);
	556
	557	FcChar32
	558	FcFreeTypeUcs4ToPrivate (FcChar32 ucs4, const FcCharMap *map);
	559
	560	FcChar32
	561	FcFreeTypePrivateToUcs4 (FcChar32 private, const FcCharMap *map);
	562
	563	const FcCharMap *
	564	FcFreeTypeGetPrivateMap (FT_Encoding encoding);
	565
	566	/* fcfs.c */
	567	/* fcgram.y */
	568	int
	569	FcConfigparse (void);
	570
	571	int
	572	FcConfigwrap (void);
	573
	574	void
	575	FcConfigerror (char *fmt, ...);
	576
	577	char *
	578	FcConfigSaveField (const char *field);
	579
	580	FcTest *
	581	FcTestCreate (FcMatchKind kind,
	582	FcQual qual,
	583	const FcChar8 *field,
	584	FcOp compare,
	585	FcExpr *expr);
	586
	587	void
	588	FcTestDestroy (FcTest *test);
	589
	590	FcExpr *
	591	FcExprCreateInteger (int i);
	592
	593	FcExpr *
	594	FcExprCreateDouble (double d);
	595
	596	FcExpr *
	597	FcExprCreateString (const FcChar8 *s);
	598
	599	FcExpr *
	600	FcExprCreateMatrix (const FcMatrix *m);
	601
	602	FcExpr *
	603	FcExprCreateBool (FcBool b);
	604
	605	FcExpr *
	606	FcExprCreateNil (void);
	607
	608	FcExpr *
	609	FcExprCreateField (const char *field);
	610
	611	FcExpr *
	612	FcExprCreateConst (const FcChar8 *constant);
	613
	614	FcExpr *
	615	FcExprCreateOp (FcExpr left, FcOp op, FcExpr right);
	616
	617	void
	618	FcExprDestroy (FcExpr *e);
	619
	620	FcEdit *
	621	FcEditCreate (const char field, FcOp op, FcExpr expr, FcValueBinding binding);
	622
	623	void
	624	FcEditDestroy (FcEdit *e);
	625
	626	/* fcinit.c */
	627
	628	void
	629	FcMemReport (void);
	630
	631	void
	632	FcMemAlloc (int kind, int size);
	633
	634	void
	635	FcMemFree (int kind, int size);
	636
	637	/* fclang.c */
	638	FcLangSet *
	639	FcFreeTypeLangSet (const FcCharSet *charset,
	640	const FcChar8 *exclusiveLang);
	641
	642	FcLangResult
	643	FcLangCompare (const FcChar8 s1, const FcChar8 s2);
	644
	645	const FcCharSet *
	646	FcCharSetForLang (const FcChar8 *lang);
	647
	648	FcLangSet *
	649	FcLangSetPromote (const FcChar8 *lang);
	650
	651	FcLangSet *
	652	FcNameParseLangSet (const FcChar8 *string);
	653
	654	FcBool
	655	FcNameUnparseLangSet (FcStrBuf buf, const FcLangSet ls);
	656
	657	/* fclist.c */
	658
	659	FcBool
	660	FcListPatternMatchAny (const FcPattern *p,
	661	const FcPattern *font);
	662
	663	/* fcmatch.c */
	664
	665	/* fcname.c */
	666
	667	FcBool
	668	FcNameBool (FcChar8 v, FcBool result);
	669
	670	/* fcpat.c */
	671	void
	672	FcValueListDestroy (FcValueList *l);
	673
	674	FcPatternElt *
	675	FcPatternFindElt (const FcPattern p, const char object);
	676
	677	FcPatternElt *
	678	FcPatternInsertElt (FcPattern p, const char object);
	679
	680	FcBool
	681	FcPatternAddWithBinding (FcPattern *p,
	682	const char *object,
	683	FcValue value,
	684	FcValueBinding binding,
	685	FcBool append);
	686
	687	FcPattern *
	688	FcPatternFreeze (FcPattern *p);
	689
	690	void
	691	FcPatternThawAll (void);
	692
	693	FcBool
	694	FcPatternAppend (FcPattern p, FcPattern s);
	695
	696	const char *
	697	FcObjectStaticName (const char *name);
	698
	699	/* fcrender.c */
	700
	701	/* fcmatrix.c */
	702
	703	extern const FcMatrix FcIdentityMatrix;
	704
	705	void
	706	FcMatrixFree (FcMatrix *mat);
	707
	708	/* fcstr.c */
	709	FcChar8 *
	710	FcStrPlus (const FcChar8 s1, const FcChar8 s2);
	711
	712	void
	713	FcStrFree (FcChar8 *s);
	714
	715	void
	716	FcStrBufInit (FcStrBuf buf, FcChar8 init, int size);
	717
	718	void
	719	FcStrBufDestroy (FcStrBuf *buf);
	720
	721	FcChar8 *
	722	FcStrBufDone (FcStrBuf *buf);
	723
	724	FcBool
	725	FcStrBufChar (FcStrBuf *buf, FcChar8 c);
	726
	727	FcBool
	728	FcStrBufString (FcStrBuf buf, const FcChar8 s);
	729
	730	FcBool
	731	FcStrBufData (FcStrBuf buf, const FcChar8 s, int len);
	732
	733	int
	734	FcStrCmpIgnoreBlanksAndCase (const FcChar8 s1, const FcChar8 s2);
	735
	736	const FcChar8 *
	737	FcStrContainsIgnoreBlanksAndCase (const FcChar8 s1, const FcChar8 s2);
	738
	739	const FcChar8 *
	740	FcStrContainsIgnoreCase (const FcChar8 s1, const FcChar8 s2);
	741
	742	FcBool
	743	FcStrUsesHome (const FcChar8 *s);
	744
	745	FcChar8 *
	746	FcStrLastSlash (const FcChar8 *path);
	747
	748	#endif /* _FC_INT_H_ */