src/fcint.h

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