walkero
/
fontconfig
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
fontconfig/src/fcint.h

1208 lines
30 KiB
C
Raw Blame History

/*
* fontconfig/src/fcint.h
*
* 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 the author(s) not be used in
* advertising or publicity pertaining to distribution of the software without
* 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.
*
* THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* 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
* PERFORMANCE OF THIS SOFTWARE.
*/
#ifndef _FCINT_H_
#define _FCINT_H_
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "fcstdint.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
#include <errno.h>
#include <limits.h>
#include <float.h>
#include <math.h>
#include <unistd.h>
#include <stddef.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <time.h>
#include <fontconfig/fontconfig.h>
#include <fontconfig/fcprivate.h>
#include "fcdeprecate.h"
#include "fcmutex.h"
#include "fcatomic.h"
#ifndef FC_CONFIG_PATH
#define FC_CONFIG_PATH "fonts.conf"
#endif
#ifdef _WIN32
# include "fcwindows.h"
typedef UINT (WINAPI *pfnGetSystemWindowsDirectory)(LPSTR, UINT);
typedef HRESULT (WINAPI *pfnSHGetFolderPathA)(HWND, int, HANDLE, DWORD, LPSTR);
extern pfnGetSystemWindowsDirectory pGetSystemWindowsDirectory;
extern pfnSHGetFolderPathA pSHGetFolderPathA;
# define FC_SEARCH_PATH_SEPARATOR ';'
# define FC_DIR_SEPARATOR '\\'
# define FC_DIR_SEPARATOR_S "\\"
#else
# define FC_SEARCH_PATH_SEPARATOR ':'
# define FC_DIR_SEPARATOR '/'
# define FC_DIR_SEPARATOR_S "/"
#endif
#if __GNUC__ >= 4
#define FC_UNUSED __attribute__((unused))
#else
#define FC_UNUSED
#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_CONFIG 1024
#define FC_DBG_LANGSET 2048
#define FC_DBG_MATCH2 4096
#define _FC_ASSERT_STATIC1(_line, _cond) typedef int _static_assert_on_line_##_line##_failed[(_cond)?1:-1] FC_UNUSED
#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
FC_ASSERT_STATIC (sizeof (FcRef) == sizeof (int));
typedef enum _FcValueBinding {
FcValueBindingWeak, FcValueBindingStrong, FcValueBindingSame,
/* to make sure sizeof (FcValueBinding) == 4 even with -fshort-enums */
FcValueBindingEnd = INT_MAX
} FcValueBinding;
#define FcStrdup(s) ((FcChar8 *) strdup ((const char *) (s)))
#define FcFree(s) (free ((FcChar8 *) (s)))
/*
* Serialized data structures use only offsets instead of pointers
* A low bit of 1 indicates an offset.
*/
/* 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)
#define FcValueRange(v) FcPointerMember(v,u.r,const FcRange)
typedef struct _FcValueList *FcValueListPtr;
typedef struct _FcValueList {
struct _FcValueList *next;
FcValue value;
FcValueBinding binding;
} FcValueList;
#define FcValueListNext(vl) FcPointerMember(vl,next,FcValueList)
typedef int FcObject;
/* The 1024 is to leave some room for future added internal objects, such
* that caches from newer fontconfig can still be used with older fontconfig
* without getting confused. */
#define FC_EXT_OBJ_INDEX 1024
#define FC_OBJ_ID(_n_) ((_n_) & (~FC_EXT_OBJ_INDEX))
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 {
FcObject object;
FcValueList *values;
} FcPatternElt;
#define FcPatternEltValues(pe) FcPointerMember(pe,values,FcValueList)
struct _FcPattern {
int num;
int size;
intptr_t elts_offset;
FcRef ref;
};
#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, FcOpRange, FcOpBool, FcOpCharSet, FcOpLangSet,
FcOpNil,
FcOpField, FcOpConst,
FcOpAssign, FcOpAssignReplace,
FcOpPrependFirst, FcOpPrepend, FcOpAppend, FcOpAppendLast,
FcOpDelete, FcOpDeleteAll,
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 enum _FcOpFlags {
FcOpFlagIgnoreBlanks = 1 << 0
} FcOpFlags;
#define FC_OP_GET_OP(_x_) ((_x_) & 0xffff)
#define FC_OP_GET_FLAGS(_x_) (((_x_) & 0xffff0000) >> 16)
#define FC_OP(_x_,_f_) (FC_OP_GET_OP (_x_) | ((_f_) << 16))
typedef struct _FcExprMatrix {
struct _FcExpr *xx, *xy, *yx, *yy;
} FcExprMatrix;
typedef struct _FcExprName {
FcObject object;
FcMatchKind kind;
} FcExprName;
struct _FcRange {
double begin;
double end;
};
typedef struct _FcExpr {
FcOp op;
union {
int ival;
double dval;
const FcChar8 *sval;
FcExprMatrix *mexpr;
FcBool bval;
FcCharSet *cval;
FcLangSet *lval;
FcRange *rval;
FcExprName name;
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[FLEXIBLE_ARRAY_MEMBER];
};
typedef enum _FcQual {
FcQualAny, FcQualAll, FcQualFirst, FcQualNotFirst
} FcQual;
#define FcMatchDefault ((FcMatchKind) -1)
typedef struct _FcTest {
FcMatchKind kind;
FcQual qual;
FcObject object;
FcOp op;
FcExpr *expr;
} FcTest;
typedef struct _FcEdit {
FcObject object;
FcOp op;
FcExpr *expr;
FcValueBinding binding;
} FcEdit;
typedef enum _FcRuleType {
FcRuleUnknown, FcRuleTest, FcRuleEdit
} FcRuleType;
typedef struct _FcRule {
struct _FcRule *next;
FcRuleType type;
union {
FcTest *test;
FcEdit *edit;
} u;
} FcRule;
typedef struct _FcSubst {
struct _FcSubst *next;
FcRule *rule;
} FcSubst;
typedef struct _FcCharLeaf {
FcChar32 map[256/32];
} FcCharLeaf;
struct _FcCharSet {
FcRef ref; /* reference count */
int num; /* size of leaves and numbers arrays */
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 {
FcRef 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;
FcChar8 buf_static[16 * sizeof (void *)];
} FcStrBuf;
struct _FcCache {
unsigned int magic; /* FC_CACHE_MAGIC_MMAP or FC_CACHE_ALLOC */
int version; /* FC_CACHE_VERSION_NUMBER */
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 checksum; /* checksum of directory state */
int64_t checksum_nano; /* checksum of directory state */
};
#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
* 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_CACHE_MAGIC_MMAP 0xFC02FC04
#define FC_CACHE_MAGIC_ALLOC 0xFC02FC05
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 */
/*
* 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;
/*
* List of directories containing cache files.
*/
FcStrSet *cacheDirs;
/*
* 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 */
FcSubst *substScan; /* substitutions for scanned 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 */
FcRef ref; /* reference count */
FcExprPage *expr_pool; /* pool of FcExpr's */
FcChar8 *sysRoot; /* override the system root directory */
};
typedef struct _FcFileTime {
time_t time;
FcBool set;
} FcFileTime;
typedef struct _FcCharMap FcCharMap;
typedef struct _FcStatFS FcStatFS;
struct _FcStatFS {
FcBool is_remote_fs;
FcBool is_mtime_broken;
};
typedef struct _FcValuePromotionBuffer FcValuePromotionBuffer;
struct _FcValuePromotionBuffer {
union {
double d;
int i;
long l;
char c[256]; /* Enlarge as needed */
} u;
};
/* fcblanks.c */
/* fccache.c */
FcPrivate FcCache *
FcDirCacheScan (const FcChar8 *dir, FcConfig *config);
FcPrivate FcCache *
FcDirCacheBuild (FcFontSet *set, const FcChar8 *dir, struct stat *dir_stat, FcStrSet *dirs);
FcPrivate FcCache *
FcDirCacheRebuild (FcCache *cache, struct stat *dir_stat, FcStrSet *dirs);
FcPrivate FcBool
FcDirCacheWrite (FcCache *cache, FcConfig *config);
FcPrivate FcBool
FcDirCacheCreateTagFile (const FcChar8 *cache_dir);
FcPrivate void
FcCacheObjectReference (void *object);
FcPrivate void
FcCacheObjectDereference (void *object);
FcPrivate void
FcCacheFini (void);
FcPrivate void
FcDirCacheReference (FcCache *cache, int nref);
FcPrivate int
FcDirCacheLock (const FcChar8 *dir,
FcConfig *config);
FcPrivate void
FcDirCacheUnlock (int fd);
/* fccfg.c */
FcPrivate FcBool
FcConfigInit (void);
FcPrivate void
FcConfigFini (void);
FcPrivate FcChar8 *
FcConfigXdgCacheHome (void);
FcPrivate FcChar8 *
FcConfigXdgConfigHome (void);
FcPrivate FcChar8 *
FcConfigXdgDataHome (void);
FcPrivate FcExpr *
FcConfigAllocExpr (FcConfig *config);
FcPrivate FcBool
FcConfigAddConfigDir (FcConfig *config,
const FcChar8 *d);
FcPrivate FcBool
FcConfigAddFontDir (FcConfig *config,
const FcChar8 *d);
FcPrivate FcBool
FcConfigAddDir (FcConfig *config,
const FcChar8 *d);
FcPrivate FcBool
FcConfigAddCacheDir (FcConfig *config,
const FcChar8 *d);
FcPrivate FcBool
FcConfigAddConfigFile (FcConfig *config,
const FcChar8 *f);
FcPrivate FcBool
FcConfigAddBlank (FcConfig *config,
FcChar32 blank);
FcBool
FcConfigAddRule (FcConfig *config,
FcRule *rule,
FcMatchKind kind);
FcPrivate void
FcConfigSetFonts (FcConfig *config,
FcFontSet *fonts,
FcSetName set);
FcPrivate FcBool
FcConfigCompareValue (const FcValue *m,
unsigned int op_,
const FcValue *v);
FcPrivate FcBool
FcConfigGlobAdd (FcConfig *config,
const FcChar8 *glob,
FcBool accept);
FcPrivate FcBool
FcConfigAcceptFilename (FcConfig *config,
const FcChar8 *filename);
FcPrivate FcBool
FcConfigPatternsAdd (FcConfig *config,
FcPattern *pattern,
FcBool accept);
FcPrivate FcBool
FcConfigAcceptFont (FcConfig *config,
const FcPattern *font);
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 */
FcPrivate FcCharSet *
FcCharSetPromote (FcValuePromotionBuffer *vbuf);
FcPrivate void
FcLangCharSetPopulate (void);
FcPrivate FcCharSetFreezer *
FcCharSetFreezerCreate (void);
FcPrivate const FcCharSet *
FcCharSetFreeze (FcCharSetFreezer *freezer, const FcCharSet *fcs);
FcPrivate void
FcCharSetFreezerDestroy (FcCharSetFreezer *freezer);
FcPrivate FcBool
FcNameUnparseCharSet (FcStrBuf *buf, const FcCharSet *c);
FcPrivate FcCharSet *
FcNameParseCharSet (FcChar8 *string);
FcPrivate FcBool
FcNameUnparseValue (FcStrBuf *buf,
FcValue *v0,
FcChar8 *escape);
FcPrivate FcBool
FcNameUnparseValueList (FcStrBuf *buf,
FcValueListPtr v,
FcChar8 *escape);
FcPrivate FcCharLeaf *
FcCharSetFindLeafCreate (FcCharSet *fcs, FcChar32 ucs4);
FcPrivate FcBool
FcCharSetSerializeAlloc(FcSerialize *serialize, const FcCharSet *cs);
FcPrivate FcCharSet *
FcCharSetSerialize(FcSerialize *serialize, const FcCharSet *cs);
FcPrivate FcChar16 *
FcCharSetGetNumbers(const FcCharSet *c);
/* fccompat.c */
FcPrivate int
FcOpen(const char *pathname, int flags, ...);
FcPrivate int
FcMakeTempfile (char *template);
FcPrivate int32_t
FcRandom (void);
FcPrivate FcBool
FcMakeDirectory (const FcChar8 *dir);
/* fcdbg.c */
FcPrivate void
FcValuePrintFile (FILE *f, const FcValue v);
FcPrivate void
FcValuePrintWithPosition (const FcValue v, FcBool show_pos_mark);
FcPrivate void
FcValueListPrintWithPosition (FcValueListPtr l, const FcValueListPtr pos);
FcPrivate void
FcValueListPrint (FcValueListPtr l);
FcPrivate void
FcLangSetPrint (const FcLangSet *ls);
FcPrivate void
FcOpPrint (FcOp op);
FcPrivate void
FcTestPrint (const FcTest *test);
FcPrivate void
FcExprPrint (const FcExpr *expr);
FcPrivate void
FcEditPrint (const FcEdit *edit);
FcPrivate void
FcSubstPrint (const FcSubst *subst);
FcPrivate void
FcCharSetPrint (const FcCharSet *c);
FcPrivate void
FcPatternPrint2 (FcPattern *p1, FcPattern *p2, const FcObjectSet *os);
extern FcPrivate int FcDebugVal;
#define FcDebug() (FcDebugVal)
FcPrivate void
FcInitDebug (void);
/* fcdefault.c */
FcPrivate FcChar8 *
FcGetDefaultLang (void);
FcPrivate FcChar8 *
FcGetPrgname (void);
FcPrivate void
FcDefaultFini (void);
/* fcdir.c */
FcPrivate FcBool
FcFileIsLink (const FcChar8 *file);
FcPrivate FcBool
FcFileIsFile (const FcChar8 *file);
FcPrivate FcBool
FcFileScanConfig (FcFontSet *set,
FcStrSet *dirs,
FcBlanks *blanks,
const FcChar8 *file,
FcConfig *config);
FcPrivate FcBool
FcDirScanConfig (FcFontSet *set,
FcStrSet *dirs,
FcBlanks *blanks,
const FcChar8 *dir,
FcBool force,
FcConfig *config,
FcBool scanOnly);
FcPrivate FcBool
FcDirScanOnly (FcStrSet *dirs,
const FcChar8 *dir,
FcConfig *config);
/* fcfont.c */
FcPrivate int
FcFontDebug (void);
/* fcfs.c */
FcPrivate FcBool
FcFontSetSerializeAlloc (FcSerialize *serialize, const FcFontSet *s);
FcPrivate FcFontSet *
FcFontSetSerialize (FcSerialize *serialize, const FcFontSet * s);
FcPrivate FcFontSet *
FcFontSetDeserialize (const FcFontSet *set);
/* fcinit.c */
FcPrivate FcConfig *
FcInitLoadOwnConfig (FcConfig *config);
FcPrivate FcConfig *
FcInitLoadOwnConfigAndFonts (FcConfig *config);
/* fcxml.c */
FcPrivate void
FcConfigPathFini (void);
FcPrivate void
FcTestDestroy (FcTest *test);
FcPrivate void
FcEditDestroy (FcEdit *e);
void
FcRuleDestroy (FcRule *rule);
/* fclang.c */
FcPrivate FcLangSet *
FcFreeTypeLangSet (const FcCharSet *charset,
const FcChar8 *exclusiveLang);
FcPrivate FcLangResult
FcLangCompare (const FcChar8 *s1, const FcChar8 *s2);
FcPrivate FcLangSet *
FcLangSetPromote (const FcChar8 *lang, FcValuePromotionBuffer *buf);
FcPrivate FcLangSet *
FcNameParseLangSet (const FcChar8 *string);
FcPrivate FcBool
FcNameUnparseLangSet (FcStrBuf *buf, const FcLangSet *ls);
FcPrivate FcChar8 *
FcNameUnparseEscaped (FcPattern *pat, FcBool escape);
/* fclist.c */
FcPrivate FcBool
FcListPatternMatchAny (const FcPattern *p,
const FcPattern *font);
/* fcmatch.c */
/* fcname.c */
enum {
FC_INVALID_OBJECT = 0,
#define FC_OBJECT(NAME, Type, Cmp) FC_##NAME##_OBJECT,
#include "fcobjs.h"
#undef FC_OBJECT
FC_ONE_AFTER_MAX_BASE_OBJECT
#define FC_MAX_BASE_OBJECT (FC_ONE_AFTER_MAX_BASE_OBJECT - 1)
};
FcPrivate FcBool
FcNameBool (const FcChar8 *v, FcBool *result);
FcPrivate FcBool
FcObjectValidType (FcObject object, FcType type);
FcPrivate FcObject
FcObjectFromName (const char * name);
FcPrivate const char *
FcObjectName (FcObject object);
FcPrivate FcObjectSet *
FcObjectGetSet (void);
#define FcObjectCompare(a, b) ((int) a - (int) b)
/* fcpat.c */
FcPrivate FcValue
FcValueCanonicalize (const FcValue *v);
FcPrivate FcValueListPtr
FcValueListCreate (void);
FcPrivate void
FcValueListDestroy (FcValueListPtr l);
FcPrivate FcValueListPtr
FcValueListPrepend (FcValueListPtr vallist,
FcValue value,
FcValueBinding binding);
FcPrivate FcValueListPtr
FcValueListAppend (FcValueListPtr vallist,
FcValue value,
FcValueBinding binding);
FcPrivate FcValueListPtr
FcValueListDuplicate(FcValueListPtr orig);
FcPrivate FcPatternElt *
FcPatternObjectFindElt (const FcPattern *p, FcObject object);
FcPrivate FcPatternElt *
FcPatternObjectInsertElt (FcPattern *p, FcObject object);
FcPrivate FcBool
FcPatternObjectListAdd (FcPattern *p,
FcObject object,
FcValueListPtr list,
FcBool append);
FcPrivate FcBool
FcPatternObjectAddWithBinding (FcPattern *p,
FcObject object,
FcValue value,
FcValueBinding binding,
FcBool append);
FcPrivate FcBool
FcPatternObjectAdd (FcPattern *p, FcObject object, FcValue value, FcBool append);
FcPrivate FcBool
FcPatternObjectAddWeak (FcPattern *p, FcObject object, FcValue value, FcBool append);
FcPrivate FcResult
FcPatternObjectGet (const FcPattern *p, FcObject object, int id, FcValue *v);
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);
FcPrivate FcBool
FcPatternObjectAddString (FcPattern *p, FcObject object, const FcChar8 *s);
FcPrivate FcBool
FcPatternObjectAddMatrix (FcPattern *p, FcObject object, const FcMatrix *s);
FcPrivate FcBool
FcPatternObjectAddCharSet (FcPattern *p, FcObject object, const FcCharSet *c);
FcPrivate FcBool
FcPatternObjectAddBool (FcPattern *p, FcObject object, FcBool b);
FcPrivate FcBool
FcPatternObjectAddLangSet (FcPattern *p, FcObject object, const FcLangSet *ls);
FcPrivate FcBool
FcPatternObjectAddRange (FcPattern *p, FcObject object, const FcRange *r);
FcPrivate FcResult
FcPatternObjectGetInteger (const FcPattern *p, FcObject object, int n, int *i);
FcPrivate FcResult
FcPatternObjectGetDouble (const FcPattern *p, FcObject object, int n, double *d);
FcPrivate FcResult
FcPatternObjectGetString (const FcPattern *p, FcObject object, int n, FcChar8 ** s);
FcPrivate FcResult
FcPatternObjectGetMatrix (const FcPattern *p, FcObject object, int n, FcMatrix **s);
FcPrivate FcResult
FcPatternObjectGetCharSet (const FcPattern *p, FcObject object, int n, FcCharSet **c);
FcPrivate FcResult
FcPatternObjectGetBool (const FcPattern *p, FcObject object, int n, FcBool *b);
FcPrivate FcResult
FcPatternObjectGetLangSet (const FcPattern *p, FcObject object, int n, FcLangSet **ls);
FcPrivate FcResult
FcPatternObjectGetRange (const FcPattern *p, FcObject object, int id, FcRange **r);
FcPrivate FcBool
FcPatternAppend (FcPattern *p, FcPattern *s);
FcPrivate int
FcPatternPosition (const FcPattern *p, const char *object);
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 FcPrivate const FcMatrix FcIdentityMatrix;
FcPrivate void
FcMatrixFree (FcMatrix *mat);
/* fcrange.c */
FcPrivate FcRange *
FcRangePromote (double v, FcValuePromotionBuffer *vbuf);
FcPrivate FcBool
FcRangeIsInRange (const FcRange *a, const FcRange *b);
FcPrivate FcBool
FcRangeCompare (FcOp op, const FcRange *a, const FcRange *b);
FcPrivate FcChar32
FcRangeHash (const FcRange *r);
FcPrivate FcBool
FcRangeSerializeAlloc (FcSerialize *serialize, const FcRange *r);
FcPrivate FcRange *
FcRangeSerialize (FcSerialize *serialize, const FcRange *r);
/* fcstat.c */
FcPrivate int
FcStat (const FcChar8 *file, struct stat *statb);
FcPrivate int
FcStatChecksum (const FcChar8 *file, struct stat *statb);
FcPrivate FcBool
FcIsFsMmapSafe (int fd);
FcPrivate FcBool
FcIsFsMtimeBroken (const FcChar8 *dir);
/* fcstr.c */
FcPrivate FcBool
FcStrSetAddLangs (FcStrSet *strs, const char *languages);
FcPrivate void
FcStrSetSort (FcStrSet * set);
FcPrivate void
FcStrBufInit (FcStrBuf *buf, FcChar8 *init, int size);
FcPrivate void
FcStrBufDestroy (FcStrBuf *buf);
FcPrivate FcChar8 *
FcStrBufDone (FcStrBuf *buf);
FcPrivate FcChar8 *
FcStrBufDoneStatic (FcStrBuf *buf);
FcPrivate FcBool
FcStrBufChar (FcStrBuf *buf, FcChar8 c);
FcPrivate FcBool
FcStrBufString (FcStrBuf *buf, const FcChar8 *s);
FcPrivate FcBool
FcStrBufData (FcStrBuf *buf, const FcChar8 *s, int len);
FcPrivate int
FcStrCmpIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2);
FcPrivate int
FcStrCmpIgnoreCaseAndDelims (const FcChar8 *s1, const FcChar8 *s2, const FcChar8 *delims);
FcPrivate const FcChar8 *
FcStrContainsIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2);
FcPrivate const FcChar8 *
FcStrContainsIgnoreCase (const FcChar8 *s1, const FcChar8 *s2);
FcPrivate const FcChar8 *
FcStrContainsWord (const FcChar8 *s1, const FcChar8 *s2);
FcPrivate int
FcStrMatchIgnoreCaseAndDelims (const FcChar8 *s1, const FcChar8 *s2, const FcChar8 *delims);
FcPrivate FcBool
FcStrGlobMatch (const FcChar8 *glob,
const FcChar8 *string);
FcPrivate FcBool
FcStrUsesHome (const FcChar8 *s);
FcPrivate FcChar8 *
FcStrBuildFilename (const FcChar8 *path,
...);
FcPrivate FcChar8 *
FcStrLastSlash (const FcChar8 *path);
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);
/* fcobjs.c */
FcPrivate void
FcObjectFini (void);
FcPrivate FcObject
FcObjectLookupIdByName (const char *str);
FcPrivate FcObject
FcObjectLookupBuiltinIdByName (const char *str);
FcPrivate const char *
FcObjectLookupOtherNameById (FcObject id);
FcPrivate const FcObjectType *
FcObjectLookupOtherTypeById (FcObject id);
FcPrivate const FcObjectType *
FcObjectLookupOtherTypeByName (const char *str);
#endif /* _FC_INT_H_ */
Reference in New Issue View Git Blame Copy Permalink