Rework Object name database to unify typechecking and object lookup.
[platform/upstream/fontconfig.git] / src / fcmatch.c
1 /*
2  * $RCSId: xc/lib/fontconfig/src/fcmatch.c,v 1.20 2002/08/31 22:17:32 keithp Exp $
3  *
4  * Copyright © 2000 Keith Packard
5  *
6  * Permission to use, copy, modify, distribute, and sell this software and its
7  * documentation for any purpose is hereby granted without fee, provided that
8  * the above copyright notice appear in all copies and that both that
9  * copyright notice and this permission notice appear in supporting
10  * documentation, and that the name of Keith Packard not be used in
11  * advertising or publicity pertaining to distribution of the software without
12  * specific, written prior permission.  Keith Packard makes no
13  * representations about the suitability of this software for any purpose.  It
14  * is provided "as is" without express or implied warranty.
15  *
16  * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
17  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
18  * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
19  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
20  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
21  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
22  * PERFORMANCE OF THIS SOFTWARE.
23  */
24
25 #include "fcint.h"
26 #include <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_ANTIALIAS_OBJECT,      FcCompareBool,  11, 11 },
229 #define MATCH_ANTIALIAS     10
230 #define MATCH_ANTIALIAS_INDEX       11
231     
232     { FC_RASTERIZER_OBJECT,     FcCompareString,        12, 12 },
233 #define MATCH_RASTERIZER    11
234 #define MATCH_RASTERIZER_INDEX    12
235
236     { FC_OUTLINE_OBJECT,        FcCompareBool,  13, 13 },
237 #define MATCH_OUTLINE       12
238 #define MATCH_OUTLINE_INDEX         13
239
240     { FC_FONTVERSION_OBJECT,    FcCompareNumber,        14, 14 },
241 #define MATCH_FONTVERSION   13
242 #define MATCH_FONTVERSION_INDEX   14
243 };
244
245 #define NUM_MATCH_VALUES    15
246
247 static FcMatcher*
248 FcObjectToMatcher (FcObject object)
249 {
250     int         i;
251
252     i = -1;
253     switch (object) {
254     case FC_FOUNDRY_OBJECT:
255         i = MATCH_FOUNDRY; break;
256     case FC_FONTVERSION_OBJECT:
257         i = MATCH_FONTVERSION; break;
258     case FC_FAMILY_OBJECT:
259         i = MATCH_FAMILY; break;
260     case FC_CHARSET_OBJECT:
261         i = MATCH_CHARSET; break;
262     case FC_ANTIALIAS_OBJECT:
263         i = MATCH_ANTIALIAS; break;
264     case FC_LANG_OBJECT:
265         i = MATCH_LANG; break;
266     case FC_SPACING_OBJECT:
267         i = MATCH_SPACING; break;
268     case FC_STYLE_OBJECT:
269         i = MATCH_STYLE; break;
270     case FC_SLANT_OBJECT:
271         i = MATCH_SLANT; break;
272     case FC_PIXEL_SIZE_OBJECT:
273         i = MATCH_PIXEL_SIZE; break;
274     case FC_WIDTH_OBJECT:
275         i = MATCH_WIDTH; break;
276     case FC_WEIGHT_OBJECT:
277         i = MATCH_WEIGHT; break;
278     case FC_RASTERIZER_OBJECT:
279         i = MATCH_RASTERIZER; break;
280     case FC_OUTLINE_OBJECT:
281         i = MATCH_OUTLINE; break;
282     }
283
284     if (i < 0)
285         return NULL;
286
287     return _FcMatchers+i;
288 }
289
290 static FcBool
291 FcCompareValueList (FcObject     object,
292                     FcValueListPtr v1orig,      /* pattern */
293                     FcValueListPtr v2orig,      /* target */
294                     FcValue     *bestValue,
295                     double      *value,
296                     FcResult    *result)
297 {
298     FcValueListPtr  v1, v2;
299     double          v, best, bestStrong, bestWeak;
300     int             j;
301     FcMatcher       *match = FcObjectToMatcher(object);
302
303     if (!match)
304     {
305         if (bestValue)
306             *bestValue = FcValueCanonicalize(&v2orig->value);
307         return FcTrue;
308     }
309
310     best = 1e99;
311     bestStrong = 1e99;
312     bestWeak = 1e99;
313     j = 0;
314     for (v1 = v1orig; v1; v1 = FcValueListNext(v1))
315     {
316         for (v2 = v2orig; v2; v2 = FcValueListNext(v2))
317         {
318             v = (match->compare) (&v1->value, &v2->value);
319             if (v < 0)
320             {
321                 *result = FcResultTypeMismatch;
322                 return FcFalse;
323             }
324             v = v * 100 + j;
325             if (v < best)
326             {
327                 if (bestValue)
328                     *bestValue = FcValueCanonicalize(&v2->value);
329                 best = v;
330             }
331             if (v1->binding == FcValueBindingStrong)
332             {
333                 if (v < bestStrong)
334                     bestStrong = v;
335             }
336             else
337             {
338                 if (v < bestWeak)
339                     bestWeak = v;
340             }
341         }
342         j++;
343     }
344     if (FcDebug () & FC_DBG_MATCHV)
345     {
346         printf (" %s: %g ", FcObjectName (object), best);
347         FcValueListPrint (v1orig);
348         printf (", ");
349         FcValueListPrint (v2orig);
350         printf ("\n");
351     }
352     if (value)
353     {
354         int weak    = match->weak;
355         int strong  = match->strong;
356         if (weak == strong)
357             value[strong] += best;
358         else
359         {
360             value[weak] += bestWeak;
361             value[strong] += bestStrong;
362         }
363     }
364     return FcTrue;
365 }
366
367 /*
368  * Return a value indicating the distance between the two lists of
369  * values
370  */
371
372 static FcBool
373 FcCompare (FcPattern    *pat,
374            FcPattern    *fnt,
375            double       *value,
376            FcResult     *result)
377 {
378     int             i, i1, i2;
379     
380     for (i = 0; i < NUM_MATCH_VALUES; i++)
381         value[i] = 0.0;
382     
383     i1 = 0;
384     i2 = 0;
385     while (i1 < pat->num && i2 < fnt->num)
386     {
387         FcPatternElt *elt_i1 = &FcPatternElts(pat)[i1];
388         FcPatternElt *elt_i2 = &FcPatternElts(fnt)[i2];
389
390         i = FcObjectCompare(elt_i1->object, elt_i2->object);
391         if (i > 0)
392             i2++;
393         else if (i < 0)
394             i1++;
395         else
396         {
397             if (!FcCompareValueList (elt_i1->object,
398                                      FcPatternEltValues(elt_i1),
399                                      FcPatternEltValues(elt_i2),
400                                      0, value, result))
401                 return FcFalse;
402             i1++;
403             i2++;
404         }
405     }
406     return FcTrue;
407 }
408
409 FcPattern *
410 FcFontRenderPrepare (FcConfig       *config,
411                      FcPattern      *pat,
412                      FcPattern      *font)
413 {
414     FcPattern       *new;
415     int             i;
416     FcPatternElt    *fe, *pe;
417     FcValue         v;
418     FcResult        result;
419     
420     new = FcPatternCreate ();
421     if (!new)
422         return 0;
423     for (i = 0; i < font->num; i++)
424     {
425         fe = &FcPatternElts(font)[i];
426         pe = FcPatternObjectFindElt (pat, fe->object);
427         if (pe)
428         {
429             if (!FcCompareValueList (pe->object, FcPatternEltValues(pe), 
430                                      FcPatternEltValues(fe), &v, 0, &result))
431             {
432                 FcPatternDestroy (new);
433                 return 0;
434             }
435         }
436         else
437             v = FcValueCanonicalize(&FcPatternEltValues (fe)->value);
438         FcPatternObjectAdd (new, fe->object, v, FcFalse);
439     }
440     for (i = 0; i < pat->num; i++)
441     {
442         pe = &FcPatternElts(pat)[i];
443         fe = FcPatternObjectFindElt (font, pe->object);
444         if (!fe)
445         {
446             v = FcValueCanonicalize(&FcPatternEltValues(pe)->value);
447             FcPatternObjectAdd (new, pe->object, v, FcTrue);
448         }
449     }
450
451     FcConfigSubstituteWithPat (config, new, pat, FcMatchFont);
452     return new;
453 }
454
455 FcPattern *
456 FcFontSetMatch (FcConfig    *config,
457                 FcFontSet   **sets,
458                 int         nsets,
459                 FcPattern   *p,
460                 FcResult    *result)
461 {
462     double          score[NUM_MATCH_VALUES], bestscore[NUM_MATCH_VALUES];
463     int             f;
464     FcFontSet       *s;
465     FcPattern       *best;
466     int             i;
467     int             set;
468
469     for (i = 0; i < NUM_MATCH_VALUES; i++)
470         bestscore[i] = 0;
471     best = 0;
472     if (FcDebug () & FC_DBG_MATCH)
473     {
474         printf ("Match ");
475         FcPatternPrint (p);
476     }
477     if (!config)
478     {
479         config = FcConfigGetCurrent ();
480         if (!config)
481             return 0;
482     }
483     for (set = 0; set < nsets; set++)
484     {
485         s = sets[set];
486         if (!s)
487             continue;
488         for (f = 0; f < s->nfont; f++)
489         {
490             if (FcDebug () & FC_DBG_MATCHV)
491             {
492                 printf ("Font %d ", f);
493                 FcPatternPrint (s->fonts[f]);
494             }
495             if (!FcCompare (p, s->fonts[f], score, result))
496                 return 0;
497             if (FcDebug () & FC_DBG_MATCHV)
498             {
499                 printf ("Score");
500                 for (i = 0; i < NUM_MATCH_VALUES; i++)
501                 {
502                     printf (" %g", score[i]);
503                 }
504                 printf ("\n");
505             }
506             for (i = 0; i < NUM_MATCH_VALUES; i++)
507             {
508                 if (best && bestscore[i] < score[i])
509                     break;
510                 if (!best || score[i] < bestscore[i])
511                 {
512                     for (i = 0; i < NUM_MATCH_VALUES; i++)
513                         bestscore[i] = score[i];
514                     best = s->fonts[f];
515                     break;
516                 }
517             }
518         }
519     }
520     if (FcDebug () & FC_DBG_MATCH)
521     {
522         printf ("Best score");
523         for (i = 0; i < NUM_MATCH_VALUES; i++)
524             printf (" %g", bestscore[i]);
525         FcPatternPrint (best);
526     }
527     if (!best)
528     {
529         *result = FcResultNoMatch;
530         return 0;
531     }
532     return FcFontRenderPrepare (config, p, best);
533 }
534
535 FcPattern *
536 FcFontMatch (FcConfig   *config,
537              FcPattern  *p, 
538              FcResult   *result)
539 {
540     FcFontSet   *sets[2];
541     int         nsets;
542
543     if (!config)
544     {
545         config = FcConfigGetCurrent ();
546         if (!config)
547             return 0;
548     }
549     nsets = 0;
550     if (config->fonts[FcSetSystem])
551         sets[nsets++] = config->fonts[FcSetSystem];
552     if (config->fonts[FcSetApplication])
553         sets[nsets++] = config->fonts[FcSetApplication];
554     return FcFontSetMatch (config, sets, nsets, p, result);
555 }
556
557 typedef struct _FcSortNode {
558     FcPattern   *pattern;
559     double      score[NUM_MATCH_VALUES];
560 } FcSortNode;
561
562 static int
563 FcSortCompare (const void *aa, const void *ab)
564 {
565     FcSortNode  *a = *(FcSortNode **) aa;
566     FcSortNode  *b = *(FcSortNode **) ab;
567     double      *as = &a->score[0];
568     double      *bs = &b->score[0];
569     double      ad = 0, bd = 0;
570     int         i;
571
572     i = NUM_MATCH_VALUES;
573     while (i-- && (ad = *as++) == (bd = *bs++))
574         ;
575     return ad < bd ? -1 : ad > bd ? 1 : 0;
576 }
577
578 static FcBool
579 FcSortWalk (FcSortNode **n, int nnode, FcFontSet *fs, FcCharSet **cs, FcBool trim, FcBool build_cs)
580 {
581     FcCharSet   *ncs;
582     FcSortNode  *node;
583
584     while (nnode--)
585     {
586         node = *n++;
587         if (FcPatternGetCharSet (node->pattern, FC_CHARSET, 0, &ncs) == 
588             FcResultMatch)
589         {
590             /*
591              * If this font isn't a subset of the previous fonts,
592              * add it to the list
593              */
594             if (!trim || !*cs || !FcCharSetIsSubset (ncs, *cs))
595             {
596                 if (trim || build_cs)
597                 {
598                     if (*cs)
599                     {
600                         ncs = FcCharSetUnion (ncs, *cs);
601                         if (!ncs)
602                             return FcFalse;
603                         FcCharSetDestroy (*cs);
604                     }
605                     else
606                         ncs = FcCharSetCopy (ncs);
607                     *cs = ncs;
608                 }
609
610                 FcPatternReference (node->pattern);
611                 if (FcDebug () & FC_DBG_MATCHV)
612                 {
613                     printf ("Add ");
614                     FcPatternPrint (node->pattern);
615                 }
616                 if (!FcFontSetAdd (fs, node->pattern))
617                 {
618                     FcPatternDestroy (node->pattern);
619                     return FcFalse;
620                 }
621             }
622         }
623     }
624     return FcTrue;
625 }
626
627 void
628 FcFontSetSortDestroy (FcFontSet *fs)
629 {
630     FcFontSetDestroy (fs);
631 }
632
633 FcFontSet *
634 FcFontSetSort (FcConfig     *config,
635                FcFontSet    **sets,
636                int          nsets,
637                FcPattern    *p,
638                FcBool       trim,
639                FcCharSet    **csp,
640                FcResult     *result)
641 {
642     FcFontSet       *ret;
643     FcFontSet       *s;
644     FcSortNode      *nodes;
645     FcSortNode      **nodeps, **nodep;
646     int             nnodes;
647     FcSortNode      *new;
648     FcCharSet       *cs;
649     int             set;
650     int             f;
651     int             i;
652     int             nPatternLang;
653     FcBool          *patternLangSat;
654     FcValue         patternLang;
655
656     if (FcDebug () & FC_DBG_MATCH)
657     {
658         printf ("Sort ");
659         FcPatternPrint (p);
660     }
661     nnodes = 0;
662     for (set = 0; set < nsets; set++)
663     {
664         s = sets[set];
665         if (!s)
666             continue;
667         nnodes += s->nfont;
668     }
669     if (!nnodes)
670         goto bail0;
671     
672     for (nPatternLang = 0;
673          FcPatternGet (p, FC_LANG, nPatternLang, &patternLang) == FcResultMatch;
674          nPatternLang++)
675         ;
676         
677     /* freed below */
678     nodes = malloc (nnodes * sizeof (FcSortNode) + 
679                     nnodes * sizeof (FcSortNode *) +
680                     nPatternLang * sizeof (FcBool));
681     if (!nodes)
682         goto bail0;
683     nodeps = (FcSortNode **) (nodes + nnodes);
684     patternLangSat = (FcBool *) (nodeps + nnodes);
685     
686     new = nodes;
687     nodep = nodeps;
688     for (set = 0; set < nsets; set++)
689     {
690         s = sets[set];
691         if (!s)
692             continue;
693         for (f = 0; f < s->nfont; f++)
694         {
695             if (FcDebug () & FC_DBG_MATCHV)
696             {
697                 printf ("Font %d ", f);
698                 FcPatternPrint (s->fonts[f]);
699             }
700             new->pattern = s->fonts[f];
701             if (!FcCompare (p, new->pattern, new->score, result))
702                 goto bail1;
703             if (FcDebug () & FC_DBG_MATCHV)
704             {
705                 printf ("Score");
706                 for (i = 0; i < NUM_MATCH_VALUES; i++)
707                 {
708                     printf (" %g", new->score[i]);
709                 }
710                 printf ("\n");
711             }
712             *nodep = new;
713             new++;
714             nodep++;
715         }
716     }
717
718     nnodes = new - nodes;
719     
720     qsort (nodeps, nnodes, sizeof (FcSortNode *),
721            FcSortCompare);
722     
723     for (i = 0; i < nPatternLang; i++)
724         patternLangSat[i] = FcFalse;
725     
726     for (f = 0; f < nnodes; f++)
727     {
728         FcBool  satisfies = FcFalse;
729         /*
730          * If this node matches any language, go check
731          * which ones and satisfy those entries
732          */
733         if (nodeps[f]->score[MATCH_LANG_INDEX] < nPatternLang)
734         {
735             for (i = 0; i < nPatternLang; i++)
736             {
737                 FcValue     nodeLang;
738                 
739                 if (!patternLangSat[i] &&
740                     FcPatternGet (p, FC_LANG, i, &patternLang) == FcResultMatch &&
741                     FcPatternGet (nodeps[f]->pattern, FC_LANG, 0, &nodeLang) == FcResultMatch)
742                 {
743                     double  compare = FcCompareLang (&patternLang, &nodeLang);
744                     if (compare >= 0 && compare < 2)
745                     {
746                         if (FcDebug () & FC_DBG_MATCHV)
747                         {
748                             FcChar8 *family;
749                             FcChar8 *style;
750
751                             if (FcPatternGetString (nodeps[f]->pattern, FC_FAMILY, 0, &family) == FcResultMatch &&
752                                 FcPatternGetString (nodeps[f]->pattern, FC_STYLE, 0, &style) == FcResultMatch)
753                                 printf ("Font %s:%s matches language %d\n", family, style, i);
754                         }
755                         patternLangSat[i] = FcTrue;
756                         satisfies = FcTrue;
757                         break;
758                     }
759                 }
760             }
761         }
762         if (!satisfies)
763             nodeps[f]->score[MATCH_LANG_INDEX] = 1000.0;
764     }
765
766     /*
767      * Re-sort once the language issues have been settled
768      */
769     qsort (nodeps, nnodes, sizeof (FcSortNode *),
770            FcSortCompare);
771
772     ret = FcFontSetCreate ();
773     if (!ret)
774         goto bail1;
775
776     cs = 0;
777
778     if (!FcSortWalk (nodeps, nnodes, ret, &cs, trim, (csp!=0)))
779         goto bail2;
780
781     if (csp)
782         *csp = cs;
783     else
784     {
785         if (cs)
786             FcCharSetDestroy (cs);
787     }
788
789     free (nodes);
790
791     if (FcDebug() & FC_DBG_MATCH)
792     {
793         printf ("First font ");
794         FcPatternPrint (ret->fonts[0]);
795     }
796     return ret;
797
798 bail2:
799     if (cs)
800         FcCharSetDestroy (cs);
801     FcFontSetDestroy (ret);
802 bail1:
803     free (nodes);
804 bail0:
805     return 0;
806 }
807
808 FcFontSet *
809 FcFontSort (FcConfig    *config,
810             FcPattern   *p, 
811             FcBool      trim,
812             FcCharSet   **csp,
813             FcResult    *result)
814 {
815     FcFontSet   *sets[2];
816     int         nsets;
817
818     if (!config)
819     {
820         config = FcConfigGetCurrent ();
821         if (!config)
822             return 0;
823     }
824     nsets = 0;
825     if (config->fonts[FcSetSystem])
826         sets[nsets++] = config->fonts[FcSetSystem];
827     if (config->fonts[FcSetApplication])
828         sets[nsets++] = config->fonts[FcSetApplication];
829     return FcFontSetSort (config, sets, nsets, p, trim, csp, result);
830 }