]> git.wh0rd.org - fontconfig.git/blob - src/fcint.h
2bc7878c1ab652dd35ce10679dd063b73479791c
[fontconfig.git] / src / fcint.h
1 /*
2 * fontconfig/src/fcint.h
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 the author(s) not be used in
11 * advertising or publicity pertaining to distribution of the software without
12 * specific, written prior permission. The authors make 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 * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
17 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
18 * EVENT SHALL THE AUTHOR(S) 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_MIN(a,b) ((a) < (b) ? (a) : (b))
111 #define FC_MAX(a,b) ((a) > (b) ? (a) : (b))
112 #define FC_ABS(a) ((a) < 0 ? -(a) : (a))
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
125 typedef 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
175 typedef struct _FcValueList *FcValueListPtr;
176
177 typedef struct _FcValueList {
178 struct _FcValueList *next;
179 FcValue value;
180 FcValueBinding binding;
181 } FcValueList;
182
183 #define FcValueListNext(vl) FcPointerMember(vl,next,FcValueList)
184
185 typedef int FcObject;
186
187 typedef 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 */
194 typedef struct _FcPatternElt {
195 FcObject object;
196 FcValueList *values;
197 } FcPatternElt;
198
199 #define FcPatternEltValues(pe) FcPointerMember(pe,values,FcValueList)
200
201 struct _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
218 typedef 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
233 typedef 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
250 typedef struct _FcExprPage FcExprPage;
251
252 struct _FcExprPage {
253 FcExprPage *next_page;
254 FcExpr *next;
255 FcExpr exprs[(1024 - 2/* two pointers */ - 2/* malloc overhead */) * sizeof (void *) / sizeof (FcExpr)];
256 FcExpr end[];
257 };
258
259 typedef enum _FcQual {
260 FcQualAny, FcQualAll, FcQualFirst, FcQualNotFirst
261 } FcQual;
262
263 #define FcMatchDefault ((FcMatchKind) -1)
264
265 typedef struct _FcTest {
266 struct _FcTest *next;
267 FcMatchKind kind;
268 FcQual qual;
269 FcObject object;
270 FcOp op;
271 FcExpr *expr;
272 } FcTest;
273
274 typedef struct _FcEdit {
275 struct _FcEdit *next;
276 FcObject object;
277 FcOp op;
278 FcExpr *expr;
279 FcValueBinding binding;
280 } FcEdit;
281
282 typedef struct _FcSubst {
283 struct _FcSubst *next;
284 FcTest *test;
285 FcEdit *edit;
286 } FcSubst;
287
288 typedef struct _FcCharLeaf {
289 FcChar32 map[256/32];
290 } FcCharLeaf;
291
292 #define FC_REF_CONSTANT -1
293
294 struct _FcCharSet {
295 int ref; /* reference count */
296 int num; /* size of leaves and numbers arrays */
297 intptr_t leaves_offset;
298 intptr_t numbers_offset;
299 };
300
301 #define FcCharSetLeaves(c) FcOffsetMember(c,leaves_offset,intptr_t)
302 #define FcCharSetLeaf(c,i) (FcOffsetToPtr(FcCharSetLeaves(c), \
303 FcCharSetLeaves(c)[i], \
304 FcCharLeaf))
305 #define FcCharSetNumbers(c) FcOffsetMember(c,numbers_offset,FcChar16)
306
307 struct _FcStrSet {
308 int ref; /* reference count */
309 int num;
310 int size;
311 FcChar8 **strs;
312 };
313
314 struct _FcStrList {
315 FcStrSet *set;
316 int n;
317 };
318
319 typedef struct _FcStrBuf {
320 FcChar8 *buf;
321 FcBool allocated;
322 FcBool failed;
323 int len;
324 int size;
325 FcChar8 buf_static[16 * sizeof (void *)];
326 } FcStrBuf;
327
328 struct _FcCache {
329 int magic; /* FC_CACHE_MAGIC_MMAP or FC_CACHE_ALLOC */
330 int version; /* FC_CACHE_CONTENT_VERSION */
331 intptr_t size; /* size of file */
332 intptr_t dir; /* offset to dir name */
333 intptr_t dirs; /* offset to subdirs */
334 int dirs_count; /* number of subdir strings */
335 intptr_t set; /* offset to font set */
336 int mtime; /* low bits of directory mtime */
337 };
338
339 #undef FcCacheDir
340 #undef FcCacheSubdir
341 #define FcCacheDir(c) FcOffsetMember(c,dir,FcChar8)
342 #define FcCacheDirs(c) FcOffsetMember(c,dirs,intptr_t)
343 #define FcCacheSet(c) FcOffsetMember(c,set,FcFontSet)
344 #define FcCacheSubdir(c,i) FcOffsetToPtr (FcCacheDirs(c),\
345 FcCacheDirs(c)[i], \
346 FcChar8)
347
348 /*
349 * Used while constructing a directory cache object
350 */
351
352 #define FC_SERIALIZE_HASH_SIZE 8191
353
354 typedef union _FcAlign {
355 double d;
356 int i;
357 intptr_t ip;
358 FcBool b;
359 void *p;
360 } FcAlign;
361
362 typedef struct _FcSerializeBucket {
363 struct _FcSerializeBucket *next;
364 const void *object;
365 intptr_t offset;
366 } FcSerializeBucket;
367
368 typedef struct _FcCharSetFreezer FcCharSetFreezer;
369
370 typedef struct _FcSerialize {
371 intptr_t size;
372 FcCharSetFreezer *cs_freezer;
373 void *linear;
374 FcSerializeBucket *buckets[FC_SERIALIZE_HASH_SIZE];
375 } FcSerialize;
376
377 /*
378 * To map adobe glyph names to unicode values, a precomputed hash
379 * table is used
380 */
381
382 typedef struct _FcGlyphName {
383 FcChar32 ucs; /* unicode value */
384 FcChar8 name[1]; /* name extends beyond struct */
385 } FcGlyphName;
386
387 /*
388 * To perform case-insensitive string comparisons, a table
389 * is used which holds three different kinds of folding data.
390 *
391 * The first is a range of upper case values mapping to a range
392 * of their lower case equivalents. Within each range, the offset
393 * between upper and lower case is constant.
394 *
395 * The second is a range of upper case values which are interleaved
396 * with their lower case equivalents.
397 *
398 * The third is a set of raw unicode values mapping to a list
399 * of unicode values for comparison purposes. This allows conversion
400 * of ß to "ss" so that SS, ss and ß all match. A separate array
401 * holds the list of unicode values for each entry.
402 *
403 * These are packed into a single table. Using a binary search,
404 * the appropriate entry can be located.
405 */
406
407 #define FC_CASE_FOLD_RANGE 0
408 #define FC_CASE_FOLD_EVEN_ODD 1
409 #define FC_CASE_FOLD_FULL 2
410
411 typedef struct _FcCaseFold {
412 FcChar32 upper;
413 FcChar16 method : 2;
414 FcChar16 count : 14;
415 short offset; /* lower - upper for RANGE, table id for FULL */
416 } FcCaseFold;
417
418 #define FC_MAX_FILE_LEN 4096
419
420 #define FC_CACHE_MAGIC_MMAP 0xFC02FC04
421 #define FC_CACHE_MAGIC_ALLOC 0xFC02FC05
422 #define FC_CACHE_CONTENT_VERSION 3 /* also check FC_CACHE_VERSION */
423
424 struct _FcAtomic {
425 FcChar8 *file; /* original file name */
426 FcChar8 *new; /* temp file name -- write data here */
427 FcChar8 *lck; /* lockfile name (used for locking) */
428 FcChar8 *tmp; /* tmpfile name (used for locking) */
429 };
430
431 struct _FcBlanks {
432 int nblank;
433 int sblank;
434 FcChar32 *blanks;
435 };
436
437 struct _FcConfig {
438 /*
439 * File names loaded from the configuration -- saved here as the
440 * cache file must be consulted before the directories are scanned,
441 * and those directives may occur in any order
442 */
443 FcStrSet *configDirs; /* directories to scan for fonts */
444 /*
445 * Set of allowed blank chars -- used to
446 * trim fonts of bogus glyphs
447 */
448 FcBlanks *blanks;
449 /*
450 * List of directories containing fonts,
451 * built by recursively scanning the set
452 * of configured directories
453 */
454 FcStrSet *fontDirs;
455 /*
456 * List of directories containing cache files.
457 */
458 FcStrSet *cacheDirs;
459 /*
460 * Names of all of the configuration files used
461 * to create this configuration
462 */
463 FcStrSet *configFiles; /* config files loaded */
464 /*
465 * Substitution instructions for patterns and fonts;
466 * maxObjects is used to allocate appropriate intermediate storage
467 * while performing a whole set of substitutions
468 */
469 FcSubst *substPattern; /* substitutions for patterns */
470 FcSubst *substFont; /* substitutions for fonts */
471 FcSubst *substScan; /* substitutions for scanned fonts */
472 int maxObjects; /* maximum number of tests in all substs */
473 /*
474 * List of patterns used to control font file selection
475 */
476 FcStrSet *acceptGlobs;
477 FcStrSet *rejectGlobs;
478 FcFontSet *acceptPatterns;
479 FcFontSet *rejectPatterns;
480 /*
481 * The set of fonts loaded from the listed directories; the
482 * order within the set does not determine the font selection,
483 * except in the case of identical matches in which case earlier fonts
484 * match preferrentially
485 */
486 FcFontSet *fonts[FcSetApplication + 1];
487 /*
488 * Fontconfig can periodically rescan the system configuration
489 * and font directories. This rescanning occurs when font
490 * listing requests are made, but no more often than rescanInterval
491 * seconds apart.
492 */
493 time_t rescanTime; /* last time information was scanned */
494 int rescanInterval; /* interval between scans */
495
496 int ref; /* reference count */
497
498 FcExprPage *expr_pool; /* pool of FcExpr's */
499 };
500
501 extern FcPrivate FcConfig *_fcConfig;
502
503 typedef struct _FcFileTime {
504 time_t time;
505 FcBool set;
506 } FcFileTime;
507
508 typedef struct _FcCharMap FcCharMap;
509
510 /* fcblanks.c */
511
512 /* fccache.c */
513
514 FcPrivate FcCache *
515 FcDirCacheScan (const FcChar8 *dir, FcConfig *config);
516
517 FcPrivate FcCache *
518 FcDirCacheBuild (FcFontSet *set, const FcChar8 *dir, struct stat *dir_stat, FcStrSet *dirs);
519
520 FcPrivate FcBool
521 FcDirCacheWrite (FcCache *cache, FcConfig *config);
522
523 FcPrivate void
524 FcCacheObjectReference (void *object);
525
526 FcPrivate void
527 FcCacheObjectDereference (void *object);
528
529 FcPrivate void
530 FcCacheFini (void);
531
532 FcPrivate void
533 FcDirCacheReference (FcCache *cache, int nref);
534
535 #ifdef _WIN32
536 FcPrivate int
537 FcStat (const char *file, struct stat *statb);
538 #else
539 #define FcStat stat
540 #endif
541
542 /* fccfg.c */
543
544 FcPrivate FcExpr *
545 FcConfigAllocExpr (FcConfig *config);
546
547 FcPrivate FcBool
548 FcConfigAddConfigDir (FcConfig *config,
549 const FcChar8 *d);
550
551 FcPrivate FcBool
552 FcConfigAddFontDir (FcConfig *config,
553 const FcChar8 *d);
554
555 FcPrivate FcBool
556 FcConfigAddDir (FcConfig *config,
557 const FcChar8 *d);
558
559 FcPrivate FcBool
560 FcConfigAddCacheDir (FcConfig *config,
561 const FcChar8 *d);
562
563 FcPrivate FcBool
564 FcConfigAddConfigFile (FcConfig *config,
565 const FcChar8 *f);
566
567 FcPrivate FcBool
568 FcConfigAddBlank (FcConfig *config,
569 FcChar32 blank);
570
571 FcPrivate FcBool
572 FcConfigAddEdit (FcConfig *config,
573 FcTest *test,
574 FcEdit *edit,
575 FcMatchKind kind);
576
577 FcPrivate void
578 FcConfigSetFonts (FcConfig *config,
579 FcFontSet *fonts,
580 FcSetName set);
581
582 FcPrivate FcBool
583 FcConfigCompareValue (const FcValue *m,
584 FcOp op,
585 const FcValue *v);
586
587 FcPrivate FcBool
588 FcConfigGlobAdd (FcConfig *config,
589 const FcChar8 *glob,
590 FcBool accept);
591
592 FcPrivate FcBool
593 FcConfigAcceptFilename (FcConfig *config,
594 const FcChar8 *filename);
595
596 FcPrivate FcBool
597 FcConfigPatternsAdd (FcConfig *config,
598 FcPattern *pattern,
599 FcBool accept);
600
601 FcPrivate FcBool
602 FcConfigAcceptFont (FcConfig *config,
603 const FcPattern *font);
604
605 FcPrivate FcFileTime
606 FcConfigModifiedTime (FcConfig *config);
607
608 FcPrivate FcBool
609 FcConfigAddCache (FcConfig *config, FcCache *cache,
610 FcSetName set, FcStrSet *dirSet);
611
612 /* fcserialize.c */
613 FcPrivate intptr_t
614 FcAlignSize (intptr_t size);
615
616 FcPrivate FcSerialize *
617 FcSerializeCreate (void);
618
619 FcPrivate void
620 FcSerializeDestroy (FcSerialize *serialize);
621
622 FcPrivate FcBool
623 FcSerializeAlloc (FcSerialize *serialize, const void *object, int size);
624
625 FcPrivate intptr_t
626 FcSerializeReserve (FcSerialize *serialize, int size);
627
628 FcPrivate intptr_t
629 FcSerializeOffset (FcSerialize *serialize, const void *object);
630
631 FcPrivate void *
632 FcSerializePtr (FcSerialize *serialize, const void *object);
633
634 FcPrivate FcBool
635 FcLangSetSerializeAlloc (FcSerialize *serialize, const FcLangSet *l);
636
637 FcPrivate FcLangSet *
638 FcLangSetSerialize(FcSerialize *serialize, const FcLangSet *l);
639
640 /* fccharset.c */
641 FcPrivate void
642 FcLangCharSetPopulate (void);
643
644 FcPrivate FcCharSetFreezer *
645 FcCharSetFreezerCreate (void);
646
647 FcPrivate const FcCharSet *
648 FcCharSetFreeze (FcCharSetFreezer *freezer, const FcCharSet *fcs);
649
650 FcPrivate void
651 FcCharSetFreezerDestroy (FcCharSetFreezer *freezer);
652
653 FcPrivate FcBool
654 FcNameUnparseCharSet (FcStrBuf *buf, const FcCharSet *c);
655
656 FcPrivate FcCharSet *
657 FcNameParseCharSet (FcChar8 *string);
658
659 FcPrivate FcBool
660 FcNameUnparseValue (FcStrBuf *buf,
661 FcValue *v0,
662 FcChar8 *escape);
663
664 FcPrivate FcBool
665 FcNameUnparseValueList (FcStrBuf *buf,
666 FcValueListPtr v,
667 FcChar8 *escape);
668
669 FcPrivate FcCharLeaf *
670 FcCharSetFindLeafCreate (FcCharSet *fcs, FcChar32 ucs4);
671
672 FcPrivate FcBool
673 FcCharSetSerializeAlloc(FcSerialize *serialize, const FcCharSet *cs);
674
675 FcPrivate FcCharSet *
676 FcCharSetSerialize(FcSerialize *serialize, const FcCharSet *cs);
677
678 FcPrivate FcChar16 *
679 FcCharSetGetNumbers(const FcCharSet *c);
680
681 /* fcdbg.c */
682 FcPrivate void
683 FcValueListPrint (const FcValueListPtr l);
684
685 FcPrivate void
686 FcLangSetPrint (const FcLangSet *ls);
687
688 FcPrivate void
689 FcOpPrint (FcOp op);
690
691 FcPrivate void
692 FcTestPrint (const FcTest *test);
693
694 FcPrivate void
695 FcExprPrint (const FcExpr *expr);
696
697 FcPrivate void
698 FcEditPrint (const FcEdit *edit);
699
700 FcPrivate void
701 FcSubstPrint (const FcSubst *subst);
702
703 FcPrivate void
704 FcCharSetPrint (const FcCharSet *c);
705
706 extern FcPrivate int FcDebugVal;
707
708 #define FcDebug() (FcDebugVal)
709
710 FcPrivate void
711 FcInitDebug (void);
712
713 /* fcdefault.c */
714 FcPrivate FcChar8 *
715 FcGetDefaultLang (void);
716
717 /* fcdir.c */
718
719 FcPrivate FcBool
720 FcFileScanConfig (FcFontSet *set,
721 FcStrSet *dirs,
722 FcBlanks *blanks,
723 const FcChar8 *file,
724 FcConfig *config);
725
726 FcPrivate FcBool
727 FcDirScanConfig (FcFontSet *set,
728 FcStrSet *dirs,
729 FcBlanks *blanks,
730 const FcChar8 *dir,
731 FcBool force,
732 FcConfig *config);
733
734 /* fcfont.c */
735 FcPrivate int
736 FcFontDebug (void);
737
738 /* fcfs.c */
739
740 FcPrivate FcBool
741 FcFontSetSerializeAlloc (FcSerialize *serialize, const FcFontSet *s);
742
743 FcPrivate FcFontSet *
744 FcFontSetSerialize (FcSerialize *serialize, const FcFontSet * s);
745
746 /* fcxml.c */
747 FcPrivate void
748 FcTestDestroy (FcTest *test);
749
750 FcPrivate void
751 FcEditDestroy (FcEdit *e);
752
753 /* fcinit.c */
754
755 FcPrivate void
756 FcMemReport (void);
757
758 FcPrivate void
759 FcMemAlloc (int kind, int size);
760
761 FcPrivate void
762 FcMemFree (int kind, int size);
763
764 /* fclang.c */
765 FcPrivate FcLangSet *
766 FcFreeTypeLangSet (const FcCharSet *charset,
767 const FcChar8 *exclusiveLang);
768
769 FcPrivate FcLangResult
770 FcLangCompare (const FcChar8 *s1, const FcChar8 *s2);
771
772 FcPrivate FcLangSet *
773 FcLangSetPromote (const FcChar8 *lang);
774
775 FcPrivate FcLangSet *
776 FcNameParseLangSet (const FcChar8 *string);
777
778 FcPrivate FcBool
779 FcNameUnparseLangSet (FcStrBuf *buf, const FcLangSet *ls);
780
781 FcPrivate FcChar8 *
782 FcNameUnparseEscaped (FcPattern *pat, FcBool escape);
783
784 /* fclist.c */
785
786 FcPrivate FcBool
787 FcListPatternMatchAny (const FcPattern *p,
788 const FcPattern *font);
789
790 /* fcmatch.c */
791
792 /* fcname.c */
793
794 /*
795 * NOTE -- this ordering is part of the cache file format.
796 * It must also match the ordering in fcname.c
797 */
798
799 #define FC_FAMILY_OBJECT 1
800 #define FC_FAMILYLANG_OBJECT 2
801 #define FC_STYLE_OBJECT 3
802 #define FC_STYLELANG_OBJECT 4
803 #define FC_FULLNAME_OBJECT 5
804 #define FC_FULLNAMELANG_OBJECT 6
805 #define FC_SLANT_OBJECT 7
806 #define FC_WEIGHT_OBJECT 8
807 #define FC_WIDTH_OBJECT 9
808 #define FC_SIZE_OBJECT 10
809 #define FC_ASPECT_OBJECT 11
810 #define FC_PIXEL_SIZE_OBJECT 12
811 #define FC_SPACING_OBJECT 13
812 #define FC_FOUNDRY_OBJECT 14
813 #define FC_ANTIALIAS_OBJECT 15
814 #define FC_HINT_STYLE_OBJECT 16
815 #define FC_HINTING_OBJECT 17
816 #define FC_VERTICAL_LAYOUT_OBJECT 18
817 #define FC_AUTOHINT_OBJECT 19
818 #define FC_GLOBAL_ADVANCE_OBJECT 20
819 #define FC_FILE_OBJECT 21
820 #define FC_INDEX_OBJECT 22
821 #define FC_RASTERIZER_OBJECT 23
822 #define FC_OUTLINE_OBJECT 24
823 #define FC_SCALABLE_OBJECT 25
824 #define FC_DPI_OBJECT 26
825 #define FC_RGBA_OBJECT 27
826 #define FC_SCALE_OBJECT 28
827 #define FC_MINSPACE_OBJECT 29
828 #define FC_CHAR_WIDTH_OBJECT 30
829 #define FC_CHAR_HEIGHT_OBJECT 31
830 #define FC_MATRIX_OBJECT 32
831 #define FC_CHARSET_OBJECT 33
832 #define FC_LANG_OBJECT 34
833 #define FC_FONTVERSION_OBJECT 35
834 #define FC_CAPABILITY_OBJECT 36
835 #define FC_FONTFORMAT_OBJECT 37
836 #define FC_EMBOLDEN_OBJECT 38
837 #define FC_EMBEDDED_BITMAP_OBJECT 39
838 #define FC_DECORATIVE_OBJECT 40
839 #define FC_LCD_FILTER_OBJECT 41
840 #define FC_MAX_BASE_OBJECT FC_LCD_FILTER_OBJECT
841
842 FcPrivate FcBool
843 FcNameBool (const FcChar8 *v, FcBool *result);
844
845 FcPrivate FcBool
846 FcObjectValidType (FcObject object, FcType type);
847
848 FcPrivate FcObject
849 FcObjectFromName (const char * name);
850
851 FcPrivate const char *
852 FcObjectName (FcObject object);
853
854 FcPrivate FcObjectSet *
855 FcObjectGetSet (void);
856
857 FcPrivate FcBool
858 FcObjectInit (void);
859
860 FcPrivate void
861 FcObjectFini (void);
862
863 #define FcObjectCompare(a, b) ((int) a - (int) b)
864
865 /* fcpat.c */
866
867 FcPrivate FcValue
868 FcValueCanonicalize (const FcValue *v);
869
870 FcPrivate void
871 FcValueListDestroy (FcValueListPtr l);
872
873 FcPrivate FcPatternElt *
874 FcPatternObjectFindElt (const FcPattern *p, FcObject object);
875
876 FcPrivate FcPatternElt *
877 FcPatternObjectInsertElt (FcPattern *p, FcObject object);
878
879 FcPrivate FcBool
880 FcPatternObjectAddWithBinding (FcPattern *p,
881 FcObject object,
882 FcValue value,
883 FcValueBinding binding,
884 FcBool append);
885
886 FcPrivate FcBool
887 FcPatternObjectAdd (FcPattern *p, FcObject object, FcValue value, FcBool append);
888
889 FcPrivate FcBool
890 FcPatternObjectAddWeak (FcPattern *p, FcObject object, FcValue value, FcBool append);
891
892 FcPrivate FcResult
893 FcPatternObjectGet (const FcPattern *p, FcObject object, int id, FcValue *v);
894
895 FcPrivate FcBool
896 FcPatternObjectDel (FcPattern *p, FcObject object);
897
898 FcPrivate FcBool
899 FcPatternObjectRemove (FcPattern *p, FcObject object, int id);
900
901 FcPrivate FcBool
902 FcPatternObjectAddInteger (FcPattern *p, FcObject object, int i);
903
904 FcPrivate FcBool
905 FcPatternObjectAddDouble (FcPattern *p, FcObject object, double d);
906
907 FcPrivate FcBool
908 FcPatternObjectAddString (FcPattern *p, FcObject object, const FcChar8 *s);
909
910 FcPrivate FcBool
911 FcPatternObjectAddMatrix (FcPattern *p, FcObject object, const FcMatrix *s);
912
913 FcPrivate FcBool
914 FcPatternObjectAddCharSet (FcPattern *p, FcObject object, const FcCharSet *c);
915
916 FcPrivate FcBool
917 FcPatternObjectAddBool (FcPattern *p, FcObject object, FcBool b);
918
919 FcPrivate FcBool
920 FcPatternObjectAddLangSet (FcPattern *p, FcObject object, const FcLangSet *ls);
921
922 FcPrivate FcResult
923 FcPatternObjectGetInteger (const FcPattern *p, FcObject object, int n, int *i);
924
925 FcPrivate FcResult
926 FcPatternObjectGetDouble (const FcPattern *p, FcObject object, int n, double *d);
927
928 FcPrivate FcResult
929 FcPatternObjectGetString (const FcPattern *p, FcObject object, int n, FcChar8 ** s);
930
931 FcPrivate FcResult
932 FcPatternObjectGetMatrix (const FcPattern *p, FcObject object, int n, FcMatrix **s);
933
934 FcPrivate FcResult
935 FcPatternObjectGetCharSet (const FcPattern *p, FcObject object, int n, FcCharSet **c);
936
937 FcPrivate FcResult
938 FcPatternObjectGetBool (const FcPattern *p, FcObject object, int n, FcBool *b);
939
940 FcPrivate FcResult
941 FcPatternObjectGetLangSet (const FcPattern *p, FcObject object, int n, FcLangSet **ls);
942
943 FcPrivate void
944 FcPatternFini (void);
945
946 FcPrivate FcBool
947 FcPatternAppend (FcPattern *p, FcPattern *s);
948
949 FcPrivate const FcChar8 *
950 FcStrStaticName (const FcChar8 *name);
951
952 FcPrivate FcChar32
953 FcStringHash (const FcChar8 *s);
954
955 FcPrivate FcBool
956 FcPatternSerializeAlloc (FcSerialize *serialize, const FcPattern *pat);
957
958 FcPrivate FcPattern *
959 FcPatternSerialize (FcSerialize *serialize, const FcPattern *pat);
960
961 FcPrivate FcBool
962 FcValueListSerializeAlloc (FcSerialize *serialize, const FcValueList *pat);
963
964 FcPrivate FcValueList *
965 FcValueListSerialize (FcSerialize *serialize, const FcValueList *pat);
966
967 /* fcrender.c */
968
969 /* fcmatrix.c */
970
971 extern FcPrivate const FcMatrix FcIdentityMatrix;
972
973 FcPrivate void
974 FcMatrixFree (FcMatrix *mat);
975
976 /* fcstr.c */
977 FcPrivate void
978 FcStrSetSort (FcStrSet * set);
979
980 FcPrivate void
981 FcStrBufInit (FcStrBuf *buf, FcChar8 *init, int size);
982
983 FcPrivate void
984 FcStrBufDestroy (FcStrBuf *buf);
985
986 FcPrivate FcChar8 *
987 FcStrBufDone (FcStrBuf *buf);
988
989 FcPrivate FcChar8 *
990 FcStrBufDoneStatic (FcStrBuf *buf);
991
992 FcPrivate FcBool
993 FcStrBufChar (FcStrBuf *buf, FcChar8 c);
994
995 FcPrivate FcBool
996 FcStrBufString (FcStrBuf *buf, const FcChar8 *s);
997
998 FcPrivate FcBool
999 FcStrBufData (FcStrBuf *buf, const FcChar8 *s, int len);
1000
1001 FcPrivate int
1002 FcStrCmpIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2);
1003
1004 FcPrivate const FcChar8 *
1005 FcStrContainsIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2);
1006
1007 FcPrivate const FcChar8 *
1008 FcStrContainsIgnoreCase (const FcChar8 *s1, const FcChar8 *s2);
1009
1010 FcPrivate const FcChar8 *
1011 FcStrContainsWord (const FcChar8 *s1, const FcChar8 *s2);
1012
1013 FcPrivate FcBool
1014 FcStrUsesHome (const FcChar8 *s);
1015
1016 FcPrivate FcChar8 *
1017 FcStrLastSlash (const FcChar8 *path);
1018
1019 FcPrivate FcChar32
1020 FcStrHashIgnoreCase (const FcChar8 *s);
1021
1022 FcPrivate FcChar8 *
1023 FcStrCanonFilename (const FcChar8 *s);
1024
1025 FcPrivate FcBool
1026 FcStrSerializeAlloc (FcSerialize *serialize, const FcChar8 *str);
1027
1028 FcPrivate FcChar8 *
1029 FcStrSerialize (FcSerialize *serialize, const FcChar8 *str);
1030
1031 #endif /* _FC_INT_H_ */