Bug Summary

File:src/fccfg.c
Location:line 1901, column 6
Description:Null pointer passed as an argument to a 'nonnull' parameter

Annotated Source Code

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 (PIC1) || defined (DLL_EXPORT))
30#define STRICT
31#include <windows.h>
32#undef STRICT
33#endif
34
35#if defined (_WIN32) && !defined (R_OK4)
36#define R_OK4 4
37#endif
38
39FcConfig *_fcConfig;
40
41FcConfig *
42FcConfigCreate (void)
43{
44 FcSetName set;
45 FcConfig *config;
46
47 config = malloc (sizeof (FcConfig));
48 if (!config)
49 goto bail0;
50 FcMemAlloc (FC_MEM_CONFIG15, sizeof (FcConfig));
51
52 config->configDirs = FcStrSetCreateIA__FcStrSetCreate ();
53 if (!config->configDirs)
54 goto bail1;
55
56 config->configFiles = FcStrSetCreateIA__FcStrSetCreate ();
57 if (!config->configFiles)
58 goto bail2;
59
60 config->fontDirs = FcStrSetCreateIA__FcStrSetCreate ();
61 if (!config->fontDirs)
62 goto bail3;
63
64 config->acceptGlobs = FcStrSetCreateIA__FcStrSetCreate ();
65 if (!config->acceptGlobs)
66 goto bail4;
67
68 config->rejectGlobs = FcStrSetCreateIA__FcStrSetCreate ();
69 if (!config->rejectGlobs)
70 goto bail5;
71
72 config->acceptPatterns = FcFontSetCreateIA__FcFontSetCreate ();
73 if (!config->acceptPatterns)
74 goto bail6;
75
76 config->rejectPatterns = FcFontSetCreateIA__FcFontSetCreate ();
77 if (!config->rejectPatterns)
78 goto bail7;
79
80 config->cacheDirs = FcStrSetCreateIA__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((void*)0);
97
98 config->ref = 1;
99
100 return config;
101
102bail8:
103 FcFontSetDestroyIA__FcFontSetDestroy (config->rejectPatterns);
104bail7:
105 FcFontSetDestroyIA__FcFontSetDestroy (config->acceptPatterns);
106bail6:
107 FcStrSetDestroyIA__FcStrSetDestroy (config->rejectGlobs);
108bail5:
109 FcStrSetDestroyIA__FcStrSetDestroy (config->acceptGlobs);
110bail4:
111 FcStrSetDestroyIA__FcStrSetDestroy (config->fontDirs);
112bail3:
113 FcStrSetDestroyIA__FcStrSetDestroy (config->configFiles);
114bail2:
115 FcStrSetDestroyIA__FcStrSetDestroy (config->configDirs);
116bail1:
117 free (config);
118 FcMemFree (FC_MEM_CONFIG15, sizeof (FcConfig));
119bail0:
120 return 0;
121}
122
123static FcFileTime
124FcConfigNewestFile (FcStrSet *files)
125{
126 FcStrList *list = FcStrListCreateIA__FcStrListCreate (files);
127 FcFileTime newest = { 0, FcFalse0 };
128 FcChar8 *file;
129 struct stat statb;
130
131 if (list)
132 {
133 while ((file = FcStrListNextIA__FcStrListNext (list)))
134 if (FcStat (file, &statb) == 0)
135 if (!newest.set || statb.st_mtimest_mtim.tv_sec - newest.time > 0)
136 {
137 newest.set = FcTrue1;
138 newest.time = statb.st_mtimest_mtim.tv_sec;
139 }
140 FcStrListDoneIA__FcStrListDone (list);
141 }
142 return newest;
143}
144
145FcBool
146FcConfigUptoDate (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 FcFalse0;
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 (stderrstderr,
169 "Fontconfig warning: Directory/file mtime in the future. New fonts may not be detected\n");
170 config->rescanTime = now;
171 return FcTrue1;
172 }
173 else
174 return FcFalse0;
175 }
176 config->rescanTime = now;
177 return FcTrue1;
178}
179
180static void
181FcSubstDestroy (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_SUBST21, sizeof (FcSubst));
194 s = n;
195 }
196}
197
198FcExpr *
199FcConfigAllocExpr (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_EXPR25, 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
218FcConfig *
219FcConfigReference (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
233void
234FcConfigDestroy (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 FcStrSetDestroyIA__FcStrSetDestroy (config->configDirs);
246 FcStrSetDestroyIA__FcStrSetDestroy (config->fontDirs);
247 FcStrSetDestroyIA__FcStrSetDestroy (config->cacheDirs);
248 FcStrSetDestroyIA__FcStrSetDestroy (config->configFiles);
249 FcStrSetDestroyIA__FcStrSetDestroy (config->acceptGlobs);
250 FcStrSetDestroyIA__FcStrSetDestroy (config->rejectGlobs);
251 FcFontSetDestroyIA__FcFontSetDestroy (config->acceptPatterns);
252 FcFontSetDestroyIA__FcFontSetDestroy (config->rejectPatterns);
253
254 if (config->blanks)
255 FcBlanksDestroyIA__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 FcFontSetDestroyIA__FcFontSetDestroy (config->fonts[set]);
263
264 page = config->expr_pool;
265 while (page)
266 {
267 FcExprPage *next = page->next_page;
268 FcMemFree (FC_MEM_EXPR25, sizeof (FcExprPage));
269 free (page);
270 page = next;
271 }
272
273 free (config);
274 FcMemFree (FC_MEM_CONFIG15, sizeof (FcConfig));
275}
276
277/*
278 * Add cache to configuration, adding fonts and directories
279 */
280
281FcBool
282FcConfigAddCache (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)((FcFontSet *) ((intptr_t) (cache) + ((cache)->set)));
293 if (fs)
294 {
295 int nref = 0;
296
297 for (i = 0; i < fs->nfont; i++)
298 {
299 FcPattern *font = FcFontSetFont (fs, i)(((((intptr_t) ((fs)->fonts)) & 1) != 0) ? ((FcPattern
*) ((intptr_t) (fs) + ((((intptr_t) ((((((intptr_t) ((fs)->
fonts)) & 1) != 0) ? ((FcPattern * *) ((intptr_t) (fs) + (
(((intptr_t) ((fs)->fonts)) & ~1)))) : (fs)->fonts)
[i])) & ~1)))) : fs->fonts[i]);
300 FcChar8 *font_file;
301
302 /*
303 * Check to see if font is banned by filename
304 */
305 if (FcPatternObjectGetString (font, FC_FILE_OBJECT21,
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 FcFontSetAddIA__FcFontSetAdd (config->fonts[set], font);
320 }
321 FcDirCacheReference (cache, nref);
322 }
323
324 /*
325 * Add directories
326 */
327 dirs = FcCacheDirs (cache)((intptr_t *) ((intptr_t) (cache) + ((cache)->dirs)));
328 if (dirs)
329 {
330 for (i = 0; i < cache->dirs_count; i++)
331 {
332 FcChar8 *dir = FcOffsetToPtr (dirs, dirs[i], FcChar8)((FcChar8 *) ((intptr_t) (dirs) + (dirs[i])));
333 if (FcConfigAcceptFilename (config, dir))
334 FcStrSetAddFilenameIA__FcStrSetAddFilename (dirSet, dir);
335 }
336 }
337 return FcTrue1;
338}
339
340static FcBool
341FcConfigAddDirList (FcConfig *config, FcSetName set, FcStrSet *dirSet)
342{
343 FcStrList *dirlist;
344 FcChar8 *dir;
345 FcCache *cache;
346
347 dirlist = FcStrListCreateIA__FcStrListCreate (dirSet);
348 if (!dirlist)
349 return FcFalse0;
350
351 while ((dir = FcStrListNextIA__FcStrListNext (dirlist)))
352 {
353 if (FcDebug ()(FcDebugVal) & FC_DBG_FONTSET8)
354 printf ("adding fonts from%s\n", dir);
355 cache = FcDirCacheReadIA__FcDirCacheRead (dir, FcFalse0, config);
356 if (!cache)
357 continue;
358 FcConfigAddCache (config, cache, set, dirSet);
359 FcDirCacheUnloadIA__FcDirCacheUnload (cache);
360 }
361 FcStrListDoneIA__FcStrListDone (dirlist);
362 return FcTrue1;
363}
364
365/*
366 * Scan the current list of directories in the configuration
367 * and build the set of available fonts.
368 */
369
370FcBool
371FcConfigBuildFonts (FcConfig *config)
372{
373 FcFontSet *fonts;
374
375 if (!config)
376 {
377 config = FcConfigGetCurrent ();
378 if (!config)
379 return FcFalse0;
380 }
381
382 fonts = FcFontSetCreateIA__FcFontSetCreate ();
383 if (!fonts)
384 return FcFalse0;
385
386 FcConfigSetFonts (config, fonts, FcSetSystem);
387
388 if (!FcConfigAddDirList (config, FcSetSystem, config->fontDirs))
389 return FcFalse0;
390 if (FcDebug ()(FcDebugVal) & FC_DBG_FONTSET8)
391 FcFontSetPrintIA__FcFontSetPrint (fonts);
392 return FcTrue1;
393}
394
395FcBool
396FcConfigSetCurrent (FcConfig *config)
397{
398 if (config == _fcConfig)
399 return FcTrue1;
400
401 if (!config->fonts)
402 if (!FcConfigBuildFonts (config))
403 return FcFalse0;
404
405 if (_fcConfig)
406 FcConfigDestroy (_fcConfig);
407 _fcConfig = config;
408 return FcTrue1;
409}
410
411FcConfig *
412FcConfigGetCurrent (void)
413{
414 if (!_fcConfig)
415 if (!FcInitIA__FcInit ())
416 return 0;
417 return _fcConfig;
418}
419
420FcBool
421FcConfigAddConfigDir (FcConfig *config,
422 const FcChar8 *d)
423{
424 return FcStrSetAddFilenameIA__FcStrSetAddFilename (config->configDirs, d);
425}
426
427FcStrList *
428FcConfigGetConfigDirs (FcConfig *config)
429{
430 if (!config)
431 {
432 config = FcConfigGetCurrent ();
433 if (!config)
434 return 0;
435 }
436 return FcStrListCreateIA__FcStrListCreate (config->configDirs);
437}
438
439FcBool
440FcConfigAddFontDir (FcConfig *config,
441 const FcChar8 *d)
442{
443 return FcStrSetAddFilenameIA__FcStrSetAddFilename (config->fontDirs, d);
444}
445
446FcBool
447FcConfigAddDir (FcConfig *config,
448 const FcChar8 *d)
449{
450 return (FcConfigAddConfigDir (config, d) &&
451 FcConfigAddFontDir (config, d));
452}
453
454FcStrList *
455FcConfigGetFontDirs (FcConfig *config)
456{
457 if (!config)
458 {
459 config = FcConfigGetCurrent ();
460 if (!config)
461 return 0;
462 }
463 return FcStrListCreateIA__FcStrListCreate (config->fontDirs);
464}
465
466FcBool
467FcConfigAddCacheDir (FcConfig *config,
468 const FcChar8 *d)
469{
470 return FcStrSetAddFilenameIA__FcStrSetAddFilename (config->cacheDirs, d);
471}
472
473FcStrList *
474FcConfigGetCacheDirs (const FcConfig *config)
475{
476 if (!config)
477 {
478 config = FcConfigGetCurrent ();
479 if (!config)
480 return 0;
481 }
482 return FcStrListCreateIA__FcStrListCreate (config->cacheDirs);
483}
484
485FcBool
486FcConfigAddConfigFile (FcConfig *config,
487 const FcChar8 *f)
488{
489 FcBool ret;
490 FcChar8 *file = FcConfigFilename (f);
491
492 if (!file)
493 return FcFalse0;
494
495 ret = FcStrSetAddIA__FcStrSetAdd (config->configFiles, file);
496 FcStrFreeIA__FcStrFree (file);
497 return ret;
498}
499
500FcStrList *
501FcConfigGetConfigFiles (FcConfig *config)
502{
503 if (!config)
504 {
505 config = FcConfigGetCurrent ();
506 if (!config)
507 return 0;
508 }
509 return FcStrListCreateIA__FcStrListCreate (config->configFiles);
510}
511
512FcChar8 *
513FcConfigGetCache (FcConfig *config)
514{
515 return NULL((void*)0);
516}
517
518FcFontSet *
519FcConfigGetFonts (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
531void
532FcConfigSetFonts (FcConfig *config,
533 FcFontSet *fonts,
534 FcSetName set)
535{
536 if (config->fonts[set])
537 FcFontSetDestroyIA__FcFontSetDestroy (config->fonts[set]);
538 config->fonts[set] = fonts;
539}
540
541FcBlanks *
542FcConfigGetBlanks (FcConfig *config)
543{
544 if (!config)
545 {
546 config = FcConfigGetCurrent ();
547 if (!config)
548 return 0;
549 }
550 return config->blanks;
551}
552
553FcBool
554FcConfigAddBlank (FcConfig *config,
555 FcChar32 blank)
556{
557 FcBlanks *b, *freeme = 0;
558
559 b = config->blanks;
560 if (!b)
561 {
562 freeme = b = FcBlanksCreateIA__FcBlanksCreate ();
563 if (!b)
564 return FcFalse0;
565 }
566 if (!FcBlanksAddIA__FcBlanksAdd (b, blank))
567 {
568 if (freeme)
569 FcBlanksDestroyIA__FcBlanksDestroy (freeme);
570 return FcFalse0;
571 }
572 config->blanks = b;
573 return FcTrue1;
574}
575
576int
577FcConfigGetRescanInterval (FcConfig *config)
578{
579 if (!config)
580 {
581 config = FcConfigGetCurrent ();
582 if (!config)
583 return 0;
584 }
585 return config->rescanInterval;
586}
587
588FcBool
589FcConfigSetRescanInterval (FcConfig *config, int rescanInterval)
590{
591 if (!config)
592 {
593 config = FcConfigGetCurrent ();
594 if (!config)
595 return FcFalse0;
596 }
597 config->rescanInterval = rescanInterval;
598 return FcTrue1;
599}
600
601/*
602 * A couple of typos escaped into the library
603 */
604int
605FcConfigGetRescanInverval (FcConfig *config)
606{
607 return FcConfigGetRescanInterval (config);
608}
609
610FcBool
611FcConfigSetRescanInverval (FcConfig *config, int rescanInterval)
612{
613 return FcConfigSetRescanInterval (config, rescanInterval);
614}
615
616
617FcBool
618FcConfigAddEdit (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 FcFalse0;
639 }
640 subst = (FcSubst *) malloc (sizeof (FcSubst));
641 if (!subst)
642 return FcFalse0;
643 FcMemAlloc (FC_MEM_SUBST21, 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((FcMatchKind) -1))
653 t->kind = kind;
654 num++;
655 }
656 if (config->maxObjects < num)
657 config->maxObjects = num;
658 if (FcDebug ()(FcDebugVal) & FC_DBG_EDIT4)
659 {
660 printf ("Add Subst ");
661 FcSubstPrint (subst);
662 }
663 return FcTrue1;
664}
665
666typedef struct _FcSubState {
667 FcPatternElt *elt;
668 FcValueList *value;
669} FcSubState;
670
671static FcValue
672FcConfigPromote (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
692FcBool
693FcConfigCompareValue (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 = FcFalse0;
700 FcOp op = FC_OP_GET_OP (op_)((op_) & 0xffff);
701 int flags = FC_OP_GET_FLAGS (op_)(((op_) & 0xffff0000) >> 16);
702
703 left = FcConfigPromote (left, right);
704 right = FcConfigPromote (right, left);
705 if (left.type == right.type)
706 {
707 switch (left.type) {
708 case FcTypeInteger:
709 break; /* FcConfigPromote prevents this from happening */
710 case FcTypeDouble:
711 switch (op) {
712 case FcOpEqual:
713 case FcOpContains:
714 case FcOpListing:
715 ret = left.u.d == right.u.d;
716 break;
717 case FcOpNotEqual:
718 case FcOpNotContains:
719 ret = left.u.d != right.u.d;
720 break;
721 case FcOpLess:
722 ret = left.u.d < right.u.d;
723 break;
724 case FcOpLessEqual:
725 ret = left.u.d <= right.u.d;
726 break;
727 case FcOpMore:
728 ret = left.u.d > right.u.d;
729 break;
730 case FcOpMoreEqual:
731 ret = left.u.d >= right.u.d;
732 break;
733 default:
734 break;
735 }
736 break;
737 case FcTypeBool:
738 switch (op) {
739 case FcOpEqual:
740 case FcOpContains:
741 case FcOpListing:
742 ret = left.u.b == right.u.b;
743 break;
744 case FcOpNotEqual:
745 case FcOpNotContains:
746 ret = left.u.b != right.u.b;
747 break;
748 default:
749 break;
750 }
751 break;
752 case FcTypeString:
753 switch (op) {
754 case FcOpEqual:
755 case FcOpListing:
756 if (flags & FcOpFlagIgnoreBlanks)
757 ret = FcStrCmpIgnoreBlanksAndCase (left.u.s, right.u.s) == 0;
758 else
759 ret = FcStrCmpIgnoreCaseIA__FcStrCmpIgnoreCase (left.u.s, right.u.s) == 0;
760 break;
761 case FcOpContains:
762 ret = FcStrStrIgnoreCaseIA__FcStrStrIgnoreCase (left.u.s, right.u.s) != 0;
763 break;
764 case FcOpNotEqual:
765 if (flags & FcOpFlagIgnoreBlanks)
766 ret = FcStrCmpIgnoreBlanksAndCase (left.u.s, right.u.s) != 0;
767 else
768 ret = FcStrCmpIgnoreCaseIA__FcStrCmpIgnoreCase (left.u.s, right.u.s) != 0;
769 break;
770 case FcOpNotContains:
771 ret = FcStrStrIgnoreCaseIA__FcStrStrIgnoreCase (left.u.s, right.u.s) == 0;
772 break;
773 default:
774 break;
775 }
776 break;
777 case FcTypeMatrix:
778 switch (op) {
779 case FcOpEqual:
780 case FcOpContains:
781 case FcOpListing:
782 ret = FcMatrixEqualIA__FcMatrixEqual (left.u.m, right.u.m);
783 break;
784 case FcOpNotEqual:
785 case FcOpNotContains:
786 ret = !FcMatrixEqualIA__FcMatrixEqual (left.u.m, right.u.m);
787 break;
788 default:
789 break;
790 }
791 break;
792 case FcTypeCharSet:
793 switch (op) {
794 case FcOpContains:
795 case FcOpListing:
796 /* left contains right if right is a subset of left */
797 ret = FcCharSetIsSubsetIA__FcCharSetIsSubset (right.u.c, left.u.c);
798 break;
799 case FcOpNotContains:
800 /* left contains right if right is a subset of left */
801 ret = !FcCharSetIsSubsetIA__FcCharSetIsSubset (right.u.c, left.u.c);
802 break;
803 case FcOpEqual:
804 ret = FcCharSetEqualIA__FcCharSetEqual (left.u.c, right.u.c);
805 break;
806 case FcOpNotEqual:
807 ret = !FcCharSetEqualIA__FcCharSetEqual (left.u.c, right.u.c);
808 break;
809 default:
810 break;
811 }
812 break;
813 case FcTypeLangSet:
814 switch (op) {
815 case FcOpContains:
816 case FcOpListing:
817 ret = FcLangSetContainsIA__FcLangSetContains (left.u.l, right.u.l);
818 break;
819 case FcOpNotContains:
820 ret = !FcLangSetContainsIA__FcLangSetContains (left.u.l, right.u.l);
821 break;
822 case FcOpEqual:
823 ret = FcLangSetEqualIA__FcLangSetEqual (left.u.l, right.u.l);
824 break;
825 case FcOpNotEqual:
826 ret = !FcLangSetEqualIA__FcLangSetEqual (left.u.l, right.u.l);
827 break;
828 default:
829 break;
830 }
831 break;
832 case FcTypeVoid:
833 switch (op) {
834 case FcOpEqual:
835 case FcOpContains:
836 case FcOpListing:
837 ret = FcTrue1;
838 break;
839 default:
840 break;
841 }
842 break;
843 case FcTypeFTFace:
844 switch (op) {
845 case FcOpEqual:
846 case FcOpContains:
847 case FcOpListing:
848 ret = left.u.f == right.u.f;
849 break;
850 case FcOpNotEqual:
851 case FcOpNotContains:
852 ret = left.u.f != right.u.f;
853 break;
854 default:
855 break;
856 }
857 break;
858 }
859 }
860 else
861 {
862 if (op == FcOpNotEqual || op == FcOpNotContains)
863 ret = FcTrue1;
864 }
865 return ret;
866}
867
868
869#define _FcDoubleFloor(d)((int) (d)) ((int) (d))
870#define _FcDoubleCeil(d)((double) (int) (d) == (d) ? (int) (d) : (int) ((d) + 1)) ((double) (int) (d) == (d) ? (int) (d) : (int) ((d) + 1))
871#define FcDoubleFloor(d)((d) >= 0 ? ((int) (d)) : -((double) (int) (-(d)) == (-(d)
) ? (int) (-(d)) : (int) ((-(d)) + 1))) ((d) >= 0 ? _FcDoubleFloor(d)((int) (d)) : -_FcDoubleCeil(-(d))((double) (int) (-(d)) == (-(d)) ? (int) (-(d)) : (int) ((-(d
)) + 1)))
872#define FcDoubleCeil(d)((d) >= 0 ? ((double) (int) (d) == (d) ? (int) (d) : (int)
((d) + 1)) : -((int) (-(d)))) ((d) >= 0 ? _FcDoubleCeil(d)((double) (int) (d) == (d) ? (int) (d) : (int) ((d) + 1)) : -_FcDoubleFloor(-(d))((int) (-(d))))
873#define FcDoubleRound(d)(((d) + 0.5) >= 0 ? ((int) ((d) + 0.5)) : -((double) (int)
(-((d) + 0.5)) == (-((d) + 0.5)) ? (int) (-((d) + 0.5)) : (int
) ((-((d) + 0.5)) + 1))) FcDoubleFloor ((d) + 0.5)(((d) + 0.5) >= 0 ? ((int) ((d) + 0.5)) : -((double) (int)
(-((d) + 0.5)) == (-((d) + 0.5)) ? (int) (-((d) + 0.5)) : (int
) ((-((d) + 0.5)) + 1)))
874#define FcDoubleTrunc(d)((d) >= 0 ? ((int) (d)) : -((int) (-(d)))) ((d) >= 0 ? _FcDoubleFloor (d)((int) (d)) : -_FcDoubleFloor (-(d))((int) (-(d))))
875
876static FcValue
877FcConfigEvaluate (FcPattern *p, FcExpr *e)
878{
879 FcValue v, vl, vr;
880 FcResult r;
881 FcMatrix *m;
882 FcChar8 *str;
883 FcOp op = FC_OP_GET_OP (e->op)((e->op) & 0xffff);
884
885 switch (op) {
886 case FcOpInteger:
887 v.type = FcTypeInteger;
888 v.u.i = e->u.ival;
889 break;
890 case FcOpDouble:
891 v.type = FcTypeDouble;
892 v.u.d = e->u.dval;
893 break;
894 case FcOpString:
895 v.type = FcTypeString;
896 v.u.s = e->u.sval;
897 v = FcValueSaveIA__FcValueSave (v);
898 break;
899 case FcOpMatrix:
900 v.type = FcTypeMatrix;
901 v.u.m = e->u.mval;
902 v = FcValueSaveIA__FcValueSave (v);
903 break;
904 case FcOpCharSet:
905 v.type = FcTypeCharSet;
906 v.u.c = e->u.cval;
907 v = FcValueSaveIA__FcValueSave (v);
908 break;
909 case FcOpLangSet:
910 v.type = FcTypeLangSet;
911 v.u.l = e->u.lval;
912 v = FcValueSaveIA__FcValueSave (v);
913 break;
914 case FcOpBool:
915 v.type = FcTypeBool;
916 v.u.b = e->u.bval;
917 break;
918 case FcOpField:
919 r = FcPatternObjectGet (p, e->u.object, 0, &v);
920 if (r != FcResultMatch)
921 v.type = FcTypeVoid;
922 v = FcValueSaveIA__FcValueSave (v);
923 break;
924 case FcOpConst:
925 if (FcNameConstantIA__FcNameConstant (e->u.constant, &v.u.i))
926 v.type = FcTypeInteger;
927 else
928 v.type = FcTypeVoid;
929 break;
930 case FcOpQuest:
931 vl = FcConfigEvaluate (p, e->u.tree.left);
932 if (vl.type == FcTypeBool)
933 {
934 if (vl.u.b)
935 v = FcConfigEvaluate (p, e->u.tree.right->u.tree.left);
936 else
937 v = FcConfigEvaluate (p, e->u.tree.right->u.tree.right);
938 }
939 else
940 v.type = FcTypeVoid;
941 FcValueDestroyIA__FcValueDestroy (vl);
942 break;
943 case FcOpEqual:
944 case FcOpNotEqual:
945 case FcOpLess:
946 case FcOpLessEqual:
947 case FcOpMore:
948 case FcOpMoreEqual:
949 case FcOpContains:
950 case FcOpNotContains:
951 case FcOpListing:
952 vl = FcConfigEvaluate (p, e->u.tree.left);
953 vr = FcConfigEvaluate (p, e->u.tree.right);
954 v.type = FcTypeBool;
955 v.u.b = FcConfigCompareValue (&vl, e->op, &vr);
956 FcValueDestroyIA__FcValueDestroy (vl);
957 FcValueDestroyIA__FcValueDestroy (vr);
958 break;
959 case FcOpOr:
960 case FcOpAnd:
961 case FcOpPlus:
962 case FcOpMinus:
963 case FcOpTimes:
964 case FcOpDivide:
965 vl = FcConfigEvaluate (p, e->u.tree.left);
966 vr = FcConfigEvaluate (p, e->u.tree.right);
967 vl = FcConfigPromote (vl, vr);
968 vr = FcConfigPromote (vr, vl);
969 if (vl.type == vr.type)
970 {
971 switch (vl.type) {
972 case FcTypeDouble:
973 switch (op) {
974 case FcOpPlus:
975 v.type = FcTypeDouble;
976 v.u.d = vl.u.d + vr.u.d;
977 break;
978 case FcOpMinus:
979 v.type = FcTypeDouble;
980 v.u.d = vl.u.d - vr.u.d;
981 break;
982 case FcOpTimes:
983 v.type = FcTypeDouble;
984 v.u.d = vl.u.d * vr.u.d;
985 break;
986 case FcOpDivide:
987 v.type = FcTypeDouble;
988 v.u.d = vl.u.d / vr.u.d;
989 break;
990 default:
991 v.type = FcTypeVoid;
992 break;
993 }
994 if (v.type == FcTypeDouble &&
995 v.u.d == (double) (int) v.u.d)
996 {
997 v.type = FcTypeInteger;
998 v.u.i = (int) v.u.d;
999 }
1000 break;
1001 case FcTypeBool:
1002 switch (op) {
1003 case FcOpOr:
1004 v.type = FcTypeBool;
1005 v.u.b = vl.u.b || vr.u.b;
1006 break;
1007 case FcOpAnd:
1008 v.type = FcTypeBool;
1009 v.u.b = vl.u.b && vr.u.b;
1010 break;
1011 default:
1012 v.type = FcTypeVoid;
1013 break;
1014 }
1015 break;
1016 case FcTypeString:
1017 switch (op) {
1018 case FcOpPlus:
1019 v.type = FcTypeString;
1020 str = FcStrPlusIA__FcStrPlus (vl.u.s, vr.u.s);
1021 v.u.s = FcSharedStr (str);
1022 FcStrFreeIA__FcStrFree (str);
1023
1024 if (!v.u.s)
1025 v.type = FcTypeVoid;
1026 break;
1027 default:
1028 v.type = FcTypeVoid;
1029 break;
1030 }
1031 break;
1032 case FcTypeMatrix:
1033 switch (op) {
1034 case FcOpTimes:
1035 v.type = FcTypeMatrix;
1036 m = malloc (sizeof (FcMatrix));
1037 if (m)
1038 {
1039 FcMemAlloc (FC_MEM_MATRIX6, sizeof (FcMatrix));
1040 FcMatrixMultiplyIA__FcMatrixMultiply (m, vl.u.m, vr.u.m);
1041 v.u.m = m;
1042 }
1043 else
1044 {
1045 v.type = FcTypeVoid;
1046 }
1047 break;
1048 default:
1049 v.type = FcTypeVoid;
1050 break;
1051 }
1052 break;
1053 case FcTypeCharSet:
1054 switch (op) {
1055 case FcOpPlus:
1056 v.type = FcTypeCharSet;
1057 v.u.c = FcCharSetUnionIA__FcCharSetUnion (vl.u.c, vr.u.c);
1058 if (!v.u.c)
1059 v.type = FcTypeVoid;
1060 break;
1061 case FcOpMinus:
1062 v.type = FcTypeCharSet;
1063 v.u.c = FcCharSetSubtractIA__FcCharSetSubtract (vl.u.c, vr.u.c);
1064 if (!v.u.c)
1065 v.type = FcTypeVoid;
1066 break;
1067 default:
1068 v.type = FcTypeVoid;
1069 break;
1070 }
1071 break;
1072 case FcTypeLangSet:
1073 switch (op) {
1074 case FcOpPlus:
1075 v.type = FcTypeLangSet;
1076 v.u.l = FcLangSetUnionIA__FcLangSetUnion (vl.u.l, vr.u.l);
1077 if (!v.u.l)
1078 v.type = FcTypeVoid;
1079 break;
1080 case FcOpMinus:
1081 v.type = FcTypeLangSet;
1082 v.u.l = FcLangSetSubtractIA__FcLangSetSubtract (vl.u.l, vr.u.l);
1083 if (!v.u.l)
1084 v.type = FcTypeVoid;
1085 break;
1086 default:
1087 v.type = FcTypeVoid;
1088 break;
1089 }
1090 break;
1091 default:
1092 v.type = FcTypeVoid;
1093 break;
1094 }
1095 }
1096 else
1097 v.type = FcTypeVoid;
1098 FcValueDestroyIA__FcValueDestroy (vl);
1099 FcValueDestroyIA__FcValueDestroy (vr);
1100 break;
1101 case FcOpNot:
1102 vl = FcConfigEvaluate (p, e->u.tree.left);
1103 switch (vl.type) {
1104 case FcTypeBool:
1105 v.type = FcTypeBool;
1106 v.u.b = !vl.u.b;
1107 break;
1108 default:
1109 v.type = FcTypeVoid;
1110 break;
1111 }
1112 FcValueDestroyIA__FcValueDestroy (vl);
1113 break;
1114 case FcOpFloor:
1115 vl = FcConfigEvaluate (p, e->u.tree.left);
1116 switch (vl.type) {
1117 case FcTypeInteger:
1118 v = vl;
1119 break;
1120 case FcTypeDouble:
1121 v.type = FcTypeInteger;
1122 v.u.i = FcDoubleFloor (vl.u.d)((vl.u.d) >= 0 ? ((int) (vl.u.d)) : -((double) (int) (-(vl
.u.d)) == (-(vl.u.d)) ? (int) (-(vl.u.d)) : (int) ((-(vl.u.d)
) + 1)));
1123 break;
1124 default:
1125 v.type = FcTypeVoid;
1126 break;
1127 }
1128 FcValueDestroyIA__FcValueDestroy (vl);
1129 break;
1130 case FcOpCeil:
1131 vl = FcConfigEvaluate (p, e->u.tree.left);
1132 switch (vl.type) {
1133 case FcTypeInteger:
1134 v = vl;
1135 break;
1136 case FcTypeDouble:
1137 v.type = FcTypeInteger;
1138 v.u.i = FcDoubleCeil (vl.u.d)((vl.u.d) >= 0 ? ((double) (int) (vl.u.d) == (vl.u.d) ? (int
) (vl.u.d) : (int) ((vl.u.d) + 1)) : -((int) (-(vl.u.d))));
1139 break;
1140 default:
1141 v.type = FcTypeVoid;
1142 break;
1143 }
1144 FcValueDestroyIA__FcValueDestroy (vl);
1145 break;
1146 case FcOpRound:
1147 vl = FcConfigEvaluate (p, e->u.tree.left);
1148 switch (vl.type) {
1149 case FcTypeInteger:
1150 v = vl;
1151 break;
1152 case FcTypeDouble:
1153 v.type = FcTypeInteger;
1154 v.u.i = FcDoubleRound (vl.u.d)(((vl.u.d) + 0.5) >= 0 ? ((int) ((vl.u.d) + 0.5)) : -((double
) (int) (-((vl.u.d) + 0.5)) == (-((vl.u.d) + 0.5)) ? (int) (-
((vl.u.d) + 0.5)) : (int) ((-((vl.u.d) + 0.5)) + 1)));
1155 break;
1156 default:
1157 v.type = FcTypeVoid;
1158 break;
1159 }
1160 FcValueDestroyIA__FcValueDestroy (vl);
1161 break;
1162 case FcOpTrunc:
1163 vl = FcConfigEvaluate (p, e->u.tree.left);
1164 switch (vl.type) {
1165 case FcTypeInteger:
1166 v = vl;
1167 break;
1168 case FcTypeDouble:
1169 v.type = FcTypeInteger;
1170 v.u.i = FcDoubleTrunc (vl.u.d)((vl.u.d) >= 0 ? ((int) (vl.u.d)) : -((int) (-(vl.u.d))));
1171 break;
1172 default:
1173 v.type = FcTypeVoid;
1174 break;
1175 }
1176 FcValueDestroyIA__FcValueDestroy (vl);
1177 break;
1178 default:
1179 v.type = FcTypeVoid;
1180 break;
1181 }
1182 return v;
1183}
1184
1185static FcValueList *
1186FcConfigMatchValueList (FcPattern *p,
1187 FcTest *t,
1188 FcValueList *values)
1189{
1190 FcValueList *ret = 0;
1191 FcExpr *e = t->expr;
1192 FcValue value;
1193 FcValueList *v;
1194
1195 while (e)
1196 {
1197 /* Compute the value of the match expression */
1198 if (FC_OP_GET_OP (e->op)((e->op) & 0xffff) == FcOpComma)
1199 {
1200 value = FcConfigEvaluate (p, e->u.tree.left);
1201 e = e->u.tree.right;
1202 }
1203 else
1204 {
1205 value = FcConfigEvaluate (p, e);
1206 e = 0;
1207 }
1208
1209 for (v = values; v; v = FcValueListNext(v)(((((intptr_t) ((v)->next)) & 1) != 0) ? ((FcValueList
*) ((intptr_t) (v) + ((((intptr_t) ((v)->next)) & ~1)
))) : (v)->next))
1210 {
1211 /* Compare the pattern value to the match expression value */
1212 if (FcConfigCompareValue (&v->value, t->op, &value))
1213 {
1214 if (!ret)
1215 ret = v;
1216 }
1217 else
1218 {
1219 if (t->qual == FcQualAll)
1220 {
1221 ret = 0;
1222 break;
1223 }
1224 }
1225 }
1226 FcValueDestroyIA__FcValueDestroy (value);
1227 }
1228 return ret;
1229}
1230
1231static FcValueList *
1232FcConfigValues (FcPattern *p, FcExpr *e, FcValueBinding binding)
1233{
1234 FcValueList *l;
1235
1236 if (!e)
1237 return 0;
1238 l = (FcValueList *) malloc (sizeof (FcValueList));
1239 if (!l)
1240 return 0;
1241 FcMemAlloc (FC_MEM_VALLIST9, sizeof (FcValueList));
1242 if (FC_OP_GET_OP (e->op)((e->op) & 0xffff) == FcOpComma)
1243 {
1244 l->value = FcConfigEvaluate (p, e->u.tree.left);
1245 l->next = FcConfigValues (p, e->u.tree.right, binding);
1246 }
1247 else
1248 {
1249 l->value = FcConfigEvaluate (p, e);
1250 l->next = NULL((void*)0);
1251 }
1252 l->binding = binding;
1253 if (l->value.type == FcTypeVoid)
1254 {
1255 FcValueList *next = FcValueListNext(l)(((((intptr_t) ((l)->next)) & 1) != 0) ? ((FcValueList
*) ((intptr_t) (l) + ((((intptr_t) ((l)->next)) & ~1)
))) : (l)->next);
1256
1257 FcMemFree (FC_MEM_VALLIST9, sizeof (FcValueList));
1258 free (l);
1259 l = next;
1260 }
1261
1262 return l;
1263}
1264
1265static FcBool
1266FcConfigAdd (FcValueListPtr *head,
1267 FcValueList *position,
1268 FcBool append,
1269 FcValueList *new)
1270{
1271 FcValueListPtr *prev, last, v;
1272 FcValueBinding sameBinding;
1273
1274 if (position)
1275 sameBinding = position->binding;
1276 else
1277 sameBinding = FcValueBindingWeak;
1278 for (v = new; v != NULL((void*)0); v = FcValueListNext(v)(((((intptr_t) ((v)->next)) & 1) != 0) ? ((FcValueList
*) ((intptr_t) (v) + ((((intptr_t) ((v)->next)) & ~1)
))) : (v)->next))
1279 if (v->binding == FcValueBindingSame)
1280 v->binding = sameBinding;
1281 if (append)
1282 {
1283 if (position)
1284 prev = &position->next;
1285 else
1286 for (prev = head; *prev != NULL((void*)0);
1287 prev = &(*prev)->next)
1288 ;
1289 }
1290 else
1291 {
1292 if (position)
1293 {
1294 for (prev = head; *prev != NULL((void*)0);
1295 prev = &(*prev)->next)
1296 {
1297 if (*prev == position)
1298 break;
1299 }
1300 }
1301 else
1302 prev = head;
1303
1304 if (FcDebug ()(FcDebugVal) & FC_DBG_EDIT4)
1305 {
1306 if (*prev == NULL((void*)0))
1307 printf ("position not on list\n");
1308 }
1309 }
1310
1311 if (FcDebug ()(FcDebugVal) & FC_DBG_EDIT4)
1312 {
1313 printf ("%s list before ", append ? "Append" : "Prepend");
1314 FcValueListPrintWithPosition (*head, *prev);
1315 printf ("\n");
1316 }
1317
1318 if (new)
1319 {
1320 last = new;
1321 while (last->next != NULL((void*)0))
1322 last = last->next;
1323
1324 last->next = *prev;
1325 *prev = new;
1326 }
1327
1328 if (FcDebug ()(FcDebugVal) & FC_DBG_EDIT4)
1329 {
1330 printf ("%s list after ", append ? "Append" : "Prepend");
1331 FcValueListPrint (*head);
1332 printf ("\n");
1333 }
1334
1335 return FcTrue1;
1336}
1337
1338static void
1339FcConfigDel (FcValueListPtr *head,
1340 FcValueList *position)
1341{
1342 FcValueListPtr *prev;
1343
1344 for (prev = head; *prev != NULL((void*)0); prev = &(*prev)->next)
1345 {
1346 if (*prev == position)
1347 {
1348 *prev = position->next;
1349 position->next = NULL((void*)0);
1350 FcValueListDestroy (position);
1351 break;
1352 }
1353 }
1354}
1355
1356static void
1357FcConfigPatternAdd (FcPattern *p,
1358 FcObject object,
1359 FcValueList *list,
1360 FcBool append)
1361{
1362 if (list)
1363 {
1364 FcPatternElt *e = FcPatternObjectInsertElt (p, object);
1365
1366 if (!e)
1367 return;
1368 FcConfigAdd (&e->values, 0, append, list);
1369 }
1370}
1371
1372/*
1373 * Delete all values associated with a field
1374 */
1375static void
1376FcConfigPatternDel (FcPattern *p,
1377 FcObject object)
1378{
1379 FcPatternElt *e = FcPatternObjectFindElt (p, object);
1380 if (!e)
1381 return;
1382 while (e->values != NULL((void*)0))
1383 FcConfigDel (&e->values, e->values);
1384}
1385
1386static void
1387FcConfigPatternCanon (FcPattern *p,
1388 FcObject object)
1389{
1390 FcPatternElt *e = FcPatternObjectFindElt (p, object);
1391 if (!e)
1392 return;
1393 if (e->values == NULL((void*)0))
1394 FcPatternObjectDel (p, object);
1395}
1396
1397FcBool
1398FcConfigSubstituteWithPat (FcConfig *config,
1399 FcPattern *p,
1400 FcPattern *p_pat,
1401 FcMatchKind kind)
1402{
1403 FcSubst *s;
1404 FcSubState *st;
1405 int i;
1406 FcTest *t;
1407 FcEdit *e;
1408 FcValueList *l;
1409 FcPattern *m;
1410 FcStrSet *strs;
1411
1412 if (!config)
1413 {
1414 config = FcConfigGetCurrent ();
1415 if (!config)
1416 return FcFalse0;
1417 }
1418
1419 switch (kind) {
1420 case FcMatchPattern:
1421 s = config->substPattern;
1422 strs = FcGetDefaultLangsIA__FcGetDefaultLangs ();
1423 if (strs)
1424 {
1425 FcStrList *l = FcStrListCreateIA__FcStrListCreate (strs);
1426 FcChar8 *lang;
1427 FcValue v;
1428
1429 FcStrSetDestroyIA__FcStrSetDestroy (strs);
1430 while (l && (lang = FcStrListNextIA__FcStrListNext (l)))
1431 {
1432 v.type = FcTypeString;
1433 v.u.s = lang;
1434 FcPatternObjectAddWithBinding (p, FC_LANG_OBJECT34, v, FcValueBindingWeak, FcTrue1);
1435 }
1436 FcStrListDoneIA__FcStrListDone (l);
1437 }
1438 break;
1439 case FcMatchFont:
1440 s = config->substFont;
1441 break;
1442 case FcMatchScan:
1443 s = config->substScan;
1444 break;
1445 default:
1446 return FcFalse0;
1447 }
1448
1449 st = (FcSubState *) malloc (config->maxObjects * sizeof (FcSubState));
1450 if (!st && config->maxObjects)
1451 return FcFalse0;
1452 FcMemAlloc (FC_MEM_SUBSTATE10, config->maxObjects * sizeof (FcSubState));
1453
1454 if (FcDebug ()(FcDebugVal) & FC_DBG_EDIT4)
1455 {
1456 printf ("FcConfigSubstitute ");
1457 FcPatternPrintIA__FcPatternPrint (p);
1458 }
1459 for (; s; s = s->next)
1460 {
1461 /*
1462 * Check the tests to see if
1463 * they all match the pattern
1464 */
1465 for (t = s->test, i = 0; t; t = t->next, i++)
1466 {
1467 if (FcDebug ()(FcDebugVal) & FC_DBG_EDIT4)
1468 {
1469 printf ("FcConfigSubstitute test ");
1470 FcTestPrint (t);
1471 }
1472 st[i].elt = 0;
1473 if (kind == FcMatchFont && t->kind == FcMatchPattern)
1474 m = p_pat;
1475 else
1476 m = p;
1477 if (m)
1478 st[i].elt = FcPatternObjectFindElt (m, t->object);
1479 else
1480 st[i].elt = 0;
1481 /*
1482 * If there's no such field in the font,
1483 * then FcQualAll matches while FcQualAny does not
1484 */
1485 if (!st[i].elt)
1486 {
1487 if (t->qual == FcQualAll)
1488 {
1489 st[i].value = 0;
1490 continue;
1491 }
1492 else
1493 break;
1494 }
1495 /*
1496 * Check to see if there is a match, mark the location
1497 * to apply match-relative edits
1498 */
1499 st[i].value = FcConfigMatchValueList (m, t, st[i].elt->values);
1500 if (!st[i].value)
1501 break;
1502 if (t->qual == FcQualFirst && st[i].value != st[i].elt->values)
1503 break;
1504 if (t->qual == FcQualNotFirst && st[i].value == st[i].elt->values)
1505 break;
1506 }
1507 if (t)
1508 {
1509 if (FcDebug ()(FcDebugVal) & FC_DBG_EDIT4)
1510 printf ("No match\n");
1511 continue;
1512 }
1513 if (FcDebug ()(FcDebugVal) & FC_DBG_EDIT4)
1514 {
1515 printf ("Substitute ");
1516 FcSubstPrint (s);
1517 }
1518 for (e = s->edit; e; e = e->next)
1519 {
1520 /*
1521 * Evaluate the list of expressions
1522 */
1523 l = FcConfigValues (p, e->expr, e->binding);
1524 /*
1525 * Locate any test associated with this field, skipping
1526 * tests associated with the pattern when substituting in
1527 * the font
1528 */
1529 for (t = s->test, i = 0; t; t = t->next, i++)
1530 {
1531 if ((t->kind == FcMatchFont || kind == FcMatchPattern) &&
1532 t->object == e->object)
1533 {
1534 /*
1535 * KLUDGE - the pattern may have been reallocated or
1536 * things may have been inserted or deleted above
1537 * this element by other edits. Go back and find
1538 * the element again
1539 */
1540 if (e != s->edit && st[i].elt)
1541 st[i].elt = FcPatternObjectFindElt (p, t->object);
1542 if (!st[i].elt)
1543 t = 0;
1544 break;
1545 }
1546 }
1547 switch (FC_OP_GET_OP (e->op)((e->op) & 0xffff)) {
1548 case FcOpAssign:
1549 /*
1550 * If there was a test, then replace the matched
1551 * value with the new list of values
1552 */
1553 if (t)
1554 {
1555 FcValueList *thisValue = st[i].value;
1556 FcValueList *nextValue = thisValue;
1557
1558 /*
1559 * Append the new list of values after the current value
1560 */
1561 FcConfigAdd (&st[i].elt->values, thisValue, FcTrue1, l);
1562 /*
1563 * Delete the marked value
1564 */
1565 if (thisValue)
1566 FcConfigDel (&st[i].elt->values, thisValue);
1567 /*
1568 * Adjust any pointers into the value list to ensure
1569 * future edits occur at the same place
1570 */
1571 for (t = s->test, i = 0; t; t = t->next, i++)
1572 {
1573 if (st[i].value == thisValue)
1574 st[i].value = nextValue;
1575 }
1576 break;
1577 }
1578 /* fall through ... */
1579 case FcOpAssignReplace:
1580 /*
1581 * Delete all of the values and insert
1582 * the new set
1583 */
1584 FcConfigPatternDel (p, e->object);
1585 FcConfigPatternAdd (p, e->object, l, FcTrue1);
1586 /*
1587 * Adjust any pointers into the value list as they no
1588 * longer point to anything valid
1589 */
1590 if (t)
1591 {
1592 FcPatternElt *thisElt = st[i].elt;
1593 for (t = s->test, i = 0; t; t = t->next, i++)
1594 {
1595 if (st[i].elt == thisElt)
1596 st[i].value = 0;
1597 }
1598 }
1599 break;
1600 case FcOpPrepend:
1601 if (t)
1602 {
1603 FcConfigAdd (&st[i].elt->values, st[i].value, FcFalse0, l);
1604 break;
1605 }
1606 /* fall through ... */
1607 case FcOpPrependFirst:
1608 FcConfigPatternAdd (p, e->object, l, FcFalse0);
1609 break;
1610 case FcOpAppend:
1611 if (t)
1612 {
1613 FcConfigAdd (&st[i].elt->values, st[i].value, FcTrue1, l);
1614 break;
1615 }
1616 /* fall through ... */
1617 case FcOpAppendLast:
1618 FcConfigPatternAdd (p, e->object, l, FcTrue1);
1619 break;
1620 default:
1621 FcValueListDestroy (l);
1622 break;
1623 }
1624 }
1625 /*
1626 * Now go through the pattern and eliminate
1627 * any properties without data
1628 */
1629 for (e = s->edit; e; e = e->next)
1630 FcConfigPatternCanon (p, e->object);
1631
1632 if (FcDebug ()(FcDebugVal) & FC_DBG_EDIT4)
1633 {
1634 printf ("FcConfigSubstitute edit");
1635 FcPatternPrintIA__FcPatternPrint (p);
1636 }
1637 }
1638 FcMemFree (FC_MEM_SUBSTATE10, config->maxObjects * sizeof (FcSubState));
1639 free (st);
1640 if (FcDebug ()(FcDebugVal) & FC_DBG_EDIT4)
1641 {
1642 printf ("FcConfigSubstitute done");
1643 FcPatternPrintIA__FcPatternPrint (p);
1644 }
1645 return FcTrue1;
1646}
1647
1648FcBool
1649FcConfigSubstitute (FcConfig *config,
1650 FcPattern *p,
1651 FcMatchKind kind)
1652{
1653 return FcConfigSubstituteWithPat (config, p, 0, kind);
1654}
1655
1656#if defined (_WIN32)
1657
1658# define WIN32_LEAN_AND_MEAN
1659# define WIN32_EXTRA_LEAN
1660# include <windows.h>
1661
1662static FcChar8 fontconfig_path[1000] = "";
1663
1664# if (defined (PIC1) || defined (DLL_EXPORT))
1665
1666BOOL WINAPI
1667DllMain (HINSTANCE hinstDLL,
1668 DWORD fdwReason,
1669 LPVOID lpvReserved)
1670{
1671 FcChar8 *p;
1672
1673 switch (fdwReason) {
1674 case DLL_PROCESS_ATTACH:
1675 if (!GetModuleFileName ((HMODULE) hinstDLL, (LPCH) fontconfig_path,
1676 sizeof (fontconfig_path)))
1677 break;
1678
1679 /* If the fontconfig DLL is in a "bin" or "lib" subfolder,
1680 * assume it's a Unix-style installation tree, and use
1681 * "etc/fonts" in there as FONTCONFIG_PATH. Otherwise use the
1682 * folder where the DLL is as FONTCONFIG_PATH.
1683 */
1684 p = (FcChar8 *) strrchr ((const char *) fontconfig_path, '\\');
1685 if (p)
1686 {
1687 *p = '\0';
1688 p = (FcChar8 *) strrchr ((const char *) fontconfig_path, '\\');
1689 if (p && (FcStrCmpIgnoreCaseIA__FcStrCmpIgnoreCase (p + 1, (const FcChar8 *) "bin") == 0 ||
1690 FcStrCmpIgnoreCaseIA__FcStrCmpIgnoreCase (p + 1, (const FcChar8 *) "lib") == 0))
1691 *p = '\0';
1692 strcat ((char *) fontconfig_path, "\\etc\\fonts");
1693 }
1694 else
1695 fontconfig_path[0] = '\0';
1696
1697 break;
1698 }
1699
1700 return TRUE;
1701}
1702
1703# endif /* !PIC */
1704
1705#undef FONTCONFIG_PATH"/var/tmp/jhbuild/etc/fonts"
1706#define FONTCONFIG_PATH"/var/tmp/jhbuild/etc/fonts" fontconfig_path
1707
1708#endif /* !_WIN32 */
1709
1710#ifndef FONTCONFIG_FILE"fonts.conf"
1711#define FONTCONFIG_FILE"fonts.conf" "fonts.conf"
1712#endif
1713
1714static FcChar8 *
1715FcConfigFileExists (const FcChar8 *dir, const FcChar8 *file)
1716{
1717 FcChar8 *path;
1718 int size, osize;
1719
1720 if (!dir)
1721 dir = (FcChar8 *) "";
1722
1723 osize = strlen ((char *) dir) + 1 + strlen ((char *) file) + 1;
1724 /*
1725 * workaround valgrind warning because glibc takes advantage of how it knows memory is
1726 * allocated to implement strlen by reading in groups of 4
1727 */
1728 size = (osize + 3) & ~3;
1729
1730 path = malloc (size);
1731 if (!path)
1732 return 0;
1733
1734 strcpy ((char *) path, (const char *) dir);
1735 /* make sure there's a single separator */
1736#ifdef _WIN32
1737 if ((!path[0] || (path[strlen((char *) path)-1] != '/' &&
1738 path[strlen((char *) path)-1] != '\\')) &&
1739 !(file[0] == '/' ||
1740 file[0] == '\\' ||
1741 (isalpha (file[0])((*__ctype_b_loc ())[(int) ((file[0]))] & (unsigned short
int) _ISalpha) && file[1] == ':' && (file[2] == '/' || file[2] == '\\'))))
1742 strcat ((char *) path, "\\");
1743#else
1744 if ((!path[0] || path[strlen((char *) path)-1] != '/') && file[0] != '/')
1745 strcat ((char *) path, "/");
1746#endif
1747 strcat ((char *) path, (char *) file);
1748
1749 FcMemAlloc (FC_MEM_STRING11, osize);
1750 if (access ((char *) path, R_OK4) == 0)
1751 return path;
1752
1753 FcStrFreeIA__FcStrFree (path);
1754
1755 return 0;
1756}
1757
1758static FcChar8 **
1759FcConfigGetPath (void)
1760{
1761 FcChar8 **path;
1762 FcChar8 *env, *e, *colon;
1763 FcChar8 *dir;
1764 int npath;
1765 int i;
1766
1767 npath = 2; /* default dir + null */
1768 env = (FcChar8 *) getenv ("FONTCONFIG_PATH");
1769 if (env)
1770 {
1771 e = env;
1772 npath++;
1773 while (*e)
1774 if (*e++ == FC_SEARCH_PATH_SEPARATOR':')
1775 npath++;
1776 }
1777 path = calloc (npath, sizeof (FcChar8 *));
1778 if (!path)
1779 goto bail0;
1780 i = 0;
1781
1782 if (env)
1783 {
1784 e = env;
1785 while (*e)
1786 {
1787 colon = (FcChar8 *) strchr ((char *) e, FC_SEARCH_PATH_SEPARATOR':');
1788 if (!colon)
1789 colon = e + strlen ((char *) e);
1790 path[i] = malloc (colon - e + 1);
1791 if (!path[i])
1792 goto bail1;
1793 strncpy ((char *) path[i], (const char *) e, colon - e);
1794 path[i][colon - e] = '\0';
1795 if (*colon)
1796 e = colon + 1;
1797 else
1798 e = colon;
1799 i++;
1800 }
1801 }
1802
1803#ifdef _WIN32
1804 if (fontconfig_path[0] == '\0')
1805 {
1806 char *p;
1807 if(!GetModuleFileName(NULL((void*)0), (LPCH) fontconfig_path, sizeof(fontconfig_path)))
1808 goto bail1;
1809 p = strrchr ((const char *) fontconfig_path, '\\');
1810 if (p) *p = '\0';
1811 strcat ((char *) fontconfig_path, "\\fonts");
1812 }
1813#endif
1814 dir = (FcChar8 *) FONTCONFIG_PATH"/var/tmp/jhbuild/etc/fonts";
1815 path[i] = malloc (strlen ((char *) dir) + 1);
1816 if (!path[i])
1817 goto bail1;
1818 strcpy ((char *) path[i], (const char *) dir);
1819 return path;
1820
1821bail1:
1822 for (i = 0; path[i]; i++)
1823 free (path[i]);
1824 free (path);
1825bail0:
1826 return 0;
1827}
1828
1829static void
1830FcConfigFreePath (FcChar8 **path)
1831{
1832 FcChar8 **p;
1833
1834 for (p = path; *p; p++)
1835 free (*p);
1836 free (path);
1837}
1838
1839static FcBool _FcConfigHomeEnabled = FcTrue1;
1840
1841FcChar8 *
1842FcConfigHome (void)
1843{
1844 if (_FcConfigHomeEnabled)
1845 {
1846 char *home = getenv ("HOME");
1847
1848#ifdef _WIN32
1849 if (home == NULL((void*)0))
1850 home = getenv ("USERPROFILE");
1851#endif
1852
1853 return (FcChar8 *) home;
1854 }
1855 return 0;
1856}
1857
1858FcChar8 *
1859FcConfigXdgCacheHome (void)
1860{
1861 const char *env = getenv ("XDG_CACHE_HOME");
1862 FcChar8 *ret = NULL((void*)0);
1863
1864 if (env)
1865 ret = FcStrCopyIA__FcStrCopy ((const FcChar8 *)env);
1866 else
1867 {
1868 const FcChar8 *home = FcConfigHome ();
1869 size_t len = home ? strlen ((const char *)home) : 0;
1870
1871 ret = malloc (len + 7 + 1);
1872 if (ret)
1873 {
1874 FcMemAlloc (FC_MEM_STRING11, len + 7 + 1);
1875 memcpy (ret, home, len);
1876 memcpy (&ret[len], FC_DIR_SEPARATOR_S"/" ".cache", 7);
1877 ret[len + 7] = 0;
1878 }
1879 }
1880
1881 return ret;
1882}
1883
1884FcChar8 *
1885FcConfigXdgConfigHome (void)
1886{
1887 const char *env = getenv ("XDG_CONFIG_HOME");
1888 FcChar8 *ret = NULL((void*)0);
1889
1890 if (env)
1
Assuming 'env' is null
2
Taking false branch
1891 ret = FcStrCopyIA__FcStrCopy ((const FcChar8 *)env);
1892 else
1893 {
1894 const FcChar8 *home = FcConfigHome ();
1895 size_t len = home ? strlen ((const char *)home) : 0;
3
Assuming 'home' is null
4
'?' condition is false
1896
1897 ret = malloc (len + 8 + 1);
1898 if (ret)
5
Assuming 'ret' is non-null
6
Taking true branch
1899 {
1900 FcMemAlloc (FC_MEM_STRING11, len + 8 + 1);
1901 memcpy (ret, home, len);
7
Null pointer passed as an argument to a 'nonnull' parameter
1902 memcpy (&ret[len], FC_DIR_SEPARATOR_S"/" ".config", 8);
1903 ret[len + 8] = 0;
1904 }
1905 }
1906
1907 return ret;
1908}
1909
1910FcChar8 *
1911FcConfigXdgDataHome (void)
1912{
1913 const char *env = getenv ("XDG_DATA_HOME");
1914 FcChar8 *ret = NULL((void*)0);
1915
1916 if (env)
1917 ret = FcStrCopyIA__FcStrCopy ((const FcChar8 *)env);
1918 else
1919 {
1920 const FcChar8 *home = FcConfigHome ();
1921 size_t len = home ? strlen ((const char *)home) : 0;
1922
1923 ret = malloc (len + 13 + 1);
1924 if (ret)
1925 {
1926 FcMemAlloc (FC_MEM_STRING11, len + 13 + 1);
1927 memcpy (ret, home, len);
1928 memcpy (&ret[len], FC_DIR_SEPARATOR_S"/" ".local" FC_DIR_SEPARATOR_S"/" "share", 13);
1929 ret[len + 13] = 0;
1930 }
1931 }
1932
1933 return ret;
1934}
1935
1936FcBool
1937FcConfigEnableHome (FcBool enable)
1938{
1939 FcBool prev = _FcConfigHomeEnabled;
1940 _FcConfigHomeEnabled = enable;
1941 return prev;
1942}
1943
1944FcChar8 *
1945FcConfigFilename (const FcChar8 *url)
1946{
1947 FcChar8 *file, *dir, **path, **p;
1948
1949 if (!url || !*url)
1950 {
1951 url = (FcChar8 *) getenv ("FONTCONFIG_FILE");
1952 if (!url)
1953 url = (FcChar8 *) FONTCONFIG_FILE"fonts.conf";
1954 }
1955 file = 0;
1956
1957#ifdef _WIN32
1958 if (isalpha (*url)((*__ctype_b_loc ())[(int) ((*url))] & (unsigned short int
) _ISalpha) &&
1959 url[1] == ':' &&
1960 (url[2] == '/' || url[2] == '\\'))
1961 goto absolute_path;
1962#endif
1963
1964 switch (*url) {
1965 case '~':
1966 dir = FcConfigHome ();
1967 if (dir)
1968 file = FcConfigFileExists (dir, url + 1);
1969 else
1970 file = 0;
1971 break;
1972#ifdef _WIN32
1973 case '\\':
1974 absolute_path:
1975#endif
1976 case '/':
1977 file = FcConfigFileExists (0, url);
1978 break;
1979 default:
1980 path = FcConfigGetPath ();
1981 if (!path)
1982 return NULL((void*)0);
1983 for (p = path; *p; p++)
1984 {
1985 file = FcConfigFileExists (*p, url);
1986 if (file)
1987 break;
1988 }
1989 FcConfigFreePath (path);
1990 break;
1991 }
1992
1993 return file;
1994}
1995
1996/*
1997 * Manage the application-specific fonts
1998 */
1999
2000FcBool
2001FcConfigAppFontAddFile (FcConfig *config,
2002 const FcChar8 *file)
2003{
2004 FcFontSet *set;
2005 FcStrSet *subdirs;
2006 FcStrList *sublist;
2007 FcChar8 *subdir;
2008
2009 if (!config)
2010 {
2011 config = FcConfigGetCurrent ();
2012 if (!config)
2013 return FcFalse0;
2014 }
2015
2016 subdirs = FcStrSetCreateIA__FcStrSetCreate ();
2017 if (!subdirs)
2018 return FcFalse0;
2019
2020 set = FcConfigGetFonts (config, FcSetApplication);
2021 if (!set)
2022 {
2023 set = FcFontSetCreateIA__FcFontSetCreate ();
2024 if (!set)
2025 {
2026 FcStrSetDestroyIA__FcStrSetDestroy (subdirs);
2027 return FcFalse0;
2028 }
2029 FcConfigSetFonts (config, set, FcSetApplication);
2030 }
2031
2032 if (!FcFileScanConfig (set, subdirs, config->blanks, file, config))
2033 {
2034 FcStrSetDestroyIA__FcStrSetDestroy (subdirs);
2035 return FcFalse0;
2036 }
2037 if ((sublist = FcStrListCreateIA__FcStrListCreate (subdirs)))
2038 {
2039 while ((subdir = FcStrListNextIA__FcStrListNext (sublist)))
2040 {
2041 FcConfigAppFontAddDir (config, subdir);
2042 }
2043 FcStrListDoneIA__FcStrListDone (sublist);
2044 }
2045 FcStrSetDestroyIA__FcStrSetDestroy (subdirs);
2046 return FcTrue1;
2047}
2048
2049FcBool
2050FcConfigAppFontAddDir (FcConfig *config,
2051 const FcChar8 *dir)
2052{
2053 FcFontSet *set;
2054 FcStrSet *dirs;
2055
2056 if (!config)
2057 {
2058 config = FcConfigGetCurrent ();
2059 if (!config)
2060 return FcFalse0;
2061 }
2062
2063 dirs = FcStrSetCreateIA__FcStrSetCreate ();
2064 if (!dirs)
2065 return FcFalse0;
2066
2067 set = FcConfigGetFonts (config, FcSetApplication);
2068 if (!set)
2069 {
2070 set = FcFontSetCreateIA__FcFontSetCreate ();
2071 if (!set)
2072 {
2073 FcStrSetDestroyIA__FcStrSetDestroy (dirs);
2074 return FcFalse0;
2075 }
2076 FcConfigSetFonts (config, set, FcSetApplication);
2077 }
2078
2079 FcStrSetAddFilenameIA__FcStrSetAddFilename (dirs, dir);
2080
2081 if (!FcConfigAddDirList (config, FcSetApplication, dirs))
2082 {
2083 FcStrSetDestroyIA__FcStrSetDestroy (dirs);
2084 return FcFalse0;
2085 }
2086 FcStrSetDestroyIA__FcStrSetDestroy (dirs);
2087 return FcTrue1;
2088}
2089
2090void
2091FcConfigAppFontClear (FcConfig *config)
2092{
2093 if (!config)
2094 {
2095 config = FcConfigGetCurrent ();
2096 if (!config)
2097 return;
2098 }
2099
2100 FcConfigSetFonts (config, 0, FcSetApplication);
2101}
2102
2103/*
2104 * Manage filename-based font source selectors
2105 */
2106
2107FcBool
2108FcConfigGlobAdd (FcConfig *config,
2109 const FcChar8 *glob,
2110 FcBool accept)
2111{
2112 FcStrSet *set = accept ? config->acceptGlobs : config->rejectGlobs;
2113
2114 return FcStrSetAddIA__FcStrSetAdd (set, glob);
2115}
2116
2117static FcBool
2118FcConfigGlobMatch (const FcChar8 *glob,
2119 const FcChar8 *string)
2120{
2121 FcChar8 c;
2122
2123 while ((c = *glob++))
2124 {
2125 switch (c) {
2126 case '*':
2127 /* short circuit common case */
2128 if (!*glob)
2129 return FcTrue1;
2130 /* short circuit another common case */
2131 if (strchr ((char *) glob, '*') == 0)
2132 {
2133 size_t l1, l2;
2134
2135 l1 = strlen ((char *) string);
2136 l2 = strlen ((char *) glob);
2137 if (l1 < l2)
2138 return FcFalse0;
2139 string += (l1 - l2);
2140 }
2141 while (*string)
2142 {
2143 if (FcConfigGlobMatch (glob, string))
2144 return FcTrue1;
2145 string++;
2146 }
2147 return FcFalse0;
2148 case '?':
2149 if (*string++ == '\0')
2150 return FcFalse0;
2151 break;
2152 default:
2153 if (*string++ != c)
2154 return FcFalse0;
2155 break;
2156 }
2157 }
2158 return *string == '\0';
2159}
2160
2161static FcBool
2162FcConfigGlobsMatch (const FcStrSet *globs,
2163 const FcChar8 *string)
2164{
2165 int i;
2166
2167 for (i = 0; i < globs->num; i++)
2168 if (FcConfigGlobMatch (globs->strs[i], string))
2169 return FcTrue1;
2170 return FcFalse0;
2171}
2172
2173FcBool
2174FcConfigAcceptFilename (FcConfig *config,
2175 const FcChar8 *filename)
2176{
2177 if (FcConfigGlobsMatch (config->acceptGlobs, filename))
2178 return FcTrue1;
2179 if (FcConfigGlobsMatch (config->rejectGlobs, filename))
2180 return FcFalse0;
2181 return FcTrue1;
2182}
2183
2184/*
2185 * Manage font-pattern based font source selectors
2186 */
2187
2188FcBool
2189FcConfigPatternsAdd (FcConfig *config,
2190 FcPattern *pattern,
2191 FcBool accept)
2192{
2193 FcFontSet *set = accept ? config->acceptPatterns : config->rejectPatterns;
2194
2195 return FcFontSetAddIA__FcFontSetAdd (set, pattern);
2196}
2197
2198static FcBool
2199FcConfigPatternsMatch (const FcFontSet *patterns,
2200 const FcPattern *font)
2201{
2202 int i;
2203
2204 for (i = 0; i < patterns->nfont; i++)
2205 if (FcListPatternMatchAny (patterns->fonts[i], font))
2206 return FcTrue1;
2207 return FcFalse0;
2208}
2209
2210FcBool
2211FcConfigAcceptFont (FcConfig *config,
2212 const FcPattern *font)
2213{
2214 if (FcConfigPatternsMatch (config->acceptPatterns, font))
2215 return FcTrue1;
2216 if (FcConfigPatternsMatch (config->rejectPatterns, font))
2217 return FcFalse0;
2218 return FcTrue1;
2219}
2220#define __fccfg__
2221#include "fcaliastail.h"
2222#undef __fccfg__