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