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