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 "fcstdint.h"
33
34 #include <stdlib.h>
35 #include <stdio.h>
36 #include <string.h>
37 #include <ctype.h>
38 #include <assert.h>
39 #include <errno.h>
40 #include <limits.h>
41 #include <float.h>
42 #include <math.h>
43 #ifdef HAVE_UNISTD_H
44 #include <unistd.h>
45 #endif
46 #include <stddef.h>
47 #include <sys/types.h>
48 #include <sys/stat.h>
49 #include <time.h>
50 #include <fontconfig/fontconfig.h>
51 #include <fontconfig/fcprivate.h>
52 #include "fcdeprecate.h"
53 #include "fcmutex.h"
54 #include "fcatomic.h"
55
56 #ifndef FC_CONFIG_PATH
57 #define FC_CONFIG_PATH "fonts.conf"
58 #endif
59
60 #ifdef _WIN32
61 #define FC_LIKELY(expr) (expr)
62 #define FC_UNLIKELY(expr) (expr)
63 #else
64 #define FC_LIKELY(expr) (__builtin_expect (((expr) ? 1 : 0), 1))
65 #define FC_UNLIKELY(expr) (__builtin_expect (((expr) ? 1 : 0), 0))
66 #endif
67
68 #ifdef _WIN32
69 # include "fcwindows.h"
70 typedef UINT (WINAPI *pfnGetSystemWindowsDirectory)(LPSTR, UINT);
71 typedef HRESULT (WINAPI *pfnSHGetFolderPathA)(HWND, int, HANDLE, DWORD, LPSTR);
72 extern pfnGetSystemWindowsDirectory pGetSystemWindowsDirectory;
73 extern pfnSHGetFolderPathA pSHGetFolderPathA;
74 # define FC_SEARCH_PATH_SEPARATOR ';'
75 # define FC_DIR_SEPARATOR '\\'
76 # define FC_DIR_SEPARATOR_S "\\"
77 #else
78 # define FC_SEARCH_PATH_SEPARATOR ':'
79 # define FC_DIR_SEPARATOR '/'
80 # define FC_DIR_SEPARATOR_S "/"
81 #endif
82
83 #ifdef PATH_MAX
84 #define FC_PATH_MAX PATH_MAX
85 #else
86 #define FC_PATH_MAX 128
87 #endif
88
89 #if __GNUC__ >= 4
90 #define FC_UNUSED __attribute__((unused))
91 #else
92 #define FC_UNUSED
93 #endif
94
95 #ifndef FC_UINT64_FORMAT
96 #define FC_UINT64_FORMAT "llu"
97 #endif
98
99 #define FC_DBG_MATCH 1
100 #define FC_DBG_MATCHV 2
101 #define FC_DBG_EDIT 4
102 #define FC_DBG_FONTSET 8
103 #define FC_DBG_CACHE 16
104 #define FC_DBG_CACHEV 32
105 #define FC_DBG_PARSE 64
106 #define FC_DBG_SCAN 128
107 #define FC_DBG_SCANV 256
108 #define FC_DBG_CONFIG 1024
109 #define FC_DBG_LANGSET 2048
110 #define FC_DBG_MATCH2 4096
111
112 #define _FC_ASSERT_STATIC1(_line, _cond) typedef int _static_assert_on_line_##_line##_failed[(_cond)?1:-1] FC_UNUSED
113 #define _FC_ASSERT_STATIC0(_line, _cond) _FC_ASSERT_STATIC1 (_line, (_cond))
114 #define FC_ASSERT_STATIC(_cond) _FC_ASSERT_STATIC0 (__LINE__, (_cond))
115
116 #define FC_MIN(a,b) ((a) < (b) ? (a) : (b))
117 #define FC_MAX(a,b) ((a) > (b) ? (a) : (b))
118
119 /* slim_internal.h */
120 #if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)) && defined(__ELF__) && !defined(__sun)
121 #define FcPrivate __attribute__((__visibility__("hidden")))
122 #define HAVE_GNUC_ATTRIBUTE 1
123 #include "fcalias.h"
124 #elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550)
125 #define FcPrivate __hidden
126 #else /* not gcc >= 3.3 and not Sun Studio >= 8 */
127 #define FcPrivate
128 #endif
129
130 /* NLS */
131 #ifdef ENABLE_NLS
132 #include <libintl.h>
133 #define _(x) (dgettext(GETTEXT_PACKAGE, x))
134 #else
135 #define dgettext(d, s) (s)
136 #define _(x) (x)
137 #endif
138
139 #define N_(x) x
140
141 FC_ASSERT_STATIC (sizeof (FcRef) == sizeof (int));
142
143 #define FcStrdup(s) ((FcChar8 *) strdup ((const char *) (s)))
144 #define FcFree(s) (free ((FcChar8 *) (s)))
145
146 /*
147 * Serialized data structures use only offsets instead of pointers
148 * A low bit of 1 indicates an offset.
149 */
150
151 /* Is the provided pointer actually an offset? */
152 #define FcIsEncodedOffset(p) ((((intptr_t) (p)) & 1) != 0)
153
154 /* Encode offset in a pointer of type t */
155 #define FcOffsetEncode(o,t) ((t *) (intptr_t) ((o) | 1))
156
157 /* Decode a pointer into an offset */
158 #define FcOffsetDecode(p) (((intptr_t) (p)) & ~1)
159
160 /* Compute pointer offset */
161 #define FcPtrToOffset(b,p) ((ptrdiff_t) ((intptr_t) (p) - (intptr_t) (b)))
162
163 /* Given base address, offset and type, return a pointer */
164 #define FcOffsetToPtr(b,o,t) ((t *) ((intptr_t) (b) + (ptrdiff_t) (o)))
165
166 /* Given base address, encoded offset and type, return a pointer */
167 #define FcEncodedOffsetToPtr(b,p,t) FcOffsetToPtr(b,FcOffsetDecode(p),t)
168
169 /* Given base address, pointer and type, return an encoded offset */
170 #define FcPtrToEncodedOffset(b,p,t) FcOffsetEncode(FcPtrToOffset(b,p),t)
171
172 /* Given a structure, offset member and type, return pointer */
173 #define FcOffsetMember(s,m,t) FcOffsetToPtr(s,(s)->m,t)
174
175 /* Given a structure, encoded offset member and type, return pointer to member */
176 #define FcEncodedOffsetMember(s,m,t) FcOffsetToPtr(s,FcOffsetDecode((s)->m), t)
177
178 /* Given a structure, member and type, convert the member to a pointer */
179 #define FcPointerMember(s,m,t) (FcIsEncodedOffset((s)->m) ? \
180 FcEncodedOffsetMember (s,m,t) : \
181 (s)->m)
182
183 /*
184 * Serialized values may hold strings, charsets and langsets as pointers,
185 * unfortunately FcValue is an exposed type so we can't just always use
186 * offsets
187 */
188 #define FcValueString(v) FcPointerMember(v,u.s,FcChar8)
189 #define FcValueCharSet(v) FcPointerMember(v,u.c,const FcCharSet)
190 #define FcValueLangSet(v) FcPointerMember(v,u.l,const FcLangSet)
191 #define FcValueRange(v) FcPointerMember(v,u.r,const FcRange)
192
193 typedef struct _FcValueList *FcValueListPtr;
194
195 typedef struct _FcValueList {
196 struct _FcValueList *next;
197 FcValue value;
198 FcValueBinding binding;
199 } FcValueList;
200
201 #define FcValueListNext(vl) FcPointerMember(vl,next,FcValueList)
202
203 typedef int FcObject;
204
205 /* The 1024 is to leave some room for future added internal objects, such
206 * that caches from newer fontconfig can still be used with older fontconfig
207 * without getting confused. */
208 #define FC_EXT_OBJ_INDEX 1024
209 #define FC_OBJ_ID(_n_) ((_n_) & (~FC_EXT_OBJ_INDEX))
210
211 typedef struct _FcPatternElt *FcPatternEltPtr;
212
213 /*
214 * Pattern elts are stuck in a structure connected to the pattern,
215 * so they get moved around when the pattern is resized. Hence, the
216 * values field must be a pointer/offset instead of just an offset
217 */
218 typedef struct _FcPatternElt {
219 FcObject object;
220 FcValueList *values;
221 } FcPatternElt;
222
223 #define FcPatternEltValues(pe) FcPointerMember(pe,values,FcValueList)
224
225 struct _FcPattern {
226 int num;
227 int size;
228 intptr_t elts_offset;
229 FcRef ref;
230 };
231
232 #define FcPatternElts(p) FcOffsetMember(p,elts_offset,FcPatternElt)
233
234 #define FcFontSetFonts(fs) FcPointerMember(fs,fonts,FcPattern *)
235
236 #define FcFontSetFont(fs,i) (FcIsEncodedOffset((fs)->fonts) ? \
237 FcEncodedOffsetToPtr(fs, \
238 FcFontSetFonts(fs)[i], \
239 FcPattern) : \
240 fs->fonts[i])
241
242 typedef enum _FcOp {
243 FcOpInteger, FcOpDouble, FcOpString, FcOpMatrix, FcOpRange, FcOpBool, FcOpCharSet, FcOpLangSet,
244 FcOpNil,
245 FcOpField, FcOpConst,
246 FcOpAssign, FcOpAssignReplace,
247 FcOpPrependFirst, FcOpPrepend, FcOpAppend, FcOpAppendLast,
248 FcOpDelete, FcOpDeleteAll,
249 FcOpQuest,
250 FcOpOr, FcOpAnd, FcOpEqual, FcOpNotEqual,
251 FcOpContains, FcOpListing, FcOpNotContains,
252 FcOpLess, FcOpLessEqual, FcOpMore, FcOpMoreEqual,
253 FcOpPlus, FcOpMinus, FcOpTimes, FcOpDivide,
254 FcOpNot, FcOpComma, FcOpFloor, FcOpCeil, FcOpRound, FcOpTrunc,
255 FcOpInvalid
256 } FcOp;
257
258 typedef enum _FcOpFlags {
259 FcOpFlagIgnoreBlanks = 1U << 0
260 } FcOpFlags;
261
262 #define FC_OP_GET_OP(_x_) ((_x_) & 0xffff)
263 #define FC_OP_GET_FLAGS(_x_) (((_x_) & 0xffff0000) >> 16)
264 #define FC_OP(_x_,_f_) (FC_OP_GET_OP (_x_) | ((_f_) << 16))
265
266 typedef struct _FcExprMatrix {
267 struct _FcExpr *xx, *xy, *yx, *yy;
268 } FcExprMatrix;
269
270 typedef struct _FcExprName {
271 FcObject object;
272 FcMatchKind kind;
273 } FcExprName;
274
275 struct _FcRange {
276 double begin;
277 double end;
278 };
279
280
281 typedef struct _FcExpr {
282 FcOp op;
283 union {
284 int ival;
285 double dval;
286 const FcChar8 *sval;
287 FcExprMatrix *mexpr;
288 FcBool bval;
289 FcCharSet *cval;
290 FcLangSet *lval;
291 FcRange *rval;
292
293 FcExprName name;
294 const FcChar8 *constant;
295 struct {
296 struct _FcExpr *left, *right;
297 } tree;
298 } u;
299 } FcExpr;
300
301 typedef struct _FcExprPage FcExprPage;
302
303 struct _FcExprPage {
304 FcExprPage *next_page;
305 FcExpr *next;
306 FcExpr exprs[(1024 - 2/* two pointers */ - 2/* malloc overhead */) * sizeof (void *) / sizeof (FcExpr)];
307 FcExpr end[FLEXIBLE_ARRAY_MEMBER];
308 };
309
310 typedef enum _FcQual {
311 FcQualAny, FcQualAll, FcQualFirst, FcQualNotFirst
312 } FcQual;
313
314 #define FcMatchDefault ((FcMatchKind) -1)
315
316 typedef struct _FcTest {
317 FcMatchKind kind;
318 FcQual qual;
319 FcObject object;
320 FcOp op;
321 FcExpr *expr;
322 } FcTest;
323
324 typedef struct _FcEdit {
325 FcObject object;
326 FcOp op;
327 FcExpr *expr;
328 FcValueBinding binding;
329 } FcEdit;
330
331 typedef void (* FcDestroyFunc) (void *data);
332
333 typedef struct _FcPtrList FcPtrList;
334 /* need to sync with FcConfigFileInfoIter at fontconfig.h */
335 typedef struct _FcPtrListIter {
336 void *dummy1;
337 void *dummy2;
338 void *dummy3;
339 } FcPtrListIter;
340
341 typedef enum _FcRuleType {
342 FcRuleUnknown, FcRuleTest, FcRuleEdit
343 } FcRuleType;
344
345 typedef struct _FcRule {
346 struct _FcRule *next;
347 FcRuleType type;
348 union {
349 FcTest *test;
350 FcEdit *edit;
351 } u;
352 } FcRule;
353
354 typedef struct _FcRuleSet {
355 FcRef ref;
356 FcChar8 *name;
357 FcChar8 *description;
358 FcChar8 *domain;
359 FcBool enabled;
360 FcPtrList *subst[FcMatchKindEnd];
361 } FcRuleSet;
362
363 typedef struct _FcCharLeaf {
364 FcChar32 map[256/32];
365 } FcCharLeaf;
366
367 struct _FcCharSet {
368 FcRef ref; /* reference count */
369 int num; /* size of leaves and numbers arrays */
370 intptr_t leaves_offset;
371 intptr_t numbers_offset;
372 };
373
374 #define FcCharSetLeaves(c) FcOffsetMember(c,leaves_offset,intptr_t)
375 #define FcCharSetLeaf(c,i) (FcOffsetToPtr(FcCharSetLeaves(c), \
376 FcCharSetLeaves(c)[i], \
377 FcCharLeaf))
378 #define FcCharSetNumbers(c) FcOffsetMember(c,numbers_offset,FcChar16)
379
380 #define FCSS_DEFAULT 0 /* default behavior */
381 #define FCSS_ALLOW_DUPLICATES 1 /* allows for duplicate strings in the set */
382 #define FCSS_GROW_BY_64 2 /* grows buffer by 64 elements instead of 1 */
383
384 #define FcStrSetHasControlBit(s,c) (s->control & c)
385 #define FcStrSetHasControlBits(s,c) ( (c) == (s->control & (c)) )
386
387 struct _FcStrSet {
388 FcRef ref; /* reference count */
389 int num;
390 int size;
391 FcChar8 **strs;
392 unsigned int control; /* control bits for set behavior */
393 };
394
395 struct _FcStrList {
396 FcStrSet *set;
397 int n;
398 };
399
400 typedef struct _FcStrBuf {
401 FcChar8 *buf;
402 FcBool allocated;
403 FcBool failed;
404 int len;
405 int size;
406 FcChar8 buf_static[16 * sizeof (void *)];
407 } FcStrBuf;
408
409 typedef struct _FcHashTable FcHashTable;
410
411 typedef FcChar32 (* FcHashFunc) (const void *data);
412 typedef int (* FcCompareFunc) (const void *v1, const void *v2);
413 typedef FcBool (* FcCopyFunc) (const void *src, void **dest);
414
415
416 struct _FcCache {
417 unsigned int magic; /* FC_CACHE_MAGIC_MMAP or FC_CACHE_ALLOC */
418 int version; /* FC_CACHE_VERSION_NUMBER */
419 intptr_t size; /* size of file */
420 intptr_t dir; /* offset to dir name */
421 intptr_t dirs; /* offset to subdirs */
422 int dirs_count; /* number of subdir strings */
423 intptr_t set; /* offset to font set */
424 int checksum; /* checksum of directory state */
425 int64_t checksum_nano; /* checksum of directory state */
426 };
427
428 #undef FcCacheDir
429 #undef FcCacheSubdir
430 #define FcCacheDir(c) FcOffsetMember(c,dir,FcChar8)
431 #define FcCacheDirs(c) FcOffsetMember(c,dirs,intptr_t)
432 #define FcCacheSet(c) FcOffsetMember(c,set,FcFontSet)
433 #define FcCacheSubdir(c,i) FcOffsetToPtr (FcCacheDirs(c),\
434 FcCacheDirs(c)[i], \
435 FcChar8)
436
437 /*
438 * Used while constructing a directory cache object
439 */
440
441 typedef union _FcAlign {
442 double d;
443 int i;
444 intptr_t ip;
445 FcBool b;
446 void *p;
447 } FcAlign;
448
449 typedef struct _FcSerializeBucket {
450 const void *object; /* key */
451 uintptr_t hash; /* hash of key */
452 intptr_t offset; /* value */
453 } FcSerializeBucket;
454
455 typedef struct _FcCharSetFreezer FcCharSetFreezer;
456
457 typedef struct _FcSerialize {
458 intptr_t size;
459 FcCharSetFreezer *cs_freezer;
460 void *linear;
461 FcSerializeBucket *buckets;
462 size_t buckets_count;
463 size_t buckets_used;
464 size_t buckets_used_max;
465 } FcSerialize;
466
467 /*
468 * To map adobe glyph names to unicode values, a precomputed hash
469 * table is used
470 */
471
472 typedef struct _FcGlyphName {
473 FcChar32 ucs; /* unicode value */
474 FcChar8 name[1]; /* name extends beyond struct */
475 } FcGlyphName;
476
477 /*
478 * To perform case-insensitive string comparisons, a table
479 * is used which holds three different kinds of folding data.
480 *
481 * The first is a range of upper case values mapping to a range
482 * of their lower case equivalents. Within each range, the offset
483 * between upper and lower case is constant.
484 *
485 * The second is a range of upper case values which are interleaved
486 * with their lower case equivalents.
487 *
488 * The third is a set of raw unicode values mapping to a list
489 * of unicode values for comparison purposes. This allows conversion
490 * of ß to "ss" so that SS, ss and ß all match. A separate array
491 * holds the list of unicode values for each entry.
492 *
493 * These are packed into a single table. Using a binary search,
494 * the appropriate entry can be located.
495 */
496
497 #define FC_CASE_FOLD_RANGE 0
498 #define FC_CASE_FOLD_EVEN_ODD 1
499 #define FC_CASE_FOLD_FULL 2
500
501 typedef struct _FcCaseFold {
502 FcChar32 upper;
503 FcChar16 method : 2;
504 FcChar16 count : 14;
505 short offset; /* lower - upper for RANGE, table id for FULL */
506 } FcCaseFold;
507
508 #define FC_MAX_FILE_LEN 4096
509
510 #define FC_CACHE_MAGIC_MMAP 0xFC02FC04
511 #define FC_CACHE_MAGIC_ALLOC 0xFC02FC05
512
513 struct _FcAtomic {
514 FcChar8 *file; /* original file name */
515 FcChar8 *new; /* temp file name -- write data here */
516 FcChar8 *lck; /* lockfile name (used for locking) */
517 FcChar8 *tmp; /* tmpfile name (used for locking) */
518 };
519
520 struct _FcConfig {
521 /*
522 * File names loaded from the configuration -- saved here as the
523 * cache file must be consulted before the directories are scanned,
524 * and those directives may occur in any order
525 */
526 FcStrSet *configDirs; /* directories to scan for fonts */
527 FcStrSet *configMapDirs; /* mapped names to generate cache entries */
528 /*
529 * List of directories containing fonts,
530 * built by recursively scanning the set
531 * of configured directories
532 */
533 FcStrSet *fontDirs;
534 /*
535 * List of directories containing cache files.
536 */
537 FcStrSet *cacheDirs;
538 /*
539 * Names of all of the configuration files used
540 * to create this configuration
541 */
542 FcStrSet *configFiles; /* config files loaded */
543 /*
544 * Substitution instructions for patterns and fonts;
545 * maxObjects is used to allocate appropriate intermediate storage
546 * while performing a whole set of substitutions
547 *
548 * 0.. substitutions for patterns
549 * 1.. substitutions for fonts
550 * 2.. substitutions for scanned fonts
551 */
552 FcPtrList *subst[FcMatchKindEnd];
553 int maxObjects; /* maximum number of tests in all substs */
554 /*
555 * List of patterns used to control font file selection
556 */
557 FcStrSet *acceptGlobs;
558 FcStrSet *rejectGlobs;
559 FcFontSet *acceptPatterns;
560 FcFontSet *rejectPatterns;
561 /*
562 * The set of fonts loaded from the listed directories; the
563 * order within the set does not determine the font selection,
564 * except in the case of identical matches in which case earlier fonts
565 * match preferrentially
566 */
567 FcFontSet *fonts[FcSetApplication + 1];
568 /*
569 * Fontconfig can periodically rescan the system configuration
570 * and font directories. This rescanning occurs when font
571 * listing requests are made, but no more often than rescanInterval
572 * seconds apart.
573 */
574 time_t rescanTime; /* last time information was scanned */
575 int rescanInterval; /* interval between scans */
576
577 FcRef ref; /* reference count */
578
579 FcExprPage *expr_pool; /* pool of FcExpr's */
580
581 FcChar8 *sysRoot; /* override the system root directory */
582 FcStrSet *availConfigFiles; /* config files available */
583 FcPtrList *rulesetList; /* List of rulesets being installed */
584 };
585
586 typedef struct _FcFileTime {
587 time_t time;
588 FcBool set;
589 } FcFileTime;
590
591 typedef struct _FcCharMap FcCharMap;
592
593 typedef struct _FcStatFS FcStatFS;
594
595 struct _FcStatFS {
596 FcBool is_remote_fs;
597 FcBool is_mtime_broken;
598 };
599
600 typedef struct _FcValuePromotionBuffer FcValuePromotionBuffer;
601
602 struct _FcValuePromotionBuffer {
603 union {
604 double d;
605 int i;
606 long l;
607 char c[256]; /* Enlarge as needed */
608 } u;
609 };
610
611 /* fccache.c */
612
613 FcPrivate FcCache *
614 FcDirCacheScan (const FcChar8 *dir, FcConfig *config);
615
616 FcPrivate FcCache *
617 FcDirCacheBuild (FcFontSet *set, const FcChar8 *dir, struct stat *dir_stat, FcStrSet *dirs);
618
619 FcPrivate FcCache *
620 FcDirCacheRebuild (FcCache *cache, struct stat *dir_stat, FcStrSet *dirs);
621
622 FcPrivate FcBool
623 FcDirCacheWrite (FcCache *cache, FcConfig *config);
624
625 FcPrivate FcBool
626 FcDirCacheCreateTagFile (const FcChar8 *cache_dir);
627
628 FcPrivate void
629 FcCacheObjectReference (void *object);
630
631 FcPrivate void
632 FcCacheObjectDereference (void *object);
633
634 FcPrivate void *
635 FcCacheAllocate (FcCache *cache, size_t len);
636
637 FcPrivate void
638 FcCacheFini (void);
639
640
641 FcPrivate void
642 FcDirCacheReference (FcCache *cache, int nref);
643
644 FcPrivate int
645 FcDirCacheLock (const FcChar8 *dir,
646 FcConfig *config);
647
648 FcPrivate void
649 FcDirCacheUnlock (int fd);
650
651 /* fccfg.c */
652
653 FcPrivate FcBool
654 FcConfigInit (void);
655
656 FcPrivate void
657 FcConfigFini (void);
658
659 FcPrivate FcChar8 *
660 FcConfigXdgCacheHome (void);
661
662 FcPrivate FcChar8 *
663 FcConfigXdgConfigHome (void);
664
665 FcPrivate FcChar8 *
666 FcConfigXdgDataHome (void);
667
668 FcPrivate FcStrSet *
669 FcConfigXdgDataDirs (void);
670
671 FcPrivate FcExpr *
672 FcConfigAllocExpr (FcConfig *config);
673
674 FcPrivate FcBool
675 FcConfigAddConfigDir (FcConfig *config,
676 const FcChar8 *d);
677
678 FcPrivate FcBool
679 FcConfigAddFontDir (FcConfig *config,
680 const FcChar8 *d,
681 const FcChar8 *m,
682 const FcChar8 *salt);
683
684 FcPrivate FcBool
685 FcConfigResetFontDirs (FcConfig *config);
686
687 FcPrivate FcChar8 *
688 FcConfigMapFontPath(FcConfig *config,
689 const FcChar8 *path);
690
691 FcPrivate const FcChar8 *
692 FcConfigMapSalt (FcConfig *config,
693 const FcChar8 *path);
694
695 FcPrivate FcBool
696 FcConfigAddCacheDir (FcConfig *config,
697 const FcChar8 *d);
698
699 FcPrivate FcBool
700 FcConfigAddConfigFile (FcConfig *config,
701 const FcChar8 *f);
702
703 FcPrivate FcBool
704 FcConfigAddBlank (FcConfig *config,
705 FcChar32 blank);
706
707 FcBool
708 FcConfigAddRule (FcConfig *config,
709 FcRule *rule,
710 FcMatchKind kind);
711
712 FcPrivate void
713 FcConfigSetFonts (FcConfig *config,
714 FcFontSet *fonts,
715 FcSetName set);
716
717 FcPrivate FcBool
718 FcConfigCompareValue (const FcValue *m,
719 unsigned int op_,
720 const FcValue *v);
721
722 FcPrivate FcBool
723 FcConfigGlobAdd (FcConfig *config,
724 const FcChar8 *glob,
725 FcBool accept);
726
727 FcPrivate FcBool
728 FcConfigAcceptFilename (FcConfig *config,
729 const FcChar8 *filename);
730
731 FcPrivate FcBool
732 FcConfigPatternsAdd (FcConfig *config,
733 FcPattern *pattern,
734 FcBool accept);
735
736 FcPrivate FcBool
737 FcConfigAcceptFont (FcConfig *config,
738 const FcPattern *font);
739
740 FcPrivate FcFileTime
741 FcConfigModifiedTime (FcConfig *config);
742
743 FcPrivate FcBool
744 FcConfigAddCache (FcConfig *config, FcCache *cache,
745 FcSetName set, FcStrSet *dirSet, FcChar8 *forDir);
746
747 FcPrivate FcRuleSet *
748 FcRuleSetCreate (const FcChar8 *name);
749
750 FcPrivate void
751 FcRuleSetDestroy (FcRuleSet *rs);
752
753 FcPrivate void
754 FcRuleSetReference (FcRuleSet *rs);
755
756 FcPrivate void
757 FcRuleSetEnable (FcRuleSet *rs,
758 FcBool flag);
759
760 FcPrivate void
761 FcRuleSetAddDescription (FcRuleSet *rs,
762 const FcChar8 *domain,
763 const FcChar8 *description);
764
765 FcPrivate int
766 FcRuleSetAdd (FcRuleSet *rs,
767 FcRule *rule,
768 FcMatchKind kind);
769
770 /* fcserialize.c */
771 FcPrivate intptr_t
772 FcAlignSize (intptr_t size);
773
774 FcPrivate FcSerialize *
775 FcSerializeCreate (void);
776
777 FcPrivate void
778 FcSerializeDestroy (FcSerialize *serialize);
779
780 FcPrivate FcBool
781 FcSerializeAlloc (FcSerialize *serialize, const void *object, int size);
782
783 FcPrivate intptr_t
784 FcSerializeReserve (FcSerialize *serialize, int size);
785
786 FcPrivate intptr_t
787 FcSerializeOffset (FcSerialize *serialize, const void *object);
788
789 FcPrivate void *
790 FcSerializePtr (FcSerialize *serialize, const void *object);
791
792 FcPrivate FcBool
793 FcLangSetSerializeAlloc (FcSerialize *serialize, const FcLangSet *l);
794
795 FcPrivate FcLangSet *
796 FcLangSetSerialize(FcSerialize *serialize, const FcLangSet *l);
797
798 /* fccharset.c */
799 FcPrivate FcCharSet *
800 FcCharSetPromote (FcValuePromotionBuffer *vbuf);
801
802 FcPrivate void
803 FcLangCharSetPopulate (void);
804
805 FcPrivate FcCharSetFreezer *
806 FcCharSetFreezerCreate (void);
807
808 FcPrivate const FcCharSet *
809 FcCharSetFreeze (FcCharSetFreezer *freezer, const FcCharSet *fcs);
810
811 FcPrivate void
812 FcCharSetFreezerDestroy (FcCharSetFreezer *freezer);
813
814 FcPrivate FcBool
815 FcNameUnparseCharSet (FcStrBuf *buf, const FcCharSet *c);
816
817 FcPrivate FcCharSet *
818 FcNameParseCharSet (FcChar8 *string);
819
820 FcPrivate FcBool
821 FcNameUnparseValue (FcStrBuf *buf,
822 FcValue *v0,
823 FcChar8 *escape);
824
825 FcPrivate FcBool
826 FcNameUnparseValueList (FcStrBuf *buf,
827 FcValueListPtr v,
828 FcChar8 *escape);
829
830 FcPrivate FcCharLeaf *
831 FcCharSetFindLeafCreate (FcCharSet *fcs, FcChar32 ucs4);
832
833 FcPrivate FcBool
834 FcCharSetSerializeAlloc(FcSerialize *serialize, const FcCharSet *cs);
835
836 FcPrivate FcCharSet *
837 FcCharSetSerialize(FcSerialize *serialize, const FcCharSet *cs);
838
839 FcPrivate FcChar16 *
840 FcCharSetGetNumbers(const FcCharSet *c);
841
842 /* fccompat.c */
843 FcPrivate int
844 FcOpen(const char *pathname, int flags, ...);
845
846 FcPrivate int
847 FcMakeTempfile (char *template);
848
849 FcPrivate int32_t
850 FcRandom (void);
851
852 FcPrivate FcBool
853 FcMakeDirectory (const FcChar8 *dir);
854
855 FcPrivate ssize_t
856 FcReadLink (const FcChar8 *pathname,
857 FcChar8 *buf,
858 size_t bufsiz);
859
860 /* fcdbg.c */
861
862 FcPrivate void
863 FcValuePrintFile (FILE *f, const FcValue v);
864
865 FcPrivate void
866 FcValuePrintWithPosition (const FcValue v, FcBool show_pos_mark);
867
868 FcPrivate void
869 FcValueListPrintWithPosition (FcValueListPtr l, const FcValueListPtr pos);
870
871 FcPrivate void
872 FcValueListPrint (FcValueListPtr l);
873
874 FcPrivate void
875 FcLangSetPrint (const FcLangSet *ls);
876
877 FcPrivate void
878 FcOpPrint (FcOp op);
879
880 FcPrivate void
881 FcTestPrint (const FcTest *test);
882
883 FcPrivate void
884 FcExprPrint (const FcExpr *expr);
885
886 FcPrivate void
887 FcEditPrint (const FcEdit *edit);
888
889 FcPrivate void
890 FcRulePrint (const FcRule *rule);
891
892 FcPrivate void
893 FcCharSetPrint (const FcCharSet *c);
894
895 FcPrivate void
896 FcPatternPrint2 (FcPattern *p1, FcPattern *p2, const FcObjectSet *os);
897
898 extern FcPrivate int FcDebugVal;
899
900 #define FcDebug() (FcDebugVal)
901
902 FcPrivate void
903 FcInitDebug (void);
904
905 /* fcdefault.c */
906 FcPrivate FcChar8 *
907 FcGetDefaultLang (void);
908
909 FcPrivate FcChar8 *
910 FcGetPrgname (void);
911
912 FcPrivate FcChar8 *
913 FcGetDesktopName (void);
914
915 FcPrivate void
916 FcDefaultFini (void);
917
918 /* fcdir.c */
919
920 FcPrivate FcBool
921 FcFileIsLink (const FcChar8 *file);
922
923 FcPrivate FcBool
924 FcFileIsFile (const FcChar8 *file);
925
926 FcPrivate FcBool
927 FcFileScanConfig (FcFontSet *set,
928 FcStrSet *dirs,
929 const FcChar8 *file,
930 FcConfig *config);
931
932 FcPrivate FcBool
933 FcDirScanConfig (FcFontSet *set,
934 FcStrSet *dirs,
935 const FcChar8 *dir,
936 FcBool force,
937 FcConfig *config);
938
939 /* fcfont.c */
940 FcPrivate int
941 FcFontDebug (void);
942
943 /* fcfs.c */
944
945 FcPrivate FcBool
946 FcFontSetSerializeAlloc (FcSerialize *serialize, const FcFontSet *s);
947
948 FcPrivate FcFontSet *
949 FcFontSetSerialize (FcSerialize *serialize, const FcFontSet * s);
950
951 FcPrivate FcFontSet *
952 FcFontSetDeserialize (const FcFontSet *set);
953
954 /* fcplist.c */
955 FcPrivate FcPtrList *
956 FcPtrListCreate (FcDestroyFunc func);
957
958 FcPrivate void
959 FcPtrListDestroy (FcPtrList *list);
960
961 FcPrivate void
962 FcPtrListIterInit (const FcPtrList *list,
963 FcPtrListIter *iter);
964
965 FcPrivate void
966 FcPtrListIterInitAtLast (FcPtrList *list,
967 FcPtrListIter *iter);
968
969 FcPrivate FcBool
970 FcPtrListIterNext (const FcPtrList *list,
971 FcPtrListIter *iter);
972
973 FcPrivate FcBool
974 FcPtrListIterIsValid (const FcPtrList *list,
975 const FcPtrListIter *iter);
976
977 FcPrivate void *
978 FcPtrListIterGetValue (const FcPtrList *list,
979 const FcPtrListIter *iter);
980
981 FcPrivate FcBool
982 FcPtrListIterAdd (FcPtrList *list,
983 FcPtrListIter *iter,
984 void *data);
985
986 FcPrivate FcBool
987 FcPtrListIterRemove (FcPtrList *list,
988 FcPtrListIter *iter);
989
990 /* fcinit.c */
991 FcPrivate FcConfig *
992 FcInitLoadOwnConfig (FcConfig *config);
993
994 FcPrivate FcConfig *
995 FcInitLoadOwnConfigAndFonts (FcConfig *config);
996
997 /* fcxml.c */
998 FcPrivate void
999 FcConfigPathFini (void);
1000
1001 FcPrivate void
1002 FcTestDestroy (FcTest *test);
1003
1004 FcPrivate void
1005 FcEditDestroy (FcEdit *e);
1006
1007 void
1008 FcRuleDestroy (FcRule *rule);
1009
1010 /* fclang.c */
1011 FcPrivate FcLangSet *
1012 FcFreeTypeLangSet (const FcCharSet *charset,
1013 const FcChar8 *exclusiveLang);
1014
1015 FcPrivate FcLangResult
1016 FcLangCompare (const FcChar8 *s1, const FcChar8 *s2);
1017
1018 FcPrivate FcLangSet *
1019 FcLangSetPromote (const FcChar8 *lang, FcValuePromotionBuffer *buf);
1020
1021 FcPrivate FcLangSet *
1022 FcNameParseLangSet (const FcChar8 *string);
1023
1024 FcPrivate FcBool
1025 FcNameUnparseLangSet (FcStrBuf *buf, const FcLangSet *ls);
1026
1027 FcPrivate FcChar8 *
1028 FcNameUnparseEscaped (FcPattern *pat, FcBool escape);
1029
1030 FcPrivate FcBool
1031 FcConfigParseOnly (FcConfig *config,
1032 const FcChar8 *name,
1033 FcBool complain);
1034
1035 FcPrivate FcChar8 *
1036 FcConfigRealFilename (FcConfig *config,
1037 const FcChar8 *url);
1038
1039 /* fclist.c */
1040
1041 FcPrivate FcBool
1042 FcListPatternMatchAny (const FcPattern *p,
1043 const FcPattern *font);
1044
1045 /* fcmatch.c */
1046
1047 /* fcname.c */
1048
1049 enum {
1050 FC_INVALID_OBJECT = 0,
1051 #define FC_OBJECT(NAME, Type, Cmp) FC_##NAME##_OBJECT,
1052 #include "fcobjs.h"
1053 #undef FC_OBJECT
1054 FC_ONE_AFTER_MAX_BASE_OBJECT
1055 #define FC_MAX_BASE_OBJECT (FC_ONE_AFTER_MAX_BASE_OBJECT - 1)
1056 };
1057
1058 FcPrivate FcBool
1059 FcNameConstantWithObjectCheck (const FcChar8 *string, const char *object, int *result);
1060
1061 FcPrivate FcBool
1062 FcNameBool (const FcChar8 *v, FcBool *result);
1063
1064 FcPrivate FcBool
1065 FcObjectValidType (FcObject object, FcType type);
1066
1067 FcPrivate FcObject
1068 FcObjectFromName (const char * name);
1069
1070 FcPrivate const char *
1071 FcObjectName (FcObject object);
1072
1073 FcPrivate FcObjectSet *
1074 FcObjectGetSet (void);
1075
1076 #define FcObjectCompare(a, b) ((int) a - (int) b)
1077
1078 /* fcpat.c */
1079
1080 FcPrivate FcValue
1081 FcValueCanonicalize (const FcValue *v);
1082
1083 FcPrivate FcValueListPtr
1084 FcValueListCreate (void);
1085
1086 FcPrivate void
1087 FcValueListDestroy (FcValueListPtr l);
1088
1089 FcPrivate FcValueListPtr
1090 FcValueListPrepend (FcValueListPtr vallist,
1091 FcValue value,
1092 FcValueBinding binding);
1093
1094 FcPrivate FcValueListPtr
1095 FcValueListAppend (FcValueListPtr vallist,
1096 FcValue value,
1097 FcValueBinding binding);
1098
1099 FcPrivate FcValueListPtr
1100 FcValueListDuplicate(FcValueListPtr orig);
1101
1102 FcPrivate FcPatternElt *
1103 FcPatternObjectFindElt (const FcPattern *p, FcObject object);
1104
1105 FcPrivate FcPatternElt *
1106 FcPatternObjectInsertElt (FcPattern *p, FcObject object);
1107
1108 FcPrivate FcBool
1109 FcPatternObjectListAdd (FcPattern *p,
1110 FcObject object,
1111 FcValueListPtr list,
1112 FcBool append);
1113
1114 FcPrivate FcBool
1115 FcPatternObjectAddWithBinding (FcPattern *p,
1116 FcObject object,
1117 FcValue value,
1118 FcValueBinding binding,
1119 FcBool append);
1120
1121 FcPrivate FcBool
1122 FcPatternObjectAdd (FcPattern *p, FcObject object, FcValue value, FcBool append);
1123
1124 FcPrivate FcBool
1125 FcPatternObjectAddWeak (FcPattern *p, FcObject object, FcValue value, FcBool append);
1126
1127 FcPrivate FcResult
1128 FcPatternObjectGetWithBinding (const FcPattern *p, FcObject object, int id, FcValue *v, FcValueBinding *b);
1129
1130 FcPrivate FcResult
1131 FcPatternObjectGet (const FcPattern *p, FcObject object, int id, FcValue *v);
1132
1133 FcPrivate FcBool
1134 FcPatternObjectDel (FcPattern *p, FcObject object);
1135
1136 FcPrivate FcBool
1137 FcPatternObjectRemove (FcPattern *p, FcObject object, int id);
1138
1139 FcPrivate FcBool
1140 FcPatternObjectAddInteger (FcPattern *p, FcObject object, int i);
1141
1142 FcPrivate FcBool
1143 FcPatternObjectAddDouble (FcPattern *p, FcObject object, double d);
1144
1145 FcPrivate FcBool
1146 FcPatternObjectAddString (FcPattern *p, FcObject object, const FcChar8 *s);
1147
1148 FcPrivate FcBool
1149 FcPatternObjectAddMatrix (FcPattern *p, FcObject object, const FcMatrix *s);
1150
1151 FcPrivate FcBool
1152 FcPatternObjectAddCharSet (FcPattern *p, FcObject object, const FcCharSet *c);
1153
1154 FcPrivate FcBool
1155 FcPatternObjectAddBool (FcPattern *p, FcObject object, FcBool b);
1156
1157 FcPrivate FcBool
1158 FcPatternObjectAddLangSet (FcPattern *p, FcObject object, const FcLangSet *ls);
1159
1160 FcPrivate FcBool
1161 FcPatternObjectAddRange (FcPattern *p, FcObject object, const FcRange *r);
1162
1163 FcPrivate FcResult
1164 FcPatternObjectGetInteger (const FcPattern *p, FcObject object, int n, int *i);
1165
1166 FcPrivate FcResult
1167 FcPatternObjectGetDouble (const FcPattern *p, FcObject object, int n, double *d);
1168
1169 FcPrivate FcResult
1170 FcPatternObjectGetString (const FcPattern *p, FcObject object, int n, FcChar8 ** s);
1171
1172 FcPrivate FcResult
1173 FcPatternObjectGetMatrix (const FcPattern *p, FcObject object, int n, FcMatrix **s);
1174
1175 FcPrivate FcResult
1176 FcPatternObjectGetCharSet (const FcPattern *p, FcObject object, int n, FcCharSet **c);
1177
1178 FcPrivate FcResult
1179 FcPatternObjectGetBool (const FcPattern *p, FcObject object, int n, FcBool *b);
1180
1181 FcPrivate FcResult
1182 FcPatternObjectGetLangSet (const FcPattern *p, FcObject object, int n, FcLangSet **ls);
1183
1184 FcPrivate FcResult
1185 FcPatternObjectGetRange (const FcPattern *p, FcObject object, int id, FcRange **r);
1186
1187 FcPrivate FcBool
1188 FcPatternAppend (FcPattern *p, FcPattern *s);
1189
1190 FcPrivate int
1191 FcPatternPosition (const FcPattern *p, const char *object);
1192
1193 FcPrivate FcBool
1194 FcPatternFindObjectIter (const FcPattern *pat, FcPatternIter *iter, FcObject object);
1195
1196 FcPrivate FcObject
1197 FcPatternIterGetObjectId (const FcPattern *pat, FcPatternIter *iter);
1198
1199 FcPrivate FcValueListPtr
1200 FcPatternIterGetValues (const FcPattern *pat, FcPatternIter *iter);
1201
1202 FcPrivate FcPattern *
1203 FcPatternCacheRewriteFile (const FcPattern *pat, FcCache *cache, const FcChar8 *relocated_font_file);
1204
1205 FcPrivate FcChar32
1206 FcStringHash (const FcChar8 *s);
1207
1208 FcPrivate FcBool
1209 FcPatternSerializeAlloc (FcSerialize *serialize, const FcPattern *pat);
1210
1211 FcPrivate FcPattern *
1212 FcPatternSerialize (FcSerialize *serialize, const FcPattern *pat);
1213
1214 FcPrivate FcBool
1215 FcValueListSerializeAlloc (FcSerialize *serialize, const FcValueList *pat);
1216
1217 FcPrivate FcValueList *
1218 FcValueListSerialize (FcSerialize *serialize, const FcValueList *pat);
1219
1220 /* fcrender.c */
1221
1222 /* fcmatrix.c */
1223
1224 extern FcPrivate const FcMatrix FcIdentityMatrix;
1225
1226 FcPrivate void
1227 FcMatrixFree (FcMatrix *mat);
1228
1229 /* fcrange.c */
1230
1231 FcPrivate FcRange *
1232 FcRangePromote (double v, FcValuePromotionBuffer *vbuf);
1233
1234 FcPrivate FcBool
1235 FcRangeIsInRange (const FcRange *a, const FcRange *b);
1236
1237 FcPrivate FcBool
1238 FcRangeCompare (FcOp op, const FcRange *a, const FcRange *b);
1239
1240 FcPrivate FcChar32
1241 FcRangeHash (const FcRange *r);
1242
1243 FcPrivate FcBool
1244 FcRangeSerializeAlloc (FcSerialize *serialize, const FcRange *r);
1245
1246 FcPrivate FcRange *
1247 FcRangeSerialize (FcSerialize *serialize, const FcRange *r);
1248
1249 /* fcstat.c */
1250
1251 FcPrivate int
1252 FcStat (const FcChar8 *file, struct stat *statb);
1253
1254 FcPrivate int
1255 FcStatChecksum (const FcChar8 *file, struct stat *statb);
1256
1257 FcPrivate FcBool
1258 FcIsFsMmapSafe (int fd);
1259
1260 FcPrivate FcBool
1261 FcIsFsMtimeBroken (const FcChar8 *dir);
1262
1263 /* fcstr.c */
1264 FcPrivate FcStrSet *
1265 FcStrSetCreateEx (unsigned int control);
1266
1267 FcPrivate FcBool
1268 FcStrSetInsert (FcStrSet *set, const FcChar8 *s, int pos);
1269
1270 FcPrivate FcBool
1271 FcStrSetAddLangs (FcStrSet *strs, const char *languages);
1272
1273 FcPrivate void
1274 FcStrSetSort (FcStrSet * set);
1275
1276 FcPrivate FcBool
1277 FcStrSetMemberAB (FcStrSet *set, const FcChar8 *a, FcChar8 *b, FcChar8 **ret);
1278
1279 FcPrivate FcBool
1280 FcStrSetAddTriple (FcStrSet *set, const FcChar8 *a, const FcChar8 *b, const FcChar8 *c);
1281
1282 FcPrivate const FcChar8 *
1283 FcStrTripleSecond (FcChar8 *s);
1284
1285 FcPrivate const FcChar8 *
1286 FcStrTripleThird (FcChar8 *str);
1287
1288 FcPrivate FcBool
1289 FcStrSetAddFilenamePairWithSalt (FcStrSet *strs, const FcChar8 *d, const FcChar8 *m, const FcChar8 *salt);
1290
1291 FcPrivate FcBool
1292 FcStrSetDeleteAll (FcStrSet *set);
1293
1294 FcPrivate void
1295 FcStrBufInit (FcStrBuf *buf, FcChar8 *init, int size);
1296
1297 FcPrivate void
1298 FcStrBufDestroy (FcStrBuf *buf);
1299
1300 FcPrivate FcChar8 *
1301 FcStrBufDone (FcStrBuf *buf);
1302
1303 FcPrivate FcChar8 *
1304 FcStrBufDoneStatic (FcStrBuf *buf);
1305
1306 FcPrivate FcBool
1307 FcStrBufChar (FcStrBuf *buf, FcChar8 c);
1308
1309 FcPrivate FcBool
1310 FcStrBufString (FcStrBuf *buf, const FcChar8 *s);
1311
1312 FcPrivate FcBool
1313 FcStrBufData (FcStrBuf *buf, const FcChar8 *s, int len);
1314
1315 FcPrivate int
1316 FcStrCmpIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2);
1317
1318 FcPrivate int
1319 FcStrCmpIgnoreCaseAndDelims (const FcChar8 *s1, const FcChar8 *s2, const FcChar8 *delims);
1320
1321 FcPrivate const FcChar8 *
1322 FcStrContainsIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2);
1323
1324 FcPrivate const FcChar8 *
1325 FcStrContainsIgnoreCase (const FcChar8 *s1, const FcChar8 *s2);
1326
1327 FcPrivate const FcChar8 *
1328 FcStrContainsWord (const FcChar8 *s1, const FcChar8 *s2);
1329
1330 FcPrivate int
1331 FcStrMatchIgnoreCaseAndDelims (const FcChar8 *s1, const FcChar8 *s2, const FcChar8 *delims);
1332
1333 FcPrivate FcBool
1334 FcStrGlobMatch (const FcChar8 *glob,
1335 const FcChar8 *string);
1336
1337 FcPrivate FcBool
1338 FcStrUsesHome (const FcChar8 *s);
1339
1340 FcPrivate FcBool
1341 FcStrIsAbsoluteFilename (const FcChar8 *s);
1342
1343 FcPrivate FcChar8 *
1344 FcStrLastSlash (const FcChar8 *path);
1345
1346 FcPrivate FcChar32
1347 FcStrHashIgnoreCase (const FcChar8 *s);
1348
1349 FcPrivate FcChar32
1350 FcStrHashIgnoreBlanksAndCase (const FcChar8 *s);
1351
1352 FcPrivate FcChar8 *
1353 FcStrRealPath (const FcChar8 *path);
1354
1355 FcPrivate FcChar8 *
1356 FcStrCanonFilename (const FcChar8 *s);
1357
1358 FcPrivate FcBool
1359 FcStrSerializeAlloc (FcSerialize *serialize, const FcChar8 *str);
1360
1361 FcPrivate FcChar8 *
1362 FcStrSerialize (FcSerialize *serialize, const FcChar8 *str);
1363
1364 /* fcobjs.c */
1365
1366 FcPrivate void
1367 FcObjectFini (void);
1368
1369 FcPrivate FcObject
1370 FcObjectLookupIdByName (const char *str);
1371
1372 FcPrivate FcObject
1373 FcObjectLookupBuiltinIdByName (const char *str);
1374
1375 FcPrivate const char *
1376 FcObjectLookupOtherNameById (FcObject id);
1377
1378 FcPrivate const FcObjectType *
1379 FcObjectLookupOtherTypeById (FcObject id);
1380
1381 FcPrivate const FcObjectType *
1382 FcObjectLookupOtherTypeByName (const char *str);
1383
1384 /* fchash.c */
1385 FcPrivate FcBool
1386 FcHashStrCopy (const void *src,
1387 void **dest);
1388
1389 FcPrivate FcBool
1390 FcHashUuidCopy (const void *src,
1391 void **dest);
1392
1393 FcPrivate void
1394 FcHashUuidFree (void *data);
1395
1396 FcPrivate FcHashTable *
1397 FcHashTableCreate (FcHashFunc hash_func,
1398 FcCompareFunc compare_func,
1399 FcCopyFunc key_copy_func,
1400 FcCopyFunc value_copy_func,
1401 FcDestroyFunc key_destroy_func,
1402 FcDestroyFunc value_destroy_func);
1403
1404 FcPrivate void
1405 FcHashTableDestroy (FcHashTable *table);
1406
1407 FcPrivate FcBool
1408 FcHashTableFind (FcHashTable *table,
1409 const void *key,
1410 void **value);
1411
1412 FcPrivate FcBool
1413 FcHashTableAdd (FcHashTable *table,
1414 void *key,
1415 void *value);
1416
1417 FcPrivate FcBool
1418 FcHashTableReplace (FcHashTable *table,
1419 void *key,
1420 void *value);
1421
1422 FcPrivate FcBool
1423 FcHashTableRemove (FcHashTable *table,
1424 void *key);
1425
1426 #endif /* _FC_INT_H_ */