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