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 (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 FcOpLangSet:
 901         v.type = FcTypeLangSet;
 902         v.u.l = e->u.lval;
 903         v = FcValueSave (v);
 904         break;
 905     case FcOpBool:
 906         v.type = FcTypeBool;
 907         v.u.b = e->u.bval;
 908         break;
 909     case FcOpField:
 910         r = FcPatternObjectGet (p, e->u.object, 0, &v);
 911         if (r != FcResultMatch)
 912             v.type = FcTypeVoid;
 913         v = FcValueSave (v);
 914         break;
 915     case FcOpConst:
 916         if (FcNameConstant (e->u.constant, &v.u.i))
 917             v.type = FcTypeInteger;
 918         else
 919             v.type = FcTypeVoid;
 920         break;
 921     case FcOpQuest:
 922         vl = FcConfigEvaluate (p, e->u.tree.left);
 923         if (vl.type == FcTypeBool)
 924         {
 925             if (vl.u.b)
 926                 v = FcConfigEvaluate (p, e->u.tree.right->u.tree.left);
 927             else
 928                 v = FcConfigEvaluate (p, e->u.tree.right->u.tree.right);
 929         }
 930         else
 931             v.type = FcTypeVoid;
 932         FcValueDestroy (vl);
 933         break;
 934     case FcOpEqual:
 935     case FcOpNotEqual:
 936     case FcOpLess:
 937     case FcOpLessEqual:
 938     case FcOpMore:
 939     case FcOpMoreEqual:
 940     case FcOpContains:
 941     case FcOpNotContains:
 942     case FcOpListing:
 943         vl = FcConfigEvaluate (p, e->u.tree.left);
 944         vr = FcConfigEvaluate (p, e->u.tree.right);
 945         v.type = FcTypeBool;
 946         v.u.b = FcConfigCompareValue (&vl, e->op, &vr);
 947         FcValueDestroy (vl);
 948         FcValueDestroy (vr);
 949         break;
 950     case FcOpOr:
 951     case FcOpAnd:
 952     case FcOpPlus:
 953     case FcOpMinus:
 954     case FcOpTimes:
 955     case FcOpDivide:
 956         vl = FcConfigEvaluate (p, e->u.tree.left);
 957         vr = FcConfigEvaluate (p, e->u.tree.right);
 958         vl = FcConfigPromote (vl, vr);
 959         vr = FcConfigPromote (vr, vl);
 960         if (vl.type == vr.type)
 961         {
 962             switch (vl.type) {
 963             case FcTypeDouble:
 964                 switch (e->op) {
 965                 case FcOpPlus:
 966                     v.type = FcTypeDouble;
 967                     v.u.d = vl.u.d + vr.u.d;
 968                     break;
 969                 case FcOpMinus:
 970                     v.type = FcTypeDouble;
 971                     v.u.d = vl.u.d - vr.u.d;
 972                     break;
 973                 case FcOpTimes:
 974                     v.type = FcTypeDouble;
 975                     v.u.d = vl.u.d * vr.u.d;
 976                     break;
 977                 case FcOpDivide:
 978                     v.type = FcTypeDouble;
 979                     v.u.d = vl.u.d / vr.u.d;
 980                     break;
 981                 default:
 982                     v.type = FcTypeVoid;
 983                     break;
 984                 }
 985                 if (v.type == FcTypeDouble &&
 986                     v.u.d == (double) (int) v.u.d)
 987                 {
 988                     v.type = FcTypeInteger;
 989                     v.u.i = (int) v.u.d;
 990                 }
 991                 break;
 992             case FcTypeBool:
 993                 switch (e->op) {
 994                 case FcOpOr:
 995                     v.type = FcTypeBool;
 996                     v.u.b = vl.u.b || vr.u.b;
 997                     break;
 998                 case FcOpAnd:
 999                     v.type = FcTypeBool;
1000                     v.u.b = vl.u.b && vr.u.b;
1001                     break;
1002                 default:
1003                     v.type = FcTypeVoid;
1004                     break;
1005                 }
1006                 break;
1007             case FcTypeString:
1008                 switch (e->op) {
1009                 case FcOpPlus:
1010                     v.type = FcTypeString;
1011                     str = FcStrPlus (vl.u.s, vr.u.s);
1012                     v.u.s = FcStrStaticName (str);
1013                     FcStrFree (str);
1014
1015                     if (!v.u.s)
1016                         v.type = FcTypeVoid;
1017                     break;
1018                 default:
1019                     v.type = FcTypeVoid;
1020                     break;
1021                 }
1022                 break;
1023             case FcTypeMatrix:
1024                 switch (e->op) {
1025                 case FcOpTimes:
1026                     v.type = FcTypeMatrix;
1027                     m = malloc (sizeof (FcMatrix));
1028                     if (m)
1029                     {
1030                         FcMemAlloc (FC_MEM_MATRIX, sizeof (FcMatrix));
1031                         FcMatrixMultiply (m, vl.u.m, vr.u.m);
1032                         v.u.m = m;
1033                     }
1034                     else
1035                     {
1036                         v.type = FcTypeVoid;
1037                     }
1038                     break;
1039                 default:
1040                     v.type = FcTypeVoid;
1041                     break;
1042                 }
1043                 break;
1044             case FcTypeCharSet:
1045                 switch (e->op) {
1046                 case FcOpPlus:
1047                     v.type = FcTypeCharSet;
1048                     v.u.c = FcCharSetUnion (vl.u.c, vr.u.c);
1049                     if (!v.u.c)
1050                         v.type = FcTypeVoid;
1051                     break;
1052                 case FcOpMinus:
1053                     v.type = FcTypeCharSet;
1054                     v.u.c = FcCharSetSubtract (vl.u.c, vr.u.c);
1055                     if (!v.u.c)
1056                         v.type = FcTypeVoid;
1057                     break;
1058                 default:
1059                     v.type = FcTypeVoid;
1060                     break;
1061                 }
1062                 break;
1063             case FcTypeLangSet:
1064                 switch (e->op) {
1065                 case FcOpPlus:
1066                     v.type = FcTypeLangSet;
1067                     v.u.l = FcLangSetUnion (vl.u.l, vr.u.l);
1068                     if (!v.u.l)
1069                         v.type = FcTypeVoid;
1070                     break;
1071                 case FcOpMinus:
1072                     v.type = FcTypeLangSet;
1073                     v.u.l = FcLangSetSubtract (vl.u.l, vr.u.l);
1074                     if (!v.u.l)
1075                         v.type = FcTypeVoid;
1076                     break;
1077                 default:
1078                     v.type = FcTypeVoid;
1079                     break;
1080                 }
1081                 break;
1082             default:
1083                 v.type = FcTypeVoid;
1084                 break;
1085             }
1086         }
1087         else
1088             v.type = FcTypeVoid;
1089         FcValueDestroy (vl);
1090         FcValueDestroy (vr);
1091         break;
1092     case FcOpNot:
1093         vl = FcConfigEvaluate (p, e->u.tree.left);
1094         switch (vl.type) {
1095         case FcTypeBool:
1096             v.type = FcTypeBool;
1097             v.u.b = !vl.u.b;
1098             break;
1099         default:
1100             v.type = FcTypeVoid;
1101             break;
1102         }
1103         FcValueDestroy (vl);
1104         break;
1105     case FcOpFloor:
1106         vl = FcConfigEvaluate (p, e->u.tree.left);
1107         switch (vl.type) {
1108         case FcTypeInteger:
1109             v = vl;
1110             break;
1111         case FcTypeDouble:
1112             v.type = FcTypeInteger;
1113             v.u.i = FcDoubleFloor (vl.u.d);
1114             break;
1115         default:
1116             v.type = FcTypeVoid;
1117             break;
1118         }
1119         FcValueDestroy (vl);
1120         break;
1121     case FcOpCeil:
1122         vl = FcConfigEvaluate (p, e->u.tree.left);
1123         switch (vl.type) {
1124         case FcTypeInteger:
1125             v = vl;
1126             break;
1127         case FcTypeDouble:
1128             v.type = FcTypeInteger;
1129             v.u.i = FcDoubleCeil (vl.u.d);
1130             break;
1131         default:
1132             v.type = FcTypeVoid;
1133             break;
1134         }
1135         FcValueDestroy (vl);
1136         break;
1137     case FcOpRound:
1138         vl = FcConfigEvaluate (p, e->u.tree.left);
1139         switch (vl.type) {
1140         case FcTypeInteger:
1141             v = vl;
1142             break;
1143         case FcTypeDouble:
1144             v.type = FcTypeInteger;
1145             v.u.i = FcDoubleRound (vl.u.d);
1146             break;
1147         default:
1148             v.type = FcTypeVoid;
1149             break;
1150         }
1151         FcValueDestroy (vl);
1152         break;
1153     case FcOpTrunc:
1154         vl = FcConfigEvaluate (p, e->u.tree.left);
1155         switch (vl.type) {
1156         case FcTypeInteger:
1157             v = vl;
1158             break;
1159         case FcTypeDouble:
1160             v.type = FcTypeInteger;
1161             v.u.i = FcDoubleTrunc (vl.u.d);
1162             break;
1163         default:
1164             v.type = FcTypeVoid;
1165             break;
1166         }
1167         FcValueDestroy (vl);
1168         break;
1169     default:
1170         v.type = FcTypeVoid;
1171         break;
1172     }
1173     return v;
1174 }
1175
1176 static FcValueList *
1177 FcConfigMatchValueList (FcPattern       *p,
1178                         FcTest          *t,
1179                         FcValueList     *values)
1180 {
1181     FcValueList     *ret = 0;
1182     FcExpr          *e = t->expr;
1183     FcValue         value;
1184     FcValueList     *v;
1185
1186     while (e)
1187     {
1188         /* Compute the value of the match expression */
1189         if (e->op == FcOpComma)
1190         {
1191             value = FcConfigEvaluate (p, e->u.tree.left);
1192             e = e->u.tree.right;
1193         }
1194         else
1195         {
1196             value = FcConfigEvaluate (p, e);
1197             e = 0;
1198         }
1199
1200         for (v = values; v; v = FcValueListNext(v))
1201         {
1202             /* Compare the pattern value to the match expression value */
1203             if (FcConfigCompareValue (&v->value, t->op, &value))
1204             {
1205                 if (!ret)
1206                     ret = v;
1207             }
1208             else
1209             {
1210                 if (t->qual == FcQualAll)
1211                 {
1212                     ret = 0;
1213                     break;
1214                 }
1215             }
1216         }
1217         FcValueDestroy (value);
1218     }
1219     return ret;
1220 }
1221
1222 static FcValueList *
1223 FcConfigValues (FcPattern *p, FcExpr *e, FcValueBinding binding)
1224 {
1225     FcValueList *l;
1226
1227     if (!e)
1228         return 0;
1229     l = (FcValueList *) malloc (sizeof (FcValueList));
1230     if (!l)
1231         return 0;
1232     FcMemAlloc (FC_MEM_VALLIST, sizeof (FcValueList));
1233     if (e->op == FcOpComma)
1234     {
1235         l->value = FcConfigEvaluate (p, e->u.tree.left);
1236         l->next = FcConfigValues (p, e->u.tree.right, binding);
1237     }
1238     else
1239     {
1240         l->value = FcConfigEvaluate (p, e);
1241         l->next = NULL;
1242     }
1243     l->binding = binding;
1244     if (l->value.type == FcTypeVoid)
1245     {
1246         FcValueList  *next = FcValueListNext(l);
1247
1248         FcMemFree (FC_MEM_VALLIST, sizeof (FcValueList));
1249         free (l);
1250         l = next;
1251     }
1252
1253     return l;
1254 }
1255
1256 static FcBool
1257 FcConfigAdd (FcValueListPtr *head,
1258              FcValueList    *position,
1259              FcBool         append,
1260              FcValueList    *new)
1261 {
1262     FcValueListPtr  *prev, last, v;
1263     FcValueBinding  sameBinding;
1264
1265     if (position)
1266         sameBinding = position->binding;
1267     else
1268         sameBinding = FcValueBindingWeak;
1269     for (v = new; v != NULL; v = FcValueListNext(v))
1270         if (v->binding == FcValueBindingSame)
1271             v->binding = sameBinding;
1272     if (append)
1273     {
1274         if (position)
1275             prev = &position->next;
1276         else
1277             for (prev = head; *prev != NULL;
1278                  prev = &(*prev)->next)
1279                 ;
1280     }
1281     else
1282     {
1283         if (position)
1284         {
1285             for (prev = head; *prev != NULL;
1286                  prev = &(*prev)->next)
1287             {
1288                 if (*prev == position)
1289                     break;
1290             }
1291         }
1292         else
1293             prev = head;
1294
1295         if (FcDebug () & FC_DBG_EDIT)
1296         {
1297             if (*prev == NULL)
1298                 printf ("position not on list\n");
1299         }
1300     }
1301
1302     if (FcDebug () & FC_DBG_EDIT)
1303     {
1304         printf ("%s list before ", append ? "Append" : "Prepend");
1305         FcValueListPrint (*head);
1306         printf ("\n");
1307     }
1308
1309     if (new)
1310     {
1311         last = new;
1312         while (last->next != NULL)
1313             last = last->next;
1314
1315         last->next = *prev;
1316         *prev = new;
1317     }
1318
1319     if (FcDebug () & FC_DBG_EDIT)
1320     {
1321         printf ("%s list after ", append ? "Append" : "Prepend");
1322         FcValueListPrint (*head);
1323         printf ("\n");
1324     }
1325
1326     return FcTrue;
1327 }
1328
1329 static void
1330 FcConfigDel (FcValueListPtr *head,
1331              FcValueList    *position)
1332 {
1333     FcValueListPtr *prev;
1334
1335     for (prev = head; *prev != NULL; prev = &(*prev)->next)
1336     {
1337         if (*prev == position)
1338         {
1339             *prev = position->next;
1340             position->next = NULL;
1341             FcValueListDestroy (position);
1342             break;
1343         }
1344     }
1345 }
1346
1347 static void
1348 FcConfigPatternAdd (FcPattern   *p,
1349                     FcObject    object,
1350                     FcValueList *list,
1351                     FcBool      append)
1352 {
1353     if (list)
1354     {
1355         FcPatternElt    *e = FcPatternObjectInsertElt (p, object);
1356
1357         if (!e)
1358             return;
1359         FcConfigAdd (&e->values, 0, append, list);
1360     }
1361 }
1362
1363 /*
1364  * Delete all values associated with a field
1365  */
1366 static void
1367 FcConfigPatternDel (FcPattern   *p,
1368                     FcObject    object)
1369 {
1370     FcPatternElt    *e = FcPatternObjectFindElt (p, object);
1371     if (!e)
1372         return;
1373     while (e->values != NULL)
1374         FcConfigDel (&e->values, e->values);
1375 }
1376
1377 static void
1378 FcConfigPatternCanon (FcPattern     *p,
1379                       FcObject      object)
1380 {
1381     FcPatternElt    *e = FcPatternObjectFindElt (p, object);
1382     if (!e)
1383         return;
1384     if (e->values == NULL)
1385         FcPatternObjectDel (p, object);
1386 }
1387
1388 FcBool
1389 FcConfigSubstituteWithPat (FcConfig    *config,
1390                            FcPattern   *p,
1391                            FcPattern   *p_pat,
1392                            FcMatchKind kind)
1393 {
1394     FcSubst         *s;
1395     FcSubState      *st;
1396     int             i;
1397     FcTest          *t;
1398     FcEdit          *e;
1399     FcValueList     *l;
1400     FcPattern       *m;
1401
1402     if (!config)
1403     {
1404         config = FcConfigGetCurrent ();
1405         if (!config)
1406             return FcFalse;
1407     }
1408
1409     switch (kind) {
1410     case FcMatchPattern:
1411         s = config->substPattern;
1412         break;
1413     case FcMatchFont:
1414         s = config->substFont;
1415         break;
1416     case FcMatchScan:
1417         s = config->substScan;
1418         break;
1419     default:
1420         return FcFalse;
1421     }
1422
1423     st = (FcSubState *) malloc (config->maxObjects * sizeof (FcSubState));
1424     if (!st && config->maxObjects)
1425         return FcFalse;
1426     FcMemAlloc (FC_MEM_SUBSTATE, config->maxObjects * sizeof (FcSubState));
1427
1428     if (FcDebug () & FC_DBG_EDIT)
1429     {
1430         printf ("FcConfigSubstitute ");
1431         FcPatternPrint (p);
1432     }
1433     for (; s; s = s->next)
1434     {
1435         /*
1436          * Check the tests to see if
1437          * they all match the pattern
1438          */
1439         for (t = s->test, i = 0; t; t = t->next, i++)
1440         {
1441             if (FcDebug () & FC_DBG_EDIT)
1442             {
1443                 printf ("FcConfigSubstitute test ");
1444                 FcTestPrint (t);
1445             }
1446             st[i].elt = 0;
1447             if (kind == FcMatchFont && t->kind == FcMatchPattern)
1448                 m = p_pat;
1449             else
1450                 m = p;
1451             if (m)
1452                 st[i].elt = FcPatternObjectFindElt (m, t->object);
1453             else
1454                 st[i].elt = 0;
1455             /*
1456              * If there's no such field in the font,
1457              * then FcQualAll matches while FcQualAny does not
1458              */
1459             if (!st[i].elt)
1460             {
1461                 if (t->qual == FcQualAll)
1462                 {
1463                     st[i].value = 0;
1464                     continue;
1465                 }
1466                 else
1467                     break;
1468             }
1469             /*
1470              * Check to see if there is a match, mark the location
1471              * to apply match-relative edits
1472              */
1473             st[i].value = FcConfigMatchValueList (m, t, st[i].elt->values);
1474             if (!st[i].value)
1475                 break;
1476             if (t->qual == FcQualFirst && st[i].value != st[i].elt->values)
1477                 break;
1478             if (t->qual == FcQualNotFirst && st[i].value == st[i].elt->values)
1479                 break;
1480         }
1481         if (t)
1482         {
1483             if (FcDebug () & FC_DBG_EDIT)
1484                 printf ("No match\n");
1485             continue;
1486         }
1487         if (FcDebug () & FC_DBG_EDIT)
1488         {
1489             printf ("Substitute ");
1490             FcSubstPrint (s);
1491         }
1492         for (e = s->edit; e; e = e->next)
1493         {
1494             /*
1495              * Evaluate the list of expressions
1496              */
1497             l = FcConfigValues (p, e->expr, e->binding);
1498             /*
1499              * Locate any test associated with this field, skipping
1500              * tests associated with the pattern when substituting in
1501              * the font
1502              */
1503             for (t = s->test, i = 0; t; t = t->next, i++)
1504             {
1505                 if ((t->kind == FcMatchFont || kind == FcMatchPattern) &&
1506                     t->object == e->object)
1507                 {
1508                     /*
1509                      * KLUDGE - the pattern may have been reallocated or
1510                      * things may have been inserted or deleted above
1511                      * this element by other edits.  Go back and find
1512                      * the element again
1513                      */
1514                     if (e != s->edit && st[i].elt)
1515                         st[i].elt = FcPatternObjectFindElt (p, t->object);
1516                     if (!st[i].elt)
1517                         t = 0;
1518                     break;
1519                 }
1520             }
1521             switch (e->op) {
1522             case FcOpAssign:
1523                 /*
1524                  * If there was a test, then replace the matched
1525                  * value with the new list of values
1526                  */
1527                 if (t)
1528                 {
1529                     FcValueList *thisValue = st[i].value;
1530                     FcValueList *nextValue = thisValue;
1531
1532                     /*
1533                      * Append the new list of values after the current value
1534                      */
1535                     FcConfigAdd (&st[i].elt->values, thisValue, FcTrue, l);
1536                     /*
1537                      * Delete the marked value
1538                      */
1539                     if (thisValue)
1540                         FcConfigDel (&st[i].elt->values, thisValue);
1541                     /*
1542                      * Adjust any pointers into the value list to ensure
1543                      * future edits occur at the same place
1544                      */
1545                     for (t = s->test, i = 0; t; t = t->next, i++)
1546                     {
1547                         if (st[i].value == thisValue)
1548                             st[i].value = nextValue;
1549                     }
1550                     break;
1551                 }
1552                 /* fall through ... */
1553             case FcOpAssignReplace:
1554                 /*
1555                  * Delete all of the values and insert
1556                  * the new set
1557                  */
1558                 FcConfigPatternDel (p, e->object);
1559                 FcConfigPatternAdd (p, e->object, l, FcTrue);
1560                 /*
1561                  * Adjust any pointers into the value list as they no
1562                  * longer point to anything valid
1563                  */
1564                 if (t)
1565                 {
1566                     FcPatternElt    *thisElt = st[i].elt;
1567                     for (t = s->test, i = 0; t; t = t->next, i++)
1568                     {
1569                         if (st[i].elt == thisElt)
1570                             st[i].value = 0;
1571                     }
1572                 }
1573                 break;
1574             case FcOpPrepend:
1575                 if (t)
1576                 {
1577                     FcConfigAdd (&st[i].elt->values, st[i].value, FcFalse, l);
1578                     break;
1579                 }
1580                 /* fall through ... */
1581             case FcOpPrependFirst:
1582                 FcConfigPatternAdd (p, e->object, l, FcFalse);
1583                 break;
1584             case FcOpAppend:
1585                 if (t)
1586                 {
1587                     FcConfigAdd (&st[i].elt->values, st[i].value, FcTrue, l);
1588                     break;
1589                 }
1590                 /* fall through ... */
1591             case FcOpAppendLast:
1592                 FcConfigPatternAdd (p, e->object, l, FcTrue);
1593                 break;
1594             default:
1595                 FcValueListDestroy (l);
1596                 break;
1597             }
1598         }
1599         /*
1600          * Now go through the pattern and eliminate
1601          * any properties without data
1602          */
1603         for (e = s->edit; e; e = e->next)
1604             FcConfigPatternCanon (p, e->object);
1605
1606         if (FcDebug () & FC_DBG_EDIT)
1607         {
1608             printf ("FcConfigSubstitute edit");
1609             FcPatternPrint (p);
1610         }
1611     }
1612     FcMemFree (FC_MEM_SUBSTATE, config->maxObjects * sizeof (FcSubState));
1613     free (st);
1614     if (FcDebug () & FC_DBG_EDIT)
1615     {
1616         printf ("FcConfigSubstitute done");
1617         FcPatternPrint (p);
1618     }
1619     return FcTrue;
1620 }
1621
1622 FcBool
1623 FcConfigSubstitute (FcConfig    *config,
1624                     FcPattern   *p,
1625                     FcMatchKind kind)
1626 {
1627     return FcConfigSubstituteWithPat (config, p, 0, kind);
1628 }
1629
1630 #if defined (_WIN32)
1631
1632 #  define WIN32_LEAN_AND_MEAN
1633 #  define WIN32_EXTRA_LEAN
1634 #  include <windows.h>
1635
1636 static FcChar8 fontconfig_path[1000] = "";
1637
1638 #  if (defined (PIC) || defined (DLL_EXPORT))
1639
1640 BOOL WINAPI
1641 DllMain (HINSTANCE hinstDLL,
1642          DWORD     fdwReason,
1643          LPVOID    lpvReserved)
1644 {
1645   FcChar8 *p;
1646
1647   switch (fdwReason) {
1648   case DLL_PROCESS_ATTACH:
1649       if (!GetModuleFileName ((HMODULE) hinstDLL, fontconfig_path,
1650                               sizeof (fontconfig_path)))
1651           break;
1652
1653       /* If the fontconfig DLL is in a "bin" or "lib" subfolder,
1654        * assume it's a Unix-style installation tree, and use
1655        * "etc/fonts" in there as FONTCONFIG_PATH. Otherwise use the
1656        * folder where the DLL is as FONTCONFIG_PATH.
1657        */
1658       p = strrchr (fontconfig_path, '\\');
1659       if (p)
1660       {
1661           *p = '\0';
1662           p = strrchr (fontconfig_path, '\\');
1663           if (p && (FcStrCmpIgnoreCase (p + 1, "bin") == 0 ||
1664                     FcStrCmpIgnoreCase (p + 1, "lib") == 0))
1665               *p = '\0';
1666           strcat (fontconfig_path, "\\etc\\fonts");
1667       }
1668       else
1669           fontconfig_path[0] = '\0';
1670
1671       break;
1672   }
1673
1674   return TRUE;
1675 }
1676
1677 #  endif /* !PIC */
1678
1679 #undef FONTCONFIG_PATH
1680 #define FONTCONFIG_PATH fontconfig_path
1681
1682 #endif /* !_WIN32 */
1683
1684 #ifndef FONTCONFIG_FILE
1685 #define FONTCONFIG_FILE "fonts.conf"
1686 #endif
1687
1688 static FcChar8 *
1689 FcConfigFileExists (const FcChar8 *dir, const FcChar8 *file)
1690 {
1691     FcChar8    *path;
1692     int         size;
1693
1694     if (!dir)
1695         dir = (FcChar8 *) "";
1696
1697     size = strlen ((char *) dir) + 1 + strlen ((char *) file) + 1;
1698     /*
1699      * workaround valgrind warning because glibc takes advantage of how it knows memory is
1700      * allocated to implement strlen by reading in groups of 4
1701      */
1702     size = (size + 3) & ~3;
1703
1704     path = malloc (size);
1705     if (!path)
1706         return 0;
1707
1708     strcpy ((char *) path, (const char *) dir);
1709     /* make sure there's a single separator */
1710 #ifdef _WIN32
1711     if ((!path[0] || (path[strlen((char *) path)-1] != '/' &&
1712                       path[strlen((char *) path)-1] != '\\')) &&
1713         !(file[0] == '/' ||
1714           file[0] == '\\' ||
1715           (isalpha (file[0]) && file[1] == ':' && (file[2] == '/' || file[2] == '\\'))))
1716         strcat ((char *) path, "\\");
1717 #else
1718     if ((!path[0] || path[strlen((char *) path)-1] != '/') && file[0] != '/')
1719         strcat ((char *) path, "/");
1720 #endif
1721     strcat ((char *) path, (char *) file);
1722
1723     FcMemAlloc (FC_MEM_STRING, size);
1724     if (access ((char *) path, R_OK) == 0)
1725         return path;
1726
1727     FcStrFree (path);
1728     return 0;
1729 }
1730
1731 static FcChar8 **
1732 FcConfigGetPath (void)
1733 {
1734     FcChar8    **path;
1735     FcChar8    *env, *e, *colon;
1736     FcChar8    *dir;
1737     int     npath;
1738     int     i;
1739
1740     npath = 2;  /* default dir + null */
1741     env = (FcChar8 *) getenv ("FONTCONFIG_PATH");
1742     if (env)
1743     {
1744         e = env;
1745         npath++;
1746         while (*e)
1747             if (*e++ == FC_SEARCH_PATH_SEPARATOR)
1748                 npath++;
1749     }
1750     path = calloc (npath, sizeof (FcChar8 *));
1751     if (!path)
1752         goto bail0;
1753     i = 0;
1754
1755     if (env)
1756     {
1757         e = env;
1758         while (*e)
1759         {
1760             colon = (FcChar8 *) strchr ((char *) e, FC_SEARCH_PATH_SEPARATOR);
1761             if (!colon)
1762                 colon = e + strlen ((char *) e);
1763             path[i] = malloc (colon - e + 1);
1764             if (!path[i])
1765                 goto bail1;
1766             strncpy ((char *) path[i], (const char *) e, colon - e);
1767             path[i][colon - e] = '\0';
1768             if (*colon)
1769                 e = colon + 1;
1770             else
1771                 e = colon;
1772             i++;
1773         }
1774     }
1775
1776 #ifdef _WIN32
1777         if (fontconfig_path[0] == '\0')
1778         {
1779                 char *p;
1780                 if(!GetModuleFileName(NULL, fontconfig_path, sizeof(fontconfig_path)))
1781                         goto bail1;
1782                 p = strrchr (fontconfig_path, '\\');
1783                 if (p) *p = '\0';
1784                 strcat (fontconfig_path, "\\fonts");
1785         }
1786 #endif
1787     dir = (FcChar8 *) FONTCONFIG_PATH;
1788     path[i] = malloc (strlen ((char *) dir) + 1);
1789     if (!path[i])
1790         goto bail1;
1791     strcpy ((char *) path[i], (const char *) dir);
1792     return path;
1793
1794 bail1:
1795     for (i = 0; path[i]; i++)
1796         free (path[i]);
1797     free (path);
1798 bail0:
1799     return 0;
1800 }
1801
1802 static void
1803 FcConfigFreePath (FcChar8 **path)
1804 {
1805     FcChar8    **p;
1806
1807     for (p = path; *p; p++)
1808         free (*p);
1809     free (path);
1810 }
1811
1812 static FcBool   _FcConfigHomeEnabled = FcTrue;
1813
1814 FcChar8 *
1815 FcConfigHome (void)
1816 {
1817     if (_FcConfigHomeEnabled)
1818     {
1819         char *home = getenv ("HOME");
1820
1821 #ifdef _WIN32
1822         if (home == NULL)
1823             home = getenv ("USERPROFILE");
1824 #endif
1825
1826         return (FcChar8 *) home;
1827     }
1828     return 0;
1829 }
1830
1831 FcBool
1832 FcConfigEnableHome (FcBool enable)
1833 {
1834     FcBool  prev = _FcConfigHomeEnabled;
1835     _FcConfigHomeEnabled = enable;
1836     return prev;
1837 }
1838
1839 FcChar8 *
1840 FcConfigFilename (const FcChar8 *url)
1841 {
1842     FcChar8    *file, *dir, **path, **p;
1843
1844     if (!url || !*url)
1845     {
1846         url = (FcChar8 *) getenv ("FONTCONFIG_FILE");
1847         if (!url)
1848             url = (FcChar8 *) FONTCONFIG_FILE;
1849     }
1850     file = 0;
1851
1852 #ifdef _WIN32
1853     if (isalpha (*url) &&
1854         url[1] == ':' &&
1855         (url[2] == '/' || url[2] == '\\'))
1856         goto absolute_path;
1857 #endif
1858
1859     switch (*url) {
1860     case '~':
1861         dir = FcConfigHome ();
1862         if (dir)
1863             file = FcConfigFileExists (dir, url + 1);
1864         else
1865             file = 0;
1866         break;
1867 #ifdef _WIN32
1868     case '\\':
1869     absolute_path:
1870 #endif
1871     case '/':
1872         file = FcConfigFileExists (0, url);
1873         break;
1874     default:
1875         path = FcConfigGetPath ();
1876         if (!path)
1877             return 0;
1878         for (p = path; *p; p++)
1879         {
1880             file = FcConfigFileExists (*p, url);
1881             if (file)
1882                 break;
1883         }
1884         FcConfigFreePath (path);
1885         break;
1886     }
1887     return file;
1888 }
1889
1890 /*
1891  * Manage the application-specific fonts
1892  */
1893
1894 FcBool
1895 FcConfigAppFontAddFile (FcConfig    *config,
1896                         const FcChar8  *file)
1897 {
1898     FcFontSet   *set;
1899     FcStrSet    *subdirs;
1900     FcStrList   *sublist;
1901     FcChar8     *subdir;
1902
1903     if (!config)
1904     {
1905         config = FcConfigGetCurrent ();
1906         if (!config)
1907             return FcFalse;
1908     }
1909
1910     subdirs = FcStrSetCreate ();
1911     if (!subdirs)
1912         return FcFalse;
1913
1914     set = FcConfigGetFonts (config, FcSetApplication);
1915     if (!set)
1916     {
1917         set = FcFontSetCreate ();
1918         if (!set)
1919         {
1920             FcStrSetDestroy (subdirs);
1921             return FcFalse;
1922         }
1923         FcConfigSetFonts (config, set, FcSetApplication);
1924     }
1925
1926     if (!FcFileScanConfig (set, subdirs, config->blanks, file, config))
1927     {
1928         FcStrSetDestroy (subdirs);
1929         return FcFalse;
1930     }
1931     if ((sublist = FcStrListCreate (subdirs)))
1932     {
1933         while ((subdir = FcStrListNext (sublist)))
1934         {
1935             FcConfigAppFontAddDir (config, subdir);
1936         }
1937         FcStrListDone (sublist);
1938     }
1939     FcStrSetDestroy (subdirs);
1940     return FcTrue;
1941 }
1942
1943 FcBool
1944 FcConfigAppFontAddDir (FcConfig     *config,
1945                        const FcChar8   *dir)
1946 {
1947     FcFontSet   *set;
1948     FcStrSet    *dirs;
1949
1950     if (!config)
1951     {
1952         config = FcConfigGetCurrent ();
1953         if (!config)
1954             return FcFalse;
1955     }
1956
1957     dirs = FcStrSetCreate ();
1958     if (!dirs)
1959         return FcFalse;
1960
1961     set = FcConfigGetFonts (config, FcSetApplication);
1962     if (!set)
1963     {
1964         set = FcFontSetCreate ();
1965         if (!set)
1966         {
1967             FcStrSetDestroy (dirs);
1968             return FcFalse;
1969         }
1970         FcConfigSetFonts (config, set, FcSetApplication);
1971     }
1972
1973     FcStrSetAddFilename (dirs, dir);
1974
1975     if (!FcConfigAddDirList (config, FcSetApplication, dirs))
1976     {
1977         FcStrSetDestroy (dirs);
1978         return FcFalse;
1979     }
1980     FcStrSetDestroy (dirs);
1981     return FcTrue;
1982 }
1983
1984 void
1985 FcConfigAppFontClear (FcConfig      *config)
1986 {
1987     if (!config)
1988     {
1989         config = FcConfigGetCurrent ();
1990         if (!config)
1991             return;
1992     }
1993
1994     FcConfigSetFonts (config, 0, FcSetApplication);
1995 }
1996
1997 /*
1998  * Manage filename-based font source selectors
1999  */
2000
2001 FcBool
2002 FcConfigGlobAdd (FcConfig       *config,
2003                  const FcChar8  *glob,
2004                  FcBool         accept)
2005 {
2006     FcStrSet    *set = accept ? config->acceptGlobs : config->rejectGlobs;
2007
2008     return FcStrSetAdd (set, glob);
2009 }
2010
2011 static FcBool
2012 FcConfigGlobMatch (const FcChar8    *glob,
2013                    const FcChar8    *string)
2014 {
2015     FcChar8     c;
2016
2017     while ((c = *glob++))
2018     {
2019         switch (c) {
2020         case '*':
2021             /* short circuit common case */
2022             if (!*glob)
2023                 return FcTrue;
2024             /* short circuit another common case */
2025             if (strchr ((char *) glob, '*') == 0)
2026                 string += strlen ((char *) string) - strlen ((char *) glob);
2027             while (*string)
2028             {
2029                 if (FcConfigGlobMatch (glob, string))
2030                     return FcTrue;
2031                 string++;
2032             }
2033             return FcFalse;
2034         case '?':
2035             if (*string++ == '\0')
2036                 return FcFalse;
2037             break;
2038         default:
2039             if (*string++ != c)
2040                 return FcFalse;
2041             break;
2042         }
2043     }
2044     return *string == '\0';
2045 }
2046
2047 static FcBool
2048 FcConfigGlobsMatch (const FcStrSet      *globs,
2049                     const FcChar8       *string)
2050 {
2051     int i;
2052
2053     for (i = 0; i < globs->num; i++)
2054         if (FcConfigGlobMatch (globs->strs[i], string))
2055             return FcTrue;
2056     return FcFalse;
2057 }
2058
2059 FcBool
2060 FcConfigAcceptFilename (FcConfig        *config,
2061                         const FcChar8   *filename)
2062 {
2063     if (FcConfigGlobsMatch (config->acceptGlobs, filename))
2064         return FcTrue;
2065     if (FcConfigGlobsMatch (config->rejectGlobs, filename))
2066         return FcFalse;
2067     return FcTrue;
2068 }
2069
2070 /*
2071  * Manage font-pattern based font source selectors
2072  */
2073
2074 FcBool
2075 FcConfigPatternsAdd (FcConfig   *config,
2076                      FcPattern  *pattern,
2077                      FcBool     accept)
2078 {
2079     FcFontSet   *set = accept ? config->acceptPatterns : config->rejectPatterns;
2080
2081     return FcFontSetAdd (set, pattern);
2082 }
2083
2084 static FcBool
2085 FcConfigPatternsMatch (const FcFontSet  *patterns,
2086                        const FcPattern  *font)
2087 {
2088     int i;
2089
2090     for (i = 0; i < patterns->nfont; i++)
2091         if (FcListPatternMatchAny (patterns->fonts[i], font))
2092             return FcTrue;
2093     return FcFalse;
2094 }
2095
2096 FcBool
2097 FcConfigAcceptFont (FcConfig        *config,
2098                     const FcPattern *font)
2099 {
2100     if (FcConfigPatternsMatch (config->acceptPatterns, font))
2101         return FcTrue;
2102     if (FcConfigPatternsMatch (config->rejectPatterns, font))
2103         return FcFalse;
2104     return FcTrue;
2105 }
2106 #define __fccfg__
2107 #include "fcaliastail.h"
2108 #undef __fccfg__