src/fccfg.c

   1 /*
   2  * $RCSId: xc/lib/fontconfig/src/fccfg.c,v 1.23 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 #include "fcint.h"
  26 #include <dirent.h>
  27 #include <sys/types.h>
  28
  29 #if defined (_WIN32) && (defined (PIC) || defined (DLL_EXPORT))
  30 #define STRICT
  31 #include <windows.h>
  32 #undef STRICT
  33 #endif
  34
  35 #if defined (_WIN32) && !defined (R_OK)
  36 #define R_OK 4
  37 #endif
  38
  39 FcConfig    *_fcConfig;
  40
  41 FcConfig *
  42 FcConfigCreate (void)
  43 {
  44     FcSetName   set;
  45     FcConfig    *config;
  46
  47     config = malloc (sizeof (FcConfig));
  48     if (!config)
  49         goto bail0;
  50     FcMemAlloc (FC_MEM_CONFIG, sizeof (FcConfig));
  51
  52     config->configDirs = FcStrSetCreate ();
  53     if (!config->configDirs)
  54         goto bail1;
  55
  56     config->configFiles = FcStrSetCreate ();
  57     if (!config->configFiles)
  58         goto bail2;
  59
  60     config->fontDirs = FcStrSetCreate ();
  61     if (!config->fontDirs)
  62         goto bail3;
  63
  64     config->acceptGlobs = FcStrSetCreate ();
  65     if (!config->acceptGlobs)
  66         goto bail4;
  67
  68     config->rejectGlobs = FcStrSetCreate ();
  69     if (!config->rejectGlobs)
  70         goto bail5;
  71
  72     config->acceptPatterns = FcFontSetCreate ();
  73     if (!config->acceptPatterns)
  74         goto bail6;
  75
  76     config->rejectPatterns = FcFontSetCreate ();
  77     if (!config->rejectPatterns)
  78         goto bail7;
  79
  80     config->cacheDirs = FcStrSetCreate ();
  81     if (!config->cacheDirs)
  82         goto bail8;
  83
  84     config->blanks = 0;
  85
  86     config->substPattern = 0;
  87     config->substFont = 0;
  88     config->maxObjects = 0;
  89     for (set = FcSetSystem; set <= FcSetApplication; set++)
  90         config->fonts[set] = 0;
  91
  92     config->caches = NULL;
  93
  94     config->rescanTime = time(0);
  95     config->rescanInterval = 30;
  96
  97     return config;
  98
  99 bail8:
 100     FcFontSetDestroy (config->rejectPatterns);
 101 bail7:
 102     FcFontSetDestroy (config->acceptPatterns);
 103 bail6:
 104     FcStrSetDestroy (config->rejectGlobs);
 105 bail5:
 106     FcStrSetDestroy (config->acceptGlobs);
 107 bail4:
 108     FcStrSetDestroy (config->fontDirs);
 109 bail3:
 110     FcStrSetDestroy (config->configFiles);
 111 bail2:
 112     FcStrSetDestroy (config->configDirs);
 113 bail1:
 114     free (config);
 115     FcMemFree (FC_MEM_CONFIG, sizeof (FcConfig));
 116 bail0:
 117     return 0;
 118 }
 119
 120 static FcFileTime
 121 FcConfigNewestFile (FcStrSet *files)
 122 {
 123     FcStrList       *list = FcStrListCreate (files);
 124     FcFileTime      newest = { 0, FcFalse };
 125     FcChar8         *file;
 126     struct  stat    statb;
 127
 128     if (list)
 129     {
 130         while ((file = FcStrListNext (list)))
 131             if (stat ((char *) file, &statb) == 0)
 132                 if (!newest.set || statb.st_mtime - newest.time > 0)
 133                 {
 134                     newest.set = FcTrue;
 135                     newest.time = statb.st_mtime;
 136                 }
 137         FcStrListDone (list);
 138     }
 139     return newest;
 140 }
 141
 142 FcFileTime
 143 FcConfigModifiedTime (FcConfig *config)
 144 {
 145     if (!config)
 146     {
 147         FcFileTime v = { 0, FcFalse };
 148         config = FcConfigGetCurrent ();
 149         if (!config)
 150             return v;
 151     }
 152     return FcConfigNewestFile (config->configFiles);
 153 }
 154
 155 FcBool
 156 FcConfigUptoDate (FcConfig *config)
 157 {
 158     FcFileTime  config_time, font_time;
 159     time_t      now = time(0);
 160     if (!config)
 161     {
 162         config = FcConfigGetCurrent ();
 163         if (!config)
 164             return FcFalse;
 165     }
 166     config_time = FcConfigNewestFile (config->configFiles);
 167     font_time = FcConfigNewestFile (config->fontDirs);
 168     if ((config_time.set && config_time.time - config->rescanTime > 0) ||
 169         (font_time.set && (font_time.time - config->rescanTime) > 0))
 170     {
 171         return FcFalse;
 172     }
 173     config->rescanTime = now;
 174     return FcTrue;
 175 }
 176
 177 static void
 178 FcSubstDestroy (FcSubst *s)
 179 {
 180     FcSubst *n;
 181
 182     while (s)
 183     {
 184         n = s->next;
 185         if (s->test)
 186             FcTestDestroy (s->test);
 187         if (s->edit)
 188             FcEditDestroy (s->edit);
 189         free (s);
 190         FcMemFree (FC_MEM_SUBST, sizeof (FcSubst));
 191         s = n;
 192     }
 193 }
 194
 195 void
 196 FcConfigDestroy (FcConfig *config)
 197 {
 198     FcSetName   set;
 199     FcCacheList *cl, *cl_next;
 200
 201     if (config == _fcConfig)
 202         _fcConfig = 0;
 203
 204     FcStrSetDestroy (config->configDirs);
 205     FcStrSetDestroy (config->fontDirs);
 206     FcStrSetDestroy (config->cacheDirs);
 207     FcStrSetDestroy (config->configFiles);
 208     FcStrSetDestroy (config->acceptGlobs);
 209     FcStrSetDestroy (config->rejectGlobs);
 210     FcFontSetDestroy (config->acceptPatterns);
 211     FcFontSetDestroy (config->rejectPatterns);
 212
 213     if (config->blanks)
 214         FcBlanksDestroy (config->blanks);
 215
 216     FcSubstDestroy (config->substPattern);
 217     FcSubstDestroy (config->substFont);
 218     for (set = FcSetSystem; set <= FcSetApplication; set++)
 219         if (config->fonts[set])
 220             FcFontSetDestroy (config->fonts[set]);
 221
 222     for (cl = config->caches; cl; cl = cl_next)
 223     {
 224         cl_next = cl->next;
 225         FcDirCacheUnload (cl->cache);
 226         free (cl);
 227     }
 228
 229     free (config);
 230     FcMemFree (FC_MEM_CONFIG, sizeof (FcConfig));
 231 }
 232
 233 /*
 234  * Add cache to configuration, adding fonts and directories
 235  */
 236
 237 FcBool
 238 FcConfigAddCache (FcConfig *config, FcCache *cache)
 239 {
 240     FcCacheList *cl = malloc (sizeof (FcCacheList));
 241     FcFontSet   *fs;
 242     intptr_t    *dirs;
 243     int         i;
 244
 245     /*
 246      * Add to cache list
 247      */
 248     if (!cl)
 249         return FcFalse;
 250     cl->cache = cache;
 251     cl->next = config->caches;
 252     config->caches = cl;
 253
 254     /*
 255      * Add fonts
 256      */
 257     fs = FcCacheSet (cache);
 258     if (fs)
 259     {
 260         for (i = 0; i < fs->nfont; i++)
 261         {
 262             FcPattern   *font = FcFontSetFont (fs, i);
 263             FcChar8     *font_file;
 264
 265             /*
 266              * Check to see if font is banned by filename
 267              */
 268             if (FcPatternObjectGetString (font, FC_FILE_OBJECT,
 269                                           0, &font_file) == FcResultMatch &&
 270                 !FcConfigAcceptFilename (config, font_file))
 271             {
 272                 continue;
 273             }
 274
 275             /*
 276              * Check to see if font is banned by pattern
 277              */
 278             if (!FcConfigAcceptFont (config, font))
 279                 continue;
 280
 281             FcFontSetAdd (config->fonts[FcSetSystem], font);
 282         }
 283     }
 284
 285     /*
 286      * Add directories
 287      */
 288     dirs = FcCacheDirs (cache);
 289     if (dirs)
 290     {
 291         for (i = 0; i < cache->dirs_count; i++)
 292         {
 293             FcChar8     *dir = FcOffsetToPtr (dirs, dirs[i], FcChar8);
 294             if (FcConfigAcceptFilename (config, dir))
 295                 FcConfigAddFontDir (config, dir);
 296         }
 297     }
 298     return FcTrue;
 299 }
 300
 301 /*
 302  * Scan the current list of directories in the configuration
 303  * and build the set of available fonts.
 304  */
 305
 306 FcBool
 307 FcConfigBuildFonts (FcConfig *config)
 308 {
 309     FcFontSet       *fonts;
 310     FcStrList       *dirlist;
 311     FcChar8         *dir;
 312     FcCache         *cache;
 313
 314     if (!config)
 315     {
 316         config = FcConfigGetCurrent ();
 317         if (!config)
 318             return FcFalse;
 319     }
 320
 321     fonts = FcFontSetCreate ();
 322     if (!fonts)
 323         goto bail;
 324
 325     FcConfigSetFonts (config, fonts, FcSetSystem);
 326
 327     dirlist = FcStrListCreate (config->fontDirs);
 328     if (!dirlist)
 329         goto bail;
 330
 331     while ((dir = FcStrListNext (dirlist)))
 332     {
 333         if (FcDebug () & FC_DBG_FONTSET)
 334             printf ("adding fonts from%s\n", dir);
 335         cache = FcDirCacheRead (dir, FcFalse, config);
 336         if (!cache)
 337             continue;
 338         FcConfigAddCache (config, cache);
 339     }
 340
 341     FcStrListDone (dirlist);
 342
 343     if (FcDebug () & FC_DBG_FONTSET)
 344         FcFontSetPrint (fonts);
 345
 346     return FcTrue;
 347 bail:
 348     return FcFalse;
 349 }
 350
 351 FcBool
 352 FcConfigSetCurrent (FcConfig *config)
 353 {
 354     if (!config->fonts)
 355         if (!FcConfigBuildFonts (config))
 356             return FcFalse;
 357
 358     if (_fcConfig)
 359         FcConfigDestroy (_fcConfig);
 360     _fcConfig = config;
 361     return FcTrue;
 362 }
 363
 364 FcConfig *
 365 FcConfigGetCurrent (void)
 366 {
 367     if (!_fcConfig)
 368         if (!FcInit ())
 369             return 0;
 370     return _fcConfig;
 371 }
 372
 373 FcBool
 374 FcConfigAddConfigDir (FcConfig      *config,
 375                       const FcChar8 *d)
 376 {
 377     return FcStrSetAddFilename (config->configDirs, d);
 378 }
 379
 380 FcStrList *
 381 FcConfigGetConfigDirs (FcConfig   *config)
 382 {
 383     if (!config)
 384     {
 385         config = FcConfigGetCurrent ();
 386         if (!config)
 387             return 0;
 388     }
 389     return FcStrListCreate (config->configDirs);
 390 }
 391
 392 FcBool
 393 FcConfigAddFontDir (FcConfig        *config,
 394                     const FcChar8   *d)
 395 {
 396     return FcStrSetAddFilename (config->fontDirs, d);
 397 }
 398
 399 FcBool
 400 FcConfigAddDir (FcConfig            *config,
 401                 const FcChar8       *d)
 402 {
 403     return (FcConfigAddConfigDir (config, d) &&
 404             FcConfigAddFontDir (config, d));
 405 }
 406
 407 FcStrList *
 408 FcConfigGetFontDirs (FcConfig   *config)
 409 {
 410     if (!config)
 411     {
 412         config = FcConfigGetCurrent ();
 413         if (!config)
 414             return 0;
 415     }
 416     return FcStrListCreate (config->fontDirs);
 417 }
 418
 419 FcBool
 420 FcConfigAddCacheDir (FcConfig       *config,
 421                      const FcChar8  *d)
 422 {
 423     return FcStrSetAddFilename (config->cacheDirs, d);
 424 }
 425
 426 FcStrList *
 427 FcConfigGetCacheDirs (FcConfig  *config)
 428 {
 429     if (!config)
 430     {
 431         config = FcConfigGetCurrent ();
 432         if (!config)
 433             return 0;
 434     }
 435     return FcStrListCreate (config->cacheDirs);
 436 }
 437
 438 FcBool
 439 FcConfigAddConfigFile (FcConfig     *config,
 440                        const FcChar8   *f)
 441 {
 442     FcBool      ret;
 443     FcChar8     *file = FcConfigFilename (f);
 444
 445     if (!file)
 446         return FcFalse;
 447
 448     ret = FcStrSetAdd (config->configFiles, file);
 449     FcStrFree (file);
 450     return ret;
 451 }
 452
 453 FcStrList *
 454 FcConfigGetConfigFiles (FcConfig    *config)
 455 {
 456     if (!config)
 457     {
 458         config = FcConfigGetCurrent ();
 459         if (!config)
 460             return 0;
 461     }
 462     return FcStrListCreate (config->configFiles);
 463 }
 464
 465 FcChar8 *
 466 FcConfigGetCache (FcConfig  *config)
 467 {
 468     return NULL;
 469 }
 470
 471 FcFontSet *
 472 FcConfigGetFonts (FcConfig      *config,
 473                   FcSetName     set)
 474 {
 475     if (!config)
 476     {
 477         config = FcConfigGetCurrent ();
 478         if (!config)
 479             return 0;
 480     }
 481     return config->fonts[set];
 482 }
 483
 484 void
 485 FcConfigSetFonts (FcConfig      *config,
 486                   FcFontSet     *fonts,
 487                   FcSetName     set)
 488 {
 489     if (config->fonts[set])
 490         FcFontSetDestroy (config->fonts[set]);
 491     config->fonts[set] = fonts;
 492 }
 493
 494 FcBlanks *
 495 FcConfigGetBlanks (FcConfig     *config)
 496 {
 497     if (!config)
 498     {
 499         config = FcConfigGetCurrent ();
 500         if (!config)
 501             return 0;
 502     }
 503     return config->blanks;
 504 }
 505
 506 FcBool
 507 FcConfigAddBlank (FcConfig      *config,
 508                   FcChar32      blank)
 509 {
 510     FcBlanks    *b, *freeme = 0;
 511
 512     b = config->blanks;
 513     if (!b)
 514     {
 515         freeme = b = FcBlanksCreate ();
 516         if (!b)
 517             return FcFalse;
 518     }
 519     if (!FcBlanksAdd (b, blank))
 520     {
 521         if (freeme)
 522             FcBlanksDestroy (freeme);
 523         return FcFalse;
 524     }
 525     config->blanks = b;
 526     return FcTrue;
 527 }
 528
 529 int
 530 FcConfigGetRescanInverval (FcConfig *config)
 531 {
 532     if (!config)
 533     {
 534         config = FcConfigGetCurrent ();
 535         if (!config)
 536             return 0;
 537     }
 538     return config->rescanInterval;
 539 }
 540
 541 FcBool
 542 FcConfigSetRescanInverval (FcConfig *config, int rescanInterval)
 543 {
 544     if (!config)
 545     {
 546         config = FcConfigGetCurrent ();
 547         if (!config)
 548             return FcFalse;
 549     }
 550     config->rescanInterval = rescanInterval;
 551     return FcTrue;
 552 }
 553
 554 FcBool
 555 FcConfigAddEdit (FcConfig       *config,
 556                  FcTest         *test,
 557                  FcEdit         *edit,
 558                  FcMatchKind    kind)
 559 {
 560     FcSubst     *subst, **prev;
 561     FcTest      *t;
 562     int         num;
 563
 564     subst = (FcSubst *) malloc (sizeof (FcSubst));
 565     if (!subst)
 566         return FcFalse;
 567     FcMemAlloc (FC_MEM_SUBST, sizeof (FcSubst));
 568     if (kind == FcMatchPattern)
 569         prev = &config->substPattern;
 570     else
 571         prev = &config->substFont;
 572     for (; *prev; prev = &(*prev)->next);
 573     *prev = subst;
 574     subst->next = 0;
 575     subst->test = test;
 576     subst->edit = edit;
 577     num = 0;
 578     for (t = test; t; t = t->next)
 579     {
 580         if (t->kind == FcMatchDefault)
 581             t->kind = kind;
 582         num++;
 583     }
 584     if (config->maxObjects < num)
 585         config->maxObjects = num;
 586     if (FcDebug () & FC_DBG_EDIT)
 587     {
 588         printf ("Add Subst ");
 589         FcSubstPrint (subst);
 590     }
 591     return FcTrue;
 592 }
 593
 594 typedef struct _FcSubState {
 595     FcPatternElt   *elt;
 596     FcValueList    *value;
 597 } FcSubState;
 598
 599 static FcValue
 600 FcConfigPromote (FcValue v, FcValue u)
 601 {
 602     if (v.type == FcTypeInteger)
 603     {
 604         v.type = FcTypeDouble;
 605         v.u.d = (double) v.u.i;
 606     }
 607     else if (v.type == FcTypeVoid && u.type == FcTypeMatrix)
 608     {
 609         v.u.m = &FcIdentityMatrix;
 610         v.type = FcTypeMatrix;
 611     }
 612     else if (v.type == FcTypeString && u.type == FcTypeLangSet)
 613     {
 614         v.u.l = FcLangSetPromote (v.u.s);
 615         v.type = FcTypeLangSet;
 616     }
 617     return v;
 618 }
 619
 620 FcBool
 621 FcConfigCompareValue (const FcValue     *left_o,
 622                       FcOp              op,
 623                       const FcValue     *right_o)
 624 {
 625     FcValue     left = FcValueCanonicalize(left_o);
 626     FcValue     right = FcValueCanonicalize(right_o);
 627     FcBool      ret = FcFalse;
 628
 629     left = FcConfigPromote (left, right);
 630     right = FcConfigPromote (right, left);
 631     if (left.type == right.type)
 632     {
 633         switch (left.type) {
 634         case FcTypeInteger:
 635             break;      /* FcConfigPromote prevents this from happening */
 636         case FcTypeDouble:
 637             switch (op) {
 638             case FcOpEqual:
 639             case FcOpContains:
 640             case FcOpListing:
 641                 ret = left.u.d == right.u.d;
 642                 break;
 643             case FcOpNotEqual:
 644             case FcOpNotContains:
 645                 ret = left.u.d != right.u.d;
 646                 break;
 647             case FcOpLess:
 648                 ret = left.u.d < right.u.d;
 649                 break;
 650             case FcOpLessEqual:
 651                 ret = left.u.d <= right.u.d;
 652                 break;
 653             case FcOpMore:
 654                 ret = left.u.d > right.u.d;
 655                 break;
 656             case FcOpMoreEqual:
 657                 ret = left.u.d >= right.u.d;
 658                 break;
 659             default:
 660                 break;
 661             }
 662             break;
 663         case FcTypeBool:
 664             switch (op) {
 665             case FcOpEqual:
 666             case FcOpContains:
 667             case FcOpListing:
 668                 ret = left.u.b == right.u.b;
 669                 break;
 670             case FcOpNotEqual:
 671             case FcOpNotContains:
 672                 ret = left.u.b != right.u.b;
 673                 break;
 674             default:
 675                 break;
 676             }
 677             break;
 678         case FcTypeString:
 679             switch (op) {
 680             case FcOpEqual:
 681             case FcOpListing:
 682                 ret = FcStrCmpIgnoreCase (left.u.s, right.u.s) == 0;
 683                 break;
 684             case FcOpContains:
 685                 ret = FcStrStrIgnoreCase (left.u.s, right.u.s) != 0;
 686                 break;
 687             case FcOpNotEqual:
 688                 ret = FcStrCmpIgnoreCase (left.u.s, right.u.s) != 0;
 689                 break;
 690             case FcOpNotContains:
 691                 ret = FcStrCmpIgnoreCase (left.u.s, right.u.s) == 0;
 692                 break;
 693             default:
 694                 break;
 695             }
 696             break;
 697         case FcTypeMatrix:
 698             switch (op) {
 699             case FcOpEqual:
 700             case FcOpContains:
 701             case FcOpListing:
 702                 ret = FcMatrixEqual (left.u.m, right.u.m);
 703                 break;
 704             case FcOpNotEqual:
 705             case FcOpNotContains:
 706                 ret = !FcMatrixEqual (left.u.m, right.u.m);
 707                 break;
 708             default:
 709                 break;
 710             }
 711             break;
 712         case FcTypeCharSet:
 713             switch (op) {
 714             case FcOpContains:
 715             case FcOpListing:
 716                 /* left contains right if right is a subset of left */
 717                 ret = FcCharSetIsSubset (right.u.c, left.u.c);
 718                 break;
 719             case FcOpNotContains:
 720                 /* left contains right if right is a subset of left */
 721                 ret = !FcCharSetIsSubset (right.u.c, left.u.c);
 722                 break;
 723             case FcOpEqual:
 724                 ret = FcCharSetEqual (left.u.c, right.u.c);
 725                 break;
 726             case FcOpNotEqual:
 727                 ret = !FcCharSetEqual (left.u.c, right.u.c);
 728                 break;
 729             default:
 730                 break;
 731             }
 732             break;
 733         case FcTypeLangSet:
 734             switch (op) {
 735             case FcOpContains:
 736             case FcOpListing:
 737                 ret = FcLangSetContains (left.u.l, right.u.l);
 738                 break;
 739             case FcOpNotContains:
 740                 ret = !FcLangSetContains (left.u.l, right.u.l);
 741                 break;
 742             case FcOpEqual:
 743                 ret = FcLangSetEqual (left.u.l, right.u.l);
 744                 break;
 745             case FcOpNotEqual:
 746                 ret = !FcLangSetEqual (left.u.l, right.u.l);
 747                 break;
 748             default:
 749                 break;
 750             }
 751             break;
 752         case FcTypeVoid:
 753             switch (op) {
 754             case FcOpEqual:
 755             case FcOpContains:
 756             case FcOpListing:
 757                 ret = FcTrue;
 758                 break;
 759             default:
 760                 break;
 761             }
 762             break;
 763         case FcTypeFTFace:
 764             switch (op) {
 765             case FcOpEqual:
 766             case FcOpContains:
 767             case FcOpListing:
 768                 ret = left.u.f == right.u.f;
 769                 break;
 770             case FcOpNotEqual:
 771             case FcOpNotContains:
 772                 ret = left.u.f != right.u.f;
 773                 break;
 774             default:
 775                 break;
 776             }
 777             break;
 778         }
 779     }
 780     else
 781     {
 782         if (op == FcOpNotEqual || op == FcOpNotContains)
 783             ret = FcTrue;
 784     }
 785     return ret;
 786 }
 787
 788
 789 #define _FcDoubleFloor(d)       ((int) (d))
 790 #define _FcDoubleCeil(d)        ((double) (int) (d) == (d) ? (int) (d) : (int) ((d) + 1))
 791 #define FcDoubleFloor(d)        ((d) >= 0 ? _FcDoubleFloor(d) : -_FcDoubleCeil(-(d)))
 792 #define FcDoubleCeil(d)         ((d) >= 0 ? _FcDoubleCeil(d) : -_FcDoubleFloor(-(d)))
 793 #define FcDoubleRound(d)        FcDoubleFloor ((d) + 0.5)
 794 #define FcDoubleTrunc(d)        ((d) >= 0 ? _FcDoubleFloor (d) : -_FcDoubleFloor (-(d)))
 795
 796 static FcValue
 797 FcConfigEvaluate (FcPattern *p, FcExpr *e)
 798 {
 799     FcValue     v, vl, vr;
 800     FcResult    r;
 801     FcMatrix    *m;
 802     FcChar8     *str;
 803
 804     switch (e->op) {
 805     case FcOpInteger:
 806         v.type = FcTypeInteger;
 807         v.u.i = e->u.ival;
 808         break;
 809     case FcOpDouble:
 810         v.type = FcTypeDouble;
 811         v.u.d = e->u.dval;
 812         break;
 813     case FcOpString:
 814         v.type = FcTypeString;
 815         v.u.s = FcStrStaticName(e->u.sval);
 816         break;
 817     case FcOpMatrix:
 818         v.type = FcTypeMatrix;
 819         v.u.m = e->u.mval;
 820         v = FcValueSave (v);
 821         break;
 822     case FcOpCharSet:
 823         v.type = FcTypeCharSet;
 824         v.u.c = e->u.cval;
 825         v = FcValueSave (v);
 826         break;
 827     case FcOpBool:
 828         v.type = FcTypeBool;
 829         v.u.b = e->u.bval;
 830         break;
 831     case FcOpField:
 832         r = FcPatternObjectGet (p, e->u.object, 0, &v);
 833         if (r != FcResultMatch)
 834             v.type = FcTypeVoid;
 835         v = FcValueSave (v);
 836         break;
 837     case FcOpConst:
 838         if (FcNameConstant (e->u.constant, &v.u.i))
 839             v.type = FcTypeInteger;
 840         else
 841             v.type = FcTypeVoid;
 842         break;
 843     case FcOpQuest:
 844         vl = FcConfigEvaluate (p, e->u.tree.left);
 845         if (vl.type == FcTypeBool)
 846         {
 847             if (vl.u.b)
 848                 v = FcConfigEvaluate (p, e->u.tree.right->u.tree.left);
 849             else
 850                 v = FcConfigEvaluate (p, e->u.tree.right->u.tree.right);
 851         }
 852         else
 853             v.type = FcTypeVoid;
 854         FcValueDestroy (vl);
 855         break;
 856     case FcOpEqual:
 857     case FcOpNotEqual:
 858     case FcOpLess:
 859     case FcOpLessEqual:
 860     case FcOpMore:
 861     case FcOpMoreEqual:
 862     case FcOpContains:
 863     case FcOpNotContains:
 864     case FcOpListing:
 865         vl = FcConfigEvaluate (p, e->u.tree.left);
 866         vr = FcConfigEvaluate (p, e->u.tree.right);
 867         v.type = FcTypeBool;
 868         v.u.b = FcConfigCompareValue (&vl, e->op, &vr);
 869         FcValueDestroy (vl);
 870         FcValueDestroy (vr);
 871         break;
 872     case FcOpOr:
 873     case FcOpAnd:
 874     case FcOpPlus:
 875     case FcOpMinus:
 876     case FcOpTimes:
 877     case FcOpDivide:
 878         vl = FcConfigEvaluate (p, e->u.tree.left);
 879         vr = FcConfigEvaluate (p, e->u.tree.right);
 880         vl = FcConfigPromote (vl, vr);
 881         vr = FcConfigPromote (vr, vl);
 882         if (vl.type == vr.type)
 883         {
 884             switch (vl.type) {
 885             case FcTypeDouble:
 886                 switch (e->op) {
 887                 case FcOpPlus:
 888                     v.type = FcTypeDouble;
 889                     v.u.d = vl.u.d + vr.u.d;
 890                     break;
 891                 case FcOpMinus:
 892                     v.type = FcTypeDouble;
 893                     v.u.d = vl.u.d - vr.u.d;
 894                     break;
 895                 case FcOpTimes:
 896                     v.type = FcTypeDouble;
 897                     v.u.d = vl.u.d * vr.u.d;
 898                     break;
 899                 case FcOpDivide:
 900                     v.type = FcTypeDouble;
 901                     v.u.d = vl.u.d / vr.u.d;
 902                     break;
 903                 default:
 904                     v.type = FcTypeVoid;
 905                     break;
 906                 }
 907                 if (v.type == FcTypeDouble &&
 908                     v.u.d == (double) (int) v.u.d)
 909                 {
 910                     v.type = FcTypeInteger;
 911                     v.u.i = (int) v.u.d;
 912                 }
 913                 break;
 914             case FcTypeBool:
 915                 switch (e->op) {
 916                 case FcOpOr:
 917                     v.type = FcTypeBool;
 918                     v.u.b = vl.u.b || vr.u.b;
 919                     break;
 920                 case FcOpAnd:
 921                     v.type = FcTypeBool;
 922                     v.u.b = vl.u.b && vr.u.b;
 923                     break;
 924                 default:
 925                     v.type = FcTypeVoid;
 926                     break;
 927                 }
 928                 break;
 929             case FcTypeString:
 930                 switch (e->op) {
 931                 case FcOpPlus:
 932                     v.type = FcTypeString;
 933                     str = FcStrPlus (vl.u.s, vr.u.s);
 934                     v.u.s = FcStrStaticName (str);
 935                     FcStrFree (str);
 936
 937                     if (!v.u.s)
 938                         v.type = FcTypeVoid;
 939                     break;
 940                 default:
 941                     v.type = FcTypeVoid;
 942                     break;
 943                 }
 944                 break;
 945             case FcTypeMatrix:
 946                 switch (e->op) {
 947                 case FcOpTimes:
 948                     v.type = FcTypeMatrix;
 949                     m = malloc (sizeof (FcMatrix));
 950                     if (m)
 951                     {
 952                         FcMemAlloc (FC_MEM_MATRIX, sizeof (FcMatrix));
 953                         FcMatrixMultiply (m, vl.u.m, vr.u.m);
 954                         v.u.m = m;
 955                     }
 956                     else
 957                     {
 958                         v.type = FcTypeVoid;
 959                     }
 960                     break;
 961                 default:
 962                     v.type = FcTypeVoid;
 963                     break;
 964                 }
 965                 break;
 966             default:
 967                 v.type = FcTypeVoid;
 968                 break;
 969             }
 970         }
 971         else
 972             v.type = FcTypeVoid;
 973         FcValueDestroy (vl);
 974         FcValueDestroy (vr);
 975         break;
 976     case FcOpNot:
 977         vl = FcConfigEvaluate (p, e->u.tree.left);
 978         switch (vl.type) {
 979         case FcTypeBool:
 980             v.type = FcTypeBool;
 981             v.u.b = !vl.u.b;
 982             break;
 983         default:
 984             v.type = FcTypeVoid;
 985             break;
 986         }
 987         FcValueDestroy (vl);
 988         break;
 989     case FcOpFloor:
 990         vl = FcConfigEvaluate (p, e->u.tree.left);
 991         switch (vl.type) {
 992         case FcTypeInteger:
 993             v = vl;
 994             break;
 995         case FcTypeDouble:
 996             v.type = FcTypeInteger;
 997             v.u.i = FcDoubleFloor (vl.u.d);
 998             break;
 999         default:
1000             v.type = FcTypeVoid;
1001             break;
1002         }
1003         FcValueDestroy (vl);
1004         break;
1005     case FcOpCeil:
1006         vl = FcConfigEvaluate (p, e->u.tree.left);
1007         switch (vl.type) {
1008         case FcTypeInteger:
1009             v = vl;
1010             break;
1011         case FcTypeDouble:
1012             v.type = FcTypeInteger;
1013             v.u.i = FcDoubleCeil (vl.u.d);
1014             break;
1015         default:
1016             v.type = FcTypeVoid;
1017             break;
1018         }
1019         FcValueDestroy (vl);
1020         break;
1021     case FcOpRound:
1022         vl = FcConfigEvaluate (p, e->u.tree.left);
1023         switch (vl.type) {
1024         case FcTypeInteger:
1025             v = vl;
1026             break;
1027         case FcTypeDouble:
1028             v.type = FcTypeInteger;
1029             v.u.i = FcDoubleRound (vl.u.d);
1030             break;
1031         default:
1032             v.type = FcTypeVoid;
1033             break;
1034         }
1035         FcValueDestroy (vl);
1036         break;
1037     case FcOpTrunc:
1038         vl = FcConfigEvaluate (p, e->u.tree.left);
1039         switch (vl.type) {
1040         case FcTypeInteger:
1041             v = vl;
1042             break;
1043         case FcTypeDouble:
1044             v.type = FcTypeInteger;
1045             v.u.i = FcDoubleTrunc (vl.u.d);
1046             break;
1047         default:
1048             v.type = FcTypeVoid;
1049             break;
1050         }
1051         FcValueDestroy (vl);
1052         break;
1053     default:
1054         v.type = FcTypeVoid;
1055         break;
1056     }
1057     return v;
1058 }
1059
1060 static FcValueList *
1061 FcConfigMatchValueList (FcPattern       *p,
1062                         FcTest          *t,
1063                         FcValueList     *values)
1064 {
1065     FcValueList     *ret = 0;
1066     FcExpr          *e = t->expr;
1067     FcValue         value;
1068     FcValueList     *v;
1069
1070     while (e)
1071     {
1072         /* Compute the value of the match expression */
1073         if (e->op == FcOpComma)
1074         {
1075             value = FcConfigEvaluate (p, e->u.tree.left);
1076             e = e->u.tree.right;
1077         }
1078         else
1079         {
1080             value = FcConfigEvaluate (p, e);
1081             e = 0;
1082         }
1083
1084         for (v = values; v; v = FcValueListNext(v))
1085         {
1086             /* Compare the pattern value to the match expression value */
1087             if (FcConfigCompareValue (&v->value, t->op, &value))
1088             {
1089                 if (!ret)
1090                     ret = v;
1091             }
1092             else
1093             {
1094                 if (t->qual == FcQualAll)
1095                 {
1096                     ret = 0;
1097                     break;
1098                 }
1099             }
1100         }
1101         FcValueDestroy (value);
1102     }
1103     return ret;
1104 }
1105
1106 static FcValueList *
1107 FcConfigValues (FcPattern *p, FcExpr *e, FcValueBinding binding)
1108 {
1109     FcValueList *l;
1110
1111     if (!e)
1112         return 0;
1113     l = (FcValueList *) malloc (sizeof (FcValueList));
1114     if (!l)
1115         return 0;
1116     FcMemAlloc (FC_MEM_VALLIST, sizeof (FcValueList));
1117     if (e->op == FcOpComma)
1118     {
1119         l->value = FcConfigEvaluate (p, e->u.tree.left);
1120         l->next = FcConfigValues (p, e->u.tree.right, binding);
1121     }
1122     else
1123     {
1124         l->value = FcConfigEvaluate (p, e);
1125         l->next = NULL;
1126     }
1127     l->binding = binding;
1128     if (l->value.type == FcTypeVoid)
1129     {
1130         FcValueList  *next = FcValueListNext(l);
1131
1132         FcMemFree (FC_MEM_VALLIST, sizeof (FcValueList));
1133         free (l);
1134         l = next;
1135     }
1136
1137     return l;
1138 }
1139
1140 static FcBool
1141 FcConfigAdd (FcValueListPtr *head,
1142              FcValueList    *position,
1143              FcBool         append,
1144              FcValueList    *new)
1145 {
1146     FcValueListPtr  *prev, last, v;
1147     FcValueBinding  sameBinding;
1148
1149     if (position)
1150         sameBinding = position->binding;
1151     else
1152         sameBinding = FcValueBindingWeak;
1153     for (v = new; v != NULL; v = FcValueListNext(v))
1154         if (v->binding == FcValueBindingSame)
1155             v->binding = sameBinding;
1156     if (append)
1157     {
1158         if (position)
1159             prev = &position->next;
1160         else
1161             for (prev = head; *prev != NULL;
1162                  prev = &(*prev)->next)
1163                 ;
1164     }
1165     else
1166     {
1167         if (position)
1168         {
1169             for (prev = head; *prev != NULL;
1170                  prev = &(*prev)->next)
1171             {
1172                 if (*prev == position)
1173                     break;
1174             }
1175         }
1176         else
1177             prev = head;
1178
1179         if (FcDebug () & FC_DBG_EDIT)
1180         {
1181             if (*prev == NULL)
1182                 printf ("position not on list\n");
1183         }
1184     }
1185
1186     if (FcDebug () & FC_DBG_EDIT)
1187     {
1188         printf ("%s list before ", append ? "Append" : "Prepend");
1189         FcValueListPrint (*head);
1190         printf ("\n");
1191     }
1192
1193     if (new)
1194     {
1195         last = new;
1196         while (last->next != NULL)
1197             last = last->next;
1198
1199         last->next = *prev;
1200         *prev = new;
1201     }
1202
1203     if (FcDebug () & FC_DBG_EDIT)
1204     {
1205         printf ("%s list after ", append ? "Append" : "Prepend");
1206         FcValueListPrint (*head);
1207         printf ("\n");
1208     }
1209
1210     return FcTrue;
1211 }
1212
1213 static void
1214 FcConfigDel (FcValueListPtr *head,
1215              FcValueList    *position)
1216 {
1217     FcValueListPtr *prev;
1218
1219     for (prev = head; *prev != NULL; prev = &(*prev)->next)
1220     {
1221         if (*prev == position)
1222         {
1223             *prev = position->next;
1224             position->next = NULL;
1225             FcValueListDestroy (position);
1226             break;
1227         }
1228     }
1229 }
1230
1231 static void
1232 FcConfigPatternAdd (FcPattern   *p,
1233                     FcObject    object,
1234                     FcValueList *list,
1235                     FcBool      append)
1236 {
1237     if (list)
1238     {
1239         FcPatternElt    *e = FcPatternObjectInsertElt (p, object);
1240
1241         if (!e)
1242             return;
1243         FcConfigAdd (&e->values, 0, append, list);
1244     }
1245 }
1246
1247 /*
1248  * Delete all values associated with a field
1249  */
1250 static void
1251 FcConfigPatternDel (FcPattern   *p,
1252                     FcObject    object)
1253 {
1254     FcPatternElt    *e = FcPatternObjectFindElt (p, object);
1255     if (!e)
1256         return;
1257     while (e->values != NULL)
1258         FcConfigDel (&e->values, e->values);
1259 }
1260
1261 static void
1262 FcConfigPatternCanon (FcPattern     *p,
1263                       FcObject      object)
1264 {
1265     FcPatternElt    *e = FcPatternObjectFindElt (p, object);
1266     if (!e)
1267         return;
1268     if (e->values == NULL)
1269         FcPatternObjectDel (p, object);
1270 }
1271
1272 FcBool
1273 FcConfigSubstituteWithPat (FcConfig    *config,
1274                            FcPattern   *p,
1275                            FcPattern   *p_pat,
1276                            FcMatchKind kind)
1277 {
1278     FcSubst         *s;
1279     FcSubState      *st;
1280     int             i;
1281     FcTest          *t;
1282     FcEdit          *e;
1283     FcValueList     *l;
1284     FcPattern       *m;
1285
1286     if (!config)
1287     {
1288         config = FcConfigGetCurrent ();
1289         if (!config)
1290             return FcFalse;
1291     }
1292
1293     st = (FcSubState *) malloc (config->maxObjects * sizeof (FcSubState));
1294     if (!st && config->maxObjects)
1295         return FcFalse;
1296     FcMemAlloc (FC_MEM_SUBSTATE, config->maxObjects * sizeof (FcSubState));
1297
1298     if (FcDebug () & FC_DBG_EDIT)
1299     {
1300         printf ("FcConfigSubstitute ");
1301         FcPatternPrint (p);
1302     }
1303     if (kind == FcMatchPattern)
1304         s = config->substPattern;
1305     else
1306         s = config->substFont;
1307     for (; s; s = s->next)
1308     {
1309         /*
1310          * Check the tests to see if
1311          * they all match the pattern
1312          */
1313         for (t = s->test, i = 0; t; t = t->next, i++)
1314         {
1315             if (FcDebug () & FC_DBG_EDIT)
1316             {
1317                 printf ("FcConfigSubstitute test ");
1318                 FcTestPrint (t);
1319             }
1320             st[i].elt = 0;
1321             if (kind == FcMatchFont && t->kind == FcMatchPattern)
1322                 m = p_pat;
1323             else
1324                 m = p;
1325             if (m)
1326                 st[i].elt = FcPatternObjectFindElt (m, t->object);
1327             else
1328                 st[i].elt = 0;
1329             /*
1330              * If there's no such field in the font,
1331              * then FcQualAll matches while FcQualAny does not
1332              */
1333             if (!st[i].elt)
1334             {
1335                 if (t->qual == FcQualAll)
1336                 {
1337                     st[i].value = 0;
1338                     continue;
1339                 }
1340                 else
1341                     break;
1342             }
1343             /*
1344              * Check to see if there is a match, mark the location
1345              * to apply match-relative edits
1346              */
1347             st[i].value = FcConfigMatchValueList (m, t, st[i].elt->values);
1348             if (!st[i].value)
1349                 break;
1350             if (t->qual == FcQualFirst && st[i].value != st[i].elt->values)
1351                 break;
1352             if (t->qual == FcQualNotFirst && st[i].value == st[i].elt->values)
1353                 break;
1354         }
1355         if (t)
1356         {
1357             if (FcDebug () & FC_DBG_EDIT)
1358                 printf ("No match\n");
1359             continue;
1360         }
1361         if (FcDebug () & FC_DBG_EDIT)
1362         {
1363             printf ("Substitute ");
1364             FcSubstPrint (s);
1365         }
1366         for (e = s->edit; e; e = e->next)
1367         {
1368             /*
1369              * Evaluate the list of expressions
1370              */
1371             l = FcConfigValues (p, e->expr, e->binding);
1372             /*
1373              * Locate any test associated with this field, skipping
1374              * tests associated with the pattern when substituting in
1375              * the font
1376              */
1377             for (t = s->test, i = 0; t; t = t->next, i++)
1378             {
1379                 if ((t->kind == FcMatchFont || kind == FcMatchPattern) &&
1380                     t->object == e->object)
1381                 {
1382                     /*
1383                      * KLUDGE - the pattern may have been reallocated or
1384                      * things may have been inserted or deleted above
1385                      * this element by other edits.  Go back and find
1386                      * the element again
1387                      */
1388                     if (e != s->edit && st[i].elt)
1389                         st[i].elt = FcPatternObjectFindElt (p, t->object);
1390                     if (!st[i].elt)
1391                         t = 0;
1392                     break;
1393                 }
1394             }
1395             switch (e->op) {
1396             case FcOpAssign:
1397                 /*
1398                  * If there was a test, then replace the matched
1399                  * value with the new list of values
1400                  */
1401                 if (t)
1402                 {
1403                     FcValueList *thisValue = st[i].value;
1404                     FcValueList *nextValue = thisValue;
1405
1406                     /*
1407                      * Append the new list of values after the current value
1408                      */
1409                     FcConfigAdd (&st[i].elt->values, thisValue, FcTrue, l);
1410                     /*
1411                      * Delete the marked value
1412                      */
1413                     if (thisValue)
1414                         FcConfigDel (&st[i].elt->values, thisValue);
1415                     /*
1416                      * Adjust any pointers into the value list to ensure
1417                      * future edits occur at the same place
1418                      */
1419                     for (t = s->test, i = 0; t; t = t->next, i++)
1420                     {
1421                         if (st[i].value == thisValue)
1422                             st[i].value = nextValue;
1423                     }
1424                     break;
1425                 }
1426                 /* fall through ... */
1427             case FcOpAssignReplace:
1428                 /*
1429                  * Delete all of the values and insert
1430                  * the new set
1431                  */
1432                 FcConfigPatternDel (p, e->object);
1433                 FcConfigPatternAdd (p, e->object, l, FcTrue);
1434                 /*
1435                  * Adjust any pointers into the value list as they no
1436                  * longer point to anything valid
1437                  */
1438                 if (t)
1439                 {
1440                     FcPatternElt    *thisElt = st[i].elt;
1441                     for (t = s->test, i = 0; t; t = t->next, i++)
1442                     {
1443                         if (st[i].elt == thisElt)
1444                             st[i].value = 0;
1445                     }
1446                 }
1447                 break;
1448             case FcOpPrepend:
1449                 if (t)
1450                 {
1451                     FcConfigAdd (&st[i].elt->values, st[i].value, FcFalse, l);
1452                     break;
1453                 }
1454                 /* fall through ... */
1455             case FcOpPrependFirst:
1456                 FcConfigPatternAdd (p, e->object, l, FcFalse);
1457                 break;
1458             case FcOpAppend:
1459                 if (t)
1460                 {
1461                     FcConfigAdd (&st[i].elt->values, st[i].value, FcTrue, l);
1462                     break;
1463                 }
1464                 /* fall through ... */
1465             case FcOpAppendLast:
1466                 FcConfigPatternAdd (p, e->object, l, FcTrue);
1467                 break;
1468             default:
1469                 FcValueListDestroy (l);
1470                 break;
1471             }
1472         }
1473         /*
1474          * Now go through the pattern and eliminate
1475          * any properties without data
1476          */
1477         for (e = s->edit; e; e = e->next)
1478             FcConfigPatternCanon (p, e->object);
1479
1480         if (FcDebug () & FC_DBG_EDIT)
1481         {
1482             printf ("FcConfigSubstitute edit");
1483             FcPatternPrint (p);
1484         }
1485     }
1486     FcMemFree (FC_MEM_SUBSTATE, config->maxObjects * sizeof (FcSubState));
1487     free (st);
1488     if (FcDebug () & FC_DBG_EDIT)
1489     {
1490         printf ("FcConfigSubstitute done");
1491         FcPatternPrint (p);
1492     }
1493     return FcTrue;
1494 }
1495
1496 FcBool
1497 FcConfigSubstitute (FcConfig    *config,
1498                     FcPattern   *p,
1499                     FcMatchKind kind)
1500 {
1501     return FcConfigSubstituteWithPat (config, p, 0, kind);
1502 }
1503
1504 #if defined (_WIN32) && (defined (PIC) || defined (DLL_EXPORT))
1505
1506 static FcChar8 fontconfig_path[1000] = "";
1507
1508 BOOL WINAPI
1509 DllMain (HINSTANCE hinstDLL,
1510          DWORD     fdwReason,
1511          LPVOID    lpvReserved)
1512 {
1513   FcChar8 *p;
1514
1515   switch (fdwReason) {
1516   case DLL_PROCESS_ATTACH:
1517       if (!GetModuleFileName ((HMODULE) hinstDLL, fontconfig_path,
1518                               sizeof (fontconfig_path)))
1519           break;
1520
1521       /* If the fontconfig DLL is in a "bin" or "lib" subfolder,
1522        * assume it's a Unix-style installation tree, and use
1523        * "etc/fonts" in there as FONTCONFIG_PATH. Otherwise use the
1524        * folder where the DLL is as FONTCONFIG_PATH.
1525        */
1526       p = strrchr (fontconfig_path, '\\');
1527       if (p)
1528       {
1529           *p = '\0';
1530           p = strrchr (fontconfig_path, '\\');
1531           if (p && (FcStrCmpIgnoreCase (p + 1, "bin") == 0 ||
1532                     FcStrCmpIgnoreCase (p + 1, "lib") == 0))
1533               *p = '\0';
1534           strcat (fontconfig_path, "\\etc\\fonts");
1535       }
1536       else
1537           fontconfig_path[0] = '\0';
1538
1539       break;
1540   }
1541
1542   return TRUE;
1543 }
1544
1545 #undef FONTCONFIG_PATH
1546 #define FONTCONFIG_PATH fontconfig_path
1547
1548 #else /* !(_WIN32 && PIC) */
1549
1550 #endif /* !(_WIN32 && PIC) */
1551
1552 #ifndef FONTCONFIG_FILE
1553 #define FONTCONFIG_FILE "fonts.conf"
1554 #endif
1555
1556 static FcChar8 *
1557 FcConfigFileExists (const FcChar8 *dir, const FcChar8 *file)
1558 {
1559     FcChar8    *path;
1560
1561     if (!dir)
1562         dir = (FcChar8 *) "";
1563     path = malloc (strlen ((char *) dir) + 1 + strlen ((char *) file) + 1);
1564     if (!path)
1565         return 0;
1566
1567     strcpy ((char *) path, (const char *) dir);
1568     /* make sure there's a single separator */
1569 #ifdef _WIN32
1570     if ((!path[0] || (path[strlen((char *) path)-1] != '/' &&
1571                       path[strlen((char *) path)-1] != '\\')) &&
1572         !(file[0] == '/' ||
1573           file[0] == '\\' ||
1574           (isalpha (file[0]) && file[1] == ':' && (file[2] == '/' || file[2] == '\\'))))
1575         strcat ((char *) path, "\\");
1576 #else
1577     if ((!path[0] || path[strlen((char *) path)-1] != '/') && file[0] != '/')
1578         strcat ((char *) path, "/");
1579 #endif
1580     strcat ((char *) path, (char *) file);
1581
1582     FcMemAlloc (FC_MEM_STRING, strlen ((char *) path) + 1);
1583     if (access ((char *) path, R_OK) == 0)
1584         return path;
1585
1586     FcStrFree (path);
1587     return 0;
1588 }
1589
1590 static FcChar8 **
1591 FcConfigGetPath (void)
1592 {
1593     FcChar8    **path;
1594     FcChar8    *env, *e, *colon;
1595     FcChar8    *dir;
1596     int     npath;
1597     int     i;
1598
1599     npath = 2;  /* default dir + null */
1600     env = (FcChar8 *) getenv ("FONTCONFIG_PATH");
1601     if (env)
1602     {
1603         e = env;
1604         npath++;
1605         while (*e)
1606             if (*e++ == FC_SEARCH_PATH_SEPARATOR)
1607                 npath++;
1608     }
1609     path = calloc (npath, sizeof (FcChar8 *));
1610     if (!path)
1611         goto bail0;
1612     i = 0;
1613
1614     if (env)
1615     {
1616         e = env;
1617         while (*e)
1618         {
1619             colon = (FcChar8 *) strchr ((char *) e, FC_SEARCH_PATH_SEPARATOR);
1620             if (!colon)
1621                 colon = e + strlen ((char *) e);
1622             path[i] = malloc (colon - e + 1);
1623             if (!path[i])
1624                 goto bail1;
1625             strncpy ((char *) path[i], (const char *) e, colon - e);
1626             path[i][colon - e] = '\0';
1627             if (*colon)
1628                 e = colon + 1;
1629             else
1630                 e = colon;
1631             i++;
1632         }
1633     }
1634
1635     dir = (FcChar8 *) FONTCONFIG_PATH;
1636     path[i] = malloc (strlen ((char *) dir) + 1);
1637     if (!path[i])
1638         goto bail1;
1639     strcpy ((char *) path[i], (const char *) dir);
1640     return path;
1641
1642 bail1:
1643     for (i = 0; path[i]; i++)
1644         free (path[i]);
1645     free (path);
1646 bail0:
1647     return 0;
1648 }
1649
1650 static void
1651 FcConfigFreePath (FcChar8 **path)
1652 {
1653     FcChar8    **p;
1654
1655     for (p = path; *p; p++)
1656         free (*p);
1657     free (path);
1658 }
1659
1660 static FcBool   _FcConfigHomeEnabled = FcTrue;
1661
1662 FcChar8 *
1663 FcConfigHome (void)
1664 {
1665     if (_FcConfigHomeEnabled)
1666     {
1667         char *home = getenv ("HOME");
1668
1669 #ifdef _WIN32
1670         if (home == NULL)
1671             home = getenv ("USERPROFILE");
1672 #endif
1673
1674         return (FcChar8 *) home;
1675     }
1676     return 0;
1677 }
1678
1679 FcBool
1680 FcConfigEnableHome (FcBool enable)
1681 {
1682     FcBool  prev = _FcConfigHomeEnabled;
1683     _FcConfigHomeEnabled = enable;
1684     return prev;
1685 }
1686
1687 FcChar8 *
1688 FcConfigFilename (const FcChar8 *url)
1689 {
1690     FcChar8    *file, *dir, **path, **p;
1691
1692     if (!url || !*url)
1693     {
1694         url = (FcChar8 *) getenv ("FONTCONFIG_FILE");
1695         if (!url)
1696             url = (FcChar8 *) FONTCONFIG_FILE;
1697     }
1698     file = 0;
1699
1700 #ifdef _WIN32
1701     if (isalpha (*url) &&
1702         url[1] == ':' &&
1703         (url[2] == '/' || url[2] == '\\'))
1704         goto absolute_path;
1705 #endif
1706
1707     switch (*url) {
1708     case '~':
1709         dir = FcConfigHome ();
1710         if (dir)
1711             file = FcConfigFileExists (dir, url + 1);
1712         else
1713             file = 0;
1714         break;
1715 #ifdef _WIN32
1716     case '\\':
1717     absolute_path:
1718 #endif
1719     case '/':
1720         file = FcConfigFileExists (0, url);
1721         break;
1722     default:
1723         path = FcConfigGetPath ();
1724         if (!path)
1725             return 0;
1726         for (p = path; *p; p++)
1727         {
1728             file = FcConfigFileExists (*p, url);
1729             if (file)
1730                 break;
1731         }
1732         FcConfigFreePath (path);
1733         break;
1734     }
1735     return file;
1736 }
1737
1738 /*
1739  * Manage the application-specific fonts
1740  */
1741
1742 FcBool
1743 FcConfigAppFontAddFile (FcConfig    *config,
1744                         const FcChar8  *file)
1745 {
1746     FcFontSet   *set;
1747     FcStrSet    *subdirs;
1748     FcStrList   *sublist;
1749     FcChar8     *subdir;
1750
1751     if (!config)
1752     {
1753         config = FcConfigGetCurrent ();
1754         if (!config)
1755             return FcFalse;
1756     }
1757
1758     subdirs = FcStrSetCreate ();
1759     if (!subdirs)
1760         return FcFalse;
1761
1762     set = FcConfigGetFonts (config, FcSetApplication);
1763     if (!set)
1764     {
1765         set = FcFontSetCreate ();
1766         if (!set)
1767         {
1768             FcStrSetDestroy (subdirs);
1769             return FcFalse;
1770         }
1771         FcConfigSetFonts (config, set, FcSetApplication);
1772     }
1773
1774     if (!FcFileScanConfig (set, subdirs, config->blanks, file, config))
1775     {
1776         FcStrSetDestroy (subdirs);
1777         return FcFalse;
1778     }
1779     if ((sublist = FcStrListCreate (subdirs)))
1780     {
1781         while ((subdir = FcStrListNext (sublist)))
1782         {
1783             FcConfigAppFontAddDir (config, subdir);
1784         }
1785         FcStrListDone (sublist);
1786     }
1787     FcStrSetDestroy (subdirs);
1788     return FcTrue;
1789 }
1790
1791 FcBool
1792 FcConfigAppFontAddDir (FcConfig     *config,
1793                        const FcChar8   *dir)
1794 {
1795     FcFontSet   *set;
1796     FcStrSet    *subdirs;
1797     FcStrList   *sublist;
1798     FcChar8     *subdir;
1799
1800     if (!config)
1801     {
1802         config = FcConfigGetCurrent ();
1803         if (!config)
1804             return FcFalse;
1805     }
1806     subdirs = FcStrSetCreate ();
1807     if (!subdirs)
1808         return FcFalse;
1809
1810     set = FcConfigGetFonts (config, FcSetApplication);
1811     if (!set)
1812     {
1813         set = FcFontSetCreate ();
1814         if (!set)
1815         {
1816             FcStrSetDestroy (subdirs);
1817             return FcFalse;
1818         }
1819         FcConfigSetFonts (config, set, FcSetApplication);
1820     }
1821
1822     if (!FcDirScanConfig (set, subdirs, config->blanks, dir, FcFalse, config))
1823     {
1824         FcStrSetDestroy (subdirs);
1825         return FcFalse;
1826     }
1827     if ((sublist = FcStrListCreate (subdirs)))
1828     {
1829         while ((subdir = FcStrListNext (sublist)))
1830         {
1831             FcConfigAppFontAddDir (config, subdir);
1832         }
1833         FcStrListDone (sublist);
1834     }
1835     FcStrSetDestroy (subdirs);
1836     return FcTrue;
1837 }
1838
1839 void
1840 FcConfigAppFontClear (FcConfig      *config)
1841 {
1842     if (!config)
1843     {
1844         config = FcConfigGetCurrent ();
1845         if (!config)
1846             return;
1847     }
1848
1849     FcConfigSetFonts (config, 0, FcSetApplication);
1850 }
1851
1852 /*
1853  * Manage filename-based font source selectors
1854  */
1855
1856 FcBool
1857 FcConfigGlobAdd (FcConfig       *config,
1858                  const FcChar8  *glob,
1859                  FcBool         accept)
1860 {
1861     FcStrSet    *set = accept ? config->acceptGlobs : config->rejectGlobs;
1862
1863     return FcStrSetAdd (set, glob);
1864 }
1865
1866 static FcBool
1867 FcConfigGlobMatch (const FcChar8    *glob,
1868                    const FcChar8    *string)
1869 {
1870     FcChar8     c;
1871
1872     while ((c = *glob++))
1873     {
1874         switch (c) {
1875         case '*':
1876             /* short circuit common case */
1877             if (!*glob)
1878                 return FcTrue;
1879             /* short circuit another common case */
1880             if (strchr ((char *) glob, '*') == 0)
1881                 string += strlen ((char *) string) - strlen ((char *) glob);
1882             while (*string)
1883             {
1884                 if (FcConfigGlobMatch (glob, string))
1885                     return FcTrue;
1886                 string++;
1887             }
1888             return FcFalse;
1889         case '?':
1890             if (*string++ == '\0')
1891                 return FcFalse;
1892             break;
1893         default:
1894             if (*string++ != c)
1895                 return FcFalse;
1896             break;
1897         }
1898     }
1899     return *string == '\0';
1900 }
1901
1902 static FcBool
1903 FcConfigGlobsMatch (const FcStrSet      *globs,
1904                     const FcChar8       *string)
1905 {
1906     int i;
1907
1908     for (i = 0; i < globs->num; i++)
1909         if (FcConfigGlobMatch (globs->strs[i], string))
1910             return FcTrue;
1911     return FcFalse;
1912 }
1913
1914 FcBool
1915 FcConfigAcceptFilename (FcConfig        *config,
1916                         const FcChar8   *filename)
1917 {
1918     if (FcConfigGlobsMatch (config->acceptGlobs, filename))
1919         return FcTrue;
1920     if (FcConfigGlobsMatch (config->rejectGlobs, filename))
1921         return FcFalse;
1922     return FcTrue;
1923 }
1924
1925 /*
1926  * Manage font-pattern based font source selectors
1927  */
1928
1929 FcBool
1930 FcConfigPatternsAdd (FcConfig   *config,
1931                      FcPattern  *pattern,
1932                      FcBool     accept)
1933 {
1934     FcFontSet   *set = accept ? config->acceptPatterns : config->rejectPatterns;
1935
1936     return FcFontSetAdd (set, pattern);
1937 }
1938
1939 static FcBool
1940 FcConfigPatternsMatch (const FcFontSet  *patterns,
1941                        const FcPattern  *font)
1942 {
1943     int i;
1944
1945     for (i = 0; i < patterns->nfont; i++)
1946         if (FcListPatternMatchAny (patterns->fonts[i], font))
1947             return FcTrue;
1948     return FcFalse;
1949 }
1950
1951 FcBool
1952 FcConfigAcceptFont (FcConfig        *config,
1953                     const FcPattern *font)
1954 {
1955     if (FcConfigPatternsMatch (config->acceptPatterns, font))
1956         return FcTrue;
1957     if (FcConfigPatternsMatch (config->rejectPatterns, font))
1958         return FcFalse;
1959     return FcTrue;
1960 }