2 * Copyright © 2000 Keith Packard
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.
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.
26 /* Objects MT-safe for readonly access. */
29 FcPatternCreate (void)
33 p = (FcPattern *) malloc (sizeof (FcPattern));
36 memset (p, 0, sizeof (FcPattern));
39 p->elts_offset = FcPtrToOffset (p, NULL);
40 FcRefInit (&p->ref, 1);
45 FcValueDestroy (FcValue v)
47 switch ((int) v.type) {
52 FcMatrixFree ((FcMatrix *) v.u.m);
55 FcCharSetDestroy ((FcCharSet *) v.u.c);
58 FcLangSetDestroy ((FcLangSet *) v.u.l);
61 FcRangeDestroy ((FcRange *) v.u.r);
69 FcValueCanonicalize (const FcValue *v)
73 switch ((int) v->type)
76 new.u.s = FcValueString(v);
77 new.type = FcTypeString;
80 new.u.c = FcValueCharSet(v);
81 new.type = FcTypeCharSet;
84 new.u.l = FcValueLangSet(v);
85 new.type = FcTypeLangSet;
88 new.u.r = FcValueRange(v);
89 new.type = FcTypeRange;
99 FcValueSave (FcValue v)
101 switch ((int) v.type) {
103 v.u.s = FcStrdup (v.u.s);
108 v.u.m = FcMatrixCopy (v.u.m);
113 v.u.c = FcCharSetCopy ((FcCharSet *) v.u.c);
118 v.u.l = FcLangSetCopy (v.u.l);
123 v.u.r = FcRangeCopy (v.u.r);
134 FcValueListCreate (void)
136 return calloc (1, sizeof (FcValueList));
140 FcValueListDestroy (FcValueListPtr l)
145 switch ((int) l->value.type) {
147 FcFree (l->value.u.s);
150 FcMatrixFree ((FcMatrix *)l->value.u.m);
154 ((FcCharSet *) (l->value.u.c));
158 ((FcLangSet *) (l->value.u.l));
161 FcRangeDestroy ((FcRange *) (l->value.u.r));
166 next = FcValueListNext(l);
172 FcValueListPrepend (FcValueListPtr vallist,
174 FcValueBinding binding)
178 if (value.type == FcTypeVoid)
180 new = FcValueListCreate ();
184 new->value = FcValueSave (value);
185 new->binding = binding;
192 FcValueListAppend (FcValueListPtr vallist,
194 FcValueBinding binding)
196 FcValueListPtr new, last;
198 if (value.type == FcTypeVoid)
200 new = FcValueListCreate ();
204 new->value = FcValueSave (value);
205 new->binding = binding;
210 for (last = vallist; FcValueListNext (last); last = FcValueListNext (last));
221 FcValueListDuplicate(FcValueListPtr orig)
223 FcValueListPtr new = NULL, l, t = NULL;
226 for (l = orig; l != NULL; l = FcValueListNext (l))
230 t = new = FcValueListCreate();
234 t->next = FcValueListCreate();
235 t = FcValueListNext (t);
237 v = FcValueCanonicalize (&l->value);
238 t->value = FcValueSave (v);
239 t->binding = l->binding;
247 FcValueEqual (FcValue va, FcValue vb)
249 if (va.type != vb.type)
251 if (va.type == FcTypeInteger)
253 va.type = FcTypeDouble;
256 if (vb.type == FcTypeInteger)
258 vb.type = FcTypeDouble;
261 if (va.type != vb.type)
266 return FcFalse; /* don't know how to compare this object */
270 return va.u.i == vb.u.i;
272 return va.u.d == vb.u.d;
274 return FcStrCmpIgnoreCase (va.u.s, vb.u.s) == 0;
276 return va.u.b == vb.u.b;
278 return FcMatrixEqual (va.u.m, vb.u.m);
280 return FcCharSetEqual (va.u.c, vb.u.c);
282 return va.u.f == vb.u.f;
284 return FcLangSetEqual (va.u.l, vb.u.l);
286 return FcRangeIsInRange (va.u.r, vb.u.r);
292 FcDoubleHash (double d)
302 FcStringHash (const FcChar8 *s)
309 h = ((h << 1) | (h >> 31)) ^ c;
314 FcValueHash (const FcValue *v)
321 return (FcChar32) v->u.i;
323 return FcDoubleHash (v->u.d);
325 return FcStringHash (FcValueString(v));
327 return (FcChar32) v->u.b;
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));
334 return (FcChar32) FcValueCharSet(v)->num;
336 return FcStringHash ((const FcChar8 *) ((FT_Face) v->u.f)->family_name) ^
337 FcStringHash ((const FcChar8 *) ((FT_Face) v->u.f)->style_name);
339 return FcLangSetHash (FcValueLangSet(v));
341 return FcRangeHash (v->u.r);
347 FcValueListEqual (FcValueListPtr la, FcValueListPtr lb)
354 if (!FcValueEqual (la->value, lb->value))
356 la = FcValueListNext(la);
357 lb = FcValueListNext(lb);
365 FcValueListHash (FcValueListPtr l)
369 for (; l; l = FcValueListNext(l))
371 hash = ((hash << 1) | (hash >> 31)) ^ FcValueHash (&l->value);
377 FcPatternDestroy (FcPattern *p)
385 if (FcRefIsConst (&p->ref))
387 FcCacheObjectDereference (p);
391 if (FcRefDec (&p->ref) != 1)
394 elts = FcPatternElts (p);
395 for (i = 0; i < p->num; i++)
396 FcValueListDestroy (FcPatternEltValues(&elts[i]));
403 FcPatternObjectPosition (const FcPattern *p, FcObject object)
405 int low, high, mid, c;
406 FcPatternElt *elts = FcPatternElts(p);
414 mid = (low + high) >> 1;
415 c = elts[mid].object - object;
429 FcPatternPosition (const FcPattern *p, const char *object)
431 return FcPatternObjectPosition (p, FcObjectFromName (object));
435 FcPatternObjectFindElt (const FcPattern *p, FcObject object)
437 int i = FcPatternObjectPosition (p, object);
440 return &FcPatternElts(p)[i];
444 FcPatternObjectInsertElt (FcPattern *p, FcObject object)
449 i = FcPatternObjectPosition (p, object);
454 /* reallocate array */
455 if (p->num + 1 >= p->size)
457 int s = p->size + 16;
460 FcPatternElt *e0 = FcPatternElts(p);
461 e = (FcPatternElt *) realloc (e0, s * sizeof (FcPatternElt));
462 if (!e) /* maybe it was mmapped */
464 e = malloc(s * sizeof (FcPatternElt));
466 memcpy(e, e0, p->num * sizeof (FcPatternElt));
470 e = (FcPatternElt *) malloc (s * sizeof (FcPatternElt));
473 p->elts_offset = FcPtrToOffset (p, e);
476 e[p->size].object = 0;
477 e[p->size].values = NULL;
482 e = FcPatternElts(p);
486 sizeof (FcPatternElt) *
492 e[i].object = object;
496 return FcPatternElts(p) + i;
500 FcPatternEqual (const FcPattern *pa, const FcPattern *pb)
503 FcPatternElt *pae, *pbe;
508 if (pa->num != pb->num)
510 pae = FcPatternElts(pa);
511 pbe = FcPatternElts(pb);
512 for (i = 0; i < pa->num; i++)
514 if (pae[i].object != pbe[i].object)
516 if (!FcValueListEqual (FcPatternEltValues(&pae[i]),
517 FcPatternEltValues(&pbe[i])))
524 FcPatternHash (const FcPattern *p)
528 FcPatternElt *pe = FcPatternElts(p);
530 for (i = 0; i < p->num; i++)
532 h = (((h << 1) | (h >> 31)) ^
534 FcValueListHash (FcPatternEltValues(&pe[i])));
540 FcPatternEqualSubset (const FcPattern *pai, const FcPattern *pbi, const FcObjectSet *os)
542 FcPatternElt *ea, *eb;
545 for (i = 0; i < os->nobject; i++)
547 FcObject object = FcObjectFromName (os->objects[i]);
548 ea = FcPatternObjectFindElt (pai, object);
549 eb = FcPatternObjectFindElt (pbi, object);
554 if (!FcValueListEqual (FcPatternEltValues(ea), FcPatternEltValues(eb)))
567 FcPatternObjectListAdd (FcPattern *p,
573 FcValueListPtr l, *prev;
575 if (FcRefIsConst (&p->ref))
579 * Make sure the stored type is valid for built-in objects
581 for (l = list; l != NULL; l = FcValueListNext (l))
583 if (!FcObjectValidType (object, l->value.type))
586 "Fontconfig warning: FcPattern object %s does not accept value", FcObjectName (object));
587 FcValuePrintFile (stderr, l->value);
588 fprintf (stderr, "\n");
593 e = FcPatternObjectInsertElt (p, object);
599 for (prev = &e->values; *prev; prev = &(*prev)->next)
605 for (prev = &list; *prev; prev = &(*prev)->next)
618 FcPatternObjectAddWithBinding (FcPattern *p,
621 FcValueBinding binding,
625 FcValueListPtr new, *prev;
627 if (FcRefIsConst (&p->ref))
630 new = FcValueListCreate ();
634 value = FcValueSave (value);
635 if (value.type == FcTypeVoid)
639 * Make sure the stored type is valid for built-in objects
641 if (!FcObjectValidType (object, value.type))
644 "Fontconfig warning: FcPattern object %s does not accept value",
645 FcObjectName (object));
646 FcValuePrintFile (stderr, value);
647 fprintf (stderr, "\n");
652 new->binding = binding;
655 e = FcPatternObjectInsertElt (p, object);
661 for (prev = &e->values; *prev; prev = &(*prev)->next)
667 new->next = e->values;
674 FcValueDestroy (value);
682 FcPatternObjectAdd (FcPattern *p, FcObject object, FcValue value, FcBool append)
684 return FcPatternObjectAddWithBinding (p, object,
685 value, FcValueBindingStrong, append);
689 FcPatternAdd (FcPattern *p, const char *object, FcValue value, FcBool append)
691 return FcPatternObjectAddWithBinding (p, FcObjectFromName (object),
692 value, FcValueBindingStrong, append);
696 FcPatternAddWeak (FcPattern *p, const char *object, FcValue value, FcBool append)
698 return FcPatternObjectAddWithBinding (p, FcObjectFromName (object),
699 value, FcValueBindingWeak, append);
703 FcPatternObjectDel (FcPattern *p, FcObject object)
707 e = FcPatternObjectFindElt (p, object);
712 FcValueListDestroy (e->values);
714 /* shuffle existing ones down */
716 (FcPatternElts(p) + p->num - (e + 1)) *
717 sizeof (FcPatternElt));
719 e = FcPatternElts(p) + p->num;
726 FcPatternDel (FcPattern *p, const char *object)
728 return FcPatternObjectDel (p, FcObjectFromName (object));
732 FcPatternRemove (FcPattern *p, const char *object, int id)
735 FcValueListPtr *prev, l;
737 e = FcPatternObjectFindElt (p, FcObjectFromName (object));
740 for (prev = &e->values; (l = *prev); prev = &l->next)
746 FcValueListDestroy (l);
748 FcPatternDel (p, object);
757 FcPatternObjectAddInteger (FcPattern *p, FcObject object, int i)
761 v.type = FcTypeInteger;
763 return FcPatternObjectAdd (p, object, v, FcTrue);
767 FcPatternAddInteger (FcPattern *p, const char *object, int i)
769 return FcPatternObjectAddInteger (p, FcObjectFromName (object), i);
773 FcPatternObjectAddDouble (FcPattern *p, FcObject object, double d)
777 v.type = FcTypeDouble;
779 return FcPatternObjectAdd (p, object, v, FcTrue);
784 FcPatternAddDouble (FcPattern *p, const char *object, double d)
786 return FcPatternObjectAddDouble (p, FcObjectFromName (object), d);
790 FcPatternObjectAddString (FcPattern *p, FcObject object, const FcChar8 *s)
798 return FcPatternObjectAdd (p, object, v, FcTrue);
801 v.type = FcTypeString;
803 return FcPatternObjectAdd (p, object, v, FcTrue);
807 FcPatternAddString (FcPattern *p, const char *object, const FcChar8 *s)
809 return FcPatternObjectAddString (p, FcObjectFromName (object), s);
813 FcPatternAddMatrix (FcPattern *p, const char *object, const FcMatrix *s)
817 v.type = FcTypeMatrix;
819 return FcPatternAdd (p, object, v, FcTrue);
824 FcPatternObjectAddBool (FcPattern *p, FcObject object, FcBool b)
830 return FcPatternObjectAdd (p, object, v, FcTrue);
834 FcPatternAddBool (FcPattern *p, const char *object, FcBool b)
836 return FcPatternObjectAddBool (p, FcObjectFromName (object), b);
840 FcPatternAddCharSet (FcPattern *p, const char *object, const FcCharSet *c)
844 v.type = FcTypeCharSet;
845 v.u.c = (FcCharSet *)c;
846 return FcPatternAdd (p, object, v, FcTrue);
850 FcPatternAddFTFace (FcPattern *p, const char *object, const FT_Face f)
854 v.type = FcTypeFTFace;
856 return FcPatternAdd (p, object, v, FcTrue);
860 FcPatternAddLangSet (FcPattern *p, const char *object, const FcLangSet *ls)
864 v.type = FcTypeLangSet;
865 v.u.l = (FcLangSet *)ls;
866 return FcPatternAdd (p, object, v, FcTrue);
870 FcPatternObjectAddRange (FcPattern *p, FcObject object, const FcRange *r)
874 v.type = FcTypeRange;
875 v.u.r = (FcRange *)r;
876 return FcPatternObjectAdd (p, object, v, FcTrue);
880 FcPatternAddRange (FcPattern *p, const char *object, const FcRange *r)
882 return FcPatternObjectAddRange (p, FcObjectFromName (object), r);
886 FcPatternObjectGetWithBinding (const FcPattern *p, FcObject object, int id, FcValue *v, FcValueBinding *b)
892 return FcResultNoMatch;
893 e = FcPatternObjectFindElt (p, object);
895 return FcResultNoMatch;
896 for (l = FcPatternEltValues(e); l; l = FcValueListNext(l))
900 *v = FcValueCanonicalize(&l->value);
903 return FcResultMatch;
911 FcPatternObjectGet (const FcPattern *p, FcObject object, int id, FcValue *v)
913 return FcPatternObjectGetWithBinding (p, object, id, v, NULL);
917 FcPatternGetWithBinding (const FcPattern *p, const char *object, int id, FcValue *v, FcValueBinding *b)
919 return FcPatternObjectGetWithBinding (p, FcObjectFromName (object), id, v, b);
923 FcPatternGet (const FcPattern *p, const char *object, int id, FcValue *v)
925 return FcPatternObjectGetWithBinding (p, FcObjectFromName (object), id, v, NULL);
929 FcPatternObjectGetInteger (const FcPattern *p, FcObject object, int id, int *i)
934 r = FcPatternObjectGet (p, object, id, &v);
935 if (r != FcResultMatch)
937 switch ((int) v.type) {
945 return FcResultTypeMismatch;
947 return FcResultMatch;
951 FcPatternGetInteger (const FcPattern *p, const char *object, int id, int *i)
953 return FcPatternObjectGetInteger (p, FcObjectFromName (object), id, i);
958 FcPatternObjectGetDouble (const FcPattern *p, FcObject object, int id, double *d)
963 r = FcPatternObjectGet (p, object, id, &v);
964 if (r != FcResultMatch)
966 switch ((int) v.type) {
974 return FcResultTypeMismatch;
976 return FcResultMatch;
980 FcPatternGetDouble (const FcPattern *p, const char *object, int id, double *d)
982 return FcPatternObjectGetDouble (p, FcObjectFromName (object), id, d);
986 FcPatternObjectGetString (const FcPattern *p, FcObject object, int id, FcChar8 ** s)
991 r = FcPatternObjectGet (p, object, id, &v);
992 if (r != FcResultMatch)
994 if (v.type != FcTypeString)
995 return FcResultTypeMismatch;
997 *s = (FcChar8 *) v.u.s;
998 return FcResultMatch;
1002 FcPatternGetString (const FcPattern *p, const char *object, int id, FcChar8 ** s)
1004 return FcPatternObjectGetString (p, FcObjectFromName (object), id, s);
1008 FcPatternGetMatrix(const FcPattern *p, const char *object, int id, FcMatrix **m)
1013 r = FcPatternGet (p, object, id, &v);
1014 if (r != FcResultMatch)
1016 if (v.type != FcTypeMatrix)
1017 return FcResultTypeMismatch;
1018 *m = (FcMatrix *)v.u.m;
1019 return FcResultMatch;
1024 FcPatternObjectGetBool (const FcPattern *p, FcObject object, int id, FcBool *b)
1029 r = FcPatternObjectGet (p, object, id, &v);
1030 if (r != FcResultMatch)
1032 if (v.type != FcTypeBool)
1033 return FcResultTypeMismatch;
1035 return FcResultMatch;
1039 FcPatternGetBool(const FcPattern *p, const char *object, int id, FcBool *b)
1041 return FcPatternObjectGetBool (p, FcObjectFromName (object), id, b);
1045 FcPatternGetCharSet(const FcPattern *p, const char *object, int id, FcCharSet **c)
1050 r = FcPatternGet (p, object, id, &v);
1051 if (r != FcResultMatch)
1053 if (v.type != FcTypeCharSet)
1054 return FcResultTypeMismatch;
1055 *c = (FcCharSet *)v.u.c;
1056 return FcResultMatch;
1060 FcPatternGetFTFace(const FcPattern *p, const char *object, int id, FT_Face *f)
1065 r = FcPatternGet (p, object, id, &v);
1066 if (r != FcResultMatch)
1068 if (v.type != FcTypeFTFace)
1069 return FcResultTypeMismatch;
1070 *f = (FT_Face) v.u.f;
1071 return FcResultMatch;
1075 FcPatternGetLangSet(const FcPattern *p, const char *object, int id, FcLangSet **ls)
1080 r = FcPatternGet (p, object, id, &v);
1081 if (r != FcResultMatch)
1083 if (v.type != FcTypeLangSet)
1084 return FcResultTypeMismatch;
1085 *ls = (FcLangSet *)v.u.l;
1086 return FcResultMatch;
1090 FcPatternObjectGetRange (const FcPattern *p, FcObject object, int id, FcRange **r)
1095 res = FcPatternObjectGet (p, object, id, &v);
1096 if (res != FcResultMatch)
1098 switch ((int)v.type) {
1100 *r = (FcRange *)v.u.r;
1103 return FcResultTypeMismatch;
1105 return FcResultMatch;
1109 FcPatternGetRange (const FcPattern *p, const char *object, int id, FcRange **r)
1111 return FcPatternObjectGetRange (p, FcObjectFromName (object), id, r);
1115 FcPatternDuplicate (const FcPattern *orig)
1125 new = FcPatternCreate ();
1129 e = FcPatternElts(orig);
1131 for (i = 0; i < orig->num; i++)
1133 for (l = FcPatternEltValues(e + i); l; l = FcValueListNext(l))
1135 if (!FcPatternObjectAddWithBinding (new, e[i].object,
1136 FcValueCanonicalize(&l->value),
1147 FcPatternDestroy (new);
1153 FcPatternReference (FcPattern *p)
1155 if (!FcRefIsConst (&p->ref))
1158 FcCacheObjectReference (p);
1162 FcPatternVaBuild (FcPattern *p, va_list va)
1166 FcPatternVapBuild (ret, p, va);
1171 FcPatternBuild (FcPattern *p, ...)
1176 FcPatternVapBuild (p, p, va);
1182 * Add all of the elements in 's' to 'p'
1185 FcPatternAppend (FcPattern *p, FcPattern *s)
1191 for (i = 0; i < s->num; i++)
1193 e = FcPatternElts(s)+i;
1194 for (v = FcPatternEltValues(e); v; v = FcValueListNext(v))
1196 if (!FcPatternObjectAddWithBinding (p, e->object,
1197 FcValueCanonicalize(&v->value),
1198 v->binding, FcTrue))
1206 FcPatternFilter (FcPattern *p, const FcObjectSet *os)
1214 return FcPatternDuplicate (p);
1216 ret = FcPatternCreate ();
1220 for (i = 0; i < os->nobject; i++)
1222 FcObject object = FcObjectFromName (os->objects[i]);
1223 e = FcPatternObjectFindElt (p, object);
1226 for (v = FcPatternEltValues(e); v; v = FcValueListNext(v))
1228 if (!FcPatternObjectAddWithBinding (ret, e->object,
1229 FcValueCanonicalize(&v->value),
1230 v->binding, FcTrue))
1238 FcPatternDestroy (ret);
1244 FcPatternSerializeAlloc (FcSerialize *serialize, const FcPattern *pat)
1247 FcPatternElt *elts = FcPatternElts(pat);
1249 if (!FcSerializeAlloc (serialize, pat, sizeof (FcPattern)))
1251 if (!FcSerializeAlloc (serialize, elts, pat->num * sizeof (FcPatternElt)))
1253 for (i = 0; i < pat->num; i++)
1254 if (!FcValueListSerializeAlloc (serialize, FcPatternEltValues(elts+i)))
1260 FcPatternSerialize (FcSerialize *serialize, const FcPattern *pat)
1262 FcPattern *pat_serialized;
1263 FcPatternElt *elts = FcPatternElts (pat);
1264 FcPatternElt *elts_serialized;
1265 FcValueList *values_serialized;
1268 pat_serialized = FcSerializePtr (serialize, pat);
1269 if (!pat_serialized)
1271 *pat_serialized = *pat;
1272 pat_serialized->size = pat->num;
1273 FcRefSetConst (&pat_serialized->ref);
1275 elts_serialized = FcSerializePtr (serialize, elts);
1276 if (!elts_serialized)
1279 pat_serialized->elts_offset = FcPtrToOffset (pat_serialized,
1282 for (i = 0; i < pat->num; i++)
1284 values_serialized = FcValueListSerialize (serialize, FcPatternEltValues (elts+i));
1285 if (!values_serialized)
1287 elts_serialized[i].object = elts[i].object;
1288 elts_serialized[i].values = FcPtrToEncodedOffset (&elts_serialized[i],
1292 if (FcDebug() & FC_DBG_CACHEV) {
1293 printf ("Raw pattern:\n");
1294 FcPatternPrint (pat);
1295 printf ("Serialized pattern:\n");
1296 FcPatternPrint (pat_serialized);
1299 return pat_serialized;
1303 FcValueListSerializeAlloc (FcSerialize *serialize, const FcValueList *vl)
1307 if (!FcSerializeAlloc (serialize, vl, sizeof (FcValueList)))
1309 switch ((int) vl->value.type) {
1311 if (!FcStrSerializeAlloc (serialize, vl->value.u.s))
1315 if (!FcCharSetSerializeAlloc (serialize, vl->value.u.c))
1319 if (!FcLangSetSerializeAlloc (serialize, vl->value.u.l))
1323 if (!FcRangeSerializeAlloc (serialize, vl->value.u.r))
1335 FcValueListSerialize (FcSerialize *serialize, const FcValueList *vl)
1337 FcValueList *vl_serialized;
1338 FcChar8 *s_serialized;
1339 FcCharSet *c_serialized;
1340 FcLangSet *l_serialized;
1341 FcRange *r_serialized;
1342 FcValueList *head_serialized = NULL;
1343 FcValueList *prev_serialized = NULL;
1347 vl_serialized = FcSerializePtr (serialize, vl);
1351 if (prev_serialized)
1352 prev_serialized->next = FcPtrToEncodedOffset (prev_serialized,
1356 head_serialized = vl_serialized;
1358 vl_serialized->next = NULL;
1359 vl_serialized->value.type = vl->value.type;
1360 switch ((int) vl->value.type) {
1362 vl_serialized->value.u.i = vl->value.u.i;
1365 vl_serialized->value.u.d = vl->value.u.d;
1368 s_serialized = FcStrSerialize (serialize, vl->value.u.s);
1371 vl_serialized->value.u.s = FcPtrToEncodedOffset (&vl_serialized->value,
1376 vl_serialized->value.u.b = vl->value.u.b;
1382 c_serialized = FcCharSetSerialize (serialize, vl->value.u.c);
1385 vl_serialized->value.u.c = FcPtrToEncodedOffset (&vl_serialized->value,
1393 l_serialized = FcLangSetSerialize (serialize, vl->value.u.l);
1396 vl_serialized->value.u.l = FcPtrToEncodedOffset (&vl_serialized->value,
1401 r_serialized = FcRangeSerialize (serialize, vl->value.u.r);
1404 vl_serialized->value.u.r = FcPtrToEncodedOffset (&vl_serialized->value,
1411 prev_serialized = vl_serialized;
1414 return head_serialized;
1418 #include "fcaliastail.h"
1419 #include "fcftaliastail.h"