src/fcint.h

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