src/fccfg.c

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