src/fcmatch.c

   1 /*
   2  * fontconfig/src/fcmatch.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 Keith Packard not be used in
  11  * advertising or publicity pertaining to distribution of the software without
  12  * specific, written prior permission.  Keith Packard makes no
  13  * representations about the suitability of this software for any purpose.  It
  14  * is provided "as is" without express or implied warranty.
  15  *
  16  * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  17  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  18  * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  19  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  20  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  21  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  22  * PERFORMANCE OF THIS SOFTWARE.
  23  */
  24
  25 #include "fcint.h"
  26 #include <string.h>
  27 #include <ctype.h>
  28 #include <stdio.h>
  29
  30 static double
  31 FcCompareNumber (FcValue *value1, FcValue *value2)
  32 {
  33     double  v1, v2, v;
  34
  35     switch (value1->type) {
  36     case FcTypeInteger:
  37         v1 = (double) value1->u.i;
  38         break;
  39     case FcTypeDouble:
  40         v1 = value1->u.d;
  41         break;
  42     default:
  43         return -1.0;
  44     }
  45     switch (value2->type) {
  46     case FcTypeInteger:
  47         v2 = (double) value2->u.i;
  48         break;
  49     case FcTypeDouble:
  50         v2 = value2->u.d;
  51         break;
  52     default:
  53         return -1.0;
  54     }
  55     v = v2 - v1;
  56     if (v < 0)
  57         v = -v;
  58     return v;
  59 }
  60
  61 static double
  62 FcCompareString (FcValue *v1, FcValue *v2)
  63 {
  64     return (double) FcStrCmpIgnoreCase (fc_value_string(v1), fc_value_string(v2)) != 0;
  65 }
  66
  67 static double
  68 FcCompareFamily (FcValue *v1, FcValue *v2)
  69 {
  70     /* rely on the guarantee in FcPatternAddWithBinding that
  71      * families are always FcTypeString. */
  72     const FcChar8* v1_string = fc_value_string(v1);
  73     const FcChar8* v2_string = fc_value_string(v2);
  74
  75     if (FcToLower(*v1_string) != FcToLower(*v2_string))
  76        return 1.0;
  77
  78     return (double) FcStrCmpIgnoreBlanksAndCase (v1_string, v2_string) != 0;
  79 }
  80
  81 static double
  82 FcCompareLang (FcValue *v1, FcValue *v2)
  83 {
  84     FcLangResult    result;
  85     FcValue value1 = FcValueCanonicalize(v1), value2 = FcValueCanonicalize(v2);
  86
  87     switch (value1.type) {
  88     case FcTypeLangSet:
  89         switch (value2.type) {
  90         case FcTypeLangSet:
  91             result = FcLangSetCompare (value1.u.l, value2.u.l);
  92             break;
  93         case FcTypeString:
  94             result = FcLangSetHasLang (value1.u.l,
  95                                        value2.u.s);
  96             break;
  97         default:
  98             return -1.0;
  99         }
 100         break;
 101     case FcTypeString:
 102         switch (value2.type) {
 103         case FcTypeLangSet:
 104             result = FcLangSetHasLang (value2.u.l, value1.u.s);
 105             break;
 106         case FcTypeString:
 107             result = FcLangCompare (value1.u.s,
 108                                     value2.u.s);
 109             break;
 110         default:
 111             return -1.0;
 112         }
 113         break;
 114     default:
 115         return -1.0;
 116     }
 117     switch (result) {
 118     case FcLangEqual:
 119         return 0;
 120     case FcLangDifferentCountry:
 121         return 1;
 122     case FcLangDifferentLang:
 123     default:
 124         return 2;
 125     }
 126 }
 127
 128 static double
 129 FcCompareBool (FcValue *v1, FcValue *v2)
 130 {
 131     if (fc_storage_type(v2) != FcTypeBool || fc_storage_type(v1) != FcTypeBool)
 132         return -1.0;
 133     return (double) v2->u.b != v1->u.b;
 134 }
 135
 136 static double
 137 FcCompareCharSet (FcValue *v1, FcValue *v2)
 138 {
 139     return (double) FcCharSetSubtractCount (fc_value_charset(v1), fc_value_charset(v2));
 140 }
 141
 142 static double
 143 FcCompareSize (FcValue *value1, FcValue *value2)
 144 {
 145     double  v1, v2, v;
 146
 147     switch (value1->type) {
 148     case FcTypeInteger:
 149         v1 = value1->u.i;
 150         break;
 151     case FcTypeDouble:
 152         v1 = value1->u.d;
 153         break;
 154     default:
 155         return -1;
 156     }
 157     switch (value2->type) {
 158     case FcTypeInteger:
 159         v2 = value2->u.i;
 160         break;
 161     case FcTypeDouble:
 162         v2 = value2->u.d;
 163         break;
 164     default:
 165         return -1;
 166     }
 167     if (v2 == 0)
 168         return 0;
 169     v = v2 - v1;
 170     if (v < 0)
 171         v = -v;
 172     return v;
 173 }
 174
 175 typedef struct _FcMatcher {
 176     FcObject        object;
 177     double          (*compare) (FcValue *value1, FcValue *value2);
 178     int             strong, weak;
 179 } FcMatcher;
 180
 181 /*
 182  * Order is significant, it defines the precedence of
 183  * each value, earlier values are more significant than
 184  * later values
 185  */
 186 static FcMatcher _FcMatchers [] = {
 187     { FC_FOUNDRY_OBJECT,        FcCompareString,        0, 0 },
 188 #define MATCH_FOUNDRY       0
 189 #define MATCH_FOUNDRY_INDEX 0
 190
 191     { FC_CHARSET_OBJECT,        FcCompareCharSet,       1, 1 },
 192 #define MATCH_CHARSET       1
 193 #define MATCH_CHARSET_INDEX 1
 194
 195     { FC_FAMILY_OBJECT,         FcCompareFamily,        2, 4 },
 196 #define MATCH_FAMILY        2
 197 #define MATCH_FAMILY_STRONG_INDEX   2
 198 #define MATCH_FAMILY_WEAK_INDEX     4
 199
 200     { FC_LANG_OBJECT,           FcCompareLang,  3, 3 },
 201 #define MATCH_LANG          3
 202 #define MATCH_LANG_INDEX    3
 203
 204     { FC_SPACING_OBJECT,        FcCompareNumber,        5, 5 },
 205 #define MATCH_SPACING       4
 206 #define MATCH_SPACING_INDEX 5
 207
 208     { FC_PIXEL_SIZE_OBJECT,     FcCompareSize,  6, 6 },
 209 #define MATCH_PIXEL_SIZE    5
 210 #define MATCH_PIXEL_SIZE_INDEX  6
 211
 212     { FC_STYLE_OBJECT,          FcCompareString,        7, 7 },
 213 #define MATCH_STYLE         6
 214 #define MATCH_STYLE_INDEX   7
 215
 216     { FC_SLANT_OBJECT,          FcCompareNumber,        8, 8 },
 217 #define MATCH_SLANT         7
 218 #define MATCH_SLANT_INDEX   8
 219
 220     { FC_WEIGHT_OBJECT,         FcCompareNumber,        9, 9 },
 221 #define MATCH_WEIGHT        8
 222 #define MATCH_WEIGHT_INDEX  9
 223
 224     { FC_WIDTH_OBJECT,          FcCompareNumber,        10, 10 },
 225 #define MATCH_WIDTH         9
 226 #define MATCH_WIDTH_INDEX   10
 227
 228     { FC_DECORATIVE_OBJECT,     FcCompareBool,          11, 11 },
 229 #define MATCH_DECORATIVE        10
 230 #define MATCH_DECORATIVE_INDEX  11
 231
 232     { FC_ANTIALIAS_OBJECT,      FcCompareBool,          12, 12 },
 233 #define MATCH_ANTIALIAS             11
 234 #define MATCH_ANTIALIAS_INDEX       12
 235
 236     { FC_RASTERIZER_OBJECT,     FcCompareString,        13, 13 },
 237 #define MATCH_RASTERIZER            12
 238 #define MATCH_RASTERIZER_INDEX      13
 239
 240     { FC_OUTLINE_OBJECT,        FcCompareBool,          14, 14 },
 241 #define MATCH_OUTLINE               13
 242 #define MATCH_OUTLINE_INDEX         14
 243
 244     { FC_FONTVERSION_OBJECT,    FcCompareNumber,        15, 15 },
 245 #define MATCH_FONTVERSION           14
 246 #define MATCH_FONTVERSION_INDEX     15
 247 };
 248
 249 #define NUM_MATCH_VALUES    16
 250
 251 static FcMatcher*
 252 FcObjectToMatcher (FcObject object)
 253 {
 254     int         i;
 255
 256     i = -1;
 257     switch (object) {
 258     case FC_FOUNDRY_OBJECT:
 259         i = MATCH_FOUNDRY; break;
 260     case FC_FONTVERSION_OBJECT:
 261         i = MATCH_FONTVERSION; break;
 262     case FC_FAMILY_OBJECT:
 263         i = MATCH_FAMILY; break;
 264     case FC_CHARSET_OBJECT:
 265         i = MATCH_CHARSET; break;
 266     case FC_ANTIALIAS_OBJECT:
 267         i = MATCH_ANTIALIAS; break;
 268     case FC_LANG_OBJECT:
 269         i = MATCH_LANG; break;
 270     case FC_SPACING_OBJECT:
 271         i = MATCH_SPACING; break;
 272     case FC_STYLE_OBJECT:
 273         i = MATCH_STYLE; break;
 274     case FC_SLANT_OBJECT:
 275         i = MATCH_SLANT; break;
 276     case FC_PIXEL_SIZE_OBJECT:
 277         i = MATCH_PIXEL_SIZE; break;
 278     case FC_WIDTH_OBJECT:
 279         i = MATCH_WIDTH; break;
 280     case FC_WEIGHT_OBJECT:
 281         i = MATCH_WEIGHT; break;
 282     case FC_RASTERIZER_OBJECT:
 283         i = MATCH_RASTERIZER; break;
 284     case FC_OUTLINE_OBJECT:
 285         i = MATCH_OUTLINE; break;
 286     case FC_DECORATIVE_OBJECT:
 287         i = MATCH_DECORATIVE; break;
 288     }
 289
 290     if (i < 0)
 291         return NULL;
 292
 293     return _FcMatchers+i;
 294 }
 295
 296 static FcBool
 297 FcCompareValueList (FcObject     object,
 298                     FcValueListPtr v1orig,      /* pattern */
 299                     FcValueListPtr v2orig,      /* target */
 300                     FcValue     *bestValue,
 301                     double      *value,
 302                     FcResult    *result)
 303 {
 304     FcValueListPtr  v1, v2;
 305     double          v, best, bestStrong, bestWeak;
 306     int             j;
 307     FcMatcher       *match = FcObjectToMatcher(object);
 308
 309     if (!match)
 310     {
 311         if (bestValue)
 312             *bestValue = FcValueCanonicalize(&v2orig->value);
 313         return FcTrue;
 314     }
 315
 316     best = 1e99;
 317     bestStrong = 1e99;
 318     bestWeak = 1e99;
 319     j = 0;
 320     for (v1 = v1orig; v1; v1 = FcValueListNext(v1))
 321     {
 322         for (v2 = v2orig; v2; v2 = FcValueListNext(v2))
 323         {
 324             v = (match->compare) (&v1->value, &v2->value);
 325             if (v < 0)
 326             {
 327                 *result = FcResultTypeMismatch;
 328                 return FcFalse;
 329             }
 330             v = v * 100 + j;
 331             if (v < best)
 332             {
 333                 if (bestValue)
 334                     *bestValue = FcValueCanonicalize(&v2->value);
 335                 best = v;
 336             }
 337             if (v1->binding == FcValueBindingStrong)
 338             {
 339                 if (v < bestStrong)
 340                     bestStrong = v;
 341             }
 342             else
 343             {
 344                 if (v < bestWeak)
 345                     bestWeak = v;
 346             }
 347         }
 348         j++;
 349     }
 350     if (FcDebug () & FC_DBG_MATCHV)
 351     {
 352         printf (" %s: %g ", FcObjectName (object), best);
 353         FcValueListPrint (v1orig);
 354         printf (", ");
 355         FcValueListPrint (v2orig);
 356         printf ("\n");
 357     }
 358     if (value)
 359     {
 360         int weak    = match->weak;
 361         int strong  = match->strong;
 362         if (weak == strong)
 363             value[strong] += best;
 364         else
 365         {
 366             value[weak] += bestWeak;
 367             value[strong] += bestStrong;
 368         }
 369     }
 370     return FcTrue;
 371 }
 372
 373 /*
 374  * Return a value indicating the distance between the two lists of
 375  * values
 376  */
 377
 378 static FcBool
 379 FcCompare (FcPattern    *pat,
 380            FcPattern    *fnt,
 381            double       *value,
 382            FcResult     *result)
 383 {
 384     int             i, i1, i2;
 385
 386     for (i = 0; i < NUM_MATCH_VALUES; i++)
 387         value[i] = 0.0;
 388
 389     i1 = 0;
 390     i2 = 0;
 391     while (i1 < pat->num && i2 < fnt->num)
 392     {
 393         FcPatternElt *elt_i1 = &FcPatternElts(pat)[i1];
 394         FcPatternElt *elt_i2 = &FcPatternElts(fnt)[i2];
 395
 396         i = FcObjectCompare(elt_i1->object, elt_i2->object);
 397         if (i > 0)
 398             i2++;
 399         else if (i < 0)
 400             i1++;
 401         else
 402         {
 403             if (!FcCompareValueList (elt_i1->object,
 404                                      FcPatternEltValues(elt_i1),
 405                                      FcPatternEltValues(elt_i2),
 406                                      0, value, result))
 407                 return FcFalse;
 408             i1++;
 409             i2++;
 410         }
 411     }
 412     return FcTrue;
 413 }
 414
 415 FcPattern *
 416 FcFontRenderPrepare (FcConfig       *config,
 417                      FcPattern      *pat,
 418                      FcPattern      *font)
 419 {
 420     FcPattern       *new;
 421     int             i;
 422     FcPatternElt    *fe, *pe;
 423     FcValue         v;
 424     FcResult        result;
 425
 426     new = FcPatternCreate ();
 427     if (!new)
 428         return 0;
 429     for (i = 0; i < font->num; i++)
 430     {
 431         fe = &FcPatternElts(font)[i];
 432         pe = FcPatternObjectFindElt (pat, fe->object);
 433         if (pe)
 434         {
 435             if (!FcCompareValueList (pe->object, FcPatternEltValues(pe),
 436                                      FcPatternEltValues(fe), &v, 0, &result))
 437             {
 438                 FcPatternDestroy (new);
 439                 return 0;
 440             }
 441         }
 442         else
 443             v = FcValueCanonicalize(&FcPatternEltValues (fe)->value);
 444         FcPatternObjectAdd (new, fe->object, v, FcFalse);
 445     }
 446     for (i = 0; i < pat->num; i++)
 447     {
 448         pe = &FcPatternElts(pat)[i];
 449         fe = FcPatternObjectFindElt (font, pe->object);
 450         if (!fe)
 451         {
 452             v = FcValueCanonicalize(&FcPatternEltValues(pe)->value);
 453             FcPatternObjectAdd (new, pe->object, v, FcTrue);
 454         }
 455     }
 456
 457     FcConfigSubstituteWithPat (config, new, pat, FcMatchFont);
 458     return new;
 459 }
 460
 461 FcPattern *
 462 FcFontSetMatch (FcConfig    *config,
 463                 FcFontSet   **sets,
 464                 int         nsets,
 465                 FcPattern   *p,
 466                 FcResult    *result)
 467 {
 468     double          score[NUM_MATCH_VALUES], bestscore[NUM_MATCH_VALUES];
 469     int             f;
 470     FcFontSet       *s;
 471     FcPattern       *best;
 472     int             i;
 473     int             set;
 474
 475     for (i = 0; i < NUM_MATCH_VALUES; i++)
 476         bestscore[i] = 0;
 477     best = 0;
 478     if (FcDebug () & FC_DBG_MATCH)
 479     {
 480         printf ("Match ");
 481         FcPatternPrint (p);
 482     }
 483     if (!config)
 484     {
 485         config = FcConfigGetCurrent ();
 486         if (!config)
 487             return 0;
 488     }
 489     for (set = 0; set < nsets; set++)
 490     {
 491         s = sets[set];
 492         if (!s)
 493             continue;
 494         for (f = 0; f < s->nfont; f++)
 495         {
 496             if (FcDebug () & FC_DBG_MATCHV)
 497             {
 498                 printf ("Font %d ", f);
 499                 FcPatternPrint (s->fonts[f]);
 500             }
 501             if (!FcCompare (p, s->fonts[f], score, result))
 502                 return 0;
 503             if (FcDebug () & FC_DBG_MATCHV)
 504             {
 505                 printf ("Score");
 506                 for (i = 0; i < NUM_MATCH_VALUES; i++)
 507                 {
 508                     printf (" %g", score[i]);
 509                 }
 510                 printf ("\n");
 511             }
 512             for (i = 0; i < NUM_MATCH_VALUES; i++)
 513             {
 514                 if (best && bestscore[i] < score[i])
 515                     break;
 516                 if (!best || score[i] < bestscore[i])
 517                 {
 518                     for (i = 0; i < NUM_MATCH_VALUES; i++)
 519                         bestscore[i] = score[i];
 520                     best = s->fonts[f];
 521                     break;
 522                 }
 523             }
 524         }
 525     }
 526     if (FcDebug () & FC_DBG_MATCH)
 527     {
 528         printf ("Best score");
 529         for (i = 0; i < NUM_MATCH_VALUES; i++)
 530             printf (" %g", bestscore[i]);
 531         FcPatternPrint (best);
 532     }
 533     if (!best)
 534     {
 535         *result = FcResultNoMatch;
 536         return 0;
 537     }
 538     return FcFontRenderPrepare (config, p, best);
 539 }
 540
 541 FcPattern *
 542 FcFontMatch (FcConfig   *config,
 543              FcPattern  *p,
 544              FcResult   *result)
 545 {
 546     FcFontSet   *sets[2];
 547     int         nsets;
 548
 549     if (!config)
 550     {
 551         config = FcConfigGetCurrent ();
 552         if (!config)
 553             return 0;
 554     }
 555     nsets = 0;
 556     if (config->fonts[FcSetSystem])
 557         sets[nsets++] = config->fonts[FcSetSystem];
 558     if (config->fonts[FcSetApplication])
 559         sets[nsets++] = config->fonts[FcSetApplication];
 560     return FcFontSetMatch (config, sets, nsets, p, result);
 561 }
 562
 563 typedef struct _FcSortNode {
 564     FcPattern   *pattern;
 565     double      score[NUM_MATCH_VALUES];
 566 } FcSortNode;
 567
 568 static int
 569 FcSortCompare (const void *aa, const void *ab)
 570 {
 571     FcSortNode  *a = *(FcSortNode **) aa;
 572     FcSortNode  *b = *(FcSortNode **) ab;
 573     double      *as = &a->score[0];
 574     double      *bs = &b->score[0];
 575     double      ad = 0, bd = 0;
 576     int         i;
 577
 578     i = NUM_MATCH_VALUES;
 579     while (i-- && (ad = *as++) == (bd = *bs++))
 580         ;
 581     return ad < bd ? -1 : ad > bd ? 1 : 0;
 582 }
 583
 584 static FcBool
 585 FcSortWalk (FcSortNode **n, int nnode, FcFontSet *fs, FcCharSet **cs, FcBool trim, FcBool build_cs)
 586 {
 587     FcCharSet   *ncs;
 588     FcSortNode  *node;
 589
 590     while (nnode--)
 591     {
 592         node = *n++;
 593
 594         /*
 595          * Only fetch node charset if we'd need it
 596          */
 597         if (trim || build_cs)
 598         {
 599             if (FcPatternGetCharSet (node->pattern, FC_CHARSET, 0, &ncs) !=
 600                 FcResultMatch)
 601                 continue;
 602         }
 603
 604         /*
 605          * If this font isn't a subset of the previous fonts,
 606          * add it to the list
 607          */
 608         if (!trim || !*cs || !FcCharSetIsSubset (ncs, *cs))
 609         {
 610             if (trim || build_cs)
 611             {
 612                 *cs = FcCharSetMerge (*cs, ncs);
 613                 if (*cs == NULL)
 614                     return FcFalse;
 615             }
 616
 617             FcPatternReference (node->pattern);
 618             if (FcDebug () & FC_DBG_MATCHV)
 619             {
 620                 printf ("Add ");
 621                 FcPatternPrint (node->pattern);
 622             }
 623             if (!FcFontSetAdd (fs, node->pattern))
 624             {
 625                 FcPatternDestroy (node->pattern);
 626                 return FcFalse;
 627             }
 628         }
 629     }
 630     return FcTrue;
 631 }
 632
 633 void
 634 FcFontSetSortDestroy (FcFontSet *fs)
 635 {
 636     FcFontSetDestroy (fs);
 637 }
 638
 639 FcFontSet *
 640 FcFontSetSort (FcConfig     *config,
 641                FcFontSet    **sets,
 642                int          nsets,
 643                FcPattern    *p,
 644                FcBool       trim,
 645                FcCharSet    **csp,
 646                FcResult     *result)
 647 {
 648     FcFontSet       *ret;
 649     FcFontSet       *s;
 650     FcSortNode      *nodes;
 651     FcSortNode      **nodeps, **nodep;
 652     int             nnodes;
 653     FcSortNode      *new;
 654     FcCharSet       *cs;
 655     int             set;
 656     int             f;
 657     int             i;
 658     int             nPatternLang;
 659     FcBool          *patternLangSat;
 660     FcValue         patternLang;
 661
 662     if (FcDebug () & FC_DBG_MATCH)
 663     {
 664         printf ("Sort ");
 665         FcPatternPrint (p);
 666     }
 667     nnodes = 0;
 668     for (set = 0; set < nsets; set++)
 669     {
 670         s = sets[set];
 671         if (!s)
 672             continue;
 673         nnodes += s->nfont;
 674     }
 675     if (!nnodes)
 676         goto bail0;
 677
 678     for (nPatternLang = 0;
 679          FcPatternGet (p, FC_LANG, nPatternLang, &patternLang) == FcResultMatch;
 680          nPatternLang++)
 681         ;
 682
 683     /* freed below */
 684     nodes = malloc (nnodes * sizeof (FcSortNode) +
 685                     nnodes * sizeof (FcSortNode *) +
 686                     nPatternLang * sizeof (FcBool));
 687     if (!nodes)
 688         goto bail0;
 689     nodeps = (FcSortNode **) (nodes + nnodes);
 690     patternLangSat = (FcBool *) (nodeps + nnodes);
 691
 692     new = nodes;
 693     nodep = nodeps;
 694     for (set = 0; set < nsets; set++)
 695     {
 696         s = sets[set];
 697         if (!s)
 698             continue;
 699         for (f = 0; f < s->nfont; f++)
 700         {
 701             if (FcDebug () & FC_DBG_MATCHV)
 702             {
 703                 printf ("Font %d ", f);
 704                 FcPatternPrint (s->fonts[f]);
 705             }
 706             new->pattern = s->fonts[f];
 707             if (!FcCompare (p, new->pattern, new->score, result))
 708                 goto bail1;
 709             if (FcDebug () & FC_DBG_MATCHV)
 710             {
 711                 printf ("Score");
 712                 for (i = 0; i < NUM_MATCH_VALUES; i++)
 713                 {
 714                     printf (" %g", new->score[i]);
 715                 }
 716                 printf ("\n");
 717             }
 718             *nodep = new;
 719             new++;
 720             nodep++;
 721         }
 722     }
 723
 724     nnodes = new - nodes;
 725
 726     qsort (nodeps, nnodes, sizeof (FcSortNode *),
 727            FcSortCompare);
 728
 729     for (i = 0; i < nPatternLang; i++)
 730         patternLangSat[i] = FcFalse;
 731
 732     for (f = 0; f < nnodes; f++)
 733     {
 734         FcBool  satisfies = FcFalse;
 735         /*
 736          * If this node matches any language, go check
 737          * which ones and satisfy those entries
 738          */
 739         if (nodeps[f]->score[MATCH_LANG_INDEX] < 200)
 740         {
 741             for (i = 0; i < nPatternLang; i++)
 742             {
 743                 FcValue     nodeLang;
 744
 745                 if (!patternLangSat[i] &&
 746                     FcPatternGet (p, FC_LANG, i, &patternLang) == FcResultMatch &&
 747                     FcPatternGet (nodeps[f]->pattern, FC_LANG, 0, &nodeLang) == FcResultMatch)
 748                 {
 749                     double  compare = FcCompareLang (&patternLang, &nodeLang);
 750                     if (compare >= 0 && compare < 2)
 751                     {
 752                         if (FcDebug () & FC_DBG_MATCHV)
 753                         {
 754                             FcChar8 *family;
 755                             FcChar8 *style;
 756
 757                             if (FcPatternGetString (nodeps[f]->pattern, FC_FAMILY, 0, &family) == FcResultMatch &&
 758                                 FcPatternGetString (nodeps[f]->pattern, FC_STYLE, 0, &style) == FcResultMatch)
 759                                 printf ("Font %s:%s matches language %d\n", family, style, i);
 760                         }
 761                         patternLangSat[i] = FcTrue;
 762                         satisfies = FcTrue;
 763                         break;
 764                     }
 765                 }
 766             }
 767         }
 768         if (!satisfies)
 769             nodeps[f]->score[MATCH_LANG_INDEX] = 1000.0;
 770     }
 771
 772     /*
 773      * Re-sort once the language issues have been settled
 774      */
 775     qsort (nodeps, nnodes, sizeof (FcSortNode *),
 776            FcSortCompare);
 777
 778     ret = FcFontSetCreate ();
 779     if (!ret)
 780         goto bail1;
 781
 782     cs = 0;
 783
 784     if (!FcSortWalk (nodeps, nnodes, ret, &cs, trim, (csp!=0)))
 785         goto bail2;
 786
 787     if (csp)
 788         *csp = cs;
 789     else
 790     {
 791         if (cs)
 792             FcCharSetDestroy (cs);
 793     }
 794
 795     free (nodes);
 796
 797     if (FcDebug() & FC_DBG_MATCH)
 798     {
 799         printf ("First font ");
 800         FcPatternPrint (ret->fonts[0]);
 801     }
 802     return ret;
 803
 804 bail2:
 805     if (cs)
 806         FcCharSetDestroy (cs);
 807     FcFontSetDestroy (ret);
 808 bail1:
 809     free (nodes);
 810 bail0:
 811     return 0;
 812 }
 813
 814 FcFontSet *
 815 FcFontSort (FcConfig    *config,
 816             FcPattern   *p,
 817             FcBool      trim,
 818             FcCharSet   **csp,
 819             FcResult    *result)
 820 {
 821     FcFontSet   *sets[2];
 822     int         nsets;
 823
 824     if (!config)
 825     {
 826         config = FcConfigGetCurrent ();
 827         if (!config)
 828             return 0;
 829     }
 830     nsets = 0;
 831     if (config->fonts[FcSetSystem])
 832         sets[nsets++] = config->fonts[FcSetSystem];
 833     if (config->fonts[FcSetApplication])
 834         sets[nsets++] = config->fonts[FcSetApplication];
 835     return FcFontSetSort (config, sets, nsets, p, trim, csp, result);
 836 }
 837 #define __fcmatch__
 838 #include "fcaliastail.h"
 839 #undef __fcmatch__