]>
git.wh0rd.org - fontconfig.git/blob - src/fcxml.c
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.
31 #include <libxml/parser.h>
33 #define XML_Char xmlChar
34 #define XML_Parser xmlParserCtxtPtr
35 #define XML_ParserFree xmlFreeParserCtxt
36 #define XML_GetCurrentLineNumber xmlSAX2GetLineNumber
37 #define XML_GetErrorCode xmlCtxtGetLastError
38 #define XML_ErrorString(Error) (Error)->message
40 #else /* ENABLE_LIBXML2 */
42 #ifndef HAVE_XMLPARSE_H
43 #define HAVE_XMLPARSE_H 0
52 #endif /* ENABLE_LIBXML2 */
62 FcTestDestroy (FcTest
*test
)
65 FcTestDestroy (test
->next
);
66 FcExprDestroy (test
->expr
);
67 FcStrFree ((FcChar8
*) test
->field
);
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
.field
= (char *) FcStrCopy ((FcChar8
*) 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
);
220 FcStrFree ((FcChar8
*) e
->u
.field
);
223 FcStrFree (e
->u
.constant
);
226 case FcOpAssignReplace
:
228 case FcOpPrependFirst
:
242 case FcOpNotContains
:
249 FcExprDestroy (e
->u
.tree
.right
);
256 FcExprDestroy (e
->u
.tree
.left
);
262 FcMemFree (FC_MEM_EXPR
, sizeof (FcExpr
));
267 FcEditDestroy (FcEdit
*e
)
270 FcEditDestroy (e
->next
);
271 FcStrFree ((FcChar8
*) e
->field
);
273 FcExprDestroy (e
->expr
);
278 FcConfigSaveField (const char *field
)
280 return (char *) FcStrCopy ((FcChar8
*) field
);
283 typedef enum _FcElement
{
327 FcElementNotContains
,
345 { "fontconfig", FcElementFontconfig
},
346 { "dir", FcElementDir
},
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
, XML_GetCurrentLineNumber (parse
->parser
));
497 fprintf (stderr
, "Fontconfig %s: line %d: ", s
,
498 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 FcConfigMessage (parse
, FcSevereWarning
, "saw %s, expected %s",
549 FcTypeName (value
), FcTypeName (type
));
554 FcTypecheckExpr (FcConfigParse
*parse
, FcExpr
*expr
, FcType type
)
556 const FcObjectType
*o
;
562 FcTypecheckValue (parse
, FcTypeDouble
, type
);
565 FcTypecheckValue (parse
, FcTypeString
, type
);
568 FcTypecheckValue (parse
, FcTypeMatrix
, type
);
571 FcTypecheckValue (parse
, FcTypeBool
, type
);
574 FcTypecheckValue (parse
, FcTypeCharSet
, type
);
579 o
= FcNameGetObjectType (expr
->u
.field
);
581 FcTypecheckValue (parse
, o
->type
, type
);
584 c
= FcNameGetConstant (expr
->u
.constant
);
587 o
= FcNameGetObjectType (c
->object
);
589 FcTypecheckValue (parse
, o
->type
, type
);
592 FcConfigMessage (parse
, FcSevereWarning
,
593 "invalid constant used : %s",
597 FcTypecheckExpr (parse
, expr
->u
.tree
.left
, FcTypeBool
);
598 FcTypecheckExpr (parse
, expr
->u
.tree
.right
->u
.tree
.left
, type
);
599 FcTypecheckExpr (parse
, expr
->u
.tree
.right
->u
.tree
.right
, type
);
602 case FcOpAssignReplace
:
611 case FcOpNotContains
:
613 FcTypecheckValue (parse
, FcTypeBool
, type
);
622 FcTypecheckExpr (parse
, expr
->u
.tree
.left
, type
);
623 FcTypecheckExpr (parse
, expr
->u
.tree
.right
, type
);
626 FcTypecheckValue (parse
, FcTypeBool
, type
);
627 FcTypecheckExpr (parse
, expr
->u
.tree
.left
, FcTypeBool
);
633 FcTypecheckValue (parse
, FcTypeDouble
, type
);
634 FcTypecheckExpr (parse
, expr
->u
.tree
.left
, FcTypeDouble
);
642 FcTestCreate (FcConfigParse
*parse
,
645 const FcChar8
*field
,
649 FcTest
*test
= (FcTest
*) malloc (sizeof (FcTest
));
653 const FcObjectType
*o
;
655 FcMemAlloc (FC_MEM_TEST
, sizeof (FcTest
));
659 test
->field
= (char *) FcStrCopy (field
);
662 o
= FcNameGetObjectType (test
->field
);
664 FcTypecheckExpr (parse
, expr
, o
->type
);
670 FcEditCreate (FcConfigParse
*parse
,
674 FcValueBinding binding
)
676 FcEdit
*e
= (FcEdit
*) malloc (sizeof (FcEdit
));
680 const FcObjectType
*o
;
683 e
->field
= field
; /* already saved in grammar */
686 e
->binding
= binding
;
687 o
= FcNameGetObjectType (e
->field
);
689 FcTypecheckExpr (parse
, expr
, o
->type
);
695 FcVStackPush (FcConfigParse
*parse
, FcVStack
*vstack
)
697 vstack
->prev
= parse
->vstack
;
698 vstack
->pstack
= parse
->pstack
? parse
->pstack
->prev
: 0;
699 parse
->vstack
= vstack
;
703 FcVStackCreate (void)
707 new = malloc (sizeof (FcVStack
));
710 FcMemAlloc (FC_MEM_VSTACK
, sizeof (FcVStack
));
711 new->tag
= FcVStackNone
;
717 FcVStackDestroy (FcVStack
*vstack
)
721 for (; vstack
; vstack
= prev
)
724 switch (vstack
->tag
) {
730 case FcVStackConstant
:
732 FcStrFree (vstack
->u
.string
);
734 case FcVStackPattern
:
735 FcPatternDestroy (vstack
->u
.pattern
);
737 case FcVStackInteger
:
741 FcMatrixFree (vstack
->u
.matrix
);
746 FcTestDestroy (vstack
->u
.test
);
751 case FcVStackDefault
:
752 FcExprDestroy (vstack
->u
.expr
);
755 FcEditDestroy (vstack
->u
.edit
);
758 FcMemFree (FC_MEM_VSTACK
, sizeof (FcVStack
));
764 FcVStackPushString (FcConfigParse
*parse
, FcVStackTag tag
, FcChar8
*string
)
766 FcVStack
*vstack
= FcVStackCreate ();
769 vstack
->u
.string
= string
;
771 FcVStackPush (parse
, vstack
);
776 FcVStackPushInteger (FcConfigParse
*parse
, int integer
)
778 FcVStack
*vstack
= FcVStackCreate ();
781 vstack
->u
.integer
= integer
;
782 vstack
->tag
= FcVStackInteger
;
783 FcVStackPush (parse
, vstack
);
788 FcVStackPushDouble (FcConfigParse
*parse
, double _double
)
790 FcVStack
*vstack
= FcVStackCreate ();
793 vstack
->u
._double
= _double
;
794 vstack
->tag
= FcVStackDouble
;
795 FcVStackPush (parse
, vstack
);
800 FcVStackPushMatrix (FcConfigParse
*parse
, FcMatrix
*matrix
)
802 FcVStack
*vstack
= FcVStackCreate ();
805 matrix
= FcMatrixCopy (matrix
);
808 FcVStackDestroy (vstack
);
811 vstack
->u
.matrix
= matrix
;
812 vstack
->tag
= FcVStackMatrix
;
813 FcVStackPush (parse
, vstack
);
818 FcVStackPushBool (FcConfigParse
*parse
, FcBool
bool)
820 FcVStack
*vstack
= FcVStackCreate ();
823 vstack
->u
.bool = bool;
824 vstack
->tag
= FcVStackBool
;
825 FcVStackPush (parse
, vstack
);
830 FcVStackPushTest (FcConfigParse
*parse
, FcTest
*test
)
832 FcVStack
*vstack
= FcVStackCreate ();
835 vstack
->u
.test
= test
;
836 vstack
->tag
= FcVStackTest
;
837 FcVStackPush (parse
, vstack
);
842 FcVStackPushExpr (FcConfigParse
*parse
, FcVStackTag tag
, FcExpr
*expr
)
844 FcVStack
*vstack
= FcVStackCreate ();
847 vstack
->u
.expr
= expr
;
849 FcVStackPush (parse
, vstack
);
854 FcVStackPushEdit (FcConfigParse
*parse
, FcEdit
*edit
)
856 FcVStack
*vstack
= FcVStackCreate ();
859 vstack
->u
.edit
= edit
;
860 vstack
->tag
= FcVStackEdit
;
861 FcVStackPush (parse
, vstack
);
866 FcVStackPushPattern (FcConfigParse
*parse
, FcPattern
*pattern
)
868 FcVStack
*vstack
= FcVStackCreate ();
871 vstack
->u
.pattern
= pattern
;
872 vstack
->tag
= FcVStackPattern
;
873 FcVStackPush (parse
, vstack
);
878 FcVStackFetch (FcConfigParse
*parse
, int off
)
882 for (vstack
= parse
->vstack
; vstack
&& off
-- > 0; vstack
= vstack
->prev
);
887 FcVStackClear (FcConfigParse
*parse
)
889 while (parse
->vstack
&& parse
->vstack
->pstack
== parse
->pstack
)
891 FcVStack
*vstack
= parse
->vstack
;
892 parse
->vstack
= vstack
->prev
;
894 FcVStackDestroy (vstack
);
899 FcVStackPop (FcConfigParse
*parse
)
901 FcVStack
*vstack
= parse
->vstack
;
903 if (!vstack
|| vstack
->pstack
!= parse
->pstack
)
905 parse
->vstack
= vstack
->prev
;
911 FcVStackElements (FcConfigParse
*parse
)
914 FcVStack
*vstack
= parse
->vstack
;
915 while (vstack
&& vstack
->pstack
== parse
->pstack
)
918 vstack
= vstack
->prev
;
924 FcConfigSaveAttr (const XML_Char
**attr
)
935 for (i
= 0; attr
[i
]; i
++)
936 slen
+= strlen ((char *) attr
[i
]) + 1;
938 new = malloc ((i
+ 1) * sizeof (FcChar8
*) + slen
);
941 FcMemAlloc (FC_MEM_ATTR
, 1); /* size is too expensive */
942 s
= (FcChar8
*) (new + (i
+ 1));
943 for (i
= 0; attr
[i
]; i
++)
946 strcpy ((char *) s
, (char *) attr
[i
]);
947 s
+= strlen ((char *) s
) + 1;
954 FcPStackPush (FcConfigParse
*parse
, FcElement element
, const XML_Char
**attr
)
956 FcPStack
*new = malloc (sizeof (FcPStack
));
960 FcMemAlloc (FC_MEM_PSTACK
, sizeof (FcPStack
));
961 new->prev
= parse
->pstack
;
962 new->element
= element
;
965 new->attr
= FcConfigSaveAttr (attr
);
967 FcConfigMessage (parse
, FcSevereError
, "out of memory");
971 FcStrBufInit (&new->str
, 0, 0);
977 FcPStackPop (FcConfigParse
*parse
)
983 FcConfigMessage (parse
, FcSevereError
, "mismatching element");
986 FcVStackClear (parse
);
988 parse
->pstack
= old
->prev
;
989 FcStrBufDestroy (&old
->str
);
992 FcMemFree (FC_MEM_ATTR
, 1); /* size is to expensive */
995 FcMemFree (FC_MEM_PSTACK
, sizeof (FcPStack
));
1001 FcConfigInit (FcConfigParse
*parse
, const FcChar8
*name
, FcConfig
*config
, XML_Parser parser
)
1005 parse
->error
= FcFalse
;
1007 parse
->config
= config
;
1008 parse
->parser
= parser
;
1013 FcConfigCleanup (FcConfigParse
*parse
)
1015 while (parse
->pstack
)
1016 FcPStackPop (parse
);
1019 static const FcChar8
*
1020 FcConfigGetAttribute (FcConfigParse
*parse
, const char *attr
)
1026 attrs
= parse
->pstack
->attr
;
1029 if (!strcmp ((char *) *attrs
, attr
))
1037 FcStartElement(void *userData
, const XML_Char
*name
, const XML_Char
**attr
)
1039 FcConfigParse
*parse
= userData
;
1042 element
= FcElementMap (name
);
1043 if (element
== FcElementUnknown
)
1044 FcConfigMessage (parse
, FcSevereWarning
, "unknown element \"%s\"", name
);
1046 if (!FcPStackPush (parse
, element
, attr
))
1048 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1055 FcParseBlank (FcConfigParse
*parse
)
1057 int n
= FcVStackElements (parse
);
1060 FcVStack
*v
= FcVStackFetch (parse
, n
);
1061 if (v
->tag
!= FcVStackInteger
)
1062 FcConfigMessage (parse
, FcSevereError
, "non-integer blank");
1065 if (!parse
->config
->blanks
)
1067 parse
->config
->blanks
= FcBlanksCreate ();
1068 if (!parse
->config
->blanks
)
1070 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1074 if (!FcBlanksAdd (parse
->config
->blanks
, v
->u
.integer
))
1076 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1084 FcParseRescan (FcConfigParse
*parse
)
1086 int n
= FcVStackElements (parse
);
1089 FcVStack
*v
= FcVStackFetch (parse
, n
);
1090 if (v
->tag
!= FcVStackInteger
)
1091 FcConfigMessage (parse
, FcSevereWarning
, "non-integer rescan");
1093 parse
->config
->rescanInterval
= v
->u
.integer
;
1098 FcParseInt (FcConfigParse
*parse
)
1105 s
= FcStrBufDone (&parse
->pstack
->str
);
1108 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1112 l
= (int) strtol ((char *) s
, (char **)&end
, 0);
1113 if (end
!= s
+ strlen ((char *) s
))
1114 FcConfigMessage (parse
, FcSevereError
, "\"%s\": not a valid integer", s
);
1116 FcVStackPushInteger (parse
, l
);
1121 * idea copied from glib g_ascii_strtod with
1122 * permission of the author (Alexander Larsson)
1128 FcStrtod (char *s
, char **end
)
1130 struct lconv
*locale_data
;
1135 * Have to swap the decimal point to match the current locale
1136 * if that locale doesn't use 0x2e
1138 if ((dot
= strchr (s
, 0x2e)) &&
1139 (locale_data
= localeconv ()) &&
1140 (locale_data
->decimal_point
[0] != 0x2e ||
1141 locale_data
->decimal_point
[1] != 0))
1144 int slen
= strlen (s
);
1145 int dlen
= strlen (locale_data
->decimal_point
);
1147 if (slen
+ dlen
> (int) sizeof (buf
))
1157 strncpy (buf
, s
, dot
- s
);
1159 strcpy (buf
+ (dot
- s
), locale_data
->decimal_point
);
1160 /* rest of number */
1161 strcpy (buf
+ (dot
- s
) + dlen
, dot
+ 1);
1163 v
= strtod (buf
, &buf_end
);
1165 buf_end
= s
+ (buf_end
- buf
);
1167 buf_end
-= dlen
- 1;
1174 v
= strtod (s
, end
);
1179 FcParseDouble (FcConfigParse
*parse
)
1186 s
= FcStrBufDone (&parse
->pstack
->str
);
1189 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1193 d
= FcStrtod ((char *) s
, (char **)&end
);
1194 if (end
!= s
+ strlen ((char *) s
))
1195 FcConfigMessage (parse
, FcSevereError
, "\"%s\": not a valid double", s
);
1197 FcVStackPushDouble (parse
, d
);
1202 FcParseString (FcConfigParse
*parse
, FcVStackTag tag
)
1208 s
= FcStrBufDone (&parse
->pstack
->str
);
1211 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1214 if (!FcVStackPushString (parse
, tag
, s
))
1219 FcParseMatrix (FcConfigParse
*parse
)
1222 enum { m_done
, m_xx
, m_xy
, m_yx
, m_yy
} matrix_state
= m_yy
;
1225 while ((vstack
= FcVStackPop (parse
)))
1228 switch (vstack
->tag
) {
1229 case FcVStackInteger
:
1230 v
= vstack
->u
.integer
;
1232 case FcVStackDouble
:
1233 v
= vstack
->u
._double
;
1236 FcConfigMessage (parse
, FcSevereError
, "non-double matrix element");
1240 switch (matrix_state
) {
1241 case m_xx
: m
.xx
= v
; break;
1242 case m_xy
: m
.xy
= v
; break;
1243 case m_yx
: m
.yx
= v
; break;
1244 case m_yy
: m
.yy
= v
; break;
1247 FcVStackDestroy (vstack
);
1250 if (matrix_state
!= m_done
)
1251 FcConfigMessage (parse
, FcSevereError
, "wrong number of matrix elements");
1253 FcVStackPushMatrix (parse
, &m
);
1257 FcConfigLexBool (FcConfigParse
*parse
, const FcChar8
*bool)
1259 FcBool result
= FcFalse
;
1261 if (!FcNameBool (bool, &result
))
1262 FcConfigMessage (parse
, FcSevereWarning
, "\"%s\" is not known boolean",
1268 FcParseBool (FcConfigParse
*parse
)
1274 s
= FcStrBufDone (&parse
->pstack
->str
);
1277 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1280 FcVStackPushBool (parse
, FcConfigLexBool (parse
, s
));
1285 FcParseFamilies (FcConfigParse
*parse
, FcVStackTag tag
)
1288 FcExpr
*left
, *expr
= 0, *new;
1290 while ((vstack
= FcVStackPop (parse
)))
1292 if (vstack
->tag
!= FcVStackFamily
)
1294 FcConfigMessage (parse
, FcSevereWarning
, "non-family");
1295 FcVStackDestroy (vstack
);
1298 left
= vstack
->u
.expr
;
1299 vstack
->tag
= FcVStackNone
;
1300 FcVStackDestroy (vstack
);
1303 new = FcExprCreateOp (left
, FcOpComma
, expr
);
1306 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1307 FcExprDestroy (left
);
1308 FcExprDestroy (expr
);
1318 if (!FcVStackPushExpr (parse
, tag
, expr
))
1320 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1322 FcExprDestroy (expr
);
1328 FcParseFamily (FcConfigParse
*parse
)
1335 s
= FcStrBufDone (&parse
->pstack
->str
);
1338 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1341 expr
= FcExprCreateString (s
);
1344 FcVStackPushExpr (parse
, FcVStackFamily
, expr
);
1348 FcParseAlias (FcConfigParse
*parse
)
1350 FcExpr
*family
= 0, *accept
= 0, *prefer
= 0, *def
= 0, *new = 0;
1351 FcEdit
*edit
= 0, *next
;
1355 while ((vstack
= FcVStackPop (parse
)))
1357 switch (vstack
->tag
) {
1358 case FcVStackFamily
:
1361 new = FcExprCreateOp (vstack
->u
.expr
, FcOpComma
, family
);
1363 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1368 new = vstack
->u
.expr
;
1372 vstack
->tag
= FcVStackNone
;
1375 case FcVStackPrefer
:
1377 FcExprDestroy (prefer
);
1378 prefer
= vstack
->u
.expr
;
1379 vstack
->tag
= FcVStackNone
;
1381 case FcVStackAccept
:
1383 FcExprDestroy (accept
);
1384 accept
= vstack
->u
.expr
;
1385 vstack
->tag
= FcVStackNone
;
1387 case FcVStackDefault
:
1389 FcExprDestroy (def
);
1390 def
= vstack
->u
.expr
;
1391 vstack
->tag
= FcVStackNone
;
1394 FcConfigMessage (parse
, FcSevereWarning
, "bad alias");
1397 FcVStackDestroy (vstack
);
1401 FcConfigMessage (parse
, FcSevereError
, "missing family in alias");
1403 FcExprDestroy (prefer
);
1405 FcExprDestroy (accept
);
1407 FcExprDestroy (def
);
1412 edit
= FcEditCreate (parse
,
1413 FcConfigSaveField ("family"),
1416 FcValueBindingWeak
);
1420 FcExprDestroy (prefer
);
1425 edit
= FcEditCreate (parse
,
1426 FcConfigSaveField ("family"),
1429 FcValueBindingWeak
);
1433 FcExprDestroy (accept
);
1438 edit
= FcEditCreate (parse
,
1439 FcConfigSaveField ("family"),
1442 FcValueBindingWeak
);
1446 FcExprDestroy (def
);
1450 test
= FcTestCreate (parse
, FcMatchPattern
,
1452 (FcChar8
*) FC_FAMILY
,
1456 if (!FcConfigAddEdit (parse
->config
, test
, edit
, FcMatchPattern
))
1457 FcTestDestroy (test
);
1460 FcExprDestroy (family
);
1464 FcPopExpr (FcConfigParse
*parse
)
1466 FcVStack
*vstack
= FcVStackPop (parse
);
1470 switch (vstack
->tag
) {
1473 case FcVStackString
:
1474 case FcVStackFamily
:
1475 expr
= FcExprCreateString (vstack
->u
.string
);
1478 expr
= FcExprCreateField ((char *) vstack
->u
.string
);
1480 case FcVStackConstant
:
1481 expr
= FcExprCreateConst (vstack
->u
.string
);
1484 /* XXX: What's the correct action here? (CDW) */
1486 case FcVStackPrefer
:
1487 case FcVStackAccept
:
1488 case FcVStackDefault
:
1489 expr
= vstack
->u
.expr
;
1490 vstack
->tag
= FcVStackNone
;
1492 case FcVStackInteger
:
1493 expr
= FcExprCreateInteger (vstack
->u
.integer
);
1495 case FcVStackDouble
:
1496 expr
= FcExprCreateDouble (vstack
->u
._double
);
1498 case FcVStackMatrix
:
1499 expr
= FcExprCreateMatrix (vstack
->u
.matrix
);
1502 expr
= FcExprCreateBool (vstack
->u
.bool);
1507 expr
= vstack
->u
.expr
;
1508 vstack
->tag
= FcVStackNone
;
1515 FcVStackDestroy (vstack
);
1520 * This builds a tree of binary operations. Note
1521 * that every operator is defined so that if only
1522 * a single operand is contained, the value of the
1523 * whole expression is the value of the operand.
1525 * This code reduces in that case to returning that
1529 FcPopBinary (FcConfigParse
*parse
, FcOp op
)
1531 FcExpr
*left
, *expr
= 0, *new;
1533 while ((left
= FcPopExpr (parse
)))
1537 new = FcExprCreateOp (left
, op
, expr
);
1540 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1541 FcExprDestroy (left
);
1542 FcExprDestroy (expr
);
1554 FcParseBinary (FcConfigParse
*parse
, FcOp op
)
1556 FcExpr
*expr
= FcPopBinary (parse
, op
);
1558 FcVStackPushExpr (parse
, FcVStackExpr
, expr
);
1562 * This builds a a unary operator, it consumes only
1567 FcPopUnary (FcConfigParse
*parse
, FcOp op
)
1569 FcExpr
*operand
, *new = 0;
1571 if ((operand
= FcPopExpr (parse
)))
1573 new = FcExprCreateOp (operand
, op
, 0);
1576 FcExprDestroy (operand
);
1577 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1584 FcParseUnary (FcConfigParse
*parse
, FcOp op
)
1586 FcExpr
*expr
= FcPopUnary (parse
, op
);
1588 FcVStackPushExpr (parse
, FcVStackExpr
, expr
);
1592 FcParseInclude (FcConfigParse
*parse
)
1596 FcBool ignore_missing
= FcFalse
;
1598 s
= FcStrBufDone (&parse
->pstack
->str
);
1601 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1604 i
= FcConfigGetAttribute (parse
, "ignore_missing");
1605 if (i
&& FcConfigLexBool (parse
, (FcChar8
*) i
) == FcTrue
)
1606 ignore_missing
= FcTrue
;
1607 if (!FcConfigParseAndLoad (parse
->config
, s
, !ignore_missing
))
1608 parse
->error
= FcTrue
;
1612 typedef struct _FcOpMap
{
1618 FcConfigLexOp (const FcChar8
*op
, const FcOpMap
*map
, int nmap
)
1622 for (i
= 0; i
< nmap
; i
++)
1623 if (!strcmp ((char *) op
, map
[i
].name
))
1628 static const FcOpMap fcCompareOps
[] = {
1629 { "eq", FcOpEqual
},
1630 { "not_eq", FcOpNotEqual
},
1631 { "less", FcOpLess
},
1632 { "less_eq", FcOpLessEqual
},
1633 { "more", FcOpMore
},
1634 { "more_eq", FcOpMoreEqual
},
1635 { "contains", FcOpContains
},
1636 { "not_contains", FcOpNotContains
}
1639 #define NUM_COMPARE_OPS (int) (sizeof fcCompareOps / sizeof fcCompareOps[0])
1642 FcConfigLexCompare (const FcChar8
*compare
)
1644 return FcConfigLexOp (compare
, fcCompareOps
, NUM_COMPARE_OPS
);
1649 FcParseTest (FcConfigParse
*parse
)
1651 const FcChar8
*kind_string
;
1653 const FcChar8
*qual_string
;
1655 const FcChar8
*name
;
1656 const FcChar8
*compare_string
;
1661 kind_string
= FcConfigGetAttribute (parse
, "target");
1663 kind
= FcMatchDefault
;
1666 if (!strcmp ((char *) kind_string
, "pattern"))
1667 kind
= FcMatchPattern
;
1668 else if (!strcmp ((char *) kind_string
, "font"))
1670 else if (!strcmp ((char *) kind_string
, "default"))
1671 kind
= FcMatchDefault
;
1674 FcConfigMessage (parse
, FcSevereWarning
, "invalid test target \"%s\"", kind_string
);
1678 qual_string
= FcConfigGetAttribute (parse
, "qual");
1683 if (!strcmp ((char *) qual_string
, "any"))
1685 else if (!strcmp ((char *) qual_string
, "all"))
1687 else if (!strcmp ((char *) qual_string
, "first"))
1689 else if (!strcmp ((char *) qual_string
, "not_first"))
1690 qual
= FcQualNotFirst
;
1693 FcConfigMessage (parse
, FcSevereWarning
, "invalid test qual \"%s\"", qual_string
);
1697 name
= FcConfigGetAttribute (parse
, "name");
1700 FcConfigMessage (parse
, FcSevereWarning
, "missing test name");
1703 compare_string
= FcConfigGetAttribute (parse
, "compare");
1704 if (!compare_string
)
1705 compare
= FcOpEqual
;
1708 compare
= FcConfigLexCompare (compare_string
);
1709 if (compare
== FcOpInvalid
)
1711 FcConfigMessage (parse
, FcSevereWarning
, "invalid test compare \"%s\"", compare_string
);
1715 expr
= FcPopBinary (parse
, FcOpComma
);
1718 FcConfigMessage (parse
, FcSevereWarning
, "missing test expression");
1721 test
= FcTestCreate (parse
, kind
, qual
, name
, compare
, expr
);
1724 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1727 FcVStackPushTest (parse
, test
);
1730 static const FcOpMap fcModeOps
[] = {
1731 { "assign", FcOpAssign
},
1732 { "assign_replace", FcOpAssignReplace
},
1733 { "prepend", FcOpPrepend
},
1734 { "prepend_first", FcOpPrependFirst
},
1735 { "append", FcOpAppend
},
1736 { "append_last", FcOpAppendLast
},
1739 #define NUM_MODE_OPS (int) (sizeof fcModeOps / sizeof fcModeOps[0])
1742 FcConfigLexMode (const FcChar8
*mode
)
1744 return FcConfigLexOp (mode
, fcModeOps
, NUM_MODE_OPS
);
1748 FcParseEdit (FcConfigParse
*parse
)
1750 const FcChar8
*name
;
1751 const FcChar8
*mode_string
;
1752 const FcChar8
*binding_string
;
1754 FcValueBinding binding
;
1758 name
= FcConfigGetAttribute (parse
, "name");
1761 FcConfigMessage (parse
, FcSevereWarning
, "missing edit name");
1764 mode_string
= FcConfigGetAttribute (parse
, "mode");
1769 mode
= FcConfigLexMode (mode_string
);
1770 if (mode
== FcOpInvalid
)
1772 FcConfigMessage (parse
, FcSevereWarning
, "invalid edit mode \"%s\"", mode_string
);
1776 binding_string
= FcConfigGetAttribute (parse
, "binding");
1777 if (!binding_string
)
1778 binding
= FcValueBindingWeak
;
1781 if (!strcmp ((char *) binding_string
, "weak"))
1782 binding
= FcValueBindingWeak
;
1783 else if (!strcmp ((char *) binding_string
, "strong"))
1784 binding
= FcValueBindingStrong
;
1785 else if (!strcmp ((char *) binding_string
, "same"))
1786 binding
= FcValueBindingSame
;
1789 FcConfigMessage (parse
, FcSevereWarning
, "invalid edit binding \"%s\"", binding_string
);
1793 expr
= FcPopBinary (parse
, FcOpComma
);
1794 edit
= FcEditCreate (parse
, (char *) FcStrCopy (name
), mode
, expr
, binding
);
1797 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1798 FcExprDestroy (expr
);
1801 if (!FcVStackPushEdit (parse
, edit
))
1802 FcEditDestroy (edit
);
1806 FcParseMatch (FcConfigParse
*parse
)
1808 const FcChar8
*kind_name
;
1814 kind_name
= FcConfigGetAttribute (parse
, "target");
1816 kind
= FcMatchPattern
;
1819 if (!strcmp ((char *) kind_name
, "pattern"))
1820 kind
= FcMatchPattern
;
1821 else if (!strcmp ((char *) kind_name
, "font"))
1825 FcConfigMessage (parse
, FcSevereWarning
, "invalid match target \"%s\"", kind_name
);
1829 while ((vstack
= FcVStackPop (parse
)))
1831 switch (vstack
->tag
) {
1833 vstack
->u
.test
->next
= test
;
1834 test
= vstack
->u
.test
;
1835 vstack
->tag
= FcVStackNone
;
1838 vstack
->u
.edit
->next
= edit
;
1839 edit
= vstack
->u
.edit
;
1840 vstack
->tag
= FcVStackNone
;
1843 FcConfigMessage (parse
, FcSevereWarning
, "invalid match element");
1846 FcVStackDestroy (vstack
);
1848 if (!FcConfigAddEdit (parse
->config
, test
, edit
, kind
))
1849 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1853 FcParseAcceptRejectFont (FcConfigParse
*parse
, FcElement element
)
1857 while ((vstack
= FcVStackPop (parse
)))
1859 switch (vstack
->tag
) {
1861 if (!FcConfigGlobAdd (parse
->config
,
1863 element
== FcElementAcceptfont
))
1865 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1868 case FcVStackPattern
:
1869 if (!FcConfigPatternsAdd (parse
->config
,
1871 element
== FcElementAcceptfont
))
1873 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1876 vstack
->tag
= FcVStackNone
;
1879 FcConfigMessage (parse
, FcSevereWarning
, "bad font selector");
1882 FcVStackDestroy (vstack
);
1888 FcPopValue (FcConfigParse
*parse
)
1890 FcVStack
*vstack
= FcVStackPop (parse
);
1893 value
.type
= FcTypeVoid
;
1898 switch (vstack
->tag
) {
1899 case FcVStackString
:
1900 value
.u
.s
= FcStrCopy (vstack
->u
.string
);
1902 value
.type
= FcTypeString
;
1904 case FcVStackConstant
:
1905 if (FcNameConstant (vstack
->u
.string
, &value
.u
.i
))
1906 value
.type
= FcTypeInteger
;
1908 case FcVStackInteger
:
1909 value
.u
.i
= vstack
->u
.integer
;
1910 value
.type
= FcTypeInteger
;
1912 case FcVStackDouble
:
1913 value
.u
.d
= vstack
->u
._double
;
1914 value
.type
= FcTypeInteger
;
1916 case FcVStackMatrix
:
1917 value
.u
.m
= FcMatrixCopy (vstack
->u
.matrix
);
1919 value
.type
= FcTypeMatrix
;
1922 value
.u
.b
= vstack
->u
.bool;
1923 value
.type
= FcTypeBool
;
1926 FcConfigMessage (parse
, FcSevereWarning
, "unknown pattern element %d",
1930 FcVStackDestroy (vstack
);
1936 FcParsePatelt (FcConfigParse
*parse
)
1939 FcPattern
*pattern
= FcPatternCreate ();
1944 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1948 name
= (char *) FcConfigGetAttribute (parse
, "name");
1951 FcConfigMessage (parse
, FcSevereWarning
, "missing pattern element name");
1957 value
= FcPopValue (parse
);
1958 if (value
.type
== FcTypeVoid
)
1960 if (!FcPatternAdd (pattern
, name
, value
, FcTrue
))
1962 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1967 FcVStackPushPattern (parse
, pattern
);
1971 FcParsePattern (FcConfigParse
*parse
)
1974 FcPattern
*pattern
= FcPatternCreate ();
1978 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1982 while ((vstack
= FcVStackPop (parse
)))
1984 switch (vstack
->tag
) {
1985 case FcVStackPattern
:
1986 if (!FcPatternAppend (pattern
, vstack
->u
.pattern
))
1988 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1993 FcConfigMessage (parse
, FcSevereWarning
, "unknown pattern element");
1996 FcVStackDestroy (vstack
);
1999 FcVStackPushPattern (parse
, pattern
);
2003 FcEndElement(void *userData
, const XML_Char
*name
)
2005 FcConfigParse
*parse
= userData
;
2010 switch (parse
->pstack
->element
) {
2013 case FcElementFontconfig
:
2016 data
= FcStrBufDone (&parse
->pstack
->str
);
2019 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2023 if (strcmp (data
, "WINDOWSFONTDIR") == 0)
2027 data
= malloc (1000);
2030 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2033 FcMemAlloc (FC_MEM_STRING
, 1000);
2034 rc
= GetWindowsDirectory (data
, 800);
2035 if (rc
== 0 || rc
> 800)
2037 FcConfigMessage (parse
, FcSevereError
, "GetWindowsDirectory failed");
2041 if (data
[strlen (data
) - 1] != '\\')
2042 strcat (data
, "\\");
2043 strcat (data
, "fonts");
2046 if (!FcStrUsesHome (data
) || FcConfigHome ())
2048 if (!FcConfigAddDir (parse
->config
, data
))
2049 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2053 case FcElementCache
:
2054 data
= FcStrBufDone (&parse
->pstack
->str
);
2057 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2060 if (!FcStrUsesHome (data
) || FcConfigHome ())
2062 if (!FcConfigSetCache (parse
->config
, data
))
2063 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2067 case FcElementInclude
:
2068 FcParseInclude (parse
);
2070 case FcElementConfig
:
2072 case FcElementMatch
:
2073 FcParseMatch (parse
);
2075 case FcElementAlias
:
2076 FcParseAlias (parse
);
2079 case FcElementBlank
:
2080 FcParseBlank (parse
);
2082 case FcElementRescan
:
2083 FcParseRescan (parse
);
2086 case FcElementPrefer
:
2087 FcParseFamilies (parse
, FcVStackPrefer
);
2089 case FcElementAccept
:
2090 FcParseFamilies (parse
, FcVStackAccept
);
2092 case FcElementDefault
:
2093 FcParseFamilies (parse
, FcVStackDefault
);
2095 case FcElementFamily
:
2096 FcParseFamily (parse
);
2100 FcParseTest (parse
);
2103 FcParseEdit (parse
);
2109 case FcElementDouble
:
2110 FcParseDouble (parse
);
2112 case FcElementString
:
2113 FcParseString (parse
, FcVStackString
);
2115 case FcElementMatrix
:
2116 FcParseMatrix (parse
);
2119 FcParseBool (parse
);
2121 case FcElementCharset
:
2122 /* FcParseCharset (parse); */
2124 case FcElementSelectfont
:
2126 case FcElementAcceptfont
:
2127 case FcElementRejectfont
:
2128 FcParseAcceptRejectFont (parse
, parse
->pstack
->element
);
2131 FcParseString (parse
, FcVStackGlob
);
2133 case FcElementPattern
:
2134 FcParsePattern (parse
);
2136 case FcElementPatelt
:
2137 FcParsePatelt (parse
);
2140 FcParseString (parse
, FcVStackField
);
2142 case FcElementConst
:
2143 FcParseString (parse
, FcVStackConstant
);
2146 FcParseBinary (parse
, FcOpOr
);
2149 FcParseBinary (parse
, FcOpAnd
);
2152 FcParseBinary (parse
, FcOpEqual
);
2154 case FcElementNotEq
:
2155 FcParseBinary (parse
, FcOpNotEqual
);
2158 FcParseBinary (parse
, FcOpLess
);
2160 case FcElementLessEq
:
2161 FcParseBinary (parse
, FcOpLessEqual
);
2164 FcParseBinary (parse
, FcOpMore
);
2166 case FcElementMoreEq
:
2167 FcParseBinary (parse
, FcOpMoreEqual
);
2169 case FcElementContains
:
2170 FcParseBinary (parse
, FcOpContains
);
2172 case FcElementNotContains
:
2173 FcParseBinary (parse
, FcOpNotContains
);
2176 FcParseBinary (parse
, FcOpPlus
);
2178 case FcElementMinus
:
2179 FcParseBinary (parse
, FcOpMinus
);
2181 case FcElementTimes
:
2182 FcParseBinary (parse
, FcOpTimes
);
2184 case FcElementDivide
:
2185 FcParseBinary (parse
, FcOpDivide
);
2188 FcParseUnary (parse
, FcOpNot
);
2191 FcParseBinary (parse
, FcOpQuest
);
2193 case FcElementFloor
:
2194 FcParseUnary (parse
, FcOpFloor
);
2197 FcParseUnary (parse
, FcOpCeil
);
2199 case FcElementRound
:
2200 FcParseUnary (parse
, FcOpRound
);
2202 case FcElementTrunc
:
2203 FcParseUnary (parse
, FcOpTrunc
);
2205 case FcElementUnknown
:
2208 (void) FcPStackPop (parse
);
2212 FcCharacterData (void *userData
, const XML_Char
*s
, int len
)
2214 FcConfigParse
*parse
= userData
;
2218 if (!FcStrBufData (&parse
->pstack
->str
, (FcChar8
*) s
, len
))
2219 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2223 FcStartDoctypeDecl (void *userData
,
2224 const XML_Char
*doctypeName
,
2225 const XML_Char
*sysid
,
2226 const XML_Char
*pubid
,
2227 int has_internal_subset
)
2229 FcConfigParse
*parse
= userData
;
2231 if (strcmp ((char *) doctypeName
, "fontconfig") != 0)
2232 FcConfigMessage (parse
, FcSevereError
, "invalid doctype \"%s\"", doctypeName
);
2238 FcInternalSubsetDecl (void *userData
,
2239 const XML_Char
*doctypeName
,
2240 const XML_Char
*sysid
,
2241 const XML_Char
*pubid
)
2243 FcStartDoctypeDecl (userData
, doctypeName
, sysid
, pubid
, 1);
2247 FcExternalSubsetDecl (void *userData
,
2248 const XML_Char
*doctypeName
,
2249 const XML_Char
*sysid
,
2250 const XML_Char
*pubid
)
2252 FcStartDoctypeDecl (userData
, doctypeName
, sysid
, pubid
, 0);
2255 #else /* ENABLE_LIBXML2 */
2258 FcEndDoctypeDecl (void *userData
)
2262 #endif /* ENABLE_LIBXML2 */
2265 FcConfigParseAndLoadDir (FcConfig
*config
,
2266 const FcChar8
*name
,
2272 FcBool ret
= FcTrue
;
2277 d
= opendir ((char *) dir
);
2281 FcConfigMessage (0, FcSevereError
, "Cannot open config dir \"%s\"",
2287 file
= (FcChar8
*) malloc (strlen ((char *) dir
) + 1 + FC_MAX_FILE_LEN
+ 1);
2294 strcpy ((char *) file
, (char *) dir
);
2295 strcat ((char *) file
, "/");
2296 base
= file
+ strlen ((char *) file
);
2298 files
= FcStrSetCreate ();
2305 if (FcDebug () & FC_DBG_CONFIG
)
2306 printf ("\tScanning config dir %s\n", dir
);
2308 while (ret
&& (e
= readdir (d
)))
2311 #define TAIL ".conf"
2314 * Add all files of the form [0-9]*.conf
2316 if ('0' <= e
->d_name
[0] && e
->d_name
[0] <= '9' &&
2317 (d_len
= strlen (e
->d_name
)) < FC_MAX_FILE_LEN
&&
2319 strcmp (e
->d_name
+ d_len
- TAIL_LEN
, TAIL
) == 0)
2321 strcpy ((char *) base
, (char *) e
->d_name
);
2322 if (!FcStrSetAdd (files
, file
))
2332 qsort (files
->strs
, files
->num
, sizeof (FcChar8
*),
2333 (int (*)(const void *, const void *)) FcStrCmp
);
2334 for (i
= 0; ret
&& i
< files
->num
; i
++)
2335 ret
= FcConfigParseAndLoad (config
, files
->strs
[i
], complain
);
2338 FcStrSetDestroy (files
);
2344 return ret
|| !complain
;
2348 FcConfigParseAndLoad (FcConfig
*config
,
2349 const FcChar8
*name
,
2357 FcConfigParse parse
;
2358 FcBool error
= FcTrue
;
2367 filename
= FcConfigFilename (name
);
2371 if (!FcStrSetAdd (config
->configFiles
, filename
))
2373 FcStrFree (filename
);
2377 if (FcFileIsDir (filename
))
2379 FcBool ret
= FcConfigParseAndLoadDir (config
, name
, filename
, complain
);
2380 FcStrFree (filename
);
2384 if (FcDebug () & FC_DBG_CONFIG
)
2385 printf ("\tLoading config file %s\n", filename
);
2387 f
= fopen ((char *) filename
, "r");
2389 FcStrFree (filename
);
2394 memset(&sax
, 0, sizeof(sax
));
2396 sax
.internalSubset
= FcInternalSubsetDecl
;
2397 sax
.externalSubset
= FcExternalSubsetDecl
;
2398 sax
.startElement
= FcStartElement
;
2399 sax
.endElement
= FcEndElement
;
2400 sax
.characters
= FcCharacterData
;
2402 p
= xmlCreatePushParserCtxt (&sax
, &parse
, NULL
, 0, (const char *) filename
);
2404 p
= XML_ParserCreate ("UTF-8");
2406 FcStrFree (filename
);
2411 if (!FcConfigInit (&parse
, name
, config
, p
))
2416 XML_SetUserData (p
, &parse
);
2418 XML_SetDoctypeDeclHandler (p
, FcStartDoctypeDecl
, FcEndDoctypeDecl
);
2419 XML_SetElementHandler (p
, FcStartElement
, FcEndElement
);
2420 XML_SetCharacterDataHandler (p
, FcCharacterData
);
2422 #endif /* ENABLE_LIBXML2 */
2426 buf
= XML_GetBuffer (p
, BUFSIZ
);
2429 FcConfigMessage (&parse
, FcSevereError
, "cannot get parse buffer");
2433 len
= fread (buf
, 1, BUFSIZ
, f
);
2436 FcConfigMessage (&parse
, FcSevereError
, "failed reading config file");
2441 if (xmlParseChunk (p
, buf
, len
, len
== 0))
2443 if (!XML_ParseBuffer (p
, len
, len
== 0))
2446 FcConfigMessage (&parse
, FcSevereError
, "%s",
2447 XML_ErrorString (XML_GetErrorCode (p
)));
2451 error
= parse
.error
;
2453 FcConfigCleanup (&parse
);
2460 if (error
&& complain
)
2463 FcConfigMessage (0, FcSevereError
, "Cannot load config file \"%s\"", name
);
2465 FcConfigMessage (0, FcSevereError
, "Cannot load default config file");