Bug Summary

File:src/fcpat.c
Location:line 484, column 2
Description:Potential leak of memory pointed to by 'e'

Annotated Source Code

1/*
2 * Copyright © 2000 Keith Packard
3 *
4 * Permission to use, copy, modify, distribute, and sell this software and its
5 * documentation for any purpose is hereby granted without fee, provided that
6 * the above copyright notice appear in all copies and that both that
7 * copyright notice and this permission notice appear in supporting
8 * documentation, and that the name of the author(s) not be used in
9 * advertising or publicity pertaining to distribution of the software without
10 * specific, written prior permission. The authors make no
11 * representations about the suitability of this software for any purpose. It
12 * is provided "as is" without express or implied warranty.
13 *
14 * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
15 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
16 * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR
17 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
18 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
19 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
20 * PERFORMANCE OF THIS SOFTWARE.
21 */
22
23#include "fcint.h"
24#include "fcftint.h"
25
26/* Objects MT-safe for readonly access. */
27
28FcPattern *
29FcPatternCreate (void)
30{
31 FcPattern *p;
32
33 p = (FcPattern *) malloc (sizeof (FcPattern));
34 if (!p)
35 return 0;
36 memset (p, 0, sizeof (FcPattern))__builtin___memset_chk (p, 0, sizeof (FcPattern), __builtin_object_size
(p, 0))
;
37 p->num = 0;
38 p->size = 0;
39 p->elts_offset = FcPtrToOffset (p, NULL)((intptr_t) (((void*)0)) - (intptr_t) (p));
40 FcRefInit (&p->ref, 1);
41 return p;
42}
43
44void
45FcValueDestroy (FcValue v)
46{
47 switch ((int) v.type) {
48 case FcTypeString:
49 FcFree (v.u.s)(free ((FcChar8 *) (v.u.s)));
50 break;
51 case FcTypeMatrix:
52 FcMatrixFree ((FcMatrix *) v.u.m);
53 break;
54 case FcTypeCharSet:
55 FcCharSetDestroy ((FcCharSet *) v.u.c);
56 break;
57 case FcTypeLangSet:
58 FcLangSetDestroy ((FcLangSet *) v.u.l);
59 break;
60 case FcTypeRange:
61 FcRangeDestroy ((FcRange *) v.u.r);
62 break;
63 default:
64 break;
65 }
66}
67
68FcValue
69FcValueCanonicalize (const FcValue *v)
70{
71 FcValue new;
72
73 switch ((int) v->type)
74 {
75 case FcTypeString:
76 new.u.s = FcValueString(v)(((((intptr_t) ((v)->u.s)) & 1) != 0) ? ((FcChar8 *) (
(intptr_t) (v) + ((((intptr_t) ((v)->u.s)) & ~1)))) : (
v)->u.s)
;
77 new.type = FcTypeString;
78 break;
79 case FcTypeCharSet:
80 new.u.c = FcValueCharSet(v)(((((intptr_t) ((v)->u.c)) & 1) != 0) ? ((const FcCharSet
*) ((intptr_t) (v) + ((((intptr_t) ((v)->u.c)) & ~1))
)) : (v)->u.c)
;
81 new.type = FcTypeCharSet;
82 break;
83 case FcTypeLangSet:
84 new.u.l = FcValueLangSet(v)(((((intptr_t) ((v)->u.l)) & 1) != 0) ? ((const FcLangSet
*) ((intptr_t) (v) + ((((intptr_t) ((v)->u.l)) & ~1))
)) : (v)->u.l)
;
85 new.type = FcTypeLangSet;
86 break;
87 case FcTypeRange:
88 new.u.r = FcValueRange(v)(((((intptr_t) ((v)->u.r)) & 1) != 0) ? ((const FcRange
*) ((intptr_t) (v) + ((((intptr_t) ((v)->u.r)) & ~1))
)) : (v)->u.r)
;
89 new.type = FcTypeRange;
90 break;
91 default:
92 new = *v;
93 break;
94 }
95 return new;
96}
97
98FcValue
99FcValueSave (FcValue v)
100{
101 switch ((int) v.type) {
102 case FcTypeString:
103 v.u.s = FcStrdup (v.u.s)((FcChar8 *) strdup ((const char *) (v.u.s)));
104 if (!v.u.s)
105 v.type = FcTypeVoid;
106 break;
107 case FcTypeMatrix:
108 v.u.m = FcMatrixCopy (v.u.m);
109 if (!v.u.m)
110 v.type = FcTypeVoid;
111 break;
112 case FcTypeCharSet:
113 v.u.c = FcCharSetCopy ((FcCharSet *) v.u.c);
114 if (!v.u.c)
115 v.type = FcTypeVoid;
116 break;
117 case FcTypeLangSet:
118 v.u.l = FcLangSetCopy (v.u.l);
119 if (!v.u.l)
120 v.type = FcTypeVoid;
121 break;
122 case FcTypeRange:
123 v.u.r = FcRangeCopy (v.u.r);
124 if (!v.u.r)
125 v.type = FcTypeVoid;
126 break;
127 default:
128 break;
129 }
130 return v;
131}
132
133FcValueListPtr
134FcValueListCreate (void)
135{
136 return calloc (1, sizeof (FcValueList));
137}
138
139void
140FcValueListDestroy (FcValueListPtr l)
141{
142 FcValueListPtr next;
143 for (; l; l = next)
144 {
145 switch ((int) l->value.type) {
146 case FcTypeString:
147 FcFree (l->value.u.s)(free ((FcChar8 *) (l->value.u.s)));
148 break;
149 case FcTypeMatrix:
150 FcMatrixFree ((FcMatrix *)l->value.u.m);
151 break;
152 case FcTypeCharSet:
153 FcCharSetDestroy
154 ((FcCharSet *) (l->value.u.c));
155 break;
156 case FcTypeLangSet:
157 FcLangSetDestroy
158 ((FcLangSet *) (l->value.u.l));
159 break;
160 case FcTypeRange:
161 FcRangeDestroy ((FcRange *) (l->value.u.r));
162 break;
163 default:
164 break;
165 }
166 next = FcValueListNext(l)(((((intptr_t) ((l)->next)) & 1) != 0) ? ((FcValueList
*) ((intptr_t) (l) + ((((intptr_t) ((l)->next)) & ~1)
))) : (l)->next)
;
167 free(l);
168 }
169}
170
171FcValueListPtr
172FcValueListPrepend (FcValueListPtr vallist,
173 FcValue value,
174 FcValueBinding binding)
175{
176 FcValueListPtr new;
177
178 if (value.type == FcTypeVoid)
179 return vallist;
180 new = FcValueListCreate ();
181 if (!new)
182 return vallist;
183
184 new->value = FcValueSave (value);
185 new->binding = binding;
186 new->next = vallist;
187
188 return new;
189}
190
191FcValueListPtr
192FcValueListAppend (FcValueListPtr vallist,
193 FcValue value,
194 FcValueBinding binding)
195{
196 FcValueListPtr new, last;
197
198 if (value.type == FcTypeVoid)
199 return vallist;
200 new = FcValueListCreate ();
201 if (!new)
202 return vallist;
203
204 new->value = FcValueSave (value);
205 new->binding = binding;
206 new->next = NULL((void*)0);
207
208 if (vallist)
209 {
210 for (last = vallist; FcValueListNext (last)(((((intptr_t) ((last)->next)) & 1) != 0) ? ((FcValueList
*) ((intptr_t) (last) + ((((intptr_t) ((last)->next)) &
~1)))) : (last)->next)
; last = FcValueListNext (last)(((((intptr_t) ((last)->next)) & 1) != 0) ? ((FcValueList
*) ((intptr_t) (last) + ((((intptr_t) ((last)->next)) &
~1)))) : (last)->next)
);
211
212 last->next = new;
213 }
214 else
215 vallist = new;
216
217 return vallist;
218}
219
220FcValueListPtr
221FcValueListDuplicate(FcValueListPtr orig)
222{
223 FcValueListPtr new = NULL((void*)0), l, t = NULL((void*)0);
224 FcValue v;
225
226 for (l = orig; l != NULL((void*)0); l = FcValueListNext (l)(((((intptr_t) ((l)->next)) & 1) != 0) ? ((FcValueList
*) ((intptr_t) (l) + ((((intptr_t) ((l)->next)) & ~1)
))) : (l)->next)
)
227 {
228 if (!new)
229 {
230 t = new = FcValueListCreate();
231 }
232 else
233 {
234 t->next = FcValueListCreate();
235 t = FcValueListNext (t)(((((intptr_t) ((t)->next)) & 1) != 0) ? ((FcValueList
*) ((intptr_t) (t) + ((((intptr_t) ((t)->next)) & ~1)
))) : (t)->next)
;
236 }
237 v = FcValueCanonicalize (&l->value);
238 t->value = FcValueSave (v);
239 t->binding = l->binding;
240 t->next = NULL((void*)0);
241 }
242
243 return new;
244}
245
246FcBool
247FcValueEqual (FcValue va, FcValue vb)
248{
249 if (va.type != vb.type)
250 {
251 if (va.type == FcTypeInteger)
252 {
253 va.type = FcTypeDouble;
254 va.u.d = va.u.i;
255 }
256 if (vb.type == FcTypeInteger)
257 {
258 vb.type = FcTypeDouble;
259 vb.u.d = vb.u.i;
260 }
261 if (va.type != vb.type)
262 return FcFalse0;
263 }
264 switch (va.type) {
265 case FcTypeUnknown:
266 return FcFalse0; /* don't know how to compare this object */
267 case FcTypeVoid:
268 return FcTrue1;
269 case FcTypeInteger:
270 return va.u.i == vb.u.i;
271 case FcTypeDouble:
272 return va.u.d == vb.u.d;
273 case FcTypeString:
274 return FcStrCmpIgnoreCase (va.u.s, vb.u.s) == 0;
275 case FcTypeBool:
276 return va.u.b == vb.u.b;
277 case FcTypeMatrix:
278 return FcMatrixEqual (va.u.m, vb.u.m);
279 case FcTypeCharSet:
280 return FcCharSetEqual (va.u.c, vb.u.c);
281 case FcTypeFTFace:
282 return va.u.f == vb.u.f;
283 case FcTypeLangSet:
284 return FcLangSetEqual (va.u.l, vb.u.l);
285 case FcTypeRange:
286 return FcRangeIsInRange (va.u.r, vb.u.r);
287 }
288 return FcFalse0;
289}
290
291static FcChar32
292FcDoubleHash (double d)
293{
294 if (d < 0)
295 d = -d;
296 if (d > 0xffffffff)
297 d = 0xffffffff;
298 return (FcChar32) d;
299}
300
301FcChar32
302FcStringHash (const FcChar8 *s)
303{
304 FcChar8 c;
305 FcChar32 h = 0;
306
307 if (s)
308 while ((c = *s++))
309 h = ((h << 1) | (h >> 31)) ^ c;
310 return h;
311}
312
313static FcChar32
314FcValueHash (const FcValue *v)
315{
316 switch (v->type) {
317 case FcTypeUnknown:
318 case FcTypeVoid:
319 return 0;
320 case FcTypeInteger:
321 return (FcChar32) v->u.i;
322 case FcTypeDouble:
323 return FcDoubleHash (v->u.d);
324 case FcTypeString:
325 return FcStringHash (FcValueString(v)(((((intptr_t) ((v)->u.s)) & 1) != 0) ? ((FcChar8 *) (
(intptr_t) (v) + ((((intptr_t) ((v)->u.s)) & ~1)))) : (
v)->u.s)
);
326 case FcTypeBool:
327 return (FcChar32) v->u.b;
328 case FcTypeMatrix:
329 return (FcDoubleHash (v->u.m->xx) ^
330 FcDoubleHash (v->u.m->xy) ^
331 FcDoubleHash (v->u.m->yx) ^
332 FcDoubleHash (v->u.m->yy));
333 case FcTypeCharSet:
334 return (FcChar32) FcValueCharSet(v)(((((intptr_t) ((v)->u.c)) & 1) != 0) ? ((const FcCharSet
*) ((intptr_t) (v) + ((((intptr_t) ((v)->u.c)) & ~1))
)) : (v)->u.c)
->num;
335 case FcTypeFTFace:
336 return FcStringHash ((const FcChar8 *) ((FT_Face) v->u.f)->family_name) ^
337 FcStringHash ((const FcChar8 *) ((FT_Face) v->u.f)->style_name);
338 case FcTypeLangSet:
339 return FcLangSetHash (FcValueLangSet(v)(((((intptr_t) ((v)->u.l)) & 1) != 0) ? ((const FcLangSet
*) ((intptr_t) (v) + ((((intptr_t) ((v)->u.l)) & ~1))
)) : (v)->u.l)
);
340 case FcTypeRange:
341 return FcRangeHash (v->u.r);
342 }
343 return 0;
344}
345
346static FcBool
347FcValueListEqual (FcValueListPtr la, FcValueListPtr lb)
348{
349 if (la == lb)
350 return FcTrue1;
351
352 while (la && lb)
353 {
354 if (!FcValueEqual (la->value, lb->value))
355 return FcFalse0;
356 la = FcValueListNext(la)(((((intptr_t) ((la)->next)) & 1) != 0) ? ((FcValueList
*) ((intptr_t) (la) + ((((intptr_t) ((la)->next)) & ~
1)))) : (la)->next)
;
357 lb = FcValueListNext(lb)(((((intptr_t) ((lb)->next)) & 1) != 0) ? ((FcValueList
*) ((intptr_t) (lb) + ((((intptr_t) ((lb)->next)) & ~
1)))) : (lb)->next)
;
358 }
359 if (la || lb)
360 return FcFalse0;
361 return FcTrue1;
362}
363
364static FcChar32
365FcValueListHash (FcValueListPtr l)
366{
367 FcChar32 hash = 0;
368
369 for (; l; l = FcValueListNext(l)(((((intptr_t) ((l)->next)) & 1) != 0) ? ((FcValueList
*) ((intptr_t) (l) + ((((intptr_t) ((l)->next)) & ~1)
))) : (l)->next)
)
370 {
371 hash = ((hash << 1) | (hash >> 31)) ^ FcValueHash (&l->value);
372 }
373 return hash;
374}
375
376void
377FcPatternDestroy (FcPattern *p)
378{
379 int i;
380 FcPatternElt *elts;
381
382 if (!p)
383 return;
384
385 if (FcRefIsConst (&p->ref))
386 {
387 FcCacheObjectDereference (p);
388 return;
389 }
390
391 if (FcRefDec (&p->ref) != 1)
392 return;
393
394 elts = FcPatternElts (p)((FcPatternElt *) ((intptr_t) (p) + ((p)->elts_offset)));
395 for (i = 0; i < p->num; i++)
396 FcValueListDestroy (FcPatternEltValues(&elts[i])(((((intptr_t) ((&elts[i])->values)) & 1) != 0) ? (
(FcValueList *) ((intptr_t) (&elts[i]) + ((((intptr_t) ((
&elts[i])->values)) & ~1)))) : (&elts[i])->
values)
);
397
398 free (elts);
399 free (p);
400}
401
402static int
403FcPatternObjectPosition (const FcPattern *p, FcObject object)
404{
405 int low, high, mid, c;
406 FcPatternElt *elts = FcPatternElts(p)((FcPatternElt *) ((intptr_t) (p) + ((p)->elts_offset)));
407
408 low = 0;
409 high = p->num - 1;
410 c = 1;
411 mid = 0;
412 while (low <= high)
413 {
414 mid = (low + high) >> 1;
415 c = elts[mid].object - object;
416 if (c == 0)
417 return mid;
418 if (c < 0)
419 low = mid + 1;
420 else
421 high = mid - 1;
422 }
423 if (c < 0)
424 mid++;
425 return -(mid + 1);
426}
427
428int
429FcPatternPosition (const FcPattern *p, const char *object)
430{
431 return FcPatternObjectPosition (p, FcObjectFromName (object));
432}
433
434FcPatternElt *
435FcPatternObjectFindElt (const FcPattern *p, FcObject object)
436{
437 int i = FcPatternObjectPosition (p, object);
438 if (i < 0)
439 return 0;
440 return &FcPatternElts(p)((FcPatternElt *) ((intptr_t) (p) + ((p)->elts_offset)))[i];
441}
442
443FcPatternElt *
444FcPatternObjectInsertElt (FcPattern *p, FcObject object)
445{
446 int i;
447 FcPatternElt *e;
448
449 i = FcPatternObjectPosition (p, object);
450 if (i < 0)
9
Assuming 'i' is < 0
10
Taking true branch
451 {
452 i = -i - 1;
453
454 /* reallocate array */
455 if (p->num + 1 >= p->size)
11
Taking true branch
456 {
457 int s = p->size + 16;
458 if (p->size)
12
Taking true branch
459 {
460 FcPatternElt *e0 = FcPatternElts(p)((FcPatternElt *) ((intptr_t) (p) + ((p)->elts_offset)));
461 e = (FcPatternElt *) realloc (e0, s * sizeof (FcPatternElt));
13
Memory is allocated
462 if (!e) /* maybe it was mmapped */
14
Assuming 'e' is non-null
15
Taking false branch
463 {
464 e = malloc(s * sizeof (FcPatternElt));
465 if (e)
466 memcpy(e, e0, p->num * sizeof (FcPatternElt))__builtin___memcpy_chk (e, e0, p->num * sizeof (FcPatternElt
), __builtin_object_size (e, 0))
;
467 }
468 }
469 else
470 e = (FcPatternElt *) malloc (s * sizeof (FcPatternElt));
471 if (!e)
16
Taking false branch
472 return FcFalse0;
473 p->elts_offset = FcPtrToOffset (p, e)((intptr_t) (e) - (intptr_t) (p));
474 while (p->size < s)
17
Loop condition is false. Execution continues on line 482
475 {
476 e[p->size].object = 0;
477 e[p->size].values = NULL((void*)0);
478 p->size++;
479 }
480 }
481
482 e = FcPatternElts(p)((FcPatternElt *) ((intptr_t) (p) + ((p)->elts_offset)));
483 /* move elts up */
484 memmove (e + i + 1,__builtin___memmove_chk (e + i + 1, e + i, sizeof (FcPatternElt
) * (p->num - i), __builtin_object_size (e + i + 1, 0))
18
Within the expansion of the macro 'memmove':
a
Potential leak of memory pointed to by 'e'
485 e + i,__builtin___memmove_chk (e + i + 1, e + i, sizeof (FcPatternElt
) * (p->num - i), __builtin_object_size (e + i + 1, 0))
486 sizeof (FcPatternElt) *__builtin___memmove_chk (e + i + 1, e + i, sizeof (FcPatternElt
) * (p->num - i), __builtin_object_size (e + i + 1, 0))
487 (p->num - i))__builtin___memmove_chk (e + i + 1, e + i, sizeof (FcPatternElt
) * (p->num - i), __builtin_object_size (e + i + 1, 0))
;
488
489 /* bump count */
490 p->num++;
491
492 e[i].object = object;
493 e[i].values = NULL((void*)0);
494 }
495
496 return FcPatternElts(p)((FcPatternElt *) ((intptr_t) (p) + ((p)->elts_offset))) + i;
497}
498
499FcBool
500FcPatternEqual (const FcPattern *pa, const FcPattern *pb)
501{
502 int i;
503 FcPatternElt *pae, *pbe;
504
505 if (pa == pb)
506 return FcTrue1;
507
508 if (pa->num != pb->num)
509 return FcFalse0;
510 pae = FcPatternElts(pa)((FcPatternElt *) ((intptr_t) (pa) + ((pa)->elts_offset)));
511 pbe = FcPatternElts(pb)((FcPatternElt *) ((intptr_t) (pb) + ((pb)->elts_offset)));
512 for (i = 0; i < pa->num; i++)
513 {
514 if (pae[i].object != pbe[i].object)
515 return FcFalse0;
516 if (!FcValueListEqual (FcPatternEltValues(&pae[i])(((((intptr_t) ((&pae[i])->values)) & 1) != 0) ? (
(FcValueList *) ((intptr_t) (&pae[i]) + ((((intptr_t) ((&
pae[i])->values)) & ~1)))) : (&pae[i])->values)
,
517 FcPatternEltValues(&pbe[i])(((((intptr_t) ((&pbe[i])->values)) & 1) != 0) ? (
(FcValueList *) ((intptr_t) (&pbe[i]) + ((((intptr_t) ((&
pbe[i])->values)) & ~1)))) : (&pbe[i])->values)
))
518 return FcFalse0;
519 }
520 return FcTrue1;
521}
522
523FcChar32
524FcPatternHash (const FcPattern *p)
525{
526 int i;
527 FcChar32 h = 0;
528 FcPatternElt *pe = FcPatternElts(p)((FcPatternElt *) ((intptr_t) (p) + ((p)->elts_offset)));
529
530 for (i = 0; i < p->num; i++)
531 {
532 h = (((h << 1) | (h >> 31)) ^
533 pe[i].object ^
534 FcValueListHash (FcPatternEltValues(&pe[i])(((((intptr_t) ((&pe[i])->values)) & 1) != 0) ? ((
FcValueList *) ((intptr_t) (&pe[i]) + ((((intptr_t) ((&
pe[i])->values)) & ~1)))) : (&pe[i])->values)
));
535 }
536 return h;
537}
538
539FcBool
540FcPatternEqualSubset (const FcPattern *pai, const FcPattern *pbi, const FcObjectSet *os)
541{
542 FcPatternElt *ea, *eb;
543 int i;
544
545 for (i = 0; i < os->nobject; i++)
546 {
547 FcObject object = FcObjectFromName (os->objects[i]);
548 ea = FcPatternObjectFindElt (pai, object);
549 eb = FcPatternObjectFindElt (pbi, object);
550 if (ea)
551 {
552 if (!eb)
553 return FcFalse0;
554 if (!FcValueListEqual (FcPatternEltValues(ea)(((((intptr_t) ((ea)->values)) & 1) != 0) ? ((FcValueList
*) ((intptr_t) (ea) + ((((intptr_t) ((ea)->values)) &
~1)))) : (ea)->values)
, FcPatternEltValues(eb)(((((intptr_t) ((eb)->values)) & 1) != 0) ? ((FcValueList
*) ((intptr_t) (eb) + ((((intptr_t) ((eb)->values)) &
~1)))) : (eb)->values)
))
555 return FcFalse0;
556 }
557 else
558 {
559 if (eb)
560 return FcFalse0;
561 }
562 }
563 return FcTrue1;
564}
565
566FcBool
567FcPatternObjectListAdd (FcPattern *p,
568 FcObject object,
569 FcValueListPtr list,
570 FcBool append)
571{
572 FcPatternElt *e;
573 FcValueListPtr l, *prev;
574
575 if (FcRefIsConst (&p->ref))
576 goto bail0;
577
578 /*
579 * Make sure the stored type is valid for built-in objects
580 */
581 for (l = list; l != NULL((void*)0); l = FcValueListNext (l)(((((intptr_t) ((l)->next)) & 1) != 0) ? ((FcValueList
*) ((intptr_t) (l) + ((((intptr_t) ((l)->next)) & ~1)
))) : (l)->next)
)
582 {
583 if (!FcObjectValidType (object, l->value.type))
584 {
585 fprintf (stderr__stderrp,
586 "Fontconfig warning: FcPattern object %s does not accept value", FcObjectName (object));
587 FcValuePrintFile (stderr__stderrp, l->value);
588 fprintf (stderr__stderrp, "\n");
589 goto bail0;
590 }
591 }
592
593 e = FcPatternObjectInsertElt (p, object);
594 if (!e)
595 goto bail0;
596
597 if (append)
598 {
599 for (prev = &e->values; *prev; prev = &(*prev)->next)
600 ;
601 *prev = list;
602 }
603 else
604 {
605 for (prev = &list; *prev; prev = &(*prev)->next)
606 ;
607 *prev = e->values;
608 e->values = list;
609 }
610
611 return FcTrue1;
612
613bail0:
614 return FcFalse0;
615}
616
617FcBool
618FcPatternObjectAddWithBinding (FcPattern *p,
619 FcObject object,
620 FcValue value,
621 FcValueBinding binding,
622 FcBool append)
623{
624 FcPatternElt *e;
625 FcValueListPtr new, *prev;
626
627 if (FcRefIsConst (&p->ref))
3
Taking false branch
628 goto bail0;
629
630 new = FcValueListCreate ();
631 if (!new)
4
Assuming 'new' is non-null
5
Taking false branch
632 goto bail0;
633
634 value = FcValueSave (value);
635 if (value.type == FcTypeVoid)
6
Taking false branch
636 goto bail1;
637
638 /*
639 * Make sure the stored type is valid for built-in objects
640 */
641 if (!FcObjectValidType (object, value.type))
7
Taking false branch
642 {
643 fprintf (stderr__stderrp,
644 "Fontconfig warning: FcPattern object %s does not accept value",
645 FcObjectName (object));
646 FcValuePrintFile (stderr__stderrp, value);
647 fprintf (stderr__stderrp, "\n");
648 goto bail1;
649 }
650
651 new->value = value;
652 new->binding = binding;
653 new->next = NULL((void*)0);
654
655 e = FcPatternObjectInsertElt (p, object);
8
Calling 'FcPatternObjectInsertElt'
656 if (!e)
657 goto bail2;
658
659 if (append)
660 {
661 for (prev = &e->values; *prev; prev = &(*prev)->next)
662 ;
663 *prev = new;
664 }
665 else
666 {
667 new->next = e->values;
668 e->values = new;
669 }
670
671 return FcTrue1;
672
673bail2:
674 FcValueDestroy (value);
675bail1:
676 free (new);
677bail0:
678 return FcFalse0;
679}
680
681FcBool
682FcPatternObjectAdd (FcPattern *p, FcObject object, FcValue value, FcBool append)
683{
684 return FcPatternObjectAddWithBinding (p, object,
685 value, FcValueBindingStrong, append);
686}
687
688FcBool
689FcPatternAdd (FcPattern *p, const char *object, FcValue value, FcBool append)
690{
691 return FcPatternObjectAddWithBinding (p, FcObjectFromName (object),
2
Calling 'FcPatternObjectAddWithBinding'
692 value, FcValueBindingStrong, append);
693}
694
695FcBool
696FcPatternAddWeak (FcPattern *p, const char *object, FcValue value, FcBool append)
697{
698 return FcPatternObjectAddWithBinding (p, FcObjectFromName (object),
699 value, FcValueBindingWeak, append);
700}
701
702FcBool
703FcPatternObjectDel (FcPattern *p, FcObject object)
704{
705 FcPatternElt *e;
706
707 e = FcPatternObjectFindElt (p, object);
708 if (!e)
709 return FcFalse0;
710
711 /* destroy value */
712 FcValueListDestroy (e->values);
713
714 /* shuffle existing ones down */
715 memmove (e, e+1,__builtin___memmove_chk (e, e+1, (((FcPatternElt *) ((intptr_t
) (p) + ((p)->elts_offset))) + p->num - (e + 1)) * sizeof
(FcPatternElt), __builtin_object_size (e, 0))
716 (FcPatternElts(p) + p->num - (e + 1)) *__builtin___memmove_chk (e, e+1, (((FcPatternElt *) ((intptr_t
) (p) + ((p)->elts_offset))) + p->num - (e + 1)) * sizeof
(FcPatternElt), __builtin_object_size (e, 0))
717 sizeof (FcPatternElt))__builtin___memmove_chk (e, e+1, (((FcPatternElt *) ((intptr_t
) (p) + ((p)->elts_offset))) + p->num - (e + 1)) * sizeof
(FcPatternElt), __builtin_object_size (e, 0))
;
718 p->num--;
719 e = FcPatternElts(p)((FcPatternElt *) ((intptr_t) (p) + ((p)->elts_offset))) + p->num;
720 e->object = 0;
721 e->values = NULL((void*)0);
722 return FcTrue1;
723}
724
725FcBool
726FcPatternDel (FcPattern *p, const char *object)
727{
728 return FcPatternObjectDel (p, FcObjectFromName (object));
729}
730
731FcBool
732FcPatternRemove (FcPattern *p, const char *object, int id)
733{
734 FcPatternElt *e;
735 FcValueListPtr *prev, l;
736
737 e = FcPatternObjectFindElt (p, FcObjectFromName (object));
738 if (!e)
739 return FcFalse0;
740 for (prev = &e->values; (l = *prev); prev = &l->next)
741 {
742 if (!id)
743 {
744 *prev = l->next;
745 l->next = NULL((void*)0);
746 FcValueListDestroy (l);
747 if (!e->values)
748 FcPatternDel (p, object);
749 return FcTrue1;
750 }
751 id--;
752 }
753 return FcFalse0;
754}
755
756FcBool
757FcPatternObjectAddInteger (FcPattern *p, FcObject object, int i)
758{
759 FcValue v;
760
761 v.type = FcTypeInteger;
762 v.u.i = i;
763 return FcPatternObjectAdd (p, object, v, FcTrue1);
764}
765
766FcBool
767FcPatternAddInteger (FcPattern *p, const char *object, int i)
768{
769 return FcPatternObjectAddInteger (p, FcObjectFromName (object), i);
770}
771
772FcBool
773FcPatternObjectAddDouble (FcPattern *p, FcObject object, double d)
774{
775 FcValue v;
776
777 v.type = FcTypeDouble;
778 v.u.d = d;
779 return FcPatternObjectAdd (p, object, v, FcTrue1);
780}
781
782
783FcBool
784FcPatternAddDouble (FcPattern *p, const char *object, double d)
785{
786 return FcPatternObjectAddDouble (p, FcObjectFromName (object), d);
787}
788
789FcBool
790FcPatternObjectAddString (FcPattern *p, FcObject object, const FcChar8 *s)
791{
792 FcValue v;
793
794 if (!s)
795 {
796 v.type = FcTypeVoid;
797 v.u.s = 0;
798 return FcPatternObjectAdd (p, object, v, FcTrue1);
799 }
800
801 v.type = FcTypeString;
802 v.u.s = s;
803 return FcPatternObjectAdd (p, object, v, FcTrue1);
804}
805
806FcBool
807FcPatternAddString (FcPattern *p, const char *object, const FcChar8 *s)
808{
809 return FcPatternObjectAddString (p, FcObjectFromName (object), s);
810}
811
812FcBool
813FcPatternAddMatrix (FcPattern *p, const char *object, const FcMatrix *s)
814{
815 FcValue v;
816
817 v.type = FcTypeMatrix;
818 v.u.m = s;
819 return FcPatternAdd (p, object, v, FcTrue1);
820}
821
822
823FcBool
824FcPatternObjectAddBool (FcPattern *p, FcObject object, FcBool b)
825{
826 FcValue v;
827
828 v.type = FcTypeBool;
829 v.u.b = b;
830 return FcPatternObjectAdd (p, object, v, FcTrue1);
831}
832
833FcBool
834FcPatternAddBool (FcPattern *p, const char *object, FcBool b)
835{
836 return FcPatternObjectAddBool (p, FcObjectFromName (object), b);
837}
838
839FcBool
840FcPatternAddCharSet (FcPattern *p, const char *object, const FcCharSet *c)
841{
842 FcValue v;
843
844 v.type = FcTypeCharSet;
845 v.u.c = (FcCharSet *)c;
846 return FcPatternAdd (p, object, v, FcTrue1);
847}
848
849FcBool
850FcPatternAddFTFace (FcPattern *p, const char *object, const FT_Face f)
851{
852 FcValue v;
853
854 v.type = FcTypeFTFace;
855 v.u.f = (void *) f;
856 return FcPatternAdd (p, object, v, FcTrue1);
1
Calling 'FcPatternAdd'
857}
858
859FcBool
860FcPatternAddLangSet (FcPattern *p, const char *object, const FcLangSet *ls)
861{
862 FcValue v;
863
864 v.type = FcTypeLangSet;
865 v.u.l = (FcLangSet *)ls;
866 return FcPatternAdd (p, object, v, FcTrue1);
867}
868
869FcBool
870FcPatternObjectAddRange (FcPattern *p, FcObject object, const FcRange *r)
871{
872 FcValue v;
873
874 v.type = FcTypeRange;
875 v.u.r = (FcRange *)r;
876 return FcPatternObjectAdd (p, object, v, FcTrue1);
877}
878
879FcBool
880FcPatternAddRange (FcPattern *p, const char *object, const FcRange *r)
881{
882 return FcPatternObjectAddRange (p, FcObjectFromName (object), r);
883}
884
885FcResult
886FcPatternObjectGet (const FcPattern *p, FcObject object, int id, FcValue *v)
887{
888 FcPatternElt *e;
889 FcValueListPtr l;
890
891 if (!p)
892 return FcResultNoMatch;
893 e = FcPatternObjectFindElt (p, object);
894 if (!e)
895 return FcResultNoMatch;
896 for (l = FcPatternEltValues(e)(((((intptr_t) ((e)->values)) & 1) != 0) ? ((FcValueList
*) ((intptr_t) (e) + ((((intptr_t) ((e)->values)) & ~
1)))) : (e)->values)
; l; l = FcValueListNext(l)(((((intptr_t) ((l)->next)) & 1) != 0) ? ((FcValueList
*) ((intptr_t) (l) + ((((intptr_t) ((l)->next)) & ~1)
))) : (l)->next)
)
897 {
898 if (!id)
899 {
900 *v = FcValueCanonicalize(&l->value);
901 return FcResultMatch;
902 }
903 id--;
904 }
905 return FcResultNoId;
906}
907
908FcResult
909FcPatternGet (const FcPattern *p, const char *object, int id, FcValue *v)
910{
911 return FcPatternObjectGet (p, FcObjectFromName (object), id, v);
912}
913
914FcResult
915FcPatternObjectGetInteger (const FcPattern *p, FcObject object, int id, int *i)
916{
917 FcValue v;
918 FcResult r;
919
920 r = FcPatternObjectGet (p, object, id, &v);
921 if (r != FcResultMatch)
922 return r;
923 switch ((int) v.type) {
924 case FcTypeDouble:
925 *i = (int) v.u.d;
926 break;
927 case FcTypeInteger:
928 *i = v.u.i;
929 break;
930 default:
931 return FcResultTypeMismatch;
932 }
933 return FcResultMatch;
934}
935
936FcResult
937FcPatternGetInteger (const FcPattern *p, const char *object, int id, int *i)
938{
939 return FcPatternObjectGetInteger (p, FcObjectFromName (object), id, i);
940}
941
942
943FcResult
944FcPatternObjectGetDouble (const FcPattern *p, FcObject object, int id, double *d)
945{
946 FcValue v;
947 FcResult r;
948
949 r = FcPatternObjectGet (p, object, id, &v);
950 if (r != FcResultMatch)
951 return r;
952 switch ((int) v.type) {
953 case FcTypeDouble:
954 *d = v.u.d;
955 break;
956 case FcTypeInteger:
957 *d = (double) v.u.i;
958 break;
959 default:
960 return FcResultTypeMismatch;
961 }
962 return FcResultMatch;
963}
964
965FcResult
966FcPatternGetDouble (const FcPattern *p, const char *object, int id, double *d)
967{
968 return FcPatternObjectGetDouble (p, FcObjectFromName (object), id, d);
969}
970
971FcResult
972FcPatternObjectGetString (const FcPattern *p, FcObject object, int id, FcChar8 ** s)
973{
974 FcValue v;
975 FcResult r;
976
977 r = FcPatternObjectGet (p, object, id, &v);
978 if (r != FcResultMatch)
979 return r;
980 if (v.type != FcTypeString)
981 return FcResultTypeMismatch;
982
983 *s = (FcChar8 *) v.u.s;
984 return FcResultMatch;
985}
986
987FcResult
988FcPatternGetString (const FcPattern *p, const char *object, int id, FcChar8 ** s)
989{
990 return FcPatternObjectGetString (p, FcObjectFromName (object), id, s);
991}
992
993FcResult
994FcPatternGetMatrix(const FcPattern *p, const char *object, int id, FcMatrix **m)
995{
996 FcValue v;
997 FcResult r;
998
999 r = FcPatternGet (p, object, id, &v);
1000 if (r != FcResultMatch)
1001 return r;
1002 if (v.type != FcTypeMatrix)
1003 return FcResultTypeMismatch;
1004 *m = (FcMatrix *)v.u.m;
1005 return FcResultMatch;
1006}
1007
1008
1009FcResult
1010FcPatternGetBool(const FcPattern *p, const char *object, int id, FcBool *b)
1011{
1012 FcValue v;
1013 FcResult r;
1014
1015 r = FcPatternGet (p, object, id, &v);
1016 if (r != FcResultMatch)
1017 return r;
1018 if (v.type != FcTypeBool)
1019 return FcResultTypeMismatch;
1020 *b = v.u.b;
1021 return FcResultMatch;
1022}
1023
1024FcResult
1025FcPatternGetCharSet(const FcPattern *p, const char *object, int id, FcCharSet **c)
1026{
1027 FcValue v;
1028 FcResult r;
1029
1030 r = FcPatternGet (p, object, id, &v);
1031 if (r != FcResultMatch)
1032 return r;
1033 if (v.type != FcTypeCharSet)
1034 return FcResultTypeMismatch;
1035 *c = (FcCharSet *)v.u.c;
1036 return FcResultMatch;
1037}
1038
1039FcResult
1040FcPatternGetFTFace(const FcPattern *p, const char *object, int id, FT_Face *f)
1041{
1042 FcValue v;
1043 FcResult r;
1044
1045 r = FcPatternGet (p, object, id, &v);
1046 if (r != FcResultMatch)
1047 return r;
1048 if (v.type != FcTypeFTFace)
1049 return FcResultTypeMismatch;
1050 *f = (FT_Face) v.u.f;
1051 return FcResultMatch;
1052}
1053
1054FcResult
1055FcPatternGetLangSet(const FcPattern *p, const char *object, int id, FcLangSet **ls)
1056{
1057 FcValue v;
1058 FcResult r;
1059
1060 r = FcPatternGet (p, object, id, &v);
1061 if (r != FcResultMatch)
1062 return r;
1063 if (v.type != FcTypeLangSet)
1064 return FcResultTypeMismatch;
1065 *ls = (FcLangSet *)v.u.l;
1066 return FcResultMatch;
1067}
1068
1069FcResult
1070FcPatternObjectGetRange (const FcPattern *p, FcObject object, int id, FcRange **r)
1071{
1072 FcValue v;
1073 FcResult res;
1074
1075 res = FcPatternObjectGet (p, object, id, &v);
1076 if (res != FcResultMatch)
1077 return res;
1078 switch ((int)v.type) {
1079 case FcTypeRange:
1080 *r = (FcRange *)v.u.r;
1081 break;
1082 default:
1083 return FcResultTypeMismatch;
1084 }
1085 return FcResultMatch;
1086}
1087
1088FcResult
1089FcPatternGetRange (const FcPattern *p, const char *object, int id, FcRange **r)
1090{
1091 return FcPatternObjectGetRange (p, FcObjectFromName (object), id, r);
1092}
1093
1094FcPattern *
1095FcPatternDuplicate (const FcPattern *orig)
1096{
1097 FcPattern *new;
1098 FcPatternElt *e;
1099 int i;
1100 FcValueListPtr l;
1101
1102 new = FcPatternCreate ();
1103 if (!new)
1104 goto bail0;
1105
1106 e = FcPatternElts(orig)((FcPatternElt *) ((intptr_t) (orig) + ((orig)->elts_offset
)))
;
1107
1108 for (i = 0; i < orig->num; i++)
1109 {
1110 for (l = FcPatternEltValues(e + i)(((((intptr_t) ((e + i)->values)) & 1) != 0) ? ((FcValueList
*) ((intptr_t) (e + i) + ((((intptr_t) ((e + i)->values))
& ~1)))) : (e + i)->values)
; l; l = FcValueListNext(l)(((((intptr_t) ((l)->next)) & 1) != 0) ? ((FcValueList
*) ((intptr_t) (l) + ((((intptr_t) ((l)->next)) & ~1)
))) : (l)->next)
)
1111 {
1112 if (!FcPatternObjectAddWithBinding (new, e[i].object,
1113 FcValueCanonicalize(&l->value),
1114 l->binding,
1115 FcTrue1))
1116 goto bail1;
1117
1118 }
1119 }
1120
1121 return new;
1122
1123bail1:
1124 FcPatternDestroy (new);
1125bail0:
1126 return 0;
1127}
1128
1129void
1130FcPatternReference (FcPattern *p)
1131{
1132 if (!FcRefIsConst (&p->ref))
1133 FcRefInc (&p->ref);
1134 else
1135 FcCacheObjectReference (p);
1136}
1137
1138FcPattern *
1139FcPatternVaBuild (FcPattern *p, va_list va)
1140{
1141 FcPattern *ret;
1142
1143 FcPatternVapBuild (ret, p, va){ FcPattern *__p__ = (p); const char *__o__; FcValue __v__; if
(!__p__) { __p__ = FcPatternCreate (); if (!__p__) goto _FcPatternVapBuild_bail0
; } for (;;) { __o__ = __builtin_va_arg(va, const char *); if
(!__o__) break; __v__.type = __builtin_va_arg(va, int); switch
(__v__.type) { case FcTypeUnknown: case FcTypeVoid: goto _FcPatternVapBuild_bail1
; case FcTypeInteger: __v__.u.i = __builtin_va_arg(va, int); break
; case FcTypeDouble: __v__.u.d = __builtin_va_arg(va, double)
; break; case FcTypeString: __v__.u.s = __builtin_va_arg(va, const
FcChar8 *); break; case FcTypeBool: __v__.u.b = __builtin_va_arg
(va, FcBool); break; case FcTypeMatrix: __v__.u.m = __builtin_va_arg
(va, const FcMatrix *); break; case FcTypeCharSet: __v__.u.c =
__builtin_va_arg(va, const FcCharSet *); break; case FcTypeFTFace
: __v__.u.f = __builtin_va_arg(va, FT_Face); break; case FcTypeLangSet
: __v__.u.l = __builtin_va_arg(va, const FcLangSet *); break;
case FcTypeRange: __v__.u.r = __builtin_va_arg(va, const FcRange
*); break; } if (!FcPatternAdd (__p__, __o__, __v__, 1)) goto
_FcPatternVapBuild_bail1; } ret = __p__; goto _FcPatternVapBuild_return
; _FcPatternVapBuild_bail1: if (!p) FcPatternDestroy (__p__);
_FcPatternVapBuild_bail0: ret = (void*)0; _FcPatternVapBuild_return
: ; }
;
1144 return ret;
1145}
1146
1147FcPattern *
1148FcPatternBuild (FcPattern *p, ...)
1149{
1150 va_list va;
1151
1152 va_start (va, p)__builtin_va_start(va, p);
1153 FcPatternVapBuild (p, p, va){ FcPattern *__p__ = (p); const char *__o__; FcValue __v__; if
(!__p__) { __p__ = FcPatternCreate (); if (!__p__) goto _FcPatternVapBuild_bail0
; } for (;;) { __o__ = __builtin_va_arg(va, const char *); if
(!__o__) break; __v__.type = __builtin_va_arg(va, int); switch
(__v__.type) { case FcTypeUnknown: case FcTypeVoid: goto _FcPatternVapBuild_bail1
; case FcTypeInteger: __v__.u.i = __builtin_va_arg(va, int); break
; case FcTypeDouble: __v__.u.d = __builtin_va_arg(va, double)
; break; case FcTypeString: __v__.u.s = __builtin_va_arg(va, const
FcChar8 *); break; case FcTypeBool: __v__.u.b = __builtin_va_arg
(va, FcBool); break; case FcTypeMatrix: __v__.u.m = __builtin_va_arg
(va, const FcMatrix *); break; case FcTypeCharSet: __v__.u.c =
__builtin_va_arg(va, const FcCharSet *); break; case FcTypeFTFace
: __v__.u.f = __builtin_va_arg(va, FT_Face); break; case FcTypeLangSet
: __v__.u.l = __builtin_va_arg(va, const FcLangSet *); break;
case FcTypeRange: __v__.u.r = __builtin_va_arg(va, const FcRange
*); break; } if (!FcPatternAdd (__p__, __o__, __v__, 1)) goto
_FcPatternVapBuild_bail1; } p = __p__; goto _FcPatternVapBuild_return
; _FcPatternVapBuild_bail1: if (!p) FcPatternDestroy (__p__);
_FcPatternVapBuild_bail0: p = (void*)0; _FcPatternVapBuild_return
: ; }
;
1154 va_end (va)__builtin_va_end(va);
1155 return p;
1156}
1157
1158/*
1159 * Add all of the elements in 's' to 'p'
1160 */
1161FcBool
1162FcPatternAppend (FcPattern *p, FcPattern *s)
1163{
1164 int i;
1165 FcPatternElt *e;
1166 FcValueListPtr v;
1167
1168 for (i = 0; i < s->num; i++)
1169 {
1170 e = FcPatternElts(s)((FcPatternElt *) ((intptr_t) (s) + ((s)->elts_offset)))+i;
1171 for (v = FcPatternEltValues(e)(((((intptr_t) ((e)->values)) & 1) != 0) ? ((FcValueList
*) ((intptr_t) (e) + ((((intptr_t) ((e)->values)) & ~
1)))) : (e)->values)
; v; v = FcValueListNext(v)(((((intptr_t) ((v)->next)) & 1) != 0) ? ((FcValueList
*) ((intptr_t) (v) + ((((intptr_t) ((v)->next)) & ~1)
))) : (v)->next)
)
1172 {
1173 if (!FcPatternObjectAddWithBinding (p, e->object,
1174 FcValueCanonicalize(&v->value),
1175 v->binding, FcTrue1))
1176 return FcFalse0;
1177 }
1178 }
1179 return FcTrue1;
1180}
1181
1182FcPattern *
1183FcPatternFilter (FcPattern *p, const FcObjectSet *os)
1184{
1185 int i;
1186 FcPattern *ret;
1187 FcPatternElt *e;
1188 FcValueListPtr v;
1189
1190 if (!os)
1191 return FcPatternDuplicate (p);
1192
1193 ret = FcPatternCreate ();
1194 if (!ret)
1195 return NULL((void*)0);
1196
1197 for (i = 0; i < os->nobject; i++)
1198 {
1199 FcObject object = FcObjectFromName (os->objects[i]);
1200 e = FcPatternObjectFindElt (p, object);
1201 if (e)
1202 {
1203 for (v = FcPatternEltValues(e)(((((intptr_t) ((e)->values)) & 1) != 0) ? ((FcValueList
*) ((intptr_t) (e) + ((((intptr_t) ((e)->values)) & ~
1)))) : (e)->values)
; v; v = FcValueListNext(v)(((((intptr_t) ((v)->next)) & 1) != 0) ? ((FcValueList
*) ((intptr_t) (v) + ((((intptr_t) ((v)->next)) & ~1)
))) : (v)->next)
)
1204 {
1205 if (!FcPatternObjectAddWithBinding (ret, e->object,
1206 FcValueCanonicalize(&v->value),
1207 v->binding, FcTrue1))
1208 goto bail0;
1209 }
1210 }
1211 }
1212 return ret;
1213
1214bail0:
1215 FcPatternDestroy (ret);
1216 return NULL((void*)0);
1217}
1218
1219
1220FcBool
1221FcPatternSerializeAlloc (FcSerialize *serialize, const FcPattern *pat)
1222{
1223 int i;
1224 FcPatternElt *elts = FcPatternElts(pat)((FcPatternElt *) ((intptr_t) (pat) + ((pat)->elts_offset)
))
;
1225
1226 if (!FcSerializeAlloc (serialize, pat, sizeof (FcPattern)))
1227 return FcFalse0;
1228 if (!FcSerializeAlloc (serialize, elts, pat->num * sizeof (FcPatternElt)))
1229 return FcFalse0;
1230 for (i = 0; i < pat->num; i++)
1231 if (!FcValueListSerializeAlloc (serialize, FcPatternEltValues(elts+i)(((((intptr_t) ((elts+i)->values)) & 1) != 0) ? ((FcValueList
*) ((intptr_t) (elts+i) + ((((intptr_t) ((elts+i)->values
)) & ~1)))) : (elts+i)->values)
))
1232 return FcFalse0;
1233 return FcTrue1;
1234}
1235
1236FcPattern *
1237FcPatternSerialize (FcSerialize *serialize, const FcPattern *pat)
1238{
1239 FcPattern *pat_serialized;
1240 FcPatternElt *elts = FcPatternElts (pat)((FcPatternElt *) ((intptr_t) (pat) + ((pat)->elts_offset)
))
;
1241 FcPatternElt *elts_serialized;
1242 FcValueList *values_serialized;
1243 int i;
1244
1245 pat_serialized = FcSerializePtr (serialize, pat);
1246 if (!pat_serialized)
1247 return NULL((void*)0);
1248 *pat_serialized = *pat;
1249 pat_serialized->size = pat->num;
1250 FcRefSetConst (&pat_serialized->ref);
1251
1252 elts_serialized = FcSerializePtr (serialize, elts);
1253 if (!elts_serialized)
1254 return NULL((void*)0);
1255
1256 pat_serialized->elts_offset = FcPtrToOffset (pat_serialized,((intptr_t) (elts_serialized) - (intptr_t) (pat_serialized))
1257 elts_serialized)((intptr_t) (elts_serialized) - (intptr_t) (pat_serialized));
1258
1259 for (i = 0; i < pat->num; i++)
1260 {
1261 values_serialized = FcValueListSerialize (serialize, FcPatternEltValues (elts+i)(((((intptr_t) ((elts+i)->values)) & 1) != 0) ? ((FcValueList
*) ((intptr_t) (elts+i) + ((((intptr_t) ((elts+i)->values
)) & ~1)))) : (elts+i)->values)
);
1262 if (!values_serialized)
1263 return NULL((void*)0);
1264 elts_serialized[i].object = elts[i].object;
1265 elts_serialized[i].values = FcPtrToEncodedOffset (&elts_serialized[i],((FcValueList *) ((((intptr_t) (values_serialized) - (intptr_t
) (&elts_serialized[i]))) | 1))
1266 values_serialized,((FcValueList *) ((((intptr_t) (values_serialized) - (intptr_t
) (&elts_serialized[i]))) | 1))
1267 FcValueList)((FcValueList *) ((((intptr_t) (values_serialized) - (intptr_t
) (&elts_serialized[i]))) | 1))
;
1268 }
1269 if (FcDebug()(FcDebugVal) & FC_DBG_CACHEV32) {
1270 printf ("Raw pattern:\n");
1271 FcPatternPrint (pat);
1272 printf ("Serialized pattern:\n");
1273 FcPatternPrint (pat_serialized);
1274 printf ("\n");
1275 }
1276 return pat_serialized;
1277}
1278
1279FcBool
1280FcValueListSerializeAlloc (FcSerialize *serialize, const FcValueList *vl)
1281{
1282 while (vl)
1283 {
1284 if (!FcSerializeAlloc (serialize, vl, sizeof (FcValueList)))
1285 return FcFalse0;
1286 switch ((int) vl->value.type) {
1287 case FcTypeString:
1288 if (!FcStrSerializeAlloc (serialize, vl->value.u.s))
1289 return FcFalse0;
1290 break;
1291 case FcTypeCharSet:
1292 if (!FcCharSetSerializeAlloc (serialize, vl->value.u.c))
1293 return FcFalse0;
1294 break;
1295 case FcTypeLangSet:
1296 if (!FcLangSetSerializeAlloc (serialize, vl->value.u.l))
1297 return FcFalse0;
1298 break;
1299 case FcTypeRange:
1300 if (!FcRangeSerializeAlloc (serialize, vl->value.u.r))
1301 return FcFalse0;
1302 break;
1303 default:
1304 break;
1305 }
1306 vl = vl->next;
1307 }
1308 return FcTrue1;
1309}
1310
1311FcValueList *
1312FcValueListSerialize (FcSerialize *serialize, const FcValueList *vl)
1313{
1314 FcValueList *vl_serialized;
1315 FcChar8 *s_serialized;
1316 FcCharSet *c_serialized;
1317 FcLangSet *l_serialized;
1318 FcRange *r_serialized;
1319 FcValueList *head_serialized = NULL((void*)0);
1320 FcValueList *prev_serialized = NULL((void*)0);
1321
1322 while (vl)
1323 {
1324 vl_serialized = FcSerializePtr (serialize, vl);
1325 if (!vl_serialized)
1326 return NULL((void*)0);
1327
1328 if (prev_serialized)
1329 prev_serialized->next = FcPtrToEncodedOffset (prev_serialized,((FcValueList *) ((((intptr_t) (vl_serialized) - (intptr_t) (
prev_serialized))) | 1))
1330 vl_serialized,((FcValueList *) ((((intptr_t) (vl_serialized) - (intptr_t) (
prev_serialized))) | 1))
1331 FcValueList)((FcValueList *) ((((intptr_t) (vl_serialized) - (intptr_t) (
prev_serialized))) | 1))
;
1332 else
1333 head_serialized = vl_serialized;
1334
1335 vl_serialized->next = NULL((void*)0);
1336 vl_serialized->value.type = vl->value.type;
1337 switch ((int) vl->value.type) {
1338 case FcTypeInteger:
1339 vl_serialized->value.u.i = vl->value.u.i;
1340 break;
1341 case FcTypeDouble:
1342 vl_serialized->value.u.d = vl->value.u.d;
1343 break;
1344 case FcTypeString:
1345 s_serialized = FcStrSerialize (serialize, vl->value.u.s);
1346 if (!s_serialized)
1347 return NULL((void*)0);
1348 vl_serialized->value.u.s = FcPtrToEncodedOffset (&vl_serialized->value,((FcChar8 *) ((((intptr_t) (s_serialized) - (intptr_t) (&
vl_serialized->value))) | 1))
1349 s_serialized,((FcChar8 *) ((((intptr_t) (s_serialized) - (intptr_t) (&
vl_serialized->value))) | 1))
1350 FcChar8)((FcChar8 *) ((((intptr_t) (s_serialized) - (intptr_t) (&
vl_serialized->value))) | 1))
;
1351 break;
1352 case FcTypeBool:
1353 vl_serialized->value.u.b = vl->value.u.b;
1354 break;
1355 case FcTypeMatrix:
1356 /* can't happen */
1357 break;
1358 case FcTypeCharSet:
1359 c_serialized = FcCharSetSerialize (serialize, vl->value.u.c);
1360 if (!c_serialized)
1361 return NULL((void*)0);
1362 vl_serialized->value.u.c = FcPtrToEncodedOffset (&vl_serialized->value,((FcCharSet *) ((((intptr_t) (c_serialized) - (intptr_t) (&
vl_serialized->value))) | 1))
1363 c_serialized,((FcCharSet *) ((((intptr_t) (c_serialized) - (intptr_t) (&
vl_serialized->value))) | 1))
1364 FcCharSet)((FcCharSet *) ((((intptr_t) (c_serialized) - (intptr_t) (&
vl_serialized->value))) | 1))
;
1365 break;
1366 case FcTypeFTFace:
1367 /* can't happen */
1368 break;
1369 case FcTypeLangSet:
1370 l_serialized = FcLangSetSerialize (serialize, vl->value.u.l);
1371 if (!l_serialized)
1372 return NULL((void*)0);
1373 vl_serialized->value.u.l = FcPtrToEncodedOffset (&vl_serialized->value,((FcLangSet *) ((((intptr_t) (l_serialized) - (intptr_t) (&
vl_serialized->value))) | 1))
1374 l_serialized,((FcLangSet *) ((((intptr_t) (l_serialized) - (intptr_t) (&
vl_serialized->value))) | 1))
1375 FcLangSet)((FcLangSet *) ((((intptr_t) (l_serialized) - (intptr_t) (&
vl_serialized->value))) | 1))
;
1376 break;
1377 case FcTypeRange:
1378 r_serialized = FcRangeSerialize (serialize, vl->value.u.r);
1379 if (!r_serialized)
1380 return NULL((void*)0);
1381 vl_serialized->value.u.r = FcPtrToEncodedOffset (&vl_serialized->value,((FcRange *) ((((intptr_t) (r_serialized) - (intptr_t) (&
vl_serialized->value))) | 1))
1382 r_serialized,((FcRange *) ((((intptr_t) (r_serialized) - (intptr_t) (&
vl_serialized->value))) | 1))
1383 FcRange)((FcRange *) ((((intptr_t) (r_serialized) - (intptr_t) (&
vl_serialized->value))) | 1))
;
1384 break;
1385 default:
1386 break;
1387 }
1388 prev_serialized = vl_serialized;
1389 vl = vl->next;
1390 }
1391 return head_serialized;
1392}
1393
1394#define __fcpat__
1395#include "fcaliastail.h"
1396#include "fcftaliastail.h"
1397#undef __fcpat__