fcint.h revision 2c393a42 
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#ifdef HAVE_CONFIG_H
29#include <config.h>
30#endif
31
32#include <stdlib.h>
33#include <stdio.h>
34#ifdef HAVE_INTTYPES_H
35#include <inttypes.h>
36#elif defined(HAVE_STDINT_H)
37#include <stdint.h>
38#else
39#error missing C99 integer data types
40#endif
41#include <string.h>
42#include <ctype.h>
43#include <errno.h>
44#include <unistd.h>
45#include <stddef.h>
46#include <sys/types.h>
47#include <sys/stat.h>
48#include <time.h>
49#include <fontconfig/fontconfig.h>
50#include <fontconfig/fcprivate.h>
51#include "fcdeprecate.h"
52
53#ifndef FC_CONFIG_PATH
54#define FC_CONFIG_PATH "fonts.conf"
55#endif
56
57#ifdef _WIN32
58#define FC_SEARCH_PATH_SEPARATOR ';'
59#else
60#define FC_SEARCH_PATH_SEPARATOR ':'
61#endif
62
63#define FC_DBG_MATCH	1
64#define FC_DBG_MATCHV	2
65#define FC_DBG_EDIT	4
66#define FC_DBG_FONTSET	8
67#define FC_DBG_CACHE	16
68#define FC_DBG_CACHEV	32
69#define FC_DBG_PARSE	64
70#define FC_DBG_SCAN	128
71#define FC_DBG_SCANV	256
72#define FC_DBG_MEMORY	512
73#define FC_DBG_CONFIG	1024
74#define FC_DBG_LANGSET	2048
75#define FC_DBG_OBJTYPES	4096
76
77#define FC_MEM_CHARSET	    0
78#define FC_MEM_CHARLEAF	    1
79#define FC_MEM_FONTSET	    2
80#define FC_MEM_FONTPTR	    3
81#define FC_MEM_OBJECTSET    4
82#define FC_MEM_OBJECTPTR    5
83#define FC_MEM_MATRIX	    6
84#define FC_MEM_PATTERN	    7
85#define FC_MEM_PATELT	    8
86#define FC_MEM_VALLIST	    9
87#define FC_MEM_SUBSTATE	    10
88#define FC_MEM_STRING	    11
89#define FC_MEM_LISTBUCK	    12
90#define FC_MEM_STRSET	    13
91#define FC_MEM_STRLIST	    14
92#define FC_MEM_CONFIG	    15
93#define FC_MEM_LANGSET	    16
94#define FC_MEM_ATOMIC	    17
95#define FC_MEM_BLANKS	    18
96#define FC_MEM_CACHE	    19
97#define FC_MEM_STRBUF	    20
98#define FC_MEM_SUBST	    21
99#define FC_MEM_OBJECTTYPE   22
100#define FC_MEM_CONSTANT	    23
101#define FC_MEM_TEST	    24
102#define FC_MEM_EXPR	    25
103#define FC_MEM_VSTACK	    26
104#define FC_MEM_ATTR	    27
105#define FC_MEM_PSTACK	    28
106#define FC_MEM_STATICSTR    29
107
108#define FC_MEM_NUM	    30
109
110#define FC_BANK_DYNAMIC 0
111#define FC_BANK_FIRST 1
112#define FC_BANK_LANGS	    0xfcfcfcfc
113
114/* slim_internal.h */
115#if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)) && defined(__ELF__) && !defined(__sun)
116#define FcPrivate		__attribute__((__visibility__("hidden")))
117#define HAVE_GNUC_ATTRIBUTE 1
118#include "fcalias.h"
119#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550)
120#define FcPrivate		__hidden
121#else /* not gcc >= 3.3 and not Sun Studio >= 8 */
122#define FcPrivate
123#endif
124
125typedef enum _FcValueBinding {
126    FcValueBindingWeak, FcValueBindingStrong, FcValueBindingSame
127} FcValueBinding;
128
129/*
130 * Serialized data structures use only offsets instead of pointers
131 * A low bit of 1 indicates an offset.
132 */
133
134/* Is the provided pointer actually an offset? */
135#define FcIsEncodedOffset(p)	((((intptr_t) (p)) & 1) != 0)
136
137/* Encode offset in a pointer of type t */
138#define FcOffsetEncode(o,t)	((t *) ((o) | 1))
139
140/* Decode a pointer into an offset */
141#define FcOffsetDecode(p)	(((intptr_t) (p)) & ~1)
142
143/* Compute pointer offset */
144#define FcPtrToOffset(b,p)	((intptr_t) (p) - (intptr_t) (b))
145
146/* Given base address, offset and type, return a pointer */
147#define FcOffsetToPtr(b,o,t)	((t *) ((intptr_t) (b) + (o)))
148
149/* Given base address, encoded offset and type, return a pointer */
150#define FcEncodedOffsetToPtr(b,p,t) FcOffsetToPtr(b,FcOffsetDecode(p),t)
151
152/* Given base address, pointer and type, return an encoded offset */
153#define FcPtrToEncodedOffset(b,p,t) FcOffsetEncode(FcPtrToOffset(b,p),t)
154
155/* Given a structure, offset member and type, return pointer */
156#define FcOffsetMember(s,m,t)	    FcOffsetToPtr(s,(s)->m,t)
157
158/* Given a structure, encoded offset member and type, return pointer to member */
159#define FcEncodedOffsetMember(s,m,t) FcOffsetToPtr(s,FcOffsetDecode((s)->m), t)
160
161/* Given a structure, member and type, convert the member to a pointer */
162#define FcPointerMember(s,m,t)	(FcIsEncodedOffset((s)->m) ? \
163				 FcEncodedOffsetMember (s,m,t) : \
164				 (s)->m)
165
166/*
167 * Serialized values may hold strings, charsets and langsets as pointers,
168 * unfortunately FcValue is an exposed type so we can't just always use
169 * offsets
170 */
171#define FcValueString(v)	FcPointerMember(v,u.s,FcChar8)
172#define FcValueCharSet(v)	FcPointerMember(v,u.c,const FcCharSet)
173#define FcValueLangSet(v)	FcPointerMember(v,u.l,const FcLangSet)
174
175typedef struct _FcValueList *FcValueListPtr;
176
177typedef struct _FcValueList {
178    struct _FcValueList	*next;
179    FcValue		value;
180    FcValueBinding	binding;
181} FcValueList;
182
183#define FcValueListNext(vl)	FcPointerMember(vl,next,FcValueList)
184
185typedef int FcObject;
186
187typedef struct _FcPatternElt *FcPatternEltPtr;
188
189/*
190 * Pattern elts are stuck in a structure connected to the pattern,
191 * so they get moved around when the pattern is resized. Hence, the
192 * values field must be a pointer/offset instead of just an offset
193 */
194typedef struct _FcPatternElt {
195    FcObject		object;
196    FcValueList		*values;
197} FcPatternElt;
198
199#define FcPatternEltValues(pe)	FcPointerMember(pe,values,FcValueList)
200
201struct _FcPattern {
202    int		    num;
203    int		    size;
204    intptr_t	    elts_offset;
205    int		    ref;
206};
207
208#define FcPatternElts(p)	FcOffsetMember(p,elts_offset,FcPatternElt)
209
210#define FcFontSetFonts(fs)	FcPointerMember(fs,fonts,FcPattern *)
211
212#define FcFontSetFont(fs,i)	(FcIsEncodedOffset((fs)->fonts) ? \
213				 FcEncodedOffsetToPtr(fs, \
214						      FcFontSetFonts(fs)[i], \
215						      FcPattern) : \
216				 fs->fonts[i])
217
218typedef enum _FcOp {
219    FcOpInteger, FcOpDouble, FcOpString, FcOpMatrix, FcOpBool, FcOpCharSet,
220    FcOpNil,
221    FcOpField, FcOpConst,
222    FcOpAssign, FcOpAssignReplace,
223    FcOpPrependFirst, FcOpPrepend, FcOpAppend, FcOpAppendLast,
224    FcOpQuest,
225    FcOpOr, FcOpAnd, FcOpEqual, FcOpNotEqual,
226    FcOpContains, FcOpListing, FcOpNotContains,
227    FcOpLess, FcOpLessEqual, FcOpMore, FcOpMoreEqual,
228    FcOpPlus, FcOpMinus, FcOpTimes, FcOpDivide,
229    FcOpNot, FcOpComma, FcOpFloor, FcOpCeil, FcOpRound, FcOpTrunc,
230    FcOpInvalid
231} FcOp;
232
233typedef struct _FcExpr {
234    FcOp   op;
235    union {
236	int	    ival;
237	double	    dval;
238	FcChar8	    *sval;
239	FcMatrix    *mval;
240	FcBool	    bval;
241	FcCharSet   *cval;
242	FcObject    object;
243	FcChar8	    *constant;
244	struct {
245	    struct _FcExpr *left, *right;
246	} tree;
247    } u;
248} FcExpr;
249
250typedef enum _FcQual {
251    FcQualAny, FcQualAll, FcQualFirst, FcQualNotFirst
252} FcQual;
253
254#define FcMatchDefault	((FcMatchKind) -1)
255
256typedef struct _FcTest {
257    struct _FcTest	*next;
258    FcMatchKind		kind;
259    FcQual		qual;
260    FcObject		object;
261    FcOp		op;
262    FcExpr		*expr;
263} FcTest;
264
265typedef struct _FcEdit {
266    struct _FcEdit *next;
267    FcObject	    object;
268    FcOp	    op;
269    FcExpr	    *expr;
270    FcValueBinding  binding;
271} FcEdit;
272
273typedef struct _FcSubst {
274    struct _FcSubst	*next;
275    FcTest		*test;
276    FcEdit		*edit;
277} FcSubst;
278
279typedef struct _FcCharLeaf {
280    FcChar32	map[256/32];
281} FcCharLeaf;
282
283#define FC_REF_CONSTANT	    -1
284
285struct _FcCharSet {
286    int		    ref;	/* reference count */
287    int		    num;	/* size of leaves and numbers arrays */
288    intptr_t	    leaves_offset;
289    intptr_t	    numbers_offset;
290};
291
292#define FcCharSetLeaves(c)	FcOffsetMember(c,leaves_offset,intptr_t)
293#define FcCharSetLeaf(c,i)	(FcOffsetToPtr(FcCharSetLeaves(c), \
294					       FcCharSetLeaves(c)[i], \
295					       FcCharLeaf))
296#define FcCharSetNumbers(c)	FcOffsetMember(c,numbers_offset,FcChar16)
297
298struct _FcStrSet {
299    int		    ref;	/* reference count */
300    int		    num;
301    int		    size;
302    FcChar8	    **strs;
303};
304
305struct _FcStrList {
306    FcStrSet	    *set;
307    int		    n;
308};
309
310typedef struct _FcStrBuf {
311    FcChar8 *buf;
312    FcBool  allocated;
313    FcBool  failed;
314    int	    len;
315    int	    size;
316} FcStrBuf;
317
318struct _FcCache {
319    int		magic;              /* FC_CACHE_MAGIC_MMAP or FC_CACHE_ALLOC */
320    int		version;	    /* FC_CACHE_CONTENT_VERSION */
321    intptr_t	size;		    /* size of file */
322    intptr_t	dir;		    /* offset to dir name */
323    intptr_t	dirs;		    /* offset to subdirs */
324    int		dirs_count;	    /* number of subdir strings */
325    intptr_t	set;		    /* offset to font set */
326    int		mtime;		    /* low bits of directory mtime */
327};
328
329#undef FcCacheDir
330#undef FcCacheSubdir
331#define FcCacheDir(c)	FcOffsetMember(c,dir,FcChar8)
332#define FcCacheDirs(c)	FcOffsetMember(c,dirs,intptr_t)
333#define FcCacheSet(c)	FcOffsetMember(c,set,FcFontSet)
334#define FcCacheSubdir(c,i)  FcOffsetToPtr (FcCacheDirs(c),\
335					   FcCacheDirs(c)[i], \
336					   FcChar8)
337
338/*
339 * Used while constructing a directory cache object
340 */
341
342#define FC_SERIALIZE_HASH_SIZE	8191
343
344typedef struct _FcSerializeBucket {
345    struct _FcSerializeBucket *next;
346    const void	*object;
347    intptr_t	offset;
348} FcSerializeBucket;
349
350typedef struct _FcCharSetFreezer FcCharSetFreezer;
351
352typedef struct _FcSerialize {
353    intptr_t		size;
354    FcCharSetFreezer	*cs_freezer;
355    void		*linear;
356    FcSerializeBucket	*buckets[FC_SERIALIZE_HASH_SIZE];
357} FcSerialize;
358
359/*
360 * To map adobe glyph names to unicode values, a precomputed hash
361 * table is used
362 */
363
364typedef struct _FcGlyphName {
365    FcChar32	ucs;		/* unicode value */
366    FcChar8	name[1];	/* name extends beyond struct */
367} FcGlyphName;
368
369/*
370 * To perform case-insensitive string comparisons, a table
371 * is used which holds three different kinds of folding data.
372 *
373 * The first is a range of upper case values mapping to a range
374 * of their lower case equivalents.  Within each range, the offset
375 * between upper and lower case is constant.
376 *
377 * The second is a range of upper case values which are interleaved
378 * with their lower case equivalents.
379 *
380 * The third is a set of raw unicode values mapping to a list
381 * of unicode values for comparison purposes.  This allows conversion
382 * of ß to "ss" so that SS, ss and ß all match.  A separate array
383 * holds the list of unicode values for each entry.
384 *
385 * These are packed into a single table.  Using a binary search,
386 * the appropriate entry can be located.
387 */
388
389#define FC_CASE_FOLD_RANGE	    0
390#define FC_CASE_FOLD_EVEN_ODD	    1
391#define FC_CASE_FOLD_FULL	    2
392
393typedef struct _FcCaseFold {
394    FcChar32	upper;
395    FcChar16	method : 2;
396    FcChar16	count : 14;
397    short    	offset;	    /* lower - upper for RANGE, table id for FULL */
398} FcCaseFold;
399
400#define FC_MAX_FILE_LEN	    4096
401
402/* XXX remove these when we're ready */
403
404#define fc_value_string(v)	FcValueString(v)
405#define fc_value_charset(v)	FcValueCharSet(v)
406#define fc_value_langset(v)	FcValueLangSet(v)
407#define fc_storage_type(v)	((v)->type)
408
409#define fc_alignof(type) offsetof (struct { char c; type member; }, member)
410
411#define FC_CACHE_MAGIC_MMAP	    0xFC02FC04
412#define FC_CACHE_MAGIC_ALLOC	    0xFC02FC05
413#define FC_CACHE_CONTENT_VERSION    2
414
415struct _FcAtomic {
416    FcChar8	*file;		/* original file name */
417    FcChar8	*new;		/* temp file name -- write data here */
418    FcChar8	*lck;		/* lockfile name (used for locking) */
419    FcChar8	*tmp;		/* tmpfile name (used for locking) */
420};
421
422struct _FcBlanks {
423    int		nblank;
424    int		sblank;
425    FcChar32	*blanks;
426};
427
428struct _FcConfig {
429    /*
430     * File names loaded from the configuration -- saved here as the
431     * cache file must be consulted before the directories are scanned,
432     * and those directives may occur in any order
433     */
434    FcStrSet	*configDirs;	    /* directories to scan for fonts */
435    /*
436     * Set of allowed blank chars -- used to
437     * trim fonts of bogus glyphs
438     */
439    FcBlanks	*blanks;
440    /*
441     * List of directories containing fonts,
442     * built by recursively scanning the set
443     * of configured directories
444     */
445    FcStrSet	*fontDirs;
446    /*
447     * List of directories containing cache files.
448     */
449    FcStrSet	*cacheDirs;
450    /*
451     * Names of all of the configuration files used
452     * to create this configuration
453     */
454    FcStrSet	*configFiles;	    /* config files loaded */
455    /*
456     * Substitution instructions for patterns and fonts;
457     * maxObjects is used to allocate appropriate intermediate storage
458     * while performing a whole set of substitutions
459     */
460    FcSubst	*substPattern;	    /* substitutions for patterns */
461    FcSubst	*substFont;	    /* substitutions for fonts */
462    FcSubst	*substScan;	    /* substitutions for scanned fonts */
463    int		maxObjects;	    /* maximum number of tests in all substs */
464    /*
465     * List of patterns used to control font file selection
466     */
467    FcStrSet	*acceptGlobs;
468    FcStrSet	*rejectGlobs;
469    FcFontSet	*acceptPatterns;
470    FcFontSet	*rejectPatterns;
471    /*
472     * The set of fonts loaded from the listed directories; the
473     * order within the set does not determine the font selection,
474     * except in the case of identical matches in which case earlier fonts
475     * match preferrentially
476     */
477    FcFontSet	*fonts[FcSetApplication + 1];
478    /*
479     * Fontconfig can periodically rescan the system configuration
480     * and font directories.  This rescanning occurs when font
481     * listing requests are made, but no more often than rescanInterval
482     * seconds apart.
483     */
484    time_t	rescanTime;	    /* last time information was scanned */
485    int		rescanInterval;	    /* interval between scans */
486};
487
488extern FcPrivate FcConfig	*_fcConfig;
489
490typedef struct _FcFileTime {
491    time_t  time;
492    FcBool  set;
493} FcFileTime;
494
495typedef struct _FcCharMap FcCharMap;
496
497/* watch out; assumes that v is void * -PL */
498#define ALIGN(v,type) ((void *)(((uintptr_t)(v) + fc_alignof(type) - 1) & ~(fc_alignof(type) - 1)))
499
500/* fcblanks.c */
501
502/* fccache.c */
503
504FcPrivate FcCache *
505FcDirCacheScan (const FcChar8 *dir, FcConfig *config);
506
507FcPrivate FcCache *
508FcDirCacheBuild (FcFontSet *set, const FcChar8 *dir, struct stat *dir_stat, FcStrSet *dirs);
509
510FcPrivate FcBool
511FcDirCacheWrite (FcCache *cache, FcConfig *config);
512
513FcPrivate void
514FcCacheObjectReference (void *object);
515
516FcPrivate void
517FcCacheObjectDereference (void *object);
518
519FcPrivate void
520FcCacheFini (void);
521
522FcPrivate void
523FcDirCacheReference (FcCache *cache, int nref);
524
525/* fccfg.c */
526
527FcPrivate FcBool
528FcConfigAddConfigDir (FcConfig	    *config,
529		      const FcChar8 *d);
530
531FcPrivate FcBool
532FcConfigAddFontDir (FcConfig	    *config,
533		    const FcChar8   *d);
534
535FcPrivate FcBool
536FcConfigAddDir (FcConfig	*config,
537		const FcChar8	*d);
538
539FcPrivate FcBool
540FcConfigAddCacheDir (FcConfig	    *config,
541		     const FcChar8  *d);
542
543FcPrivate FcBool
544FcConfigAddConfigFile (FcConfig		*config,
545		       const FcChar8	*f);
546
547FcPrivate FcBool
548FcConfigAddBlank (FcConfig	*config,
549		  FcChar32    	blank);
550
551FcPrivate FcBool
552FcConfigAddEdit (FcConfig	*config,
553		 FcTest		*test,
554		 FcEdit		*edit,
555		 FcMatchKind	kind);
556
557FcPrivate void
558FcConfigSetFonts (FcConfig	*config,
559		  FcFontSet	*fonts,
560		  FcSetName	set);
561
562FcPrivate FcBool
563FcConfigCompareValue (const FcValue *m,
564		      FcOp	    op,
565		      const FcValue *v);
566
567FcPrivate FcBool
568FcConfigGlobAdd (FcConfig	*config,
569		 const FcChar8	*glob,
570		 FcBool		accept);
571
572FcPrivate FcBool
573FcConfigAcceptFilename (FcConfig	*config,
574			const FcChar8	*filename);
575
576FcPrivate FcBool
577FcConfigPatternsAdd (FcConfig	*config,
578		     FcPattern	*pattern,
579		     FcBool	accept);
580
581FcPrivate FcBool
582FcConfigAcceptFont (FcConfig	    *config,
583		    const FcPattern *font);
584
585FcPrivate FcFileTime
586FcConfigModifiedTime (FcConfig *config);
587
588FcPrivate FcBool
589FcConfigAddCache (FcConfig *config, FcCache *cache,
590		  FcSetName set, FcStrSet *dirSet);
591
592/* fcserialize.c */
593FcPrivate intptr_t
594FcAlignSize (intptr_t size);
595
596FcPrivate FcSerialize *
597FcSerializeCreate (void);
598
599FcPrivate void
600FcSerializeDestroy (FcSerialize *serialize);
601
602FcPrivate FcBool
603FcSerializeAlloc (FcSerialize *serialize, const void *object, int size);
604
605FcPrivate intptr_t
606FcSerializeReserve (FcSerialize *serialize, int size);
607
608FcPrivate intptr_t
609FcSerializeOffset (FcSerialize *serialize, const void *object);
610
611FcPrivate void *
612FcSerializePtr (FcSerialize *serialize, const void *object);
613
614FcPrivate FcBool
615FcLangSetSerializeAlloc (FcSerialize *serialize, const FcLangSet *l);
616
617FcPrivate FcLangSet *
618FcLangSetSerialize(FcSerialize *serialize, const FcLangSet *l);
619
620/* fccharset.c */
621FcPrivate void
622FcLangCharSetPopulate (void);
623
624FcPrivate FcCharSetFreezer *
625FcCharSetFreezerCreate (void);
626
627FcPrivate const FcCharSet *
628FcCharSetFreeze (FcCharSetFreezer *freezer, const FcCharSet *fcs);
629
630FcPrivate void
631FcCharSetFreezerDestroy (FcCharSetFreezer *freezer);
632
633FcPrivate FcBool
634FcNameUnparseCharSet (FcStrBuf *buf, const FcCharSet *c);
635
636FcPrivate FcCharSet *
637FcNameParseCharSet (FcChar8 *string);
638
639FcPrivate FcCharLeaf *
640FcCharSetFindLeafCreate (FcCharSet *fcs, FcChar32 ucs4);
641
642FcPrivate FcBool
643FcCharSetSerializeAlloc(FcSerialize *serialize, const FcCharSet *cs);
644
645FcPrivate FcCharSet *
646FcCharSetSerialize(FcSerialize *serialize, const FcCharSet *cs);
647
648FcPrivate FcChar16 *
649FcCharSetGetNumbers(const FcCharSet *c);
650
651/* fcdbg.c */
652FcPrivate void
653FcValueListPrint (const FcValueListPtr l);
654
655FcPrivate void
656FcLangSetPrint (const FcLangSet *ls);
657
658FcPrivate void
659FcOpPrint (FcOp op);
660
661FcPrivate void
662FcTestPrint (const FcTest *test);
663
664FcPrivate void
665FcExprPrint (const FcExpr *expr);
666
667FcPrivate void
668FcEditPrint (const FcEdit *edit);
669
670FcPrivate void
671FcSubstPrint (const FcSubst *subst);
672
673FcPrivate void
674FcCharSetPrint (const FcCharSet *c);
675
676extern FcPrivate int FcDebugVal;
677
678#define FcDebug() (FcDebugVal)
679
680FcPrivate void
681FcInitDebug (void);
682
683/* fcdefault.c */
684FcPrivate FcChar8 *
685FcGetDefaultLang (void);
686
687/* fcdir.c */
688
689FcPrivate FcBool
690FcFileScanConfig (FcFontSet	*set,
691		  FcStrSet	*dirs,
692		  FcBlanks	*blanks,
693		  const FcChar8 *file,
694		  FcConfig	*config);
695
696FcPrivate FcBool
697FcDirScanConfig (FcFontSet	*set,
698		 FcStrSet	*dirs,
699		 FcBlanks	*blanks,
700		 const FcChar8	*dir,
701		 FcBool		force,
702		 FcConfig	*config);
703
704/* fcfont.c */
705FcPrivate int
706FcFontDebug (void);
707
708/* fcfs.c */
709
710FcPrivate FcBool
711FcFontSetSerializeAlloc (FcSerialize *serialize, const FcFontSet *s);
712
713FcPrivate FcFontSet *
714FcFontSetSerialize (FcSerialize *serialize, const FcFontSet * s);
715
716/* fcgram.y */
717FcPrivate int
718FcConfigparse (void);
719
720FcPrivate int
721FcConfigwrap (void);
722
723FcPrivate void
724FcConfigerror (char *fmt, ...);
725
726FcPrivate char *
727FcConfigSaveField (const char *field);
728
729FcPrivate void
730FcTestDestroy (FcTest *test);
731
732FcPrivate FcExpr *
733FcExprCreateInteger (int i);
734
735FcPrivate FcExpr *
736FcExprCreateDouble (double d);
737
738FcPrivate FcExpr *
739FcExprCreateString (const FcChar8 *s);
740
741FcPrivate FcExpr *
742FcExprCreateMatrix (const FcMatrix *m);
743
744FcPrivate FcExpr *
745FcExprCreateBool (FcBool b);
746
747FcPrivate FcExpr *
748FcExprCreateNil (void);
749
750FcPrivate FcExpr *
751FcExprCreateField (const char *field);
752
753FcPrivate FcExpr *
754FcExprCreateConst (const FcChar8 *constant);
755
756FcPrivate FcExpr *
757FcExprCreateOp (FcExpr *left, FcOp op, FcExpr *right);
758
759FcPrivate void
760FcExprDestroy (FcExpr *e);
761
762FcPrivate void
763FcEditDestroy (FcEdit *e);
764
765/* fcinit.c */
766
767FcPrivate void
768FcMemReport (void);
769
770FcPrivate void
771FcMemAlloc (int kind, int size);
772
773FcPrivate void
774FcMemFree (int kind, int size);
775
776/* fclang.c */
777FcPrivate FcLangSet *
778FcFreeTypeLangSet (const FcCharSet  *charset,
779		   const FcChar8    *exclusiveLang);
780
781FcPrivate FcLangResult
782FcLangCompare (const FcChar8 *s1, const FcChar8 *s2);
783
784FcPrivate FcLangSet *
785FcLangSetPromote (const FcChar8 *lang);
786
787FcPrivate FcLangSet *
788FcNameParseLangSet (const FcChar8 *string);
789
790FcPrivate FcBool
791FcNameUnparseLangSet (FcStrBuf *buf, const FcLangSet *ls);
792
793FcPrivate FcChar8 *
794FcNameUnparseEscaped (FcPattern *pat, FcBool escape);
795
796/* fclist.c */
797
798FcPrivate FcBool
799FcListPatternMatchAny (const FcPattern *p,
800		       const FcPattern *font);
801
802/* fcmatch.c */
803
804/* fcname.c */
805
806/*
807 * NOTE -- this ordering is part of the cache file format.
808 * It must also match the ordering in fcname.c
809 */
810
811#define FC_FAMILY_OBJECT	1
812#define FC_FAMILYLANG_OBJECT	2
813#define FC_STYLE_OBJECT		3
814#define FC_STYLELANG_OBJECT	4
815#define FC_FULLNAME_OBJECT	5
816#define FC_FULLNAMELANG_OBJECT	6
817#define FC_SLANT_OBJECT		7
818#define FC_WEIGHT_OBJECT	8
819#define FC_WIDTH_OBJECT		9
820#define FC_SIZE_OBJECT		10
821#define FC_ASPECT_OBJECT	11
822#define FC_PIXEL_SIZE_OBJECT	12
823#define FC_SPACING_OBJECT	13
824#define FC_FOUNDRY_OBJECT	14
825#define FC_ANTIALIAS_OBJECT	15
826#define FC_HINT_STYLE_OBJECT	16
827#define FC_HINTING_OBJECT	17
828#define FC_VERTICAL_LAYOUT_OBJECT	18
829#define FC_AUTOHINT_OBJECT	19
830#define FC_GLOBAL_ADVANCE_OBJECT	20
831#define FC_FILE_OBJECT		21
832#define FC_INDEX_OBJECT		22
833#define FC_RASTERIZER_OBJECT	23
834#define FC_OUTLINE_OBJECT	24
835#define FC_SCALABLE_OBJECT	25
836#define FC_DPI_OBJECT		26
837#define FC_RGBA_OBJECT		27
838#define FC_SCALE_OBJECT		28
839#define FC_MINSPACE_OBJECT	29
840#define FC_CHAR_WIDTH_OBJECT	30
841#define FC_CHAR_HEIGHT_OBJECT	31
842#define FC_MATRIX_OBJECT	32
843#define FC_CHARSET_OBJECT	33
844#define FC_LANG_OBJECT		34
845#define FC_FONTVERSION_OBJECT	35
846#define FC_CAPABILITY_OBJECT	36
847#define FC_FONTFORMAT_OBJECT	37
848#define FC_EMBOLDEN_OBJECT	38
849#define FC_EMBEDDED_BITMAP_OBJECT	39
850#define FC_DECORATIVE_OBJECT	40
851#define FC_LCD_FILTER_OBJECT	41
852#define FC_MAX_BASE_OBJECT	FC_LCD_FILTER_OBJECT
853
854FcPrivate FcBool
855FcNameBool (const FcChar8 *v, FcBool *result);
856
857FcPrivate FcBool
858FcObjectValidType (FcObject object, FcType type);
859
860FcPrivate FcObject
861FcObjectFromName (const char * name);
862
863FcPrivate const char *
864FcObjectName (FcObject object);
865
866FcPrivate FcBool
867FcObjectInit (void);
868
869FcPrivate void
870FcObjectFini (void);
871
872#define FcObjectCompare(a, b)	((int) a - (int) b)
873
874/* fcpat.c */
875
876FcPrivate FcValue
877FcValueCanonicalize (const FcValue *v);
878
879FcPrivate void
880FcValueListDestroy (FcValueListPtr l);
881
882FcPrivate FcPatternElt *
883FcPatternObjectFindElt (const FcPattern *p, FcObject object);
884
885FcPrivate FcPatternElt *
886FcPatternObjectInsertElt (FcPattern *p, FcObject object);
887
888FcPrivate FcBool
889FcPatternObjectAddWithBinding  (FcPattern	*p,
890				FcObject	object,
891				FcValue		value,
892				FcValueBinding  binding,
893				FcBool		append);
894
895FcPrivate FcBool
896FcPatternObjectAdd (FcPattern *p, FcObject object, FcValue value, FcBool append);
897
898FcPrivate FcBool
899FcPatternObjectAddWeak (FcPattern *p, FcObject object, FcValue value, FcBool append);
900
901FcPrivate FcResult
902FcPatternObjectGet (const FcPattern *p, FcObject object, int id, FcValue *v);
903
904FcPrivate FcBool
905FcPatternObjectDel (FcPattern *p, FcObject object);
906
907FcPrivate FcBool
908FcPatternObjectRemove (FcPattern *p, FcObject object, int id);
909
910FcPrivate FcBool
911FcPatternObjectAddInteger (FcPattern *p, FcObject object, int i);
912
913FcPrivate FcBool
914FcPatternObjectAddDouble (FcPattern *p, FcObject object, double d);
915
916FcPrivate FcBool
917FcPatternObjectAddString (FcPattern *p, FcObject object, const FcChar8 *s);
918
919FcPrivate FcBool
920FcPatternObjectAddMatrix (FcPattern *p, FcObject object, const FcMatrix *s);
921
922FcPrivate FcBool
923FcPatternObjectAddCharSet (FcPattern *p, FcObject object, const FcCharSet *c);
924
925FcPrivate FcBool
926FcPatternObjectAddBool (FcPattern *p, FcObject object, FcBool b);
927
928FcPrivate FcBool
929FcPatternObjectAddLangSet (FcPattern *p, FcObject object, const FcLangSet *ls);
930
931FcPrivate FcResult
932FcPatternObjectGetInteger (const FcPattern *p, FcObject object, int n, int *i);
933
934FcPrivate FcResult
935FcPatternObjectGetDouble (const FcPattern *p, FcObject object, int n, double *d);
936
937FcPrivate FcResult
938FcPatternObjectGetString (const FcPattern *p, FcObject object, int n, FcChar8 ** s);
939
940FcPrivate FcResult
941FcPatternObjectGetMatrix (const FcPattern *p, FcObject object, int n, FcMatrix **s);
942
943FcPrivate FcResult
944FcPatternObjectGetCharSet (const FcPattern *p, FcObject object, int n, FcCharSet **c);
945
946FcPrivate FcResult
947FcPatternObjectGetBool (const FcPattern *p, FcObject object, int n, FcBool *b);
948
949FcPrivate FcResult
950FcPatternObjectGetLangSet (const FcPattern *p, FcObject object, int n, FcLangSet **ls);
951
952FcPrivate void
953FcPatternFini (void);
954
955FcPrivate FcBool
956FcPatternAppend (FcPattern *p, FcPattern *s);
957
958FcPrivate const FcChar8 *
959FcStrStaticName (const FcChar8 *name);
960
961FcPrivate FcChar32
962FcStringHash (const FcChar8 *s);
963
964FcPrivate FcBool
965FcPatternSerializeAlloc (FcSerialize *serialize, const FcPattern *pat);
966
967FcPrivate FcPattern *
968FcPatternSerialize (FcSerialize *serialize, const FcPattern *pat);
969
970FcPrivate FcBool
971FcValueListSerializeAlloc (FcSerialize *serialize, const FcValueList *pat);
972
973FcPrivate FcValueList *
974FcValueListSerialize (FcSerialize *serialize, const FcValueList *pat);
975
976/* fcrender.c */
977
978/* fcmatrix.c */
979
980extern FcPrivate const FcMatrix    FcIdentityMatrix;
981
982FcPrivate void
983FcMatrixFree (FcMatrix *mat);
984
985/* fcstr.c */
986FcPrivate void
987FcStrSetSort (FcStrSet * set);
988
989FcPrivate void
990FcStrBufInit (FcStrBuf *buf, FcChar8 *init, int size);
991
992FcPrivate void
993FcStrBufDestroy (FcStrBuf *buf);
994
995FcPrivate FcChar8 *
996FcStrBufDone (FcStrBuf *buf);
997
998FcPrivate FcBool
999FcStrBufChar (FcStrBuf *buf, FcChar8 c);
1000
1001FcPrivate FcBool
1002FcStrBufString (FcStrBuf *buf, const FcChar8 *s);
1003
1004FcPrivate FcBool
1005FcStrBufData (FcStrBuf *buf, const FcChar8 *s, int len);
1006
1007FcPrivate int
1008FcStrCmpIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2);
1009
1010FcPrivate const FcChar8 *
1011FcStrContainsIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2);
1012
1013FcPrivate const FcChar8 *
1014FcStrContainsIgnoreCase (const FcChar8 *s1, const FcChar8 *s2);
1015
1016FcPrivate const FcChar8 *
1017FcStrContainsWord (const FcChar8 *s1, const FcChar8 *s2);
1018
1019FcPrivate FcBool
1020FcStrUsesHome (const FcChar8 *s);
1021
1022FcPrivate FcChar8 *
1023FcStrLastSlash (const FcChar8  *path);
1024
1025FcPrivate FcChar32
1026FcStrHashIgnoreCase (const FcChar8 *s);
1027
1028FcPrivate FcChar8 *
1029FcStrCanonFilename (const FcChar8 *s);
1030
1031FcPrivate FcBool
1032FcStrSerializeAlloc (FcSerialize *serialize, const FcChar8 *str);
1033
1034FcPrivate FcChar8 *
1035FcStrSerialize (FcSerialize *serialize, const FcChar8 *str);
1036
1037#endif /* _FC_INT_H_ */
1038