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 "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_ */