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