2 * $RCSId: xc/lib/fontconfig/src/fcxml.c,v 1.21 2002/08/22 18:53:22 keithp Exp $
4 * Copyright © 2002 Keith Packard
6 * Permission to use, copy, modify, distribute, and sell this software and its
7 * documentation for any purpose is hereby granted without fee, provided that
8 * the above copyright notice appear in all copies and that both that
9 * copyright notice and this permission notice appear in supporting
10 * documentation, and that the name of Keith Packard not be used in
11 * advertising or publicity pertaining to distribution of the software without
12 * specific, written prior permission. Keith Packard makes no
13 * representations about the suitability of this software for any purpose. It
14 * is provided "as is" without express or implied warranty.
16 * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
17 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
18 * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
19 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
20 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
21 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
22 * PERFORMANCE OF THIS SOFTWARE.
32 #include <libxml/parser.h>
34 #define XML_Char xmlChar
35 #define XML_Parser xmlParserCtxtPtr
36 #define XML_ParserFree xmlFreeParserCtxt
37 #define XML_GetCurrentLineNumber xmlSAX2GetLineNumber
38 #define XML_GetErrorCode xmlCtxtGetLastError
39 #define XML_ErrorString(Error) (Error)->message
41 #else /* ENABLE_LIBXML2 */
43 #ifndef HAVE_XMLPARSE_H
44 #define HAVE_XMLPARSE_H 0
53 #endif /* ENABLE_LIBXML2 */
63 FcTestDestroy (FcTest *test)
66 FcTestDestroy (test->next);
67 FcExprDestroy (test->expr);
68 FcMemFree (FC_MEM_TEST, sizeof (FcTest));
73 FcExprCreateInteger (int i)
75 FcExpr *e = (FcExpr *) malloc (sizeof (FcExpr));
79 FcMemAlloc (FC_MEM_EXPR, sizeof (FcExpr));
87 FcExprCreateDouble (double d)
89 FcExpr *e = (FcExpr *) malloc (sizeof (FcExpr));
93 FcMemAlloc (FC_MEM_EXPR, sizeof (FcExpr));
101 FcExprCreateString (const FcChar8 *s)
103 FcExpr *e = (FcExpr *) malloc (sizeof (FcExpr));
107 FcMemAlloc (FC_MEM_EXPR, sizeof (FcExpr));
109 e->u.sval = FcStrCopy (s);
115 FcExprCreateMatrix (const FcMatrix *m)
117 FcExpr *e = (FcExpr *) malloc (sizeof (FcExpr));
121 FcMemAlloc (FC_MEM_EXPR, sizeof (FcExpr));
123 e->u.mval = FcMatrixCopy (m);
129 FcExprCreateBool (FcBool b)
131 FcExpr *e = (FcExpr *) malloc (sizeof (FcExpr));
135 FcMemAlloc (FC_MEM_EXPR, sizeof (FcExpr));
143 FcExprCreateNil (void)
145 FcExpr *e = (FcExpr *) malloc (sizeof (FcExpr));
149 FcMemAlloc (FC_MEM_EXPR, sizeof (FcExpr));
156 FcExprCreateField (const char *field)
158 FcExpr *e = (FcExpr *) malloc (sizeof (FcExpr));
162 FcMemAlloc (FC_MEM_EXPR, sizeof (FcExpr));
164 e->u.object = FcObjectFromName (field);
170 FcExprCreateConst (const FcChar8 *constant)
172 FcExpr *e = (FcExpr *) malloc (sizeof (FcExpr));
176 FcMemAlloc (FC_MEM_EXPR, sizeof (FcExpr));
178 e->u.constant = FcStrCopy (constant);
184 FcExprCreateOp (FcExpr *left, FcOp op, FcExpr *right)
186 FcExpr *e = (FcExpr *) malloc (sizeof (FcExpr));
190 FcMemAlloc (FC_MEM_EXPR, sizeof (FcExpr));
192 e->u.tree.left = left;
193 e->u.tree.right = right;
199 FcExprDestroy (FcExpr *e)
209 FcStrFree (e->u.sval);
212 FcMatrixFree (e->u.mval);
215 FcCharSetDestroy (e->u.cval);
222 FcStrFree (e->u.constant);
225 case FcOpAssignReplace:
227 case FcOpPrependFirst:
241 case FcOpNotContains:
248 FcExprDestroy (e->u.tree.right);
255 FcExprDestroy (e->u.tree.left);
261 FcMemFree (FC_MEM_EXPR, sizeof (FcExpr));
266 FcEditDestroy (FcEdit *e)
269 FcEditDestroy (e->next);
271 FcExprDestroy (e->expr);
276 FcConfigSaveField (const char *field)
278 return (char *) FcStrCopy ((FcChar8 *) field);
281 typedef enum _FcElement {
326 FcElementNotContains,
340 static const struct {
344 { "fontconfig", FcElementFontconfig },
345 { "dir", FcElementDir },
346 { "cachedir", FcElementCacheDir },
347 { "cache", FcElementCache },
348 { "include", FcElementInclude },
349 { "config", FcElementConfig },
350 { "match", FcElementMatch },
351 { "alias", FcElementAlias },
353 { "blank", FcElementBlank },
354 { "rescan", FcElementRescan },
356 { "prefer", FcElementPrefer },
357 { "accept", FcElementAccept },
358 { "default", FcElementDefault },
359 { "family", FcElementFamily },
361 { "selectfont", FcElementSelectfont },
362 { "acceptfont", FcElementAcceptfont },
363 { "rejectfont", FcElementRejectfont },
364 { "glob", FcElementGlob },
365 { "pattern", FcElementPattern },
366 { "patelt", FcElementPatelt },
368 { "test", FcElementTest },
369 { "edit", FcElementEdit },
370 { "int", FcElementInt },
371 { "double", FcElementDouble },
372 { "string", FcElementString },
373 { "matrix", FcElementMatrix },
374 { "bool", FcElementBool },
375 { "charset", FcElementCharset },
376 { "name", FcElementName },
377 { "const", FcElementConst },
378 { "or", FcElementOr },
379 { "and", FcElementAnd },
380 { "eq", FcElementEq },
381 { "not_eq", FcElementNotEq },
382 { "less", FcElementLess },
383 { "less_eq", FcElementLessEq },
384 { "more", FcElementMore },
385 { "more_eq", FcElementMoreEq },
386 { "contains", FcElementContains },
387 { "not_contains", FcElementNotContains },
388 { "plus", FcElementPlus },
389 { "minus", FcElementMinus },
390 { "times", FcElementTimes },
391 { "divide", FcElementDivide },
392 { "not", FcElementNot },
393 { "if", FcElementIf },
394 { "floor", FcElementFloor },
395 { "ceil", FcElementCeil },
396 { "round", FcElementRound },
397 { "trunc", FcElementTrunc },
399 #define NUM_ELEMENT_MAPS (int) (sizeof fcElementMap / sizeof fcElementMap[0])
402 FcElementMap (const XML_Char *name)
406 for (i = 0; i < NUM_ELEMENT_MAPS; i++)
407 if (!strcmp ((char *) name, fcElementMap[i].name))
408 return fcElementMap[i].element;
409 return FcElementUnknown;
412 typedef struct _FcPStack {
413 struct _FcPStack *prev;
419 typedef enum _FcVStackTag {
443 typedef struct _FcVStack {
444 struct _FcVStack *prev;
445 FcPStack *pstack; /* related parse element */
465 typedef struct _FcConfigParse {
474 typedef enum _FcConfigSeverity {
475 FcSevereInfo, FcSevereWarning, FcSevereError
479 FcConfigMessage (FcConfigParse *parse, FcConfigSeverity severe, const char *fmt, ...)
481 const char *s = "unknown";
484 va_start (args, fmt);
487 case FcSevereInfo: s = "info"; break;
488 case FcSevereWarning: s = "warning"; break;
489 case FcSevereError: s = "error"; break;
494 fprintf (stderr, "Fontconfig %s: \"%s\", line %d: ", s,
495 parse->name, (int)XML_GetCurrentLineNumber (parse->parser));
497 fprintf (stderr, "Fontconfig %s: line %d: ", s,
498 (int)XML_GetCurrentLineNumber (parse->parser));
499 if (severe >= FcSevereError)
500 parse->error = FcTrue;
503 fprintf (stderr, "Fontconfig %s: ", s);
504 vfprintf (stderr, fmt, args);
505 fprintf (stderr, "\n");
511 FcTypeName (FcType type)
537 FcTypecheckValue (FcConfigParse *parse, FcType value, FcType type)
539 if (value == FcTypeInteger)
540 value = FcTypeDouble;
541 if (type == FcTypeInteger)
545 if ((value == FcTypeLangSet && type == FcTypeString) ||
546 (value == FcTypeString && type == FcTypeLangSet))
548 if (type == (FcType) -1)
550 FcConfigMessage (parse, FcSevereWarning, "saw %s, expected %s",
551 FcTypeName (value), FcTypeName (type));
556 FcTypecheckExpr (FcConfigParse *parse, FcExpr *expr, FcType type)
558 const FcObjectType *o;
561 /* If parsing the expression failed, some nodes may be NULL */
568 FcTypecheckValue (parse, FcTypeDouble, type);
571 FcTypecheckValue (parse, FcTypeString, type);
574 FcTypecheckValue (parse, FcTypeMatrix, type);
577 FcTypecheckValue (parse, FcTypeBool, type);
580 FcTypecheckValue (parse, FcTypeCharSet, type);
585 o = FcNameGetObjectType (FcObjectName (expr->u.object));
587 FcTypecheckValue (parse, o->type, type);
590 c = FcNameGetConstant (expr->u.constant);
593 o = FcNameGetObjectType (c->object);
595 FcTypecheckValue (parse, o->type, type);
598 FcConfigMessage (parse, FcSevereWarning,
599 "invalid constant used : %s",
603 FcTypecheckExpr (parse, expr->u.tree.left, FcTypeBool);
604 FcTypecheckExpr (parse, expr->u.tree.right->u.tree.left, type);
605 FcTypecheckExpr (parse, expr->u.tree.right->u.tree.right, type);
608 case FcOpAssignReplace:
617 case FcOpNotContains:
619 FcTypecheckValue (parse, FcTypeBool, type);
628 FcTypecheckExpr (parse, expr->u.tree.left, type);
629 FcTypecheckExpr (parse, expr->u.tree.right, type);
632 FcTypecheckValue (parse, FcTypeBool, type);
633 FcTypecheckExpr (parse, expr->u.tree.left, FcTypeBool);
639 FcTypecheckValue (parse, FcTypeDouble, type);
640 FcTypecheckExpr (parse, expr->u.tree.left, FcTypeDouble);
648 FcTestCreate (FcConfigParse *parse,
651 const FcChar8 *field,
655 FcTest *test = (FcTest *) malloc (sizeof (FcTest));
659 const FcObjectType *o;
661 FcMemAlloc (FC_MEM_TEST, sizeof (FcTest));
665 test->object = FcObjectFromName ((const char *) field);
668 o = FcNameGetObjectType (FcObjectName (test->object));
670 FcTypecheckExpr (parse, expr, o->type);
676 FcEditCreate (FcConfigParse *parse,
680 FcValueBinding binding)
682 FcEdit *e = (FcEdit *) malloc (sizeof (FcEdit));
686 const FcObjectType *o;
692 e->binding = binding;
693 o = FcNameGetObjectType (FcObjectName (e->object));
695 FcTypecheckExpr (parse, expr, o->type);
701 FcVStackPush (FcConfigParse *parse, FcVStack *vstack)
703 vstack->prev = parse->vstack;
704 vstack->pstack = parse->pstack ? parse->pstack->prev : 0;
705 parse->vstack = vstack;
709 FcVStackCreate (void)
713 new = malloc (sizeof (FcVStack));
716 FcMemAlloc (FC_MEM_VSTACK, sizeof (FcVStack));
717 new->tag = FcVStackNone;
723 FcVStackDestroy (FcVStack *vstack)
727 for (; vstack; vstack = prev)
730 switch (vstack->tag) {
736 case FcVStackConstant:
738 FcStrFree (vstack->u.string);
740 case FcVStackPattern:
741 FcPatternDestroy (vstack->u.pattern);
743 case FcVStackInteger:
747 FcMatrixFree (vstack->u.matrix);
752 FcTestDestroy (vstack->u.test);
757 case FcVStackDefault:
758 FcExprDestroy (vstack->u.expr);
761 FcEditDestroy (vstack->u.edit);
764 FcMemFree (FC_MEM_VSTACK, sizeof (FcVStack));
770 FcVStackPushString (FcConfigParse *parse, FcVStackTag tag, FcChar8 *string)
772 FcVStack *vstack = FcVStackCreate ();
775 vstack->u.string = string;
777 FcVStackPush (parse, vstack);
782 FcVStackPushInteger (FcConfigParse *parse, int integer)
784 FcVStack *vstack = FcVStackCreate ();
787 vstack->u.integer = integer;
788 vstack->tag = FcVStackInteger;
789 FcVStackPush (parse, vstack);
794 FcVStackPushDouble (FcConfigParse *parse, double _double)
796 FcVStack *vstack = FcVStackCreate ();
799 vstack->u._double = _double;
800 vstack->tag = FcVStackDouble;
801 FcVStackPush (parse, vstack);
806 FcVStackPushMatrix (FcConfigParse *parse, FcMatrix *matrix)
808 FcVStack *vstack = FcVStackCreate ();
811 matrix = FcMatrixCopy (matrix);
814 FcVStackDestroy (vstack);
817 vstack->u.matrix = matrix;
818 vstack->tag = FcVStackMatrix;
819 FcVStackPush (parse, vstack);
824 FcVStackPushBool (FcConfigParse *parse, FcBool bool)
826 FcVStack *vstack = FcVStackCreate ();
829 vstack->u.bool = bool;
830 vstack->tag = FcVStackBool;
831 FcVStackPush (parse, vstack);
836 FcVStackPushTest (FcConfigParse *parse, FcTest *test)
838 FcVStack *vstack = FcVStackCreate ();
841 vstack->u.test = test;
842 vstack->tag = FcVStackTest;
843 FcVStackPush (parse, vstack);
848 FcVStackPushExpr (FcConfigParse *parse, FcVStackTag tag, FcExpr *expr)
850 FcVStack *vstack = FcVStackCreate ();
853 vstack->u.expr = expr;
855 FcVStackPush (parse, vstack);
860 FcVStackPushEdit (FcConfigParse *parse, FcEdit *edit)
862 FcVStack *vstack = FcVStackCreate ();
865 vstack->u.edit = edit;
866 vstack->tag = FcVStackEdit;
867 FcVStackPush (parse, vstack);
872 FcVStackPushPattern (FcConfigParse *parse, FcPattern *pattern)
874 FcVStack *vstack = FcVStackCreate ();
877 vstack->u.pattern = pattern;
878 vstack->tag = FcVStackPattern;
879 FcVStackPush (parse, vstack);
884 FcVStackFetch (FcConfigParse *parse, int off)
888 for (vstack = parse->vstack; vstack && off-- > 0; vstack = vstack->prev);
893 FcVStackClear (FcConfigParse *parse)
895 while (parse->vstack && parse->vstack->pstack == parse->pstack)
897 FcVStack *vstack = parse->vstack;
898 parse->vstack = vstack->prev;
900 FcVStackDestroy (vstack);
905 FcVStackPop (FcConfigParse *parse)
907 FcVStack *vstack = parse->vstack;
909 if (!vstack || vstack->pstack != parse->pstack)
911 parse->vstack = vstack->prev;
917 FcVStackElements (FcConfigParse *parse)
920 FcVStack *vstack = parse->vstack;
921 while (vstack && vstack->pstack == parse->pstack)
924 vstack = vstack->prev;
930 FcConfigSaveAttr (const XML_Char **attr)
940 for (i = 0; attr[i]; i++)
941 slen += strlen ((char *) attr[i]) + 1;
942 new = malloc ((i + 1) * sizeof (FcChar8 *) + slen);
945 FcMemAlloc (FC_MEM_ATTR, 1); /* size is too expensive */
946 s = (FcChar8 *) (new + (i + 1));
947 for (i = 0; attr[i]; i++)
950 strcpy ((char *) s, (char *) attr[i]);
951 s += strlen ((char *) s) + 1;
958 FcPStackPush (FcConfigParse *parse, FcElement element, const XML_Char **attr)
960 FcPStack *new = malloc (sizeof (FcPStack));
964 FcMemAlloc (FC_MEM_PSTACK, sizeof (FcPStack));
965 new->prev = parse->pstack;
966 new->element = element;
969 new->attr = FcConfigSaveAttr (attr);
971 FcConfigMessage (parse, FcSevereError, "out of memory");
975 FcStrBufInit (&new->str, 0, 0);
981 FcPStackPop (FcConfigParse *parse)
987 FcConfigMessage (parse, FcSevereError, "mismatching element");
990 FcVStackClear (parse);
992 parse->pstack = old->prev;
993 FcStrBufDestroy (&old->str);
996 FcMemFree (FC_MEM_ATTR, 1); /* size is to expensive */
999 FcMemFree (FC_MEM_PSTACK, sizeof (FcPStack));
1005 FcConfigInit (FcConfigParse *parse, const FcChar8 *name, FcConfig *config, XML_Parser parser)
1009 parse->error = FcFalse;
1011 parse->config = config;
1012 parse->parser = parser;
1017 FcConfigCleanup (FcConfigParse *parse)
1019 while (parse->pstack)
1020 FcPStackPop (parse);
1023 static const FcChar8 *
1024 FcConfigGetAttribute (FcConfigParse *parse, const char *attr)
1030 attrs = parse->pstack->attr;
1036 if (!strcmp ((char *) *attrs, attr))
1044 FcStartElement(void *userData, const XML_Char *name, const XML_Char **attr)
1046 FcConfigParse *parse = userData;
1049 element = FcElementMap (name);
1050 if (element == FcElementUnknown)
1051 FcConfigMessage (parse, FcSevereWarning, "unknown element \"%s\"", name);
1053 if (!FcPStackPush (parse, element, attr))
1055 FcConfigMessage (parse, FcSevereError, "out of memory");
1062 FcParseBlank (FcConfigParse *parse)
1064 int n = FcVStackElements (parse);
1067 FcVStack *v = FcVStackFetch (parse, n);
1068 if (v->tag != FcVStackInteger)
1069 FcConfigMessage (parse, FcSevereError, "non-integer blank");
1072 if (!parse->config->blanks)
1074 parse->config->blanks = FcBlanksCreate ();
1075 if (!parse->config->blanks)
1077 FcConfigMessage (parse, FcSevereError, "out of memory");
1081 if (!FcBlanksAdd (parse->config->blanks, v->u.integer))
1083 FcConfigMessage (parse, FcSevereError, "out of memory");
1091 FcParseRescan (FcConfigParse *parse)
1093 int n = FcVStackElements (parse);
1096 FcVStack *v = FcVStackFetch (parse, n);
1097 if (v->tag != FcVStackInteger)
1098 FcConfigMessage (parse, FcSevereWarning, "non-integer rescan");
1100 parse->config->rescanInterval = v->u.integer;
1105 FcParseInt (FcConfigParse *parse)
1112 s = FcStrBufDone (&parse->pstack->str);
1115 FcConfigMessage (parse, FcSevereError, "out of memory");
1119 l = (int) strtol ((char *) s, (char **)&end, 0);
1120 if (end != s + strlen ((char *) s))
1121 FcConfigMessage (parse, FcSevereError, "\"%s\": not a valid integer", s);
1123 FcVStackPushInteger (parse, l);
1128 * idea copied from glib g_ascii_strtod with
1129 * permission of the author (Alexander Larsson)
1135 FcStrtod (char *s, char **end)
1137 struct lconv *locale_data;
1142 * Have to swap the decimal point to match the current locale
1143 * if that locale doesn't use 0x2e
1145 if ((dot = strchr (s, 0x2e)) &&
1146 (locale_data = localeconv ()) &&
1147 (locale_data->decimal_point[0] != 0x2e ||
1148 locale_data->decimal_point[1] != 0))
1151 int slen = strlen (s);
1152 int dlen = strlen (locale_data->decimal_point);
1154 if (slen + dlen > (int) sizeof (buf))
1164 strncpy (buf, s, dot - s);
1166 strcpy (buf + (dot - s), locale_data->decimal_point);
1167 /* rest of number */
1168 strcpy (buf + (dot - s) + dlen, dot + 1);
1170 v = strtod (buf, &buf_end);
1172 buf_end = s + (buf_end - buf);
1174 buf_end -= dlen - 1;
1181 v = strtod (s, end);
1186 FcParseDouble (FcConfigParse *parse)
1193 s = FcStrBufDone (&parse->pstack->str);
1196 FcConfigMessage (parse, FcSevereError, "out of memory");
1200 d = FcStrtod ((char *) s, (char **)&end);
1201 if (end != s + strlen ((char *) s))
1202 FcConfigMessage (parse, FcSevereError, "\"%s\": not a valid double", s);
1204 FcVStackPushDouble (parse, d);
1209 FcParseString (FcConfigParse *parse, FcVStackTag tag)
1215 s = FcStrBufDone (&parse->pstack->str);
1218 FcConfigMessage (parse, FcSevereError, "out of memory");
1221 if (!FcVStackPushString (parse, tag, s))
1226 FcParseMatrix (FcConfigParse *parse)
1229 enum { m_done, m_xx, m_xy, m_yx, m_yy } matrix_state = m_yy;
1232 while ((vstack = FcVStackPop (parse)))
1235 switch (vstack->tag) {
1236 case FcVStackInteger:
1237 v = vstack->u.integer;
1239 case FcVStackDouble:
1240 v = vstack->u._double;
1243 FcConfigMessage (parse, FcSevereError, "non-double matrix element");
1247 switch (matrix_state) {
1248 case m_xx: m.xx = v; break;
1249 case m_xy: m.xy = v; break;
1250 case m_yx: m.yx = v; break;
1251 case m_yy: m.yy = v; break;
1254 FcVStackDestroy (vstack);
1257 if (matrix_state != m_done)
1258 FcConfigMessage (parse, FcSevereError, "wrong number of matrix elements");
1260 FcVStackPushMatrix (parse, &m);
1264 FcConfigLexBool (FcConfigParse *parse, const FcChar8 *bool)
1266 FcBool result = FcFalse;
1268 if (!FcNameBool (bool, &result))
1269 FcConfigMessage (parse, FcSevereWarning, "\"%s\" is not known boolean",
1275 FcParseBool (FcConfigParse *parse)
1281 s = FcStrBufDone (&parse->pstack->str);
1284 FcConfigMessage (parse, FcSevereError, "out of memory");
1287 FcVStackPushBool (parse, FcConfigLexBool (parse, s));
1292 FcConfigLexBinding (FcConfigParse *parse,
1293 const FcChar8 *binding_string,
1294 FcValueBinding *binding_ret)
1296 FcValueBinding binding;
1298 if (!binding_string)
1299 binding = FcValueBindingWeak;
1302 if (!strcmp ((char *) binding_string, "weak"))
1303 binding = FcValueBindingWeak;
1304 else if (!strcmp ((char *) binding_string, "strong"))
1305 binding = FcValueBindingStrong;
1306 else if (!strcmp ((char *) binding_string, "same"))
1307 binding = FcValueBindingSame;
1310 FcConfigMessage (parse, FcSevereWarning, "invalid binding \"%s\"", binding_string);
1314 *binding_ret = binding;
1319 FcParseFamilies (FcConfigParse *parse, FcVStackTag tag)
1322 FcExpr *left, *expr = 0, *new;
1324 while ((vstack = FcVStackPop (parse)))
1326 if (vstack->tag != FcVStackFamily)
1328 FcConfigMessage (parse, FcSevereWarning, "non-family");
1329 FcVStackDestroy (vstack);
1332 left = vstack->u.expr;
1333 vstack->tag = FcVStackNone;
1334 FcVStackDestroy (vstack);
1337 new = FcExprCreateOp (left, FcOpComma, expr);
1340 FcConfigMessage (parse, FcSevereError, "out of memory");
1341 FcExprDestroy (left);
1342 FcExprDestroy (expr);
1352 if (!FcVStackPushExpr (parse, tag, expr))
1354 FcConfigMessage (parse, FcSevereError, "out of memory");
1355 FcExprDestroy (expr);
1361 FcParseFamily (FcConfigParse *parse)
1368 s = FcStrBufDone (&parse->pstack->str);
1371 FcConfigMessage (parse, FcSevereError, "out of memory");
1374 expr = FcExprCreateString (s);
1377 FcVStackPushExpr (parse, FcVStackFamily, expr);
1381 FcParseAlias (FcConfigParse *parse)
1383 FcExpr *family = 0, *accept = 0, *prefer = 0, *def = 0, *new = 0;
1384 FcEdit *edit = 0, *next;
1387 FcValueBinding binding;
1389 if (!FcConfigLexBinding (parse, FcConfigGetAttribute (parse, "binding"), &binding))
1391 while ((vstack = FcVStackPop (parse)))
1393 switch (vstack->tag) {
1394 case FcVStackFamily:
1397 new = FcExprCreateOp (vstack->u.expr, FcOpComma, family);
1399 FcConfigMessage (parse, FcSevereError, "out of memory");
1404 new = vstack->u.expr;
1408 vstack->tag = FcVStackNone;
1411 case FcVStackPrefer:
1413 FcExprDestroy (prefer);
1414 prefer = vstack->u.expr;
1415 vstack->tag = FcVStackNone;
1417 case FcVStackAccept:
1419 FcExprDestroy (accept);
1420 accept = vstack->u.expr;
1421 vstack->tag = FcVStackNone;
1423 case FcVStackDefault:
1425 FcExprDestroy (def);
1426 def = vstack->u.expr;
1427 vstack->tag = FcVStackNone;
1430 FcConfigMessage (parse, FcSevereWarning, "bad alias");
1433 FcVStackDestroy (vstack);
1437 FcConfigMessage (parse, FcSevereError, "missing family in alias");
1439 FcExprDestroy (prefer);
1441 FcExprDestroy (accept);
1443 FcExprDestroy (def);
1448 edit = FcEditCreate (parse,
1456 FcExprDestroy (prefer);
1461 edit = FcEditCreate (parse,
1469 FcExprDestroy (accept);
1474 edit = FcEditCreate (parse,
1482 FcExprDestroy (def);
1486 test = FcTestCreate (parse, FcMatchPattern,
1488 (FcChar8 *) FC_FAMILY,
1492 if (!FcConfigAddEdit (parse->config, test, edit, FcMatchPattern))
1493 FcTestDestroy (test);
1496 FcExprDestroy (family);
1500 FcPopExpr (FcConfigParse *parse)
1502 FcVStack *vstack = FcVStackPop (parse);
1506 switch (vstack->tag) {
1509 case FcVStackString:
1510 case FcVStackFamily:
1511 expr = FcExprCreateString (vstack->u.string);
1514 expr = FcExprCreateField ((char *) vstack->u.string);
1516 case FcVStackConstant:
1517 expr = FcExprCreateConst (vstack->u.string);
1520 /* XXX: What's the correct action here? (CDW) */
1522 case FcVStackPrefer:
1523 case FcVStackAccept:
1524 case FcVStackDefault:
1525 expr = vstack->u.expr;
1526 vstack->tag = FcVStackNone;
1528 case FcVStackInteger:
1529 expr = FcExprCreateInteger (vstack->u.integer);
1531 case FcVStackDouble:
1532 expr = FcExprCreateDouble (vstack->u._double);
1534 case FcVStackMatrix:
1535 expr = FcExprCreateMatrix (vstack->u.matrix);
1538 expr = FcExprCreateBool (vstack->u.bool);
1543 expr = vstack->u.expr;
1544 vstack->tag = FcVStackNone;
1551 FcVStackDestroy (vstack);
1556 * This builds a tree of binary operations. Note
1557 * that every operator is defined so that if only
1558 * a single operand is contained, the value of the
1559 * whole expression is the value of the operand.
1561 * This code reduces in that case to returning that
1565 FcPopBinary (FcConfigParse *parse, FcOp op)
1567 FcExpr *left, *expr = 0, *new;
1569 while ((left = FcPopExpr (parse)))
1573 new = FcExprCreateOp (left, op, expr);
1576 FcConfigMessage (parse, FcSevereError, "out of memory");
1577 FcExprDestroy (left);
1578 FcExprDestroy (expr);
1590 FcParseBinary (FcConfigParse *parse, FcOp op)
1592 FcExpr *expr = FcPopBinary (parse, op);
1594 FcVStackPushExpr (parse, FcVStackExpr, expr);
1598 * This builds a a unary operator, it consumes only
1603 FcPopUnary (FcConfigParse *parse, FcOp op)
1605 FcExpr *operand, *new = 0;
1607 if ((operand = FcPopExpr (parse)))
1609 new = FcExprCreateOp (operand, op, 0);
1612 FcExprDestroy (operand);
1613 FcConfigMessage (parse, FcSevereError, "out of memory");
1620 FcParseUnary (FcConfigParse *parse, FcOp op)
1622 FcExpr *expr = FcPopUnary (parse, op);
1624 FcVStackPushExpr (parse, FcVStackExpr, expr);
1628 FcParseInclude (FcConfigParse *parse)
1632 FcBool ignore_missing = FcFalse;
1634 s = FcStrBufDone (&parse->pstack->str);
1637 FcConfigMessage (parse, FcSevereError, "out of memory");
1640 i = FcConfigGetAttribute (parse, "ignore_missing");
1641 if (i && FcConfigLexBool (parse, (FcChar8 *) i) == FcTrue)
1642 ignore_missing = FcTrue;
1643 if (!FcConfigParseAndLoad (parse->config, s, !ignore_missing))
1644 parse->error = FcTrue;
1648 typedef struct _FcOpMap {
1654 FcConfigLexOp (const FcChar8 *op, const FcOpMap *map, int nmap)
1658 for (i = 0; i < nmap; i++)
1659 if (!strcmp ((char *) op, map[i].name))
1664 static const FcOpMap fcCompareOps[] = {
1665 { "eq", FcOpEqual },
1666 { "not_eq", FcOpNotEqual },
1667 { "less", FcOpLess },
1668 { "less_eq", FcOpLessEqual },
1669 { "more", FcOpMore },
1670 { "more_eq", FcOpMoreEqual },
1671 { "contains", FcOpContains },
1672 { "not_contains", FcOpNotContains }
1675 #define NUM_COMPARE_OPS (int) (sizeof fcCompareOps / sizeof fcCompareOps[0])
1678 FcConfigLexCompare (const FcChar8 *compare)
1680 return FcConfigLexOp (compare, fcCompareOps, NUM_COMPARE_OPS);
1684 FcParseTest (FcConfigParse *parse)
1686 const FcChar8 *kind_string;
1688 const FcChar8 *qual_string;
1690 const FcChar8 *name;
1691 const FcChar8 *compare_string;
1696 kind_string = FcConfigGetAttribute (parse, "target");
1698 kind = FcMatchDefault;
1701 if (!strcmp ((char *) kind_string, "pattern"))
1702 kind = FcMatchPattern;
1703 else if (!strcmp ((char *) kind_string, "font"))
1705 else if (!strcmp ((char *) kind_string, "scan"))
1707 else if (!strcmp ((char *) kind_string, "default"))
1708 kind = FcMatchDefault;
1711 FcConfigMessage (parse, FcSevereWarning, "invalid test target \"%s\"", kind_string);
1715 qual_string = FcConfigGetAttribute (parse, "qual");
1720 if (!strcmp ((char *) qual_string, "any"))
1722 else if (!strcmp ((char *) qual_string, "all"))
1724 else if (!strcmp ((char *) qual_string, "first"))
1726 else if (!strcmp ((char *) qual_string, "not_first"))
1727 qual = FcQualNotFirst;
1730 FcConfigMessage (parse, FcSevereWarning, "invalid test qual \"%s\"", qual_string);
1734 name = FcConfigGetAttribute (parse, "name");
1737 FcConfigMessage (parse, FcSevereWarning, "missing test name");
1740 compare_string = FcConfigGetAttribute (parse, "compare");
1741 if (!compare_string)
1742 compare = FcOpEqual;
1745 compare = FcConfigLexCompare (compare_string);
1746 if (compare == FcOpInvalid)
1748 FcConfigMessage (parse, FcSevereWarning, "invalid test compare \"%s\"", compare_string);
1752 expr = FcPopBinary (parse, FcOpComma);
1755 FcConfigMessage (parse, FcSevereWarning, "missing test expression");
1758 test = FcTestCreate (parse, kind, qual, name, compare, expr);
1761 FcConfigMessage (parse, FcSevereError, "out of memory");
1764 FcVStackPushTest (parse, test);
1767 static const FcOpMap fcModeOps[] = {
1768 { "assign", FcOpAssign },
1769 { "assign_replace", FcOpAssignReplace },
1770 { "prepend", FcOpPrepend },
1771 { "prepend_first", FcOpPrependFirst },
1772 { "append", FcOpAppend },
1773 { "append_last", FcOpAppendLast },
1776 #define NUM_MODE_OPS (int) (sizeof fcModeOps / sizeof fcModeOps[0])
1779 FcConfigLexMode (const FcChar8 *mode)
1781 return FcConfigLexOp (mode, fcModeOps, NUM_MODE_OPS);
1785 FcParseEdit (FcConfigParse *parse)
1787 const FcChar8 *name;
1788 const FcChar8 *mode_string;
1790 FcValueBinding binding;
1794 name = FcConfigGetAttribute (parse, "name");
1797 FcConfigMessage (parse, FcSevereWarning, "missing edit name");
1800 mode_string = FcConfigGetAttribute (parse, "mode");
1805 mode = FcConfigLexMode (mode_string);
1806 if (mode == FcOpInvalid)
1808 FcConfigMessage (parse, FcSevereWarning, "invalid edit mode \"%s\"", mode_string);
1812 if (!FcConfigLexBinding (parse, FcConfigGetAttribute (parse, "binding"), &binding))
1815 expr = FcPopBinary (parse, FcOpComma);
1816 edit = FcEditCreate (parse, FcObjectFromName ((char *) name),
1817 mode, expr, binding);
1820 FcConfigMessage (parse, FcSevereError, "out of memory");
1821 FcExprDestroy (expr);
1824 if (!FcVStackPushEdit (parse, edit))
1825 FcEditDestroy (edit);
1829 FcParseMatch (FcConfigParse *parse)
1831 const FcChar8 *kind_name;
1837 kind_name = FcConfigGetAttribute (parse, "target");
1839 kind = FcMatchPattern;
1842 if (!strcmp ((char *) kind_name, "pattern"))
1843 kind = FcMatchPattern;
1844 else if (!strcmp ((char *) kind_name, "font"))
1846 else if (!strcmp ((char *) kind_name, "scan"))
1850 FcConfigMessage (parse, FcSevereWarning, "invalid match target \"%s\"", kind_name);
1854 while ((vstack = FcVStackPop (parse)))
1856 switch (vstack->tag) {
1858 vstack->u.test->next = test;
1859 test = vstack->u.test;
1860 vstack->tag = FcVStackNone;
1863 vstack->u.edit->next = edit;
1864 edit = vstack->u.edit;
1865 vstack->tag = FcVStackNone;
1866 if (kind == FcMatchScan && edit->object > FC_MAX_BASE_OBJECT)
1868 FcConfigMessage (parse, FcSevereError,
1869 "<match target=\"scan\"> cannot edit user-defined object \"%s\"",
1870 FcObjectName(edit->object));
1874 FcConfigMessage (parse, FcSevereWarning, "invalid match element");
1877 FcVStackDestroy (vstack);
1879 if (!FcConfigAddEdit (parse->config, test, edit, kind))
1880 FcConfigMessage (parse, FcSevereError, "out of memory");
1884 FcParseAcceptRejectFont (FcConfigParse *parse, FcElement element)
1888 while ((vstack = FcVStackPop (parse)))
1890 switch (vstack->tag) {
1892 if (!FcConfigGlobAdd (parse->config,
1894 element == FcElementAcceptfont))
1896 FcConfigMessage (parse, FcSevereError, "out of memory");
1899 case FcVStackPattern:
1900 if (!FcConfigPatternsAdd (parse->config,
1902 element == FcElementAcceptfont))
1904 FcConfigMessage (parse, FcSevereError, "out of memory");
1907 vstack->tag = FcVStackNone;
1910 FcConfigMessage (parse, FcSevereWarning, "bad font selector");
1913 FcVStackDestroy (vstack);
1919 FcPopValue (FcConfigParse *parse)
1921 FcVStack *vstack = FcVStackPop (parse);
1924 value.type = FcTypeVoid;
1929 switch (vstack->tag) {
1930 case FcVStackString:
1931 value.u.s = FcStrCopy (vstack->u.string);
1933 value.type = FcTypeString;
1935 case FcVStackConstant:
1936 if (FcNameConstant (vstack->u.string, &value.u.i))
1937 value.type = FcTypeInteger;
1939 case FcVStackInteger:
1940 value.u.i = vstack->u.integer;
1941 value.type = FcTypeInteger;
1943 case FcVStackDouble:
1944 value.u.d = vstack->u._double;
1945 value.type = FcTypeInteger;
1947 case FcVStackMatrix:
1948 value.u.m = FcMatrixCopy (vstack->u.matrix);
1950 value.type = FcTypeMatrix;
1953 value.u.b = vstack->u.bool;
1954 value.type = FcTypeBool;
1957 FcConfigMessage (parse, FcSevereWarning, "unknown pattern element %d",
1961 FcVStackDestroy (vstack);
1967 FcParsePatelt (FcConfigParse *parse)
1970 FcPattern *pattern = FcPatternCreate ();
1975 FcConfigMessage (parse, FcSevereError, "out of memory");
1979 name = (char *) FcConfigGetAttribute (parse, "name");
1982 FcConfigMessage (parse, FcSevereWarning, "missing pattern element name");
1983 FcPatternDestroy (pattern);
1989 value = FcPopValue (parse);
1990 if (value.type == FcTypeVoid)
1992 if (!FcPatternAdd (pattern, name, value, FcTrue))
1994 FcConfigMessage (parse, FcSevereError, "out of memory");
1999 FcVStackPushPattern (parse, pattern);
2003 FcParsePattern (FcConfigParse *parse)
2006 FcPattern *pattern = FcPatternCreate ();
2010 FcConfigMessage (parse, FcSevereError, "out of memory");
2014 while ((vstack = FcVStackPop (parse)))
2016 switch (vstack->tag) {
2017 case FcVStackPattern:
2018 if (!FcPatternAppend (pattern, vstack->u.pattern))
2020 FcConfigMessage (parse, FcSevereError, "out of memory");
2021 FcPatternDestroy (pattern);
2026 FcConfigMessage (parse, FcSevereWarning, "unknown pattern element");
2029 FcVStackDestroy (vstack);
2032 FcVStackPushPattern (parse, pattern);
2036 FcEndElement(void *userData, const XML_Char *name)
2038 FcConfigParse *parse = userData;
2043 switch (parse->pstack->element) {
2046 case FcElementFontconfig:
2049 data = FcStrBufDone (&parse->pstack->str);
2052 FcConfigMessage (parse, FcSevereError, "out of memory");
2056 if (strcmp (data, "WINDOWSFONTDIR") == 0)
2060 data = malloc (1000);
2063 FcConfigMessage (parse, FcSevereError, "out of memory");
2066 FcMemAlloc (FC_MEM_STRING, 1000);
2067 rc = GetWindowsDirectory (data, 800);
2068 if (rc == 0 || rc > 800)
2070 FcConfigMessage (parse, FcSevereError, "GetWindowsDirectory failed");
2074 if (data [strlen (data) - 1] != '\\')
2075 strcat (data, "\\");
2076 strcat (data, "fonts");
2079 if (!FcStrUsesHome (data) || FcConfigHome ())
2081 if (!FcConfigAddDir (parse->config, data))
2082 FcConfigMessage (parse, FcSevereError, "out of memory; cannot add directory %s", data);
2086 case FcElementCacheDir:
2087 data = FcStrBufDone (&parse->pstack->str);
2090 FcConfigMessage (parse, FcSevereError, "out of memory");
2094 if (strcmp (data, "WINDOWSTEMPDIR_FONTCONFIG_CACHE") == 0)
2098 data = malloc (1000);
2101 FcConfigMessage (parse, FcSevereError, "out of memory");
2104 FcMemAlloc (FC_MEM_STRING, 1000);
2105 rc = GetTempPath (800, data);
2106 if (rc == 0 || rc > 800)
2108 FcConfigMessage (parse, FcSevereError, "GetWindowsDirectory failed");
2112 if (data [strlen (data) - 1] != '\\')
2113 strcat (data, "\\");
2114 strcat (data, "fontconfig\\cache");
2117 if (!FcStrUsesHome (data) || FcConfigHome ())
2119 if (!FcConfigAddCacheDir (parse->config, data))
2120 FcConfigMessage (parse, FcSevereError, "out of memory; cannot add cache directory %s", data);
2125 case FcElementCache:
2126 data = FcStrBufDone (&parse->pstack->str);
2129 FcConfigMessage (parse, FcSevereError, "out of memory");
2132 /* discard this data; no longer used */
2135 case FcElementInclude:
2136 FcParseInclude (parse);
2138 case FcElementConfig:
2140 case FcElementMatch:
2141 FcParseMatch (parse);
2143 case FcElementAlias:
2144 FcParseAlias (parse);
2147 case FcElementBlank:
2148 FcParseBlank (parse);
2150 case FcElementRescan:
2151 FcParseRescan (parse);
2154 case FcElementPrefer:
2155 FcParseFamilies (parse, FcVStackPrefer);
2157 case FcElementAccept:
2158 FcParseFamilies (parse, FcVStackAccept);
2160 case FcElementDefault:
2161 FcParseFamilies (parse, FcVStackDefault);
2163 case FcElementFamily:
2164 FcParseFamily (parse);
2168 FcParseTest (parse);
2171 FcParseEdit (parse);
2177 case FcElementDouble:
2178 FcParseDouble (parse);
2180 case FcElementString:
2181 FcParseString (parse, FcVStackString);
2183 case FcElementMatrix:
2184 FcParseMatrix (parse);
2187 FcParseBool (parse);
2189 case FcElementCharset:
2190 /* FcParseCharset (parse); */
2192 case FcElementSelectfont:
2194 case FcElementAcceptfont:
2195 case FcElementRejectfont:
2196 FcParseAcceptRejectFont (parse, parse->pstack->element);
2199 FcParseString (parse, FcVStackGlob);
2201 case FcElementPattern:
2202 FcParsePattern (parse);
2204 case FcElementPatelt:
2205 FcParsePatelt (parse);
2208 FcParseString (parse, FcVStackField);
2210 case FcElementConst:
2211 FcParseString (parse, FcVStackConstant);
2214 FcParseBinary (parse, FcOpOr);
2217 FcParseBinary (parse, FcOpAnd);
2220 FcParseBinary (parse, FcOpEqual);
2222 case FcElementNotEq:
2223 FcParseBinary (parse, FcOpNotEqual);
2226 FcParseBinary (parse, FcOpLess);
2228 case FcElementLessEq:
2229 FcParseBinary (parse, FcOpLessEqual);
2232 FcParseBinary (parse, FcOpMore);
2234 case FcElementMoreEq:
2235 FcParseBinary (parse, FcOpMoreEqual);
2237 case FcElementContains:
2238 FcParseBinary (parse, FcOpContains);
2240 case FcElementNotContains:
2241 FcParseBinary (parse, FcOpNotContains);
2244 FcParseBinary (parse, FcOpPlus);
2246 case FcElementMinus:
2247 FcParseBinary (parse, FcOpMinus);
2249 case FcElementTimes:
2250 FcParseBinary (parse, FcOpTimes);
2252 case FcElementDivide:
2253 FcParseBinary (parse, FcOpDivide);
2256 FcParseUnary (parse, FcOpNot);
2259 FcParseBinary (parse, FcOpQuest);
2261 case FcElementFloor:
2262 FcParseUnary (parse, FcOpFloor);
2265 FcParseUnary (parse, FcOpCeil);
2267 case FcElementRound:
2268 FcParseUnary (parse, FcOpRound);
2270 case FcElementTrunc:
2271 FcParseUnary (parse, FcOpTrunc);
2273 case FcElementUnknown:
2276 (void) FcPStackPop (parse);
2280 FcCharacterData (void *userData, const XML_Char *s, int len)
2282 FcConfigParse *parse = userData;
2286 if (!FcStrBufData (&parse->pstack->str, (FcChar8 *) s, len))
2287 FcConfigMessage (parse, FcSevereError, "out of memory");
2291 FcStartDoctypeDecl (void *userData,
2292 const XML_Char *doctypeName,
2293 const XML_Char *sysid,
2294 const XML_Char *pubid,
2295 int has_internal_subset)
2297 FcConfigParse *parse = userData;
2299 if (strcmp ((char *) doctypeName, "fontconfig") != 0)
2300 FcConfigMessage (parse, FcSevereError, "invalid doctype \"%s\"", doctypeName);
2303 #ifdef ENABLE_LIBXML2
2306 FcInternalSubsetDecl (void *userData,
2307 const XML_Char *doctypeName,
2308 const XML_Char *sysid,
2309 const XML_Char *pubid)
2311 FcStartDoctypeDecl (userData, doctypeName, sysid, pubid, 1);
2315 FcExternalSubsetDecl (void *userData,
2316 const XML_Char *doctypeName,
2317 const XML_Char *sysid,
2318 const XML_Char *pubid)
2320 FcStartDoctypeDecl (userData, doctypeName, sysid, pubid, 0);
2323 #else /* ENABLE_LIBXML2 */
2326 FcEndDoctypeDecl (void *userData)
2330 #endif /* ENABLE_LIBXML2 */
2333 FcSortCmpStr (const void *a, const void *b)
2335 const FcChar8 *as = *((FcChar8 **) a);
2336 const FcChar8 *bs = *((FcChar8 **) b);
2337 return FcStrCmp (as, bs);
2341 FcConfigParseAndLoadDir (FcConfig *config,
2342 const FcChar8 *name,
2348 FcBool ret = FcTrue;
2353 d = opendir ((char *) dir);
2357 FcConfigMessage (0, FcSevereError, "Cannot open config dir \"%s\"",
2363 file = (FcChar8 *) malloc (strlen ((char *) dir) + 1 + FC_MAX_FILE_LEN + 1);
2370 strcpy ((char *) file, (char *) dir);
2371 strcat ((char *) file, "/");
2372 base = file + strlen ((char *) file);
2374 files = FcStrSetCreate ();
2381 if (FcDebug () & FC_DBG_CONFIG)
2382 printf ("\tScanning config dir %s\n", dir);
2384 while (ret && (e = readdir (d)))
2387 #define TAIL ".conf"
2390 * Add all files of the form [0-9]*.conf
2392 if ('0' <= e->d_name[0] && e->d_name[0] <= '9' &&
2393 (d_len = strlen (e->d_name)) < FC_MAX_FILE_LEN &&
2395 strcmp (e->d_name + d_len - TAIL_LEN, TAIL) == 0)
2397 strcpy ((char *) base, (char *) e->d_name);
2398 if (!FcStrSetAdd (files, file))
2408 qsort (files->strs, files->num, sizeof (FcChar8 *),
2409 (int (*)(const void *, const void *)) FcSortCmpStr);
2410 for (i = 0; ret && i < files->num; i++)
2411 ret = FcConfigParseAndLoad (config, files->strs[i], complain);
2414 FcStrSetDestroy (files);
2420 return ret || !complain;
2424 FcConfigParseAndLoad (FcConfig *config,
2425 const FcChar8 *name,
2433 FcConfigParse parse;
2434 FcBool error = FcTrue;
2436 #ifdef ENABLE_LIBXML2
2443 filename = FcConfigFilename (name);
2447 if (FcStrSetMember (config->configFiles, filename))
2449 FcStrFree (filename);
2453 if (!FcStrSetAdd (config->configFiles, filename))
2455 FcStrFree (filename);
2459 if (FcFileIsDir (filename))
2461 FcBool ret = FcConfigParseAndLoadDir (config, name, filename, complain);
2462 FcStrFree (filename);
2466 if (FcDebug () & FC_DBG_CONFIG)
2467 printf ("\tLoading config file %s\n", filename);
2469 fd = open ((char *) filename, O_RDONLY);
2471 FcStrFree (filename);
2475 #ifdef ENABLE_LIBXML2
2476 memset(&sax, 0, sizeof(sax));
2478 sax.internalSubset = FcInternalSubsetDecl;
2479 sax.externalSubset = FcExternalSubsetDecl;
2480 sax.startElement = FcStartElement;
2481 sax.endElement = FcEndElement;
2482 sax.characters = FcCharacterData;
2484 p = xmlCreatePushParserCtxt (&sax, &parse, NULL, 0, (const char *) filename);
2486 p = XML_ParserCreate ("UTF-8");
2488 FcStrFree (filename);
2493 if (!FcConfigInit (&parse, name, config, p))
2496 #ifndef ENABLE_LIBXML2
2498 XML_SetUserData (p, &parse);
2500 XML_SetDoctypeDeclHandler (p, FcStartDoctypeDecl, FcEndDoctypeDecl);
2501 XML_SetElementHandler (p, FcStartElement, FcEndElement);
2502 XML_SetCharacterDataHandler (p, FcCharacterData);
2504 #endif /* ENABLE_LIBXML2 */
2507 #ifndef ENABLE_LIBXML2
2508 buf = XML_GetBuffer (p, BUFSIZ);
2511 FcConfigMessage (&parse, FcSevereError, "cannot get parse buffer");
2515 len = read (fd, buf, BUFSIZ);
2518 FcConfigMessage (&parse, FcSevereError, "failed reading config file");
2522 #ifdef ENABLE_LIBXML2
2523 if (xmlParseChunk (p, buf, len, len == 0))
2525 if (!XML_ParseBuffer (p, len, len == 0))
2528 FcConfigMessage (&parse, FcSevereError, "%s",
2529 XML_ErrorString (XML_GetErrorCode (p)));
2533 error = parse.error;
2535 FcConfigCleanup (&parse);
2542 if (error && complain)
2545 FcConfigMessage (0, FcSevereError, "Cannot load config file \"%s\"", name);
2547 FcConfigMessage (0, FcSevereError, "Cannot load default config file");
2553 #include "fcaliastail.h"