2 * fontconfig/src/fcxml.c
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 the author(s) not be used in
11 * advertising or publicity pertaining to distribution of the software without
12 * specific, written prior permission. The authors make no
13 * representations about the suitability of this software for any purpose. It
14 * is provided "as is" without express or implied warranty.
16 * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
17 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
18 * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR
19 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
20 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
21 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
22 * PERFORMANCE OF THIS SOFTWARE.
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 */
56 #define _WIN32_WINNT 0x0500
64 FcExprDestroy (FcExpr *e);
67 FcTestDestroy (FcTest *test)
70 FcTestDestroy (test->next);
71 FcExprDestroy (test->expr);
72 FcMemFree (FC_MEM_TEST, sizeof (FcTest));
77 FcExprCreateInteger (FcConfig *config, int i)
79 FcExpr *e = FcConfigAllocExpr (config);
89 FcExprCreateDouble (FcConfig *config, double d)
91 FcExpr *e = FcConfigAllocExpr (config);
101 FcExprCreateString (FcConfig *config, const FcChar8 *s)
103 FcExpr *e = FcConfigAllocExpr (config);
107 e->u.sval = FcStrStaticName (s);
113 FcExprCreateMatrix (FcConfig *config, const FcMatrix *m)
115 FcExpr *e = FcConfigAllocExpr (config);
119 e->u.mval = FcMatrixCopy (m);
125 FcExprCreateBool (FcConfig *config, FcBool b)
127 FcExpr *e = FcConfigAllocExpr (config);
137 FcExprCreateCharSet (FcConfig *config, FcCharSet *charset)
139 FcExpr *e = FcConfigAllocExpr (config);
143 e->u.cval = FcCharSetCopy (charset);
149 FcExprCreateLangSet (FcConfig *config, FcLangSet *langset)
151 FcExpr *e = FcConfigAllocExpr (config);
155 e->u.lval = FcLangSetCopy (langset);
161 FcExprCreateField (FcConfig *config, const char *field)
163 FcExpr *e = FcConfigAllocExpr (config);
167 e->u.object = FcObjectFromName (field);
173 FcExprCreateConst (FcConfig *config, const FcChar8 *constant)
175 FcExpr *e = FcConfigAllocExpr (config);
179 e->u.constant = FcStrStaticName (constant);
185 FcExprCreateOp (FcConfig *config, FcExpr *left, FcOp op, FcExpr *right)
187 FcExpr *e = FcConfigAllocExpr (config);
191 e->u.tree.left = left;
192 e->u.tree.right = right;
198 FcExprDestroy (FcExpr *e)
210 FcMatrixFree (e->u.mval);
215 FcCharSetDestroy (e->u.cval);
218 FcLangSetDestroy (e->u.lval);
227 case FcOpAssignReplace:
229 case FcOpPrependFirst:
243 case FcOpNotContains:
250 FcExprDestroy (e->u.tree.right);
257 FcExprDestroy (e->u.tree.left);
268 FcEditDestroy (FcEdit *e)
271 FcEditDestroy (e->next);
273 FcExprDestroy (e->expr);
277 typedef enum _FcElement {
324 FcElementNotContains,
338 static const struct {
342 { "fontconfig", FcElementFontconfig },
343 { "dir", FcElementDir },
344 { "cachedir", FcElementCacheDir },
345 { "cache", FcElementCache },
346 { "include", FcElementInclude },
347 { "config", FcElementConfig },
348 { "match", FcElementMatch },
349 { "alias", FcElementAlias },
351 { "blank", FcElementBlank },
352 { "rescan", FcElementRescan },
354 { "prefer", FcElementPrefer },
355 { "accept", FcElementAccept },
356 { "default", FcElementDefault },
357 { "family", FcElementFamily },
359 { "selectfont", FcElementSelectfont },
360 { "acceptfont", FcElementAcceptfont },
361 { "rejectfont", FcElementRejectfont },
362 { "glob", FcElementGlob },
363 { "pattern", FcElementPattern },
364 { "patelt", FcElementPatelt },
366 { "test", FcElementTest },
367 { "edit", FcElementEdit },
368 { "int", FcElementInt },
369 { "double", FcElementDouble },
370 { "string", FcElementString },
371 { "matrix", FcElementMatrix },
372 { "range", FcElementRange },
373 { "bool", FcElementBool },
374 { "charset", FcElementCharSet },
375 { "langset", FcElementLangSet },
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;
417 FcChar8 *attr_buf_static[16];
420 typedef enum _FcVStackTag {
447 typedef struct _FcVStack {
448 struct _FcVStack *prev;
449 FcPStack *pstack; /* related parse element */
472 typedef struct _FcConfigParse {
479 int pstack_static_used;
480 FcPStack pstack_static[8];
481 int vstack_static_used;
482 FcVStack vstack_static[64];
485 typedef enum _FcConfigSeverity {
486 FcSevereInfo, FcSevereWarning, FcSevereError
490 FcConfigMessage (FcConfigParse *parse, FcConfigSeverity severe, const char *fmt, ...)
492 const char *s = "unknown";
495 va_start (args, fmt);
498 case FcSevereInfo: s = "info"; break;
499 case FcSevereWarning: s = "warning"; break;
500 case FcSevereError: s = "error"; break;
505 fprintf (stderr, "Fontconfig %s: \"%s\", line %d: ", s,
506 parse->name, (int)XML_GetCurrentLineNumber (parse->parser));
508 fprintf (stderr, "Fontconfig %s: line %d: ", s,
509 (int)XML_GetCurrentLineNumber (parse->parser));
510 if (severe >= FcSevereError)
511 parse->error = FcTrue;
514 fprintf (stderr, "Fontconfig %s: ", s);
515 vfprintf (stderr, fmt, args);
516 fprintf (stderr, "\n");
522 FcTypeName (FcType type)
548 FcTypecheckValue (FcConfigParse *parse, FcType value, FcType type)
550 if (value == FcTypeInteger)
551 value = FcTypeDouble;
552 if (type == FcTypeInteger)
556 if ((value == FcTypeLangSet && type == FcTypeString) ||
557 (value == FcTypeString && type == FcTypeLangSet))
559 if (type == (FcType) -1)
561 FcConfigMessage (parse, FcSevereWarning, "saw %s, expected %s",
562 FcTypeName (value), FcTypeName (type));
567 FcTypecheckExpr (FcConfigParse *parse, FcExpr *expr, FcType type)
569 const FcObjectType *o;
572 /* If parsing the expression failed, some nodes may be NULL */
579 FcTypecheckValue (parse, FcTypeDouble, type);
582 FcTypecheckValue (parse, FcTypeString, type);
585 FcTypecheckValue (parse, FcTypeMatrix, type);
588 FcTypecheckValue (parse, FcTypeBool, type);
591 FcTypecheckValue (parse, FcTypeCharSet, type);
594 FcTypecheckValue (parse, FcTypeLangSet, type);
599 o = FcNameGetObjectType (FcObjectName (expr->u.object));
601 FcTypecheckValue (parse, o->type, type);
604 c = FcNameGetConstant (expr->u.constant);
607 o = FcNameGetObjectType (c->object);
609 FcTypecheckValue (parse, o->type, type);
612 FcConfigMessage (parse, FcSevereWarning,
613 "invalid constant used : %s",
617 FcTypecheckExpr (parse, expr->u.tree.left, FcTypeBool);
618 FcTypecheckExpr (parse, expr->u.tree.right->u.tree.left, type);
619 FcTypecheckExpr (parse, expr->u.tree.right->u.tree.right, type);
622 case FcOpAssignReplace:
631 case FcOpNotContains:
633 FcTypecheckValue (parse, FcTypeBool, type);
642 FcTypecheckExpr (parse, expr->u.tree.left, type);
643 FcTypecheckExpr (parse, expr->u.tree.right, type);
646 FcTypecheckValue (parse, FcTypeBool, type);
647 FcTypecheckExpr (parse, expr->u.tree.left, FcTypeBool);
653 FcTypecheckValue (parse, FcTypeDouble, type);
654 FcTypecheckExpr (parse, expr->u.tree.left, FcTypeDouble);
662 FcTestCreate (FcConfigParse *parse,
665 const FcChar8 *field,
669 FcTest *test = (FcTest *) malloc (sizeof (FcTest));
673 const FcObjectType *o;
675 FcMemAlloc (FC_MEM_TEST, sizeof (FcTest));
679 test->object = FcObjectFromName ((const char *) field);
682 o = FcNameGetObjectType (FcObjectName (test->object));
684 FcTypecheckExpr (parse, expr, o->type);
690 FcEditCreate (FcConfigParse *parse,
694 FcValueBinding binding)
696 FcEdit *e = (FcEdit *) malloc (sizeof (FcEdit));
700 const FcObjectType *o;
706 e->binding = binding;
707 o = FcNameGetObjectType (FcObjectName (e->object));
709 FcTypecheckExpr (parse, expr, o->type);
715 FcVStackCreateAndPush (FcConfigParse *parse)
719 if (parse->vstack_static_used < sizeof (parse->vstack_static) / sizeof (parse->vstack_static[0]))
720 new = &parse->vstack_static[parse->vstack_static_used++];
723 new = malloc (sizeof (FcVStack));
726 FcMemAlloc (FC_MEM_VSTACK, sizeof (FcVStack));
728 new->tag = FcVStackNone;
731 new->prev = parse->vstack;
732 new->pstack = parse->pstack ? parse->pstack->prev : 0;
739 FcVStackPushString (FcConfigParse *parse, FcVStackTag tag, FcChar8 *string)
741 FcVStack *vstack = FcVStackCreateAndPush (parse);
744 vstack->u.string = string;
750 FcVStackPushInteger (FcConfigParse *parse, int integer)
752 FcVStack *vstack = FcVStackCreateAndPush (parse);
755 vstack->u.integer = integer;
756 vstack->tag = FcVStackInteger;
761 FcVStackPushDouble (FcConfigParse *parse, double _double)
763 FcVStack *vstack = FcVStackCreateAndPush (parse);
766 vstack->u._double = _double;
767 vstack->tag = FcVStackDouble;
772 FcVStackPushMatrix (FcConfigParse *parse, FcMatrix *matrix)
775 matrix = FcMatrixCopy (matrix);
778 vstack = FcVStackCreateAndPush (parse);
781 vstack->u.matrix = matrix;
782 vstack->tag = FcVStackMatrix;
787 FcVStackPushRange (FcConfigParse *parse, FcRange *range)
789 FcVStack *vstack = FcVStackCreateAndPush (parse);
792 vstack->u.range.begin = range->begin;
793 vstack->u.range.end = range->end;
794 vstack->tag = FcVStackRange;
799 FcVStackPushBool (FcConfigParse *parse, FcBool bool_)
801 FcVStack *vstack = FcVStackCreateAndPush (parse);
804 vstack->u.bool_ = bool_;
805 vstack->tag = FcVStackBool;
810 FcVStackPushCharSet (FcConfigParse *parse, FcCharSet *charset)
815 vstack = FcVStackCreateAndPush (parse);
818 vstack->u.charset = charset;
819 vstack->tag = FcVStackCharSet;
824 FcVStackPushLangSet (FcConfigParse *parse, FcLangSet *langset)
829 vstack = FcVStackCreateAndPush (parse);
832 vstack->u.langset = langset;
833 vstack->tag = FcVStackLangSet;
838 FcVStackPushTest (FcConfigParse *parse, FcTest *test)
840 FcVStack *vstack = FcVStackCreateAndPush (parse);
843 vstack->u.test = test;
844 vstack->tag = FcVStackTest;
849 FcVStackPushExpr (FcConfigParse *parse, FcVStackTag tag, FcExpr *expr)
851 FcVStack *vstack = FcVStackCreateAndPush (parse);
854 vstack->u.expr = expr;
860 FcVStackPushEdit (FcConfigParse *parse, FcEdit *edit)
862 FcVStack *vstack = FcVStackCreateAndPush (parse);
865 vstack->u.edit = edit;
866 vstack->tag = FcVStackEdit;
871 FcVStackPushPattern (FcConfigParse *parse, FcPattern *pattern)
873 FcVStack *vstack = FcVStackCreateAndPush (parse);
876 vstack->u.pattern = pattern;
877 vstack->tag = FcVStackPattern;
882 FcVStackFetch (FcConfigParse *parse, int off)
886 for (vstack = parse->vstack; vstack && off-- > 0; vstack = vstack->prev);
891 FcVStackPeek (FcConfigParse *parse)
893 FcVStack *vstack = parse->vstack;
895 return vstack && vstack->pstack == parse->pstack ? vstack : 0;
899 FcVStackPopAndDestroy (FcConfigParse *parse)
901 FcVStack *vstack = parse->vstack;
903 if (!vstack || vstack->pstack != parse->pstack)
906 parse->vstack = vstack->prev;
908 switch (vstack->tag) {
915 case FcVStackConstant:
917 FcStrFree (vstack->u.string);
919 case FcVStackPattern:
920 FcPatternDestroy (vstack->u.pattern);
922 case FcVStackInteger:
926 FcMatrixFree (vstack->u.matrix);
931 case FcVStackCharSet:
932 FcCharSetDestroy (vstack->u.charset);
934 case FcVStackLangSet:
935 FcLangSetDestroy (vstack->u.langset);
938 FcTestDestroy (vstack->u.test);
943 case FcVStackDefault:
944 FcExprDestroy (vstack->u.expr);
947 FcEditDestroy (vstack->u.edit);
951 if (vstack == &parse->vstack_static[parse->vstack_static_used - 1])
952 parse->vstack_static_used--;
955 FcMemFree (FC_MEM_VSTACK, sizeof (FcVStack));
961 FcVStackClear (FcConfigParse *parse)
963 while (FcVStackPeek (parse))
964 FcVStackPopAndDestroy (parse);
968 FcVStackElements (FcConfigParse *parse)
971 FcVStack *vstack = parse->vstack;
972 while (vstack && vstack->pstack == parse->pstack)
975 vstack = vstack->prev;
981 FcConfigSaveAttr (const XML_Char **attr, FcChar8 **buf, int size_bytes)
991 for (i = 0; attr[i]; i++)
992 slen += strlen ((char *) attr[i]) + 1;
995 slen += (i + 1) * sizeof (FcChar8 *);
996 if (slen <= size_bytes)
1000 new = malloc (slen);
1003 FcConfigMessage (0, FcSevereError, "out of memory");
1006 FcMemAlloc (FC_MEM_ATTR, 1); /* size is too expensive */
1008 s = (FcChar8 *) (new + (i + 1));
1009 for (i = 0; attr[i]; i++)
1012 strcpy ((char *) s, (char *) attr[i]);
1013 s += strlen ((char *) s) + 1;
1020 FcPStackPush (FcConfigParse *parse, FcElement element, const XML_Char **attr)
1024 if (parse->pstack_static_used < sizeof (parse->pstack_static) / sizeof (parse->pstack_static[0]))
1025 new = &parse->pstack_static[parse->pstack_static_used++];
1028 new = malloc (sizeof (FcPStack));
1031 FcMemAlloc (FC_MEM_PSTACK, sizeof (FcPStack));
1034 new->prev = parse->pstack;
1035 new->element = element;
1036 new->attr = FcConfigSaveAttr (attr, new->attr_buf_static, sizeof (new->attr_buf_static));
1037 FcStrBufInit (&new->str, 0, 0);
1038 parse->pstack = new;
1043 FcPStackPop (FcConfigParse *parse)
1049 FcConfigMessage (parse, FcSevereError, "mismatching element");
1052 FcVStackClear (parse);
1053 old = parse->pstack;
1054 parse->pstack = old->prev;
1055 FcStrBufDestroy (&old->str);
1056 if (old->attr && old->attr != old->attr_buf_static)
1058 FcMemFree (FC_MEM_ATTR, 1); /* size is to expensive */
1062 if (old == &parse->pstack_static[parse->pstack_static_used - 1])
1063 parse->pstack_static_used--;
1066 FcMemFree (FC_MEM_PSTACK, sizeof (FcPStack));
1073 FcConfigInit (FcConfigParse *parse, const FcChar8 *name, FcConfig *config, XML_Parser parser)
1076 parse->pstack_static_used = 0;
1078 parse->vstack_static_used = 0;
1079 parse->error = FcFalse;
1081 parse->config = config;
1082 parse->parser = parser;
1087 FcConfigCleanup (FcConfigParse *parse)
1089 while (parse->pstack)
1090 FcPStackPop (parse);
1093 static const FcChar8 *
1094 FcConfigGetAttribute (FcConfigParse *parse, const char *attr)
1100 attrs = parse->pstack->attr;
1106 if (!strcmp ((char *) *attrs, attr))
1114 FcStartElement(void *userData, const XML_Char *name, const XML_Char **attr)
1116 FcConfigParse *parse = userData;
1119 element = FcElementMap (name);
1120 if (element == FcElementUnknown)
1121 FcConfigMessage (parse, FcSevereWarning, "unknown element \"%s\"", name);
1123 if (!FcPStackPush (parse, element, attr))
1125 FcConfigMessage (parse, FcSevereError, "out of memory");
1132 FcParseBlank (FcConfigParse *parse)
1134 int n = FcVStackElements (parse);
1138 FcVStack *v = FcVStackFetch (parse, n);
1139 if (!parse->config->blanks)
1141 parse->config->blanks = FcBlanksCreate ();
1142 if (!parse->config->blanks)
1146 case FcVStackInteger:
1147 if (!FcBlanksAdd (parse->config->blanks, v->u.integer))
1151 for (i = v->u.range.begin; i <= v->u.range.end; i++)
1153 if (!FcBlanksAdd (parse->config->blanks, i))
1158 FcConfigMessage (parse, FcSevereError, "invalid element in blank");
1164 FcConfigMessage (parse, FcSevereError, "out of memory");
1168 FcParseRescan (FcConfigParse *parse)
1170 int n = FcVStackElements (parse);
1173 FcVStack *v = FcVStackFetch (parse, n);
1174 if (v->tag != FcVStackInteger)
1175 FcConfigMessage (parse, FcSevereWarning, "non-integer rescan");
1177 parse->config->rescanInterval = v->u.integer;
1182 FcParseInt (FcConfigParse *parse)
1189 s = FcStrBufDoneStatic (&parse->pstack->str);
1192 FcConfigMessage (parse, FcSevereError, "out of memory");
1196 l = (int) strtol ((char *) s, (char **)&end, 0);
1197 if (end != s + strlen ((char *) s))
1198 FcConfigMessage (parse, FcSevereError, "\"%s\": not a valid integer", s);
1200 FcVStackPushInteger (parse, l);
1201 FcStrBufDestroy (&parse->pstack->str);
1205 * idea copied from glib g_ascii_strtod with
1206 * permission of the author (Alexander Larsson)
1212 FcStrtod (char *s, char **end)
1214 struct lconv *locale_data;
1219 * Have to swap the decimal point to match the current locale
1220 * if that locale doesn't use 0x2e
1222 if ((dot = strchr (s, 0x2e)) &&
1223 (locale_data = localeconv ()) &&
1224 (locale_data->decimal_point[0] != 0x2e ||
1225 locale_data->decimal_point[1] != 0))
1228 int slen = strlen (s);
1229 int dlen = strlen (locale_data->decimal_point);
1231 if (slen + dlen > (int) sizeof (buf))
1241 strncpy (buf, s, dot - s);
1243 strcpy (buf + (dot - s), locale_data->decimal_point);
1244 /* rest of number */
1245 strcpy (buf + (dot - s) + dlen, dot + 1);
1247 v = strtod (buf, &buf_end);
1249 buf_end = s + (buf_end - buf);
1251 buf_end -= dlen - 1;
1258 v = strtod (s, end);
1263 FcParseDouble (FcConfigParse *parse)
1270 s = FcStrBufDoneStatic (&parse->pstack->str);
1273 FcConfigMessage (parse, FcSevereError, "out of memory");
1277 d = FcStrtod ((char *) s, (char **)&end);
1278 if (end != s + strlen ((char *) s))
1279 FcConfigMessage (parse, FcSevereError, "\"%s\": not a valid double", s);
1281 FcVStackPushDouble (parse, d);
1282 FcStrBufDestroy (&parse->pstack->str);
1286 FcParseString (FcConfigParse *parse, FcVStackTag tag)
1292 s = FcStrBufDone (&parse->pstack->str);
1295 FcConfigMessage (parse, FcSevereError, "out of memory");
1298 if (!FcVStackPushString (parse, tag, s))
1303 FcParseMatrix (FcConfigParse *parse)
1306 enum { m_done, m_xx, m_xy, m_yx, m_yy } matrix_state = m_yy;
1309 while ((vstack = FcVStackPeek (parse)))
1312 switch (vstack->tag) {
1313 case FcVStackInteger:
1314 v = vstack->u.integer;
1316 case FcVStackDouble:
1317 v = vstack->u._double;
1320 FcConfigMessage (parse, FcSevereError, "non-double matrix element");
1324 switch (matrix_state) {
1325 case m_xx: m.xx = v; break;
1326 case m_xy: m.xy = v; break;
1327 case m_yx: m.yx = v; break;
1328 case m_yy: m.yy = v; break;
1331 FcVStackPopAndDestroy (parse);
1334 if (matrix_state != m_done)
1335 FcConfigMessage (parse, FcSevereError, "wrong number of matrix elements");
1337 FcVStackPushMatrix (parse, &m);
1341 FcParseRange (FcConfigParse *parse)
1348 while ((vstack = FcVStackPeek (parse)))
1352 FcConfigMessage (parse, FcSevereError, "too many elements in range");
1355 switch (vstack->tag) {
1356 case FcVStackInteger:
1357 n = vstack->u.integer;
1360 FcConfigMessage (parse, FcSevereError, "invalid element in range");
1368 FcVStackPopAndDestroy (parse);
1372 if (r.begin > r.end)
1374 FcConfigMessage (parse, FcSevereError, "invalid range");
1377 FcVStackPushRange (parse, &r);
1380 FcConfigMessage (parse, FcSevereError, "invalid range");
1384 FcConfigLexBool (FcConfigParse *parse, const FcChar8 *bool_)
1386 FcBool result = FcFalse;
1388 if (!FcNameBool (bool_, &result))
1389 FcConfigMessage (parse, FcSevereWarning, "\"%s\" is not known boolean",
1395 FcParseBool (FcConfigParse *parse)
1401 s = FcStrBufDoneStatic (&parse->pstack->str);
1404 FcConfigMessage (parse, FcSevereError, "out of memory");
1407 FcVStackPushBool (parse, FcConfigLexBool (parse, s));
1408 FcStrBufDestroy (&parse->pstack->str);
1412 FcParseCharSet (FcConfigParse *parse)
1415 FcCharSet *charset = FcCharSetCreate ();
1419 while ((vstack = FcVStackPeek (parse)))
1421 switch (vstack->tag) {
1422 case FcVStackInteger:
1423 if (!FcCharSetAddChar (charset, vstack->u.integer))
1425 FcConfigMessage (parse, FcSevereWarning, "invalid character: 0x%04x", vstack->u.integer);
1431 for (i = vstack->u.range.begin; i <= vstack->u.range.end; i++)
1433 if (!FcCharSetAddChar (charset, i))
1435 FcConfigMessage (parse, FcSevereWarning, "invalid character: 0x%04x", i);
1442 FcConfigMessage (parse, FcSevereError, "invalid element in charset");
1445 FcVStackPopAndDestroy (parse);
1448 FcVStackPushCharSet (parse, charset);
1450 FcCharSetDestroy (charset);
1454 FcParseLangSet (FcConfigParse *parse)
1457 FcLangSet *langset = FcLangSetCreate ();
1460 while ((vstack = FcVStackPeek (parse)))
1462 switch (vstack->tag) {
1463 case FcVStackString:
1464 if (!FcLangSetAdd (langset, vstack->u.string))
1466 FcConfigMessage (parse, FcSevereWarning, "invalid langset: %s", vstack->u.string);
1472 FcConfigMessage (parse, FcSevereError, "invalid element in langset");
1475 FcVStackPopAndDestroy (parse);
1478 FcVStackPushLangSet (parse, langset);
1480 FcLangSetDestroy (langset);
1484 FcConfigLexBinding (FcConfigParse *parse,
1485 const FcChar8 *binding_string,
1486 FcValueBinding *binding_ret)
1488 FcValueBinding binding;
1490 if (!binding_string)
1491 binding = FcValueBindingWeak;
1494 if (!strcmp ((char *) binding_string, "weak"))
1495 binding = FcValueBindingWeak;
1496 else if (!strcmp ((char *) binding_string, "strong"))
1497 binding = FcValueBindingStrong;
1498 else if (!strcmp ((char *) binding_string, "same"))
1499 binding = FcValueBindingSame;
1502 FcConfigMessage (parse, FcSevereWarning, "invalid binding \"%s\"", binding_string);
1506 *binding_ret = binding;
1511 FcParseFamilies (FcConfigParse *parse, FcVStackTag tag)
1514 FcExpr *left, *expr = 0, *new;
1516 while ((vstack = FcVStackPeek (parse)))
1518 if (vstack->tag != FcVStackFamily)
1520 FcConfigMessage (parse, FcSevereWarning, "non-family");
1521 FcVStackPopAndDestroy (parse);
1524 left = vstack->u.expr;
1525 vstack->tag = FcVStackNone;
1526 FcVStackPopAndDestroy (parse);
1529 new = FcExprCreateOp (parse->config, left, FcOpComma, expr);
1532 FcConfigMessage (parse, FcSevereError, "out of memory");
1533 FcExprDestroy (left);
1534 FcExprDestroy (expr);
1544 if (!FcVStackPushExpr (parse, tag, expr))
1546 FcConfigMessage (parse, FcSevereError, "out of memory");
1547 FcExprDestroy (expr);
1553 FcParseFamily (FcConfigParse *parse)
1560 s = FcStrBufDoneStatic (&parse->pstack->str);
1563 FcConfigMessage (parse, FcSevereError, "out of memory");
1566 expr = FcExprCreateString (parse->config, s);
1567 FcStrBufDestroy (&parse->pstack->str);
1569 FcVStackPushExpr (parse, FcVStackFamily, expr);
1573 FcParseAlias (FcConfigParse *parse)
1575 FcExpr *family = 0, *accept = 0, *prefer = 0, *def = 0, *new = 0;
1576 FcEdit *edit = 0, *next;
1579 FcValueBinding binding;
1581 if (!FcConfigLexBinding (parse, FcConfigGetAttribute (parse, "binding"), &binding))
1583 while ((vstack = FcVStackPeek (parse)))
1585 switch (vstack->tag) {
1586 case FcVStackFamily:
1589 new = FcExprCreateOp (parse->config, vstack->u.expr, FcOpComma, family);
1591 FcConfigMessage (parse, FcSevereError, "out of memory");
1596 new = vstack->u.expr;
1600 vstack->tag = FcVStackNone;
1603 case FcVStackPrefer:
1605 FcExprDestroy (prefer);
1606 prefer = vstack->u.expr;
1607 vstack->tag = FcVStackNone;
1609 case FcVStackAccept:
1611 FcExprDestroy (accept);
1612 accept = vstack->u.expr;
1613 vstack->tag = FcVStackNone;
1615 case FcVStackDefault:
1617 FcExprDestroy (def);
1618 def = vstack->u.expr;
1619 vstack->tag = FcVStackNone;
1622 FcConfigMessage (parse, FcSevereWarning, "bad alias");
1625 FcVStackPopAndDestroy (parse);
1629 FcConfigMessage (parse, FcSevereError, "missing family in alias");
1631 FcExprDestroy (prefer);
1633 FcExprDestroy (accept);
1635 FcExprDestroy (def);
1640 edit = FcEditCreate (parse,
1648 FcExprDestroy (prefer);
1653 edit = FcEditCreate (parse,
1661 FcExprDestroy (accept);
1666 edit = FcEditCreate (parse,
1674 FcExprDestroy (def);
1678 test = FcTestCreate (parse, FcMatchPattern,
1680 (FcChar8 *) FC_FAMILY,
1684 if (!FcConfigAddEdit (parse->config, test, edit, FcMatchPattern))
1685 FcTestDestroy (test);
1688 FcExprDestroy (family);
1692 FcPopExpr (FcConfigParse *parse)
1694 FcVStack *vstack = FcVStackPeek (parse);
1698 switch (vstack->tag) {
1701 case FcVStackString:
1702 case FcVStackFamily:
1703 expr = FcExprCreateString (parse->config, vstack->u.string);
1706 expr = FcExprCreateField (parse->config, (char *) vstack->u.string);
1708 case FcVStackConstant:
1709 expr = FcExprCreateConst (parse->config, vstack->u.string);
1712 /* XXX: What's the correct action here? (CDW) */
1714 case FcVStackPrefer:
1715 case FcVStackAccept:
1716 case FcVStackDefault:
1717 expr = vstack->u.expr;
1718 vstack->tag = FcVStackNone;
1720 case FcVStackInteger:
1721 expr = FcExprCreateInteger (parse->config, vstack->u.integer);
1723 case FcVStackDouble:
1724 expr = FcExprCreateDouble (parse->config, vstack->u._double);
1726 case FcVStackMatrix:
1727 expr = FcExprCreateMatrix (parse->config, vstack->u.matrix);
1732 expr = FcExprCreateBool (parse->config, vstack->u.bool_);
1734 case FcVStackCharSet:
1735 expr = FcExprCreateCharSet (parse->config, vstack->u.charset);
1737 case FcVStackLangSet:
1738 expr = FcExprCreateLangSet (parse->config, vstack->u.langset);
1743 expr = vstack->u.expr;
1744 vstack->tag = FcVStackNone;
1751 FcVStackPopAndDestroy (parse);
1756 * This builds a tree of binary operations. Note
1757 * that every operator is defined so that if only
1758 * a single operand is contained, the value of the
1759 * whole expression is the value of the operand.
1761 * This code reduces in that case to returning that
1765 FcPopBinary (FcConfigParse *parse, FcOp op)
1767 FcExpr *left, *expr = 0, *new;
1769 while ((left = FcPopExpr (parse)))
1773 new = FcExprCreateOp (parse->config, left, op, expr);
1776 FcConfigMessage (parse, FcSevereError, "out of memory");
1777 FcExprDestroy (left);
1778 FcExprDestroy (expr);
1790 FcParseBinary (FcConfigParse *parse, FcOp op)
1792 FcExpr *expr = FcPopBinary (parse, op);
1794 FcVStackPushExpr (parse, FcVStackExpr, expr);
1798 * This builds a a unary operator, it consumes only
1803 FcPopUnary (FcConfigParse *parse, FcOp op)
1805 FcExpr *operand, *new = 0;
1807 if ((operand = FcPopExpr (parse)))
1809 new = FcExprCreateOp (parse->config, operand, op, 0);
1812 FcExprDestroy (operand);
1813 FcConfigMessage (parse, FcSevereError, "out of memory");
1820 FcParseUnary (FcConfigParse *parse, FcOp op)
1822 FcExpr *expr = FcPopUnary (parse, op);
1824 FcVStackPushExpr (parse, FcVStackExpr, expr);
1828 FcParseInclude (FcConfigParse *parse)
1832 FcBool ignore_missing = FcFalse;
1834 s = FcStrBufDoneStatic (&parse->pstack->str);
1837 FcConfigMessage (parse, FcSevereError, "out of memory");
1840 i = FcConfigGetAttribute (parse, "ignore_missing");
1841 if (i && FcConfigLexBool (parse, (FcChar8 *) i) == FcTrue)
1842 ignore_missing = FcTrue;
1843 if (!FcConfigParseAndLoad (parse->config, s, !ignore_missing))
1844 parse->error = FcTrue;
1845 FcStrBufDestroy (&parse->pstack->str);
1848 typedef struct _FcOpMap {
1854 FcConfigLexOp (const FcChar8 *op, const FcOpMap *map, int nmap)
1858 for (i = 0; i < nmap; i++)
1859 if (!strcmp ((char *) op, map[i].name))
1864 static const FcOpMap fcCompareOps[] = {
1865 { "eq", FcOpEqual },
1866 { "not_eq", FcOpNotEqual },
1867 { "less", FcOpLess },
1868 { "less_eq", FcOpLessEqual },
1869 { "more", FcOpMore },
1870 { "more_eq", FcOpMoreEqual },
1871 { "contains", FcOpContains },
1872 { "not_contains", FcOpNotContains }
1875 #define NUM_COMPARE_OPS (int) (sizeof fcCompareOps / sizeof fcCompareOps[0])
1878 FcConfigLexCompare (const FcChar8 *compare)
1880 return FcConfigLexOp (compare, fcCompareOps, NUM_COMPARE_OPS);
1884 FcParseTest (FcConfigParse *parse)
1886 const FcChar8 *kind_string;
1888 const FcChar8 *qual_string;
1890 const FcChar8 *name;
1891 const FcChar8 *compare_string;
1896 kind_string = FcConfigGetAttribute (parse, "target");
1898 kind = FcMatchDefault;
1901 if (!strcmp ((char *) kind_string, "pattern"))
1902 kind = FcMatchPattern;
1903 else if (!strcmp ((char *) kind_string, "font"))
1905 else if (!strcmp ((char *) kind_string, "scan"))
1907 else if (!strcmp ((char *) kind_string, "default"))
1908 kind = FcMatchDefault;
1911 FcConfigMessage (parse, FcSevereWarning, "invalid test target \"%s\"", kind_string);
1915 qual_string = FcConfigGetAttribute (parse, "qual");
1920 if (!strcmp ((char *) qual_string, "any"))
1922 else if (!strcmp ((char *) qual_string, "all"))
1924 else if (!strcmp ((char *) qual_string, "first"))
1926 else if (!strcmp ((char *) qual_string, "not_first"))
1927 qual = FcQualNotFirst;
1930 FcConfigMessage (parse, FcSevereWarning, "invalid test qual \"%s\"", qual_string);
1934 name = FcConfigGetAttribute (parse, "name");
1937 FcConfigMessage (parse, FcSevereWarning, "missing test name");
1940 compare_string = FcConfigGetAttribute (parse, "compare");
1941 if (!compare_string)
1942 compare = FcOpEqual;
1945 compare = FcConfigLexCompare (compare_string);
1946 if (compare == FcOpInvalid)
1948 FcConfigMessage (parse, FcSevereWarning, "invalid test compare \"%s\"", compare_string);
1952 expr = FcPopBinary (parse, FcOpComma);
1955 FcConfigMessage (parse, FcSevereWarning, "missing test expression");
1958 test = FcTestCreate (parse, kind, qual, name, compare, expr);
1961 FcConfigMessage (parse, FcSevereError, "out of memory");
1964 FcVStackPushTest (parse, test);
1967 static const FcOpMap fcModeOps[] = {
1968 { "assign", FcOpAssign },
1969 { "assign_replace", FcOpAssignReplace },
1970 { "prepend", FcOpPrepend },
1971 { "prepend_first", FcOpPrependFirst },
1972 { "append", FcOpAppend },
1973 { "append_last", FcOpAppendLast },
1976 #define NUM_MODE_OPS (int) (sizeof fcModeOps / sizeof fcModeOps[0])
1979 FcConfigLexMode (const FcChar8 *mode)
1981 return FcConfigLexOp (mode, fcModeOps, NUM_MODE_OPS);
1985 FcParseEdit (FcConfigParse *parse)
1987 const FcChar8 *name;
1988 const FcChar8 *mode_string;
1990 FcValueBinding binding;
1994 name = FcConfigGetAttribute (parse, "name");
1997 FcConfigMessage (parse, FcSevereWarning, "missing edit name");
2000 mode_string = FcConfigGetAttribute (parse, "mode");
2005 mode = FcConfigLexMode (mode_string);
2006 if (mode == FcOpInvalid)
2008 FcConfigMessage (parse, FcSevereWarning, "invalid edit mode \"%s\"", mode_string);
2012 if (!FcConfigLexBinding (parse, FcConfigGetAttribute (parse, "binding"), &binding))
2015 expr = FcPopBinary (parse, FcOpComma);
2016 edit = FcEditCreate (parse, FcObjectFromName ((char *) name),
2017 mode, expr, binding);
2020 FcConfigMessage (parse, FcSevereError, "out of memory");
2021 FcExprDestroy (expr);
2024 if (!FcVStackPushEdit (parse, edit))
2025 FcEditDestroy (edit);
2029 FcParseMatch (FcConfigParse *parse)
2031 const FcChar8 *kind_name;
2037 kind_name = FcConfigGetAttribute (parse, "target");
2039 kind = FcMatchPattern;
2042 if (!strcmp ((char *) kind_name, "pattern"))
2043 kind = FcMatchPattern;
2044 else if (!strcmp ((char *) kind_name, "font"))
2046 else if (!strcmp ((char *) kind_name, "scan"))
2050 FcConfigMessage (parse, FcSevereWarning, "invalid match target \"%s\"", kind_name);
2054 while ((vstack = FcVStackPeek (parse)))
2056 switch (vstack->tag) {
2058 vstack->u.test->next = test;
2059 test = vstack->u.test;
2060 vstack->tag = FcVStackNone;
2063 vstack->u.edit->next = edit;
2064 edit = vstack->u.edit;
2065 vstack->tag = FcVStackNone;
2066 if (kind == FcMatchScan && edit->object > FC_MAX_BASE_OBJECT)
2068 FcConfigMessage (parse, FcSevereError,
2069 "<match target=\"scan\"> cannot edit user-defined object \"%s\"",
2070 FcObjectName(edit->object));
2074 FcConfigMessage (parse, FcSevereWarning, "invalid match element");
2077 FcVStackPopAndDestroy (parse);
2079 if (!FcConfigAddEdit (parse->config, test, edit, kind))
2080 FcConfigMessage (parse, FcSevereError, "out of memory");
2084 FcParseAcceptRejectFont (FcConfigParse *parse, FcElement element)
2088 while ((vstack = FcVStackPeek (parse)))
2090 switch (vstack->tag) {
2092 if (!FcConfigGlobAdd (parse->config,
2094 element == FcElementAcceptfont))
2096 FcConfigMessage (parse, FcSevereError, "out of memory");
2099 case FcVStackPattern:
2100 if (!FcConfigPatternsAdd (parse->config,
2102 element == FcElementAcceptfont))
2104 FcConfigMessage (parse, FcSevereError, "out of memory");
2107 vstack->tag = FcVStackNone;
2110 FcConfigMessage (parse, FcSevereWarning, "bad font selector");
2113 FcVStackPopAndDestroy (parse);
2119 FcPopValue (FcConfigParse *parse)
2121 FcVStack *vstack = FcVStackPeek (parse);
2124 value.type = FcTypeVoid;
2129 switch (vstack->tag) {
2130 case FcVStackString:
2131 value.u.s = FcStrStaticName (vstack->u.string);
2133 value.type = FcTypeString;
2135 case FcVStackConstant:
2136 if (FcNameConstant (vstack->u.string, &value.u.i))
2137 value.type = FcTypeInteger;
2139 case FcVStackInteger:
2140 value.u.i = vstack->u.integer;
2141 value.type = FcTypeInteger;
2143 case FcVStackDouble:
2144 value.u.d = vstack->u._double;
2145 value.type = FcTypeInteger;
2147 case FcVStackMatrix:
2148 value.u.m = FcMatrixCopy (vstack->u.matrix);
2150 value.type = FcTypeMatrix;
2153 value.u.b = vstack->u.bool_;
2154 value.type = FcTypeBool;
2156 case FcVStackCharSet:
2157 value.u.c = FcCharSetCopy (vstack->u.charset);
2159 value.type = FcTypeCharSet;
2161 case FcVStackLangSet:
2162 value.u.l = FcLangSetCopy (vstack->u.langset);
2164 value.type = FcTypeLangSet;
2167 FcConfigMessage (parse, FcSevereWarning, "unknown pattern element %d",
2171 FcVStackPopAndDestroy (parse);
2177 FcParsePatelt (FcConfigParse *parse)
2180 FcPattern *pattern = FcPatternCreate ();
2185 FcConfigMessage (parse, FcSevereError, "out of memory");
2189 name = (char *) FcConfigGetAttribute (parse, "name");
2192 FcConfigMessage (parse, FcSevereWarning, "missing pattern element name");
2193 FcPatternDestroy (pattern);
2199 value = FcPopValue (parse);
2200 if (value.type == FcTypeVoid)
2202 if (!FcPatternAdd (pattern, name, value, FcTrue))
2204 FcConfigMessage (parse, FcSevereError, "out of memory");
2205 FcValueDestroy(value);
2208 FcValueDestroy(value);
2211 FcVStackPushPattern (parse, pattern);
2215 FcParsePattern (FcConfigParse *parse)
2218 FcPattern *pattern = FcPatternCreate ();
2222 FcConfigMessage (parse, FcSevereError, "out of memory");
2226 while ((vstack = FcVStackPeek (parse)))
2228 switch (vstack->tag) {
2229 case FcVStackPattern:
2230 if (!FcPatternAppend (pattern, vstack->u.pattern))
2232 FcConfigMessage (parse, FcSevereError, "out of memory");
2233 FcPatternDestroy (pattern);
2238 FcConfigMessage (parse, FcSevereWarning, "unknown pattern element");
2241 FcVStackPopAndDestroy (parse);
2244 FcVStackPushPattern (parse, pattern);
2248 FcEndElement(void *userData, const XML_Char *name)
2250 FcConfigParse *parse = userData;
2253 FcChar8 buffer[1000];
2258 switch (parse->pstack->element) {
2261 case FcElementFontconfig:
2264 data = FcStrBufDoneStatic (&parse->pstack->str);
2267 FcConfigMessage (parse, FcSevereError, "out of memory");
2271 if (strcmp (data, "CUSTOMFONTDIR") == 0)
2275 if (!GetModuleFileName (NULL, buffer, sizeof (buffer) - 20))
2277 FcConfigMessage (parse, FcSevereError, "GetModuleFileName failed");
2281 * Must use the multi-byte aware function to search
2282 * for backslash because East Asian double-byte code
2283 * pages have characters with backslash as the second
2286 p = _mbsrchr (data, '\\');
2288 strcat (data, "\\fonts");
2290 else if (strcmp (data, "APPSHAREFONTDIR") == 0)
2294 if (!GetModuleFileName (NULL, buffer, sizeof (buffer) - 20))
2296 FcConfigMessage (parse, FcSevereError, "GetModuleFileName failed");
2299 p = _mbsrchr (data, '\\');
2301 strcat (data, "\\..\\share\\fonts");
2303 else if (strcmp (data, "WINDOWSFONTDIR") == 0)
2307 #if _WIN32_WINNT >= 0x0500
2308 rc = GetSystemWindowsDirectory (buffer, sizeof (buffer) - 20);
2310 rc = GetWindowsDirectory (buffer, sizeof (buffer) - 20);
2312 if (rc == 0 || rc > sizeof (buffer) - 20)
2314 FcConfigMessage (parse, FcSevereError, "GetSystemWindowsDirectory failed");
2317 if (data [strlen (data) - 1] != '\\')
2318 strcat (data, "\\");
2319 strcat (data, "fonts");
2322 if (strlen ((char *) data) == 0)
2323 FcConfigMessage (parse, FcSevereWarning, "empty font directory name ignored");
2324 else if (!FcStrUsesHome (data) || FcConfigHome ())
2326 if (!FcConfigAddDir (parse->config, data))
2327 FcConfigMessage (parse, FcSevereError, "out of memory; cannot add directory %s", data);
2329 FcStrBufDestroy (&parse->pstack->str);
2331 case FcElementCacheDir:
2332 data = FcStrBufDone (&parse->pstack->str);
2335 FcConfigMessage (parse, FcSevereError, "out of memory");
2339 if (strcmp (data, "WINDOWSTEMPDIR_FONTCONFIG_CACHE") == 0)
2343 data = malloc (1000);
2346 FcConfigMessage (parse, FcSevereError, "out of memory");
2349 FcMemAlloc (FC_MEM_STRING, 1000);
2350 rc = GetTempPath (800, data);
2351 if (rc == 0 || rc > 800)
2353 FcConfigMessage (parse, FcSevereError, "GetTempPath failed");
2357 if (data [strlen (data) - 1] != '\\')
2358 strcat (data, "\\");
2359 strcat (data, "fontconfig\\cache");
2362 if (!FcStrUsesHome (data) || FcConfigHome ())
2364 if (!FcConfigAddCacheDir (parse->config, data))
2365 FcConfigMessage (parse, FcSevereError, "out of memory; cannot add cache directory %s", data);
2370 case FcElementCache:
2371 data = FcStrBufDoneStatic (&parse->pstack->str);
2374 FcConfigMessage (parse, FcSevereError, "out of memory");
2377 /* discard this data; no longer used */
2378 FcStrBufDestroy (&parse->pstack->str);
2380 case FcElementInclude:
2381 FcParseInclude (parse);
2383 case FcElementConfig:
2385 case FcElementMatch:
2386 FcParseMatch (parse);
2388 case FcElementAlias:
2389 FcParseAlias (parse);
2392 case FcElementBlank:
2393 FcParseBlank (parse);
2395 case FcElementRescan:
2396 FcParseRescan (parse);
2399 case FcElementPrefer:
2400 FcParseFamilies (parse, FcVStackPrefer);
2402 case FcElementAccept:
2403 FcParseFamilies (parse, FcVStackAccept);
2405 case FcElementDefault:
2406 FcParseFamilies (parse, FcVStackDefault);
2408 case FcElementFamily:
2409 FcParseFamily (parse);
2413 FcParseTest (parse);
2416 FcParseEdit (parse);
2422 case FcElementDouble:
2423 FcParseDouble (parse);
2425 case FcElementString:
2426 FcParseString (parse, FcVStackString);
2428 case FcElementMatrix:
2429 FcParseMatrix (parse);
2431 case FcElementRange:
2432 FcParseRange (parse);
2435 FcParseBool (parse);
2437 case FcElementCharSet:
2438 FcParseCharSet (parse);
2440 case FcElementLangSet:
2441 FcParseLangSet (parse);
2443 case FcElementSelectfont:
2445 case FcElementAcceptfont:
2446 case FcElementRejectfont:
2447 FcParseAcceptRejectFont (parse, parse->pstack->element);
2450 FcParseString (parse, FcVStackGlob);
2452 case FcElementPattern:
2453 FcParsePattern (parse);
2455 case FcElementPatelt:
2456 FcParsePatelt (parse);
2459 FcParseString (parse, FcVStackField);
2461 case FcElementConst:
2462 FcParseString (parse, FcVStackConstant);
2465 FcParseBinary (parse, FcOpOr);
2468 FcParseBinary (parse, FcOpAnd);
2471 FcParseBinary (parse, FcOpEqual);
2473 case FcElementNotEq:
2474 FcParseBinary (parse, FcOpNotEqual);
2477 FcParseBinary (parse, FcOpLess);
2479 case FcElementLessEq:
2480 FcParseBinary (parse, FcOpLessEqual);
2483 FcParseBinary (parse, FcOpMore);
2485 case FcElementMoreEq:
2486 FcParseBinary (parse, FcOpMoreEqual);
2488 case FcElementContains:
2489 FcParseBinary (parse, FcOpContains);
2491 case FcElementNotContains:
2492 FcParseBinary (parse, FcOpNotContains);
2495 FcParseBinary (parse, FcOpPlus);
2497 case FcElementMinus:
2498 FcParseBinary (parse, FcOpMinus);
2500 case FcElementTimes:
2501 FcParseBinary (parse, FcOpTimes);
2503 case FcElementDivide:
2504 FcParseBinary (parse, FcOpDivide);
2507 FcParseUnary (parse, FcOpNot);
2510 FcParseBinary (parse, FcOpQuest);
2512 case FcElementFloor:
2513 FcParseUnary (parse, FcOpFloor);
2516 FcParseUnary (parse, FcOpCeil);
2518 case FcElementRound:
2519 FcParseUnary (parse, FcOpRound);
2521 case FcElementTrunc:
2522 FcParseUnary (parse, FcOpTrunc);
2524 case FcElementUnknown:
2527 (void) FcPStackPop (parse);
2531 FcCharacterData (void *userData, const XML_Char *s, int len)
2533 FcConfigParse *parse = userData;
2537 if (!FcStrBufData (&parse->pstack->str, (FcChar8 *) s, len))
2538 FcConfigMessage (parse, FcSevereError, "out of memory");
2542 FcStartDoctypeDecl (void *userData,
2543 const XML_Char *doctypeName,
2544 const XML_Char *sysid,
2545 const XML_Char *pubid,
2546 int has_internal_subset)
2548 FcConfigParse *parse = userData;
2550 if (strcmp ((char *) doctypeName, "fontconfig") != 0)
2551 FcConfigMessage (parse, FcSevereError, "invalid doctype \"%s\"", doctypeName);
2554 #ifdef ENABLE_LIBXML2
2557 FcInternalSubsetDecl (void *userData,
2558 const XML_Char *doctypeName,
2559 const XML_Char *sysid,
2560 const XML_Char *pubid)
2562 FcStartDoctypeDecl (userData, doctypeName, sysid, pubid, 1);
2566 FcExternalSubsetDecl (void *userData,
2567 const XML_Char *doctypeName,
2568 const XML_Char *sysid,
2569 const XML_Char *pubid)
2571 FcStartDoctypeDecl (userData, doctypeName, sysid, pubid, 0);
2574 #else /* ENABLE_LIBXML2 */
2577 FcEndDoctypeDecl (void *userData)
2581 #endif /* ENABLE_LIBXML2 */
2584 FcSortCmpStr (const void *a, const void *b)
2586 const FcChar8 *as = *((FcChar8 **) a);
2587 const FcChar8 *bs = *((FcChar8 **) b);
2588 return FcStrCmp (as, bs);
2592 FcConfigParseAndLoadDir (FcConfig *config,
2593 const FcChar8 *name,
2599 FcBool ret = FcTrue;
2604 d = opendir ((char *) dir);
2608 FcConfigMessage (0, FcSevereError, "Cannot open config dir \"%s\"",
2614 file = (FcChar8 *) malloc (strlen ((char *) dir) + 1 + FC_MAX_FILE_LEN + 1);
2621 strcpy ((char *) file, (char *) dir);
2622 strcat ((char *) file, "/");
2623 base = file + strlen ((char *) file);
2625 files = FcStrSetCreate ();
2632 if (FcDebug () & FC_DBG_CONFIG)
2633 printf ("\tScanning config dir %s\n", dir);
2635 while (ret && (e = readdir (d)))
2638 #define TAIL ".conf"
2641 * Add all files of the form [0-9]*.conf
2643 if ('0' <= e->d_name[0] && e->d_name[0] <= '9' &&
2644 (d_len = strlen (e->d_name)) < FC_MAX_FILE_LEN &&
2646 strcmp (e->d_name + d_len - TAIL_LEN, TAIL) == 0)
2648 strcpy ((char *) base, (char *) e->d_name);
2649 if (!FcStrSetAdd (files, file))
2659 qsort (files->strs, files->num, sizeof (FcChar8 *),
2660 (int (*)(const void *, const void *)) FcSortCmpStr);
2661 for (i = 0; ret && i < files->num; i++)
2662 ret = FcConfigParseAndLoad (config, files->strs[i], complain);
2665 FcStrSetDestroy (files);
2671 return ret || !complain;
2675 FcConfigParseAndLoad (FcConfig *config,
2676 const FcChar8 *name,
2684 FcConfigParse parse;
2685 FcBool error = FcTrue;
2687 #ifdef ENABLE_LIBXML2
2694 filename = FcConfigFilename (name);
2698 if (FcStrSetMember (config->configFiles, filename))
2700 FcStrFree (filename);
2704 if (!FcStrSetAdd (config->configFiles, filename))
2706 FcStrFree (filename);
2710 if (FcFileIsDir (filename))
2712 FcBool ret = FcConfigParseAndLoadDir (config, name, filename, complain);
2713 FcStrFree (filename);
2717 if (FcDebug () & FC_DBG_CONFIG)
2718 printf ("\tLoading config file %s\n", filename);
2720 fd = open ((char *) filename, O_RDONLY);
2722 FcStrFree (filename);
2726 #ifdef ENABLE_LIBXML2
2727 memset(&sax, 0, sizeof(sax));
2729 sax.internalSubset = FcInternalSubsetDecl;
2730 sax.externalSubset = FcExternalSubsetDecl;
2731 sax.startElement = FcStartElement;
2732 sax.endElement = FcEndElement;
2733 sax.characters = FcCharacterData;
2735 p = xmlCreatePushParserCtxt (&sax, &parse, NULL, 0, (const char *) filename);
2737 p = XML_ParserCreate ("UTF-8");
2739 FcStrFree (filename);
2744 if (!FcConfigInit (&parse, name, config, p))
2747 #ifndef ENABLE_LIBXML2
2749 XML_SetUserData (p, &parse);
2751 XML_SetDoctypeDeclHandler (p, FcStartDoctypeDecl, FcEndDoctypeDecl);
2752 XML_SetElementHandler (p, FcStartElement, FcEndElement);
2753 XML_SetCharacterDataHandler (p, FcCharacterData);
2755 #endif /* ENABLE_LIBXML2 */
2758 #ifndef ENABLE_LIBXML2
2759 buf = XML_GetBuffer (p, BUFSIZ);
2762 FcConfigMessage (&parse, FcSevereError, "cannot get parse buffer");
2766 len = read (fd, buf, BUFSIZ);
2769 FcConfigMessage (&parse, FcSevereError, "failed reading config file");
2773 #ifdef ENABLE_LIBXML2
2774 if (xmlParseChunk (p, buf, len, len == 0))
2776 if (!XML_ParseBuffer (p, len, len == 0))
2779 FcConfigMessage (&parse, FcSevereError, "%s",
2780 XML_ErrorString (XML_GetErrorCode (p)));
2784 error = parse.error;
2786 FcConfigCleanup (&parse);
2793 if (error && complain)
2796 FcConfigMessage (0, FcSevereError, "Cannot load config file \"%s\"", name);
2798 FcConfigMessage (0, FcSevereError, "Cannot load default config file");
2804 #include "fcaliastail.h"