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 #include <stdlib.h>
  29 #include <stdio.h>
  30 #include <string.h>
  31 #include <ctype.h>
  32 #include <errno.h>
  33 #include <unistd.h>
  34 #include <sys/types.h>
  35 #include <sys/stat.h>
  36 #include <time.h>
  37 #include <fontconfig/fontconfig.h>
  38 #include <fontconfig/fcprivate.h>
  39 #include <fontconfig/fcfreetype.h>
  40 #ifdef HAVE_CONFIG_H
  41 #include <config.h>
  42 #endif
  43
  44 #ifndef FC_CONFIG_PATH
  45 #define FC_CONFIG_PATH "fonts.conf"
  46 #endif
  47
  48 #define FC_FONT_FILE_INVALID    ((FcChar8 *) ".")
  49 #define FC_FONT_FILE_DIR        ((FcChar8 *) ".dir")
  50
  51 #ifdef _WIN32
  52 #define FC_SEARCH_PATH_SEPARATOR ';'
  53 #else
  54 #define FC_SEARCH_PATH_SEPARATOR ':'
  55 #endif
  56
  57 #define FC_DBG_MATCH    1
  58 #define FC_DBG_MATCHV   2
  59 #define FC_DBG_EDIT     4
  60 #define FC_DBG_FONTSET  8
  61 #define FC_DBG_CACHE    16
  62 #define FC_DBG_CACHEV   32
  63 #define FC_DBG_PARSE    64
  64 #define FC_DBG_SCAN     128
  65 #define FC_DBG_SCANV    256
  66 #define FC_DBG_MEMORY   512
  67 #define FC_DBG_CONFIG   1024
  68
  69 #define FC_MEM_CHARSET      0
  70 #define FC_MEM_CHARLEAF     1
  71 #define FC_MEM_FONTSET      2
  72 #define FC_MEM_FONTPTR      3
  73 #define FC_MEM_OBJECTSET    4
  74 #define FC_MEM_OBJECTPTR    5
  75 #define FC_MEM_MATRIX       6
  76 #define FC_MEM_PATTERN      7
  77 #define FC_MEM_PATELT       8
  78 #define FC_MEM_VALLIST      9
  79 #define FC_MEM_SUBSTATE     10
  80 #define FC_MEM_STRING       11
  81 #define FC_MEM_LISTBUCK     12
  82 #define FC_MEM_STRSET       13
  83 #define FC_MEM_STRLIST      14
  84 #define FC_MEM_CONFIG       15
  85 #define FC_MEM_LANGSET      16
  86 #define FC_MEM_ATOMIC       17
  87 #define FC_MEM_BLANKS       18
  88 #define FC_MEM_CACHE        19
  89 #define FC_MEM_STRBUF       20
  90 #define FC_MEM_SUBST        21
  91 #define FC_MEM_OBJECTTYPE   22
  92 #define FC_MEM_CONSTANT     23
  93 #define FC_MEM_TEST         24
  94 #define FC_MEM_EXPR         25
  95 #define FC_MEM_VSTACK       26
  96 #define FC_MEM_ATTR         27
  97 #define FC_MEM_PSTACK       28
  98 #define FC_MEM_STATICSTR    29
  99
 100 #define FC_MEM_NUM          30
 101
 102 typedef enum _FcValueBinding {
 103     FcValueBindingWeak, FcValueBindingStrong, FcValueBindingSame
 104 } FcValueBinding;
 105
 106 typedef struct _FcValueListPtr {
 107     int                 bank;
 108     union {
 109         int                 stat;
 110         struct _FcValueList *dyn;
 111     } u;
 112 } FcValueListPtr;
 113
 114 typedef struct _FcValueList {
 115     FcValueListPtr          next;
 116
 117     FcValue                 value;
 118     FcValueBinding          binding;
 119 } FcValueList;
 120
 121 typedef int FcObjectPtr;
 122
 123 typedef struct _FcPatternEltPtr {
 124     int                 bank;
 125     union {
 126         int                 stat;
 127         struct _FcPatternElt *dyn;
 128     } u;
 129 } FcPatternEltPtr;
 130
 131 typedef struct _FcPatternElt {
 132     FcObjectPtr             object;
 133     FcValueListPtr          values;
 134 } FcPatternElt;
 135
 136 struct _FcPattern {
 137     int             num;
 138     int             size;
 139     FcPatternEltPtr elts;
 140     int             ref;
 141     int             bank;
 142 };
 143
 144 typedef enum _FcOp {
 145     FcOpInteger, FcOpDouble, FcOpString, FcOpMatrix, FcOpBool, FcOpCharSet,
 146     FcOpNil,
 147     FcOpField, FcOpConst,
 148     FcOpAssign, FcOpAssignReplace,
 149     FcOpPrependFirst, FcOpPrepend, FcOpAppend, FcOpAppendLast,
 150     FcOpQuest,
 151     FcOpOr, FcOpAnd, FcOpEqual, FcOpNotEqual,
 152     FcOpContains, FcOpListing, FcOpNotContains,
 153     FcOpLess, FcOpLessEqual, FcOpMore, FcOpMoreEqual,
 154     FcOpPlus, FcOpMinus, FcOpTimes, FcOpDivide,
 155     FcOpNot, FcOpComma, FcOpFloor, FcOpCeil, FcOpRound, FcOpTrunc,
 156     FcOpInvalid
 157 } FcOp;
 158
 159 typedef struct _FcExpr {
 160     FcOp   op;
 161     union {
 162         int         ival;
 163         double      dval;
 164         FcChar8     *sval;
 165         FcMatrix    *mval;
 166         FcBool      bval;
 167         FcCharSet   *cval;
 168         char        *field;
 169         FcChar8     *constant;
 170         struct {
 171             struct _FcExpr *left, *right;
 172         } tree;
 173     } u;
 174 } FcExpr;
 175
 176 typedef enum _FcQual {
 177     FcQualAny, FcQualAll, FcQualFirst, FcQualNotFirst
 178 } FcQual;
 179
 180 #define FcMatchDefault  ((FcMatchKind) -1)
 181
 182 typedef struct _FcTest {
 183     struct _FcTest      *next;
 184     FcMatchKind         kind;
 185     FcQual              qual;
 186     const char          *field;
 187     FcOp                op;
 188     FcExpr              *expr;
 189 } FcTest;
 190
 191 typedef struct _FcEdit {
 192     struct _FcEdit *next;
 193     const char      *field;
 194     FcOp            op;
 195     FcExpr          *expr;
 196     FcValueBinding  binding;
 197 } FcEdit;
 198
 199 typedef struct _FcSubst {
 200     struct _FcSubst     *next;
 201     FcTest              *test;
 202     FcEdit              *edit;
 203 } FcSubst;
 204
 205 typedef struct _FcCharLeaf {
 206     FcChar32    map[256/32];
 207 } FcCharLeaf;
 208
 209 #define FC_REF_CONSTANT     -1
 210
 211 struct _FcCharSet {
 212     int             ref;        /* reference count */
 213     int             num;        /* size of leaves and numbers arrays */
 214     int             bank;
 215     union {
 216         struct {
 217             FcCharLeaf  **leaves;
 218             FcChar16    *numbers;
 219         } dyn;
 220         struct {
 221             int         leafidx_offset;
 222             int         numbers_offset;
 223         } stat;
 224     } u;
 225 };
 226
 227 struct _FcStrSet {
 228     int             ref;        /* reference count */
 229     int             num;
 230     int             size;
 231     FcChar8         **strs;
 232 };
 233
 234 struct _FcStrList {
 235     FcStrSet        *set;
 236     int             n;
 237 };
 238
 239 typedef struct _FcStrBuf {
 240     FcChar8 *buf;
 241     FcBool  allocated;
 242     FcBool  failed;
 243     int     len;
 244     int     size;
 245 } FcStrBuf;
 246
 247 typedef struct _FcCache {
 248     int     magic;
 249     int     count;
 250     int     bank;
 251     int     pattern_count;
 252     int     patternelt_count;
 253     int     valuelist_count;
 254     int     str_count;
 255     int     langset_count;
 256     int     charset_count;
 257     int     charset_numbers_count;
 258     int     charset_leaf_count;
 259     int     charset_leaf_idx_count;
 260 } FcCache;
 261
 262 /*
 263  * To map adobe glyph names to unicode values, a precomputed hash
 264  * table is used
 265  */
 266
 267 typedef struct _FcGlyphName {
 268     FcChar32    ucs;            /* unicode value */
 269     FcChar8     name[1];        /* name extends beyond struct */
 270 } FcGlyphName;
 271
 272 /*
 273  * To perform case-insensitive string comparisons, a table
 274  * is used which holds three different kinds of folding data.
 275  *
 276  * The first is a range of upper case values mapping to a range
 277  * of their lower case equivalents.  Within each range, the offset
 278  * between upper and lower case is constant.
 279  *
 280  * The second is a range of upper case values which are interleaved
 281  * with their lower case equivalents.
 282  *
 283  * The third is a set of raw unicode values mapping to a list
 284  * of unicode values for comparison purposes.  This allows conversion
 285  * of ß to "ss" so that SS, ss and ß all match.  A separate array
 286  * holds the list of unicode values for each entry.
 287  *
 288  * These are packed into a single table.  Using a binary search,
 289  * the appropriate entry can be located.
 290  */
 291
 292 #define FC_CASE_FOLD_RANGE          0
 293 #define FC_CASE_FOLD_EVEN_ODD       1
 294 #define FC_CASE_FOLD_FULL           2
 295
 296 typedef struct _FcCaseFold {
 297     FcChar32    upper;
 298     FcChar16    method : 2;
 299     FcChar16    count : 14;
 300     short       offset;     /* lower - upper for RANGE, table id for FULL */
 301 } FcCaseFold;
 302
 303 #define FC_MAX_FILE_LEN     4096
 304
 305 #define FC_STORAGE_STATIC 0x80
 306 #define fc_value_string(v)  (((v)->type & FC_STORAGE_STATIC) ? ((FcChar8 *) v) + (v)->u.s_off : (v) -> u.s)
 307 #define fc_value_charset(v)  (((v)->type & FC_STORAGE_STATIC) ? (const FcCharSet *)(((char *) v) + (v)->u.c_off) : (v) -> u.c)
 308 #define fc_value_langset(v)  (((v)->type & FC_STORAGE_STATIC) ? (const FcLangSet *)(((char *) v) + (v)->u.l_off) : (v) -> u.l)
 309
 310 /*
 311  * The per-user ~/.fonts.cache-<version> file is loaded into
 312  * this data structure.  Each directory gets a substructure
 313  * which is validated by comparing the directory timestamp with
 314  * that saved in the cache.  When valid, the entire directory cache
 315  * can be immediately loaded without reading the directory.  Otherwise,
 316  * the files are checked individually; updated files are loaded into the
 317  * cache which is then rewritten to the users home directory
 318  */
 319
 320 #define FC_CACHE_MAGIC 0xFC02FC02
 321
 322 typedef struct _FcGlobalCacheDir FcGlobalCacheDir;
 323
 324 struct _FcGlobalCacheDir {
 325     struct _FcGlobalCacheDir    *next;
 326     FcChar8                     *name;
 327     FcCache                     metadata;
 328     off_t                       offset;
 329     void                        *ent;
 330 };
 331
 332 typedef struct _FcGlobalCache {
 333     FcGlobalCacheDir            *dirs;
 334     FcBool                      updated;
 335     int                         fd;
 336 } FcGlobalCache;
 337
 338 struct _FcAtomic {
 339     FcChar8     *file;          /* original file name */
 340     FcChar8     *new;           /* temp file name -- write data here */
 341     FcChar8     *lck;           /* lockfile name (used for locking) */
 342     FcChar8     *tmp;           /* tmpfile name (used for locking) */
 343 };
 344
 345 struct _FcBlanks {
 346     int         nblank;
 347     int         sblank;
 348     FcChar32    *blanks;
 349 };
 350
 351 struct _FcConfig {
 352     /*
 353      * File names loaded from the configuration -- saved here as the
 354      * cache file must be consulted before the directories are scanned,
 355      * and those directives may occur in any order
 356      */
 357     FcStrSet    *configDirs;        /* directories to scan for fonts */
 358     FcChar8     *cache;             /* name of per-user cache file */
 359     /*
 360      * Set of allowed blank chars -- used to
 361      * trim fonts of bogus glyphs
 362      */
 363     FcBlanks    *blanks;
 364     /*
 365      * List of directories containing fonts,
 366      * built by recursively scanning the set
 367      * of configured directories
 368      */
 369     FcStrSet    *fontDirs;
 370     /*
 371      * Names of all of the configuration files used
 372      * to create this configuration
 373      */
 374     FcStrSet    *configFiles;       /* config files loaded */
 375     /*
 376      * Substitution instructions for patterns and fonts;
 377      * maxObjects is used to allocate appropriate intermediate storage
 378      * while performing a whole set of substitutions
 379      */
 380     FcSubst     *substPattern;      /* substitutions for patterns */
 381     FcSubst     *substFont;         /* substitutions for fonts */
 382     int         maxObjects;         /* maximum number of tests in all substs */
 383     /*
 384      * List of patterns used to control font file selection
 385      */
 386     FcStrSet    *acceptGlobs;
 387     FcStrSet    *rejectGlobs;
 388     FcFontSet   *acceptPatterns;
 389     FcFontSet   *rejectPatterns;
 390     /*
 391      * The set of fonts loaded from the listed directories; the
 392      * order within the set does not determine the font selection,
 393      * except in the case of identical matches in which case earlier fonts
 394      * match preferrentially
 395      */
 396     FcFontSet   *fonts[FcSetApplication + 1];
 397     /*
 398      * Fontconfig can periodically rescan the system configuration
 399      * and font directories.  This rescanning occurs when font
 400      * listing requests are made, but no more often than rescanInterval
 401      * seconds apart.
 402      */
 403     time_t      rescanTime;         /* last time information was scanned */
 404     int         rescanInterval;     /* interval between scans */
 405 };
 406
 407 extern FcConfig *_fcConfig;
 408
 409 typedef struct _FcCharMap FcCharMap;
 410
 411 /* fcblanks.c */
 412
 413 /* fccache.c */
 414
 415 FcGlobalCache *
 416 FcGlobalCacheCreate (void);
 417
 418 void
 419 FcGlobalCacheDestroy (FcGlobalCache *cache);
 420
 421 FcBool
 422 FcGlobalCacheReadDir (FcFontSet     *set,
 423                       FcStrSet      *dirs,
 424                       FcGlobalCache *cache,
 425                       const FcChar8 *dir,
 426                       FcConfig      *config);
 427
 428 void
 429 FcGlobalCacheLoad (FcGlobalCache    *cache,
 430                    const FcChar8    *cache_file);
 431
 432 FcBool
 433 FcGlobalCacheUpdate (FcGlobalCache  *cache,
 434                      const FcChar8  *file,
 435                      FcFontSet      *set);
 436
 437 FcBool
 438 FcGlobalCacheSave (FcGlobalCache    *cache,
 439                    const FcChar8    *cache_file);
 440
 441 FcFontSet *
 442 FcCacheRead (FcConfig *config, FcGlobalCache * cache);
 443
 444 FcBool
 445 FcDirCacheWrite (FcFontSet *set, const FcChar8 *dir);
 446
 447 int
 448 FcCacheBankToIndex (int bank);
 449
 450 /* fccfg.c */
 451
 452 FcBool
 453 FcConfigAddConfigDir (FcConfig      *config,
 454                       const FcChar8 *d);
 455
 456 FcBool
 457 FcConfigAddFontDir (FcConfig        *config,
 458                     const FcChar8   *d);
 459
 460 FcBool
 461 FcConfigAddDir (FcConfig        *config,
 462                 const FcChar8   *d);
 463
 464 FcBool
 465 FcConfigAddConfigFile (FcConfig         *config,
 466                        const FcChar8    *f);
 467
 468 FcBool
 469 FcConfigSetCache (FcConfig      *config,
 470                   const FcChar8 *c);
 471
 472 FcBool
 473 FcConfigAddBlank (FcConfig      *config,
 474                   FcChar32      blank);
 475
 476 FcBool
 477 FcConfigAddEdit (FcConfig       *config,
 478                  FcTest         *test,
 479                  FcEdit         *edit,
 480                  FcMatchKind    kind);
 481
 482 void
 483 FcConfigSetFonts (FcConfig      *config,
 484                   FcFontSet     *fonts,
 485                   FcSetName     set);
 486
 487 FcBool
 488 FcConfigCompareValue (const FcValue *m,
 489                       FcOp          op,
 490                       const FcValue *v);
 491
 492 FcBool
 493 FcConfigGlobAdd (FcConfig       *config,
 494                  const FcChar8  *glob,
 495                  FcBool         accept);
 496
 497 FcBool
 498 FcConfigAcceptFilename (FcConfig        *config,
 499                         const FcChar8   *filename);
 500
 501 FcBool
 502 FcConfigPatternsAdd (FcConfig   *config,
 503                      FcPattern  *pattern,
 504                      FcBool     accept);
 505
 506 FcBool
 507 FcConfigAcceptFont (FcConfig        *config,
 508                     const FcPattern *font);
 509
 510 /* fccharset.c */
 511 FcCharSet *
 512 FcCharSetFreeze (FcCharSet *cs);
 513
 514 void
 515 FcCharSetThawAll (void);
 516
 517 FcBool
 518 FcNameUnparseCharSet (FcStrBuf *buf, const FcCharSet *c);
 519
 520 FcCharSet *
 521 FcNameParseCharSet (FcChar8 *string);
 522
 523 FcCharLeaf *
 524 FcCharSetFindLeafCreate (FcCharSet *fcs, FcChar32 ucs4);
 525
 526 void
 527 FcCharSetNewBank (void);
 528
 529 int
 530 FcCharSetNeededBytes (const FcCharSet *c);
 531
 532 void *
 533 FcCharSetDistributeBytes (FcCache * metadata,
 534                           void * block_ptr);
 535
 536 FcCharSet *
 537 FcCharSetSerialize(int bank, FcCharSet *c);
 538
 539 void *
 540 FcCharSetUnserialize (FcCache metadata, void *block_ptr);
 541
 542 FcCharLeaf *
 543 FcCharSetGetLeaf(const FcCharSet *c, int i);
 544
 545 FcChar16 *
 546 FcCharSetGetNumbers(const FcCharSet *c);
 547
 548 /* fcdbg.c */
 549 void
 550 FcValueListPrint (const FcValueListPtr l);
 551
 552 void
 553 FcLangSetPrint (const FcLangSet *ls);
 554
 555 void
 556 FcOpPrint (FcOp op);
 557
 558 void
 559 FcTestPrint (const FcTest *test);
 560
 561 void
 562 FcExprPrint (const FcExpr *expr);
 563
 564 void
 565 FcEditPrint (const FcEdit *edit);
 566
 567 void
 568 FcSubstPrint (const FcSubst *subst);
 569
 570 int
 571 FcDebug (void);
 572
 573 /* fcdir.c */
 574
 575 FcBool
 576 FcFileIsDir (const FcChar8 *file);
 577
 578 FcBool
 579 FcFileScanConfig (FcFontSet     *set,
 580                   FcStrSet      *dirs,
 581                   FcFileCache   *cache,
 582                   FcBlanks      *blanks,
 583                   const FcChar8 *file,
 584                   FcBool        force,
 585                   FcConfig      *config);
 586
 587 FcBool
 588 FcDirScanConfig (FcFontSet      *set,
 589                  FcStrSet       *dirs,
 590                  FcFileCache    *cache,
 591                  FcBlanks       *blanks,
 592                  const FcChar8  *dir,
 593                  FcBool         force,
 594                  FcConfig       *config);
 595
 596 /* fcfont.c */
 597 int
 598 FcFontDebug (void);
 599
 600 /* fcfreetype.c */
 601 FcBool
 602 FcFreeTypeIsExclusiveLang (const FcChar8  *lang);
 603
 604 FcBool
 605 FcFreeTypeHasLang (FcPattern *pattern, const FcChar8 *lang);
 606
 607 FcChar32
 608 FcFreeTypeUcs4ToPrivate (FcChar32 ucs4, const FcCharMap *map);
 609
 610 FcChar32
 611 FcFreeTypePrivateToUcs4 (FcChar32 private, const FcCharMap *map);
 612
 613 const FcCharMap *
 614 FcFreeTypeGetPrivateMap (FT_Encoding encoding);
 615
 616 /* fcfs.c */
 617
 618 void
 619 FcFontSetNewBank (void);
 620
 621 int
 622 FcFontSetNeededBytes (FcFontSet *s);
 623
 624 void *
 625 FcFontSetDistributeBytes (FcCache * metadata, void * block_ptr);
 626
 627 FcBool
 628 FcFontSetSerialize (int bank, FcFontSet * s);
 629
 630 FcBool
 631 FcFontSetUnserialize(FcCache metadata, FcFontSet * s, void * block_ptr);
 632
 633 /* fcgram.y */
 634 int
 635 FcConfigparse (void);
 636
 637 int
 638 FcConfigwrap (void);
 639
 640 void
 641 FcConfigerror (char *fmt, ...);
 642
 643 char *
 644 FcConfigSaveField (const char *field);
 645
 646 void
 647 FcTestDestroy (FcTest *test);
 648
 649 FcExpr *
 650 FcExprCreateInteger (int i);
 651
 652 FcExpr *
 653 FcExprCreateDouble (double d);
 654
 655 FcExpr *
 656 FcExprCreateString (const FcChar8 *s);
 657
 658 FcExpr *
 659 FcExprCreateMatrix (const FcMatrix *m);
 660
 661 FcExpr *
 662 FcExprCreateBool (FcBool b);
 663
 664 FcExpr *
 665 FcExprCreateNil (void);
 666
 667 FcExpr *
 668 FcExprCreateField (const char *field);
 669
 670 FcExpr *
 671 FcExprCreateConst (const FcChar8 *constant);
 672
 673 FcExpr *
 674 FcExprCreateOp (FcExpr *left, FcOp op, FcExpr *right);
 675
 676 void
 677 FcExprDestroy (FcExpr *e);
 678
 679 void
 680 FcEditDestroy (FcEdit *e);
 681
 682 /* fcinit.c */
 683
 684 void
 685 FcMemReport (void);
 686
 687 void
 688 FcMemAlloc (int kind, int size);
 689
 690 void
 691 FcMemFree (int kind, int size);
 692
 693 /* fclang.c */
 694 FcLangSet *
 695 FcFreeTypeLangSet (const FcCharSet  *charset,
 696                    const FcChar8    *exclusiveLang);
 697
 698 FcLangResult
 699 FcLangCompare (const FcChar8 *s1, const FcChar8 *s2);
 700
 701 const FcCharSet *
 702 FcCharSetForLang (const FcChar8 *lang);
 703
 704 FcLangSet *
 705 FcLangSetPromote (const FcChar8 *lang);
 706
 707 FcLangSet *
 708 FcNameParseLangSet (const FcChar8 *string);
 709
 710 FcBool
 711 FcNameUnparseLangSet (FcStrBuf *buf, const FcLangSet *ls);
 712
 713 void
 714 FcLangSetNewBank (void);
 715
 716 int
 717 FcLangSetNeededBytes (const FcLangSet *l);
 718
 719 void *
 720 FcLangSetDistributeBytes (FcCache * metadata,
 721                           void * block_ptr);
 722
 723 FcLangSet *
 724 FcLangSetSerialize (int bank, FcLangSet *l);
 725
 726 void *
 727 FcLangSetUnserialize (FcCache metadata, void *block_ptr);
 728
 729 /* fclist.c */
 730
 731 FcBool
 732 FcListPatternMatchAny (const FcPattern *p,
 733                        const FcPattern *font);
 734
 735 /* fcmatch.c */
 736
 737 /* fcname.c */
 738
 739 FcBool
 740 FcNameBool (const FcChar8 *v, FcBool *result);
 741
 742 void *
 743 FcObjectDistributeBytes (FcCache * metadata,
 744                          void * block_ptr);
 745
 746 FcObjectPtr
 747 FcObjectToPtr (const char * si);
 748
 749 int
 750 FcObjectNeededBytes (void);
 751
 752 void *
 753 FcObjectUnserialize (FcCache metadata, void *block_ptr);
 754
 755 void
 756 FcObjectSerialize (void);
 757
 758 const char *
 759 FcObjectPtrU (FcObjectPtr p);
 760
 761 int
 762 FcObjectPtrCompare (FcObjectPtr a, FcObjectPtr b);
 763
 764 void
 765 FcObjectStaticNameFini (void);
 766
 767 /* fcpat.c */
 768
 769 FcValue
 770 FcValueCanonicalize (const FcValue *v);
 771
 772 void
 773 FcValueListDestroy (FcValueListPtr l);
 774
 775 FcPatternElt *
 776 FcPatternFindElt (const FcPattern *p, const char *object);
 777
 778 FcPatternElt *
 779 FcPatternInsertElt (FcPattern *p, const char *object);
 780
 781 FcBool
 782 FcPatternAddWithBinding  (FcPattern         *p,
 783                           const char        *object,
 784                           FcValue           value,
 785                           FcValueBinding    binding,
 786                           FcBool            append);
 787
 788 FcPattern *
 789 FcPatternFreeze (FcPattern *p);
 790
 791 void
 792 FcPatternFini (void);
 793
 794 FcBool
 795 FcPatternAppend (FcPattern *p, FcPattern *s);
 796
 797 const char *
 798 FcStrStaticName (const char *name);
 799
 800 FcChar32
 801 FcStringHash (const FcChar8 *s);
 802
 803 void
 804 FcPatternNewBank (void);
 805
 806 int
 807 FcPatternNeededBytes (FcPattern *p);
 808
 809 void *
 810 FcPatternDistributeBytes (FcCache * metadata, void * block_ptr);
 811
 812 FcValueList *
 813 FcValueListPtrU(FcValueListPtr p);
 814
 815 FcPatternElt *
 816 FcPatternEltU (FcPatternEltPtr pei);
 817
 818 FcValueListPtr
 819 FcValueListPtrCreateDynamic(FcValueList * p);
 820
 821 FcPattern *
 822 FcPatternSerialize (int bank, FcPattern * p);
 823
 824 void *
 825 FcPatternUnserialize (FcCache metadata, void *block_ptr);
 826
 827 /* fcrender.c */
 828
 829 /* fcmatrix.c */
 830
 831 extern const FcMatrix    FcIdentityMatrix;
 832
 833 void
 834 FcMatrixFree (FcMatrix *mat);
 835
 836 /* fcstr.c */
 837 void
 838 FcStrSetSort (FcStrSet * set);
 839
 840 FcChar8 *
 841 FcStrPlus (const FcChar8 *s1, const FcChar8 *s2);
 842
 843 void
 844 FcStrFree (FcChar8 *s);
 845
 846 void
 847 FcStrBufInit (FcStrBuf *buf, FcChar8 *init, int size);
 848
 849 void
 850 FcStrBufDestroy (FcStrBuf *buf);
 851
 852 FcChar8 *
 853 FcStrBufDone (FcStrBuf *buf);
 854
 855 FcBool
 856 FcStrBufChar (FcStrBuf *buf, FcChar8 c);
 857
 858 FcBool
 859 FcStrBufString (FcStrBuf *buf, const FcChar8 *s);
 860
 861 FcBool
 862 FcStrBufData (FcStrBuf *buf, const FcChar8 *s, int len);
 863
 864 int
 865 FcStrCmpIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2);
 866
 867 const FcChar8 *
 868 FcStrContainsIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2);
 869
 870 const FcChar8 *
 871 FcStrContainsIgnoreCase (const FcChar8 *s1, const FcChar8 *s2);
 872
 873 FcBool
 874 FcStrUsesHome (const FcChar8 *s);
 875
 876 FcChar8 *
 877 FcStrLastSlash (const FcChar8  *path);
 878
 879 FcChar32
 880 FcStrHashIgnoreCase (const FcChar8 *s);
 881
 882 #endif /* _FC_INT_H_ */