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 typedef struct _FcSymbolic {
  45     const char  *name;
  46     int         value;
  47 } FcSymbolic;
  48
  49 #ifndef FC_CONFIG_PATH
  50 #define FC_CONFIG_PATH "fonts.conf"
  51 #endif
  52
  53 #define FC_FONT_FILE_INVALID    ((FcChar8 *) ".")
  54 #define FC_FONT_FILE_DIR        ((FcChar8 *) ".dir")
  55
  56 #ifdef _WIN32
  57 #define FC_SEARCH_PATH_SEPARATOR ';'
  58 #else
  59 #define FC_SEARCH_PATH_SEPARATOR ':'
  60 #endif
  61
  62 #define FC_DBG_MATCH    1
  63 #define FC_DBG_MATCHV   2
  64 #define FC_DBG_EDIT     4
  65 #define FC_DBG_FONTSET  8
  66 #define FC_DBG_CACHE    16
  67 #define FC_DBG_CACHEV   32
  68 #define FC_DBG_PARSE    64
  69 #define FC_DBG_SCAN     128
  70 #define FC_DBG_SCANV    256
  71 #define FC_DBG_MEMORY   512
  72
  73 #define FC_MEM_CHARSET      0
  74 #define FC_MEM_CHARLEAF     1
  75 #define FC_MEM_FONTSET      2
  76 #define FC_MEM_FONTPTR      3
  77 #define FC_MEM_OBJECTSET    4
  78 #define FC_MEM_OBJECTPTR    5
  79 #define FC_MEM_MATRIX       6
  80 #define FC_MEM_PATTERN      7
  81 #define FC_MEM_PATELT       8
  82 #define FC_MEM_VALLIST      9
  83 #define FC_MEM_SUBSTATE     10
  84 #define FC_MEM_STRING       11
  85 #define FC_MEM_LISTBUCK     12
  86 #define FC_MEM_STRSET       13
  87 #define FC_MEM_STRLIST      14
  88 #define FC_MEM_CONFIG       15
  89 #define FC_MEM_LANGSET      16
  90 #define FC_MEM_ATOMIC       17
  91 #define FC_MEM_BLANKS       18
  92 #define FC_MEM_CACHE        19
  93 #define FC_MEM_STRBUF       20
  94 #define FC_MEM_SUBST        21
  95 #define FC_MEM_OBJECTTYPE   22
  96 #define FC_MEM_CONSTANT     23
  97 #define FC_MEM_TEST         24
  98 #define FC_MEM_EXPR         25
  99 #define FC_MEM_VSTACK       26
 100 #define FC_MEM_ATTR         27
 101 #define FC_MEM_PSTACK       28
 102
 103 #define FC_MEM_NUM          29
 104
 105 typedef enum _FcValueBinding {
 106     FcValueBindingWeak, FcValueBindingStrong, FcValueBindingSame
 107 } FcValueBinding;
 108
 109 typedef struct _FcValueList {
 110     struct _FcValueList    *next;
 111     FcValue                 value;
 112     FcValueBinding          binding;
 113 } FcValueList;
 114
 115 typedef struct _FcPatternElt {
 116     const char      *object;
 117     FcValueList     *values;
 118 } FcPatternElt;
 119
 120
 121 struct _FcPattern {
 122     int             num;
 123     int             size;
 124     FcPatternElt    *elts;
 125     int             ref;
 126 };
 127
 128 typedef enum _FcOp {
 129     FcOpInteger, FcOpDouble, FcOpString, FcOpMatrix, FcOpBool, FcOpCharSet,
 130     FcOpNil,
 131     FcOpField, FcOpConst,
 132     FcOpAssign, FcOpAssignReplace,
 133     FcOpPrependFirst, FcOpPrepend, FcOpAppend, FcOpAppendLast,
 134     FcOpQuest,
 135     FcOpOr, FcOpAnd, FcOpEqual, FcOpNotEqual, FcOpContains, FcOpNotContains,
 136     FcOpLess, FcOpLessEqual, FcOpMore, FcOpMoreEqual,
 137     FcOpPlus, FcOpMinus, FcOpTimes, FcOpDivide,
 138     FcOpNot, FcOpComma, FcOpFloor, FcOpCeil, FcOpRound, FcOpTrunc,
 139     FcOpInvalid
 140 } FcOp;
 141
 142 typedef struct _FcExpr {
 143     FcOp   op;
 144     union {
 145         int         ival;
 146         double      dval;
 147         FcChar8     *sval;
 148         FcMatrix    *mval;
 149         FcBool      bval;
 150         FcCharSet   *cval;
 151         char        *field;
 152         FcChar8     *constant;
 153         struct {
 154             struct _FcExpr *left, *right;
 155         } tree;
 156     } u;
 157 } FcExpr;
 158
 159 typedef enum _FcQual {
 160     FcQualAny, FcQualAll, FcQualFirst, FcQualNotFirst
 161 } FcQual;
 162
 163 #define FcMatchDefault  ((FcMatchKind) -1)
 164
 165 typedef struct _FcTest {
 166     struct _FcTest      *next;
 167     FcMatchKind         kind;
 168     FcQual              qual;
 169     const char          *field;
 170     FcOp                op;
 171     FcExpr              *expr;
 172 } FcTest;
 173
 174 typedef struct _FcEdit {
 175     struct _FcEdit *next;
 176     const char      *field;
 177     FcOp            op;
 178     FcExpr          *expr;
 179     FcValueBinding  binding;
 180 } FcEdit;
 181
 182 typedef struct _FcSubst {
 183     struct _FcSubst     *next;
 184     FcTest              *test;
 185     FcEdit              *edit;
 186 } FcSubst;
 187
 188 typedef struct _FcCharLeaf {
 189     FcChar32    map[256/32];
 190 } FcCharLeaf;
 191
 192 #define FC_REF_CONSTANT     -1
 193
 194 struct _FcCharSet {
 195     int             ref;        /* reference count */
 196     int             num;        /* size of leaves and numbers arrays */
 197     FcCharLeaf      **leaves;
 198     FcChar16        *numbers;
 199 };
 200
 201 struct _FcStrSet {
 202     int             ref;        /* reference count */
 203     int             num;
 204     int             size;
 205     FcChar8         **strs;
 206 };
 207
 208 struct _FcStrList {
 209     FcStrSet        *set;
 210     int             n;
 211 };
 212
 213 typedef struct _FcStrBuf {
 214     FcChar8 *buf;
 215     FcBool  allocated;
 216     FcBool  failed;
 217     int     len;
 218     int     size;
 219 } FcStrBuf;
 220
 221 /*
 222  * To map adobe glyph names to unicode values, a precomputed hash
 223  * table is used
 224  */
 225
 226 typedef struct _FcGlyphName {
 227     FcChar32    ucs;            /* unicode value */
 228     FcChar8     name[1];        /* name extends beyond struct */
 229 } FcGlyphName;
 230
 231 /*
 232  * The per-user ~/.fonts.cache-<version> file is loaded into
 233  * this data structure.  Each directory gets a substructure
 234  * which is validated by comparing the directory timestamp with
 235  * that saved in the cache.  When valid, the entire directory cache
 236  * can be immediately loaded without reading the directory.  Otherwise,
 237  * the files are checked individually; updated files are loaded into the
 238  * cache which is then rewritten to the users home directory
 239  */
 240
 241 #define FC_GLOBAL_CACHE_DIR_HASH_SIZE       37
 242 #define FC_GLOBAL_CACHE_FILE_HASH_SIZE      67
 243
 244 typedef struct _FcGlobalCacheInfo {
 245     unsigned int                hash;
 246     FcChar8                     *file;
 247     time_t                      time;
 248     FcBool                      referenced;
 249 } FcGlobalCacheInfo;
 250
 251 typedef struct _FcGlobalCacheFile {
 252     struct _FcGlobalCacheFile   *next;
 253     FcGlobalCacheInfo           info;
 254     int                         id;
 255     FcChar8                     *name;
 256 } FcGlobalCacheFile;
 257
 258 typedef struct _FcGlobalCacheDir FcGlobalCacheDir;
 259
 260 typedef struct _FcGlobalCacheSubdir {
 261     struct _FcGlobalCacheSubdir *next;
 262     FcGlobalCacheDir            *ent;
 263 } FcGlobalCacheSubdir;
 264
 265 struct _FcGlobalCacheDir {
 266     struct _FcGlobalCacheDir    *next;
 267     FcGlobalCacheInfo           info;
 268     int                         len;
 269     FcGlobalCacheFile           *ents[FC_GLOBAL_CACHE_FILE_HASH_SIZE];
 270     FcGlobalCacheSubdir         *subdirs;
 271 };
 272
 273 typedef struct _FcGlobalCache {
 274     FcGlobalCacheDir            *ents[FC_GLOBAL_CACHE_DIR_HASH_SIZE];
 275     FcBool                      updated;
 276     FcBool                      broken;
 277     int                         entries;
 278     int                         referenced;
 279 } FcGlobalCache;
 280
 281 struct _FcAtomic {
 282     FcChar8     *file;          /* original file name */
 283     FcChar8     *new;           /* temp file name -- write data here */
 284     FcChar8     *lck;           /* lockfile name (used for locking) */
 285     FcChar8     *tmp;           /* tmpfile name (used for locking) */
 286 };
 287
 288 struct _FcBlanks {
 289     int         nblank;
 290     int         sblank;
 291     FcChar32    *blanks;
 292 };
 293
 294 struct _FcConfig {
 295     /*
 296      * File names loaded from the configuration -- saved here as the
 297      * cache file must be consulted before the directories are scanned,
 298      * and those directives may occur in any order
 299      */
 300     FcStrSet    *configDirs;        /* directories to scan for fonts */
 301     FcChar8     *cache;             /* name of per-user cache file */
 302     /*
 303      * Set of allowed blank chars -- used to
 304      * trim fonts of bogus glyphs
 305      */
 306     FcBlanks    *blanks;
 307     /*
 308      * List of directories containing fonts,
 309      * built by recursively scanning the set
 310      * of configured directories
 311      */
 312     FcStrSet    *fontDirs;
 313     /*
 314      * Names of all of the configuration files used
 315      * to create this configuration
 316      */
 317     FcStrSet    *configFiles;       /* config files loaded */
 318     /*
 319      * Substitution instructions for patterns and fonts;
 320      * maxObjects is used to allocate appropriate intermediate storage
 321      * while performing a whole set of substitutions
 322      */
 323     FcSubst     *substPattern;      /* substitutions for patterns */
 324     FcSubst     *substFont;         /* substitutions for fonts */
 325     int         maxObjects;         /* maximum number of tests in all substs */
 326     /*
 327      * The set of fonts loaded from the listed directories; the
 328      * order within the set does not determine the font selection,
 329      * except in the case of identical matches in which case earlier fonts
 330      * match preferrentially
 331      */
 332     FcFontSet   *fonts[FcSetApplication + 1];
 333     /*
 334      * Fontconfig can periodically rescan the system configuration
 335      * and font directories.  This rescanning occurs when font
 336      * listing requests are made, but no more often than rescanInterval
 337      * seconds apart.
 338      */
 339     time_t      rescanTime;         /* last time information was scanned */
 340     int         rescanInterval;     /* interval between scans */
 341 };
 342
 343 extern FcConfig *_fcConfig;
 344
 345 typedef struct _FcCharMap FcCharMap;
 346
 347 /* fcblanks.c */
 348
 349 /* fccache.c */
 350
 351 FcGlobalCache *
 352 FcGlobalCacheCreate (void);
 353
 354 void
 355 FcGlobalCacheDestroy (FcGlobalCache *cache);
 356
 357 FcBool
 358 FcGlobalCacheCheckTime (const FcChar8*file, FcGlobalCacheInfo *info);
 359
 360 void
 361 FcGlobalCacheReferenced (FcGlobalCache      *cache,
 362                          FcGlobalCacheInfo  *info);
 363
 364 void
 365 FcGlobalCacheReferenceSubdir (FcGlobalCache *cache,
 366                               const FcChar8 *dir);
 367
 368 FcGlobalCacheDir *
 369 FcGlobalCacheDirGet (FcGlobalCache  *cache,
 370                      const FcChar8  *dir,
 371                      int            len,
 372                      FcBool         create_missing);
 373
 374 FcBool
 375 FcGlobalCacheScanDir (FcFontSet         *set,
 376                       FcStrSet          *dirs,
 377                       FcGlobalCache     *cache,
 378                       const FcChar8     *dir);
 379
 380 FcGlobalCacheFile *
 381 FcGlobalCacheFileGet (FcGlobalCache *cache,
 382                       const FcChar8 *file,
 383                       int           id,
 384                       int           *count);
 385
 386
 387 void
 388 FcGlobalCacheLoad (FcGlobalCache    *cache,
 389                    const FcChar8    *cache_file);
 390
 391 FcBool
 392 FcGlobalCacheUpdate (FcGlobalCache  *cache,
 393                      const FcChar8  *file,
 394                      int            id,
 395                      const FcChar8  *name);
 396
 397 FcBool
 398 FcGlobalCacheSave (FcGlobalCache    *cache,
 399                    const FcChar8    *cache_file);
 400
 401 FcBool
 402 FcDirCacheReadDir (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir);
 403
 404 FcBool
 405 FcDirCacheWriteDir (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir);
 406
 407 /* fccfg.c */
 408
 409 FcBool
 410 FcConfigAddConfigDir (FcConfig      *config,
 411                       const FcChar8 *d);
 412
 413 FcBool
 414 FcConfigAddFontDir (FcConfig        *config,
 415                     const FcChar8   *d);
 416
 417 FcBool
 418 FcConfigAddDir (FcConfig        *config,
 419                 const FcChar8   *d);
 420
 421 FcBool
 422 FcConfigAddConfigFile (FcConfig         *config,
 423                        const FcChar8    *f);
 424
 425 FcBool
 426 FcConfigSetCache (FcConfig      *config,
 427                   const FcChar8 *c);
 428
 429 FcBool
 430 FcConfigAddBlank (FcConfig      *config,
 431                   FcChar32      blank);
 432
 433 FcBool
 434 FcConfigAddEdit (FcConfig       *config,
 435                  FcTest         *test,
 436                  FcEdit         *edit,
 437                  FcMatchKind    kind);
 438
 439 void
 440 FcConfigSetFonts (FcConfig      *config,
 441                   FcFontSet     *fonts,
 442                   FcSetName     set);
 443
 444 FcBool
 445 FcConfigCompareValue (const FcValue m,
 446                       FcOp          op,
 447                       const FcValue v);
 448
 449 /* fccharset.c */
 450 FcCharSet *
 451 FcCharSetFreeze (FcCharSet *cs);
 452
 453 FcBool
 454 FcNameUnparseCharSet (FcStrBuf *buf, const FcCharSet *c);
 455
 456 FcCharSet *
 457 FcNameParseCharSet (FcChar8 *string);
 458
 459 FcCharLeaf *
 460 FcCharSetFindLeafCreate (FcCharSet *fcs, FcChar32 ucs4);
 461
 462 /* fcdbg.c */
 463 void
 464 FcValueListPrint (const FcValueList *l);
 465
 466 void
 467 FcLangSetPrint (const FcLangSet *ls);
 468
 469 void
 470 FcOpPrint (FcOp op);
 471
 472 void
 473 FcTestPrint (const FcTest *test);
 474
 475 void
 476 FcExprPrint (const FcExpr *expr);
 477
 478 void
 479 FcEditPrint (const FcEdit *edit);
 480
 481 void
 482 FcSubstPrint (const FcSubst *subst);
 483
 484 int
 485 FcDebug (void);
 486
 487 /* fcdir.c */
 488
 489 /* fcfont.c */
 490 int
 491 FcFontDebug (void);
 492
 493 /* fcfreetype.c */
 494 FcBool
 495 FcFreeTypeIsExclusiveLang (const FcChar8  *lang);
 496
 497 FcBool
 498 FcFreeTypeHasLang (FcPattern *pattern, const FcChar8 *lang);
 499
 500 FcChar32
 501 FcFreeTypeUcs4ToPrivate (FcChar32 ucs4, const FcCharMap *map);
 502
 503 FcChar32
 504 FcFreeTypePrivateToUcs4 (FcChar32 private, const FcCharMap *map);
 505
 506 const FcCharMap *
 507 FcFreeTypeGetPrivateMap (FT_Encoding encoding);
 508
 509 /* fcfs.c */
 510 /* fcgram.y */
 511 int
 512 FcConfigparse (void);
 513
 514 int
 515 FcConfigwrap (void);
 516
 517 void
 518 FcConfigerror (char *fmt, ...);
 519
 520 char *
 521 FcConfigSaveField (const char *field);
 522
 523 FcTest *
 524 FcTestCreate (FcMatchKind   kind,
 525               FcQual        qual,
 526               const FcChar8 *field,
 527               FcOp          compare,
 528               FcExpr        *expr);
 529
 530 void
 531 FcTestDestroy (FcTest *test);
 532
 533 FcExpr *
 534 FcExprCreateInteger (int i);
 535
 536 FcExpr *
 537 FcExprCreateDouble (double d);
 538
 539 FcExpr *
 540 FcExprCreateString (const FcChar8 *s);
 541
 542 FcExpr *
 543 FcExprCreateMatrix (const FcMatrix *m);
 544
 545 FcExpr *
 546 FcExprCreateBool (FcBool b);
 547
 548 FcExpr *
 549 FcExprCreateNil (void);
 550
 551 FcExpr *
 552 FcExprCreateField (const char *field);
 553
 554 FcExpr *
 555 FcExprCreateConst (const FcChar8 *constant);
 556
 557 FcExpr *
 558 FcExprCreateOp (FcExpr *left, FcOp op, FcExpr *right);
 559
 560 void
 561 FcExprDestroy (FcExpr *e);
 562
 563 FcEdit *
 564 FcEditCreate (const char *field, FcOp op, FcExpr *expr, FcValueBinding binding);
 565
 566 void
 567 FcEditDestroy (FcEdit *e);
 568
 569 /* fcinit.c */
 570
 571 void
 572 FcMemReport (void);
 573
 574 void
 575 FcMemAlloc (int kind, int size);
 576
 577 void
 578 FcMemFree (int kind, int size);
 579
 580 /* fclang.c */
 581 FcLangSet *
 582 FcFreeTypeLangSet (const FcCharSet  *charset,
 583                    const FcChar8    *exclusiveLang);
 584
 585 FcLangResult
 586 FcLangCompare (const FcChar8 *s1, const FcChar8 *s2);
 587
 588 const FcCharSet *
 589 FcCharSetForLang (const FcChar8 *lang);
 590
 591 FcLangSet *
 592 FcLangSetPromote (const FcChar8 *lang);
 593
 594 FcLangSet *
 595 FcNameParseLangSet (const FcChar8 *string);
 596
 597 FcBool
 598 FcNameUnparseLangSet (FcStrBuf *buf, const FcLangSet *ls);
 599
 600 /* fclist.c */
 601
 602 /* fcmatch.c */
 603
 604 /* fcname.c */
 605
 606 FcBool
 607 FcNameBool (FcChar8 *v, FcBool *result);
 608
 609 /* fcpat.c */
 610 void
 611 FcValueListDestroy (FcValueList *l);
 612
 613 FcPatternElt *
 614 FcPatternFindElt (const FcPattern *p, const char *object);
 615
 616 FcPatternElt *
 617 FcPatternInsertElt (FcPattern *p, const char *object);
 618
 619 FcBool
 620 FcPatternAddWithBinding  (FcPattern         *p,
 621                           const char        *object,
 622                           FcValue           value,
 623                           FcValueBinding    binding,
 624                           FcBool            append);
 625
 626 FcPattern *
 627 FcPatternFreeze (FcPattern *p);
 628
 629 /* fcrender.c */
 630
 631 /* fcmatrix.c */
 632
 633 extern const FcMatrix    FcIdentityMatrix;
 634
 635 void
 636 FcMatrixFree (FcMatrix *mat);
 637
 638 /* fcstr.c */
 639 FcChar8 *
 640 FcStrPlus (const FcChar8 *s1, const FcChar8 *s2);
 641
 642 void
 643 FcStrFree (FcChar8 *s);
 644
 645 void
 646 FcStrBufInit (FcStrBuf *buf, FcChar8 *init, int size);
 647
 648 void
 649 FcStrBufDestroy (FcStrBuf *buf);
 650
 651 FcChar8 *
 652 FcStrBufDone (FcStrBuf *buf);
 653
 654 FcBool
 655 FcStrBufChar (FcStrBuf *buf, FcChar8 c);
 656
 657 FcBool
 658 FcStrBufString (FcStrBuf *buf, const FcChar8 *s);
 659
 660 FcBool
 661 FcStrBufData (FcStrBuf *buf, const FcChar8 *s, int len);
 662
 663 int
 664 FcStrCmpIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2);
 665
 666 const FcChar8 *
 667 FcStrContainsIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2);
 668
 669 const FcChar8 *
 670 FcStrContainsIgnoreCase (const FcChar8 *s1, const FcChar8 *s2);
 671
 672 FcBool
 673 FcStrUsesHome (const FcChar8 *s);
 674
 675 FcChar8 *
 676 FcStrLastSlash (const FcChar8  *path);
 677
 678 #endif /* _FC_INT_H_ */