]>
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.
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 FcStrFree ((FcChar8
*) test
->field
);
69 FcMemFree (FC_MEM_TEST
, sizeof (FcTest
));
74 FcExprCreateInteger (int i
)
76 FcExpr
*e
= (FcExpr
*) malloc (sizeof (FcExpr
));
80 FcMemAlloc (FC_MEM_EXPR
, sizeof (FcExpr
));
88 FcExprCreateDouble (double d
)
90 FcExpr
*e
= (FcExpr
*) malloc (sizeof (FcExpr
));
94 FcMemAlloc (FC_MEM_EXPR
, sizeof (FcExpr
));
102 FcExprCreateString (const FcChar8
*s
)
104 FcExpr
*e
= (FcExpr
*) malloc (sizeof (FcExpr
));
108 FcMemAlloc (FC_MEM_EXPR
, sizeof (FcExpr
));
110 e
->u
.sval
= FcStrCopy (s
);
116 FcExprCreateMatrix (const FcMatrix
*m
)
118 FcExpr
*e
= (FcExpr
*) malloc (sizeof (FcExpr
));
122 FcMemAlloc (FC_MEM_EXPR
, sizeof (FcExpr
));
124 e
->u
.mval
= FcMatrixCopy (m
);
130 FcExprCreateBool (FcBool b
)
132 FcExpr
*e
= (FcExpr
*) malloc (sizeof (FcExpr
));
136 FcMemAlloc (FC_MEM_EXPR
, sizeof (FcExpr
));
144 FcExprCreateNil (void)
146 FcExpr
*e
= (FcExpr
*) malloc (sizeof (FcExpr
));
150 FcMemAlloc (FC_MEM_EXPR
, sizeof (FcExpr
));
157 FcExprCreateField (const char *field
)
159 FcExpr
*e
= (FcExpr
*) malloc (sizeof (FcExpr
));
163 FcMemAlloc (FC_MEM_EXPR
, sizeof (FcExpr
));
165 e
->u
.field
= (char *) FcStrCopy ((FcChar8
*) field
);
171 FcExprCreateConst (const FcChar8
*constant
)
173 FcExpr
*e
= (FcExpr
*) malloc (sizeof (FcExpr
));
177 FcMemAlloc (FC_MEM_EXPR
, sizeof (FcExpr
));
179 e
->u
.constant
= FcStrCopy (constant
);
185 FcExprCreateOp (FcExpr
*left
, FcOp op
, FcExpr
*right
)
187 FcExpr
*e
= (FcExpr
*) malloc (sizeof (FcExpr
));
191 FcMemAlloc (FC_MEM_EXPR
, sizeof (FcExpr
));
193 e
->u
.tree
.left
= left
;
194 e
->u
.tree
.right
= right
;
200 FcExprDestroy (FcExpr
*e
)
210 FcStrFree (e
->u
.sval
);
213 FcMatrixFree (e
->u
.mval
);
216 FcCharSetDestroy (e
->u
.cval
);
221 FcStrFree ((FcChar8
*) e
->u
.field
);
224 FcStrFree (e
->u
.constant
);
227 case FcOpAssignReplace
:
229 case FcOpPrependFirst
:
243 case FcOpNotContains
:
250 FcExprDestroy (e
->u
.tree
.right
);
257 FcExprDestroy (e
->u
.tree
.left
);
263 FcMemFree (FC_MEM_EXPR
, sizeof (FcExpr
));
268 FcEditDestroy (FcEdit
*e
)
271 FcEditDestroy (e
->next
);
272 FcStrFree ((FcChar8
*) e
->field
);
274 FcExprDestroy (e
->expr
);
279 FcConfigSaveField (const char *field
)
281 return (char *) FcStrCopy ((FcChar8
*) field
);
284 typedef enum _FcElement
{
328 FcElementNotContains
,
346 { "fontconfig", FcElementFontconfig
},
347 { "dir", FcElementDir
},
348 { "cache", FcElementCache
},
349 { "include", FcElementInclude
},
350 { "config", FcElementConfig
},
351 { "match", FcElementMatch
},
352 { "alias", FcElementAlias
},
354 { "blank", FcElementBlank
},
355 { "rescan", FcElementRescan
},
357 { "prefer", FcElementPrefer
},
358 { "accept", FcElementAccept
},
359 { "default", FcElementDefault
},
360 { "family", FcElementFamily
},
362 { "selectfont", FcElementSelectfont
},
363 { "acceptfont", FcElementAcceptfont
},
364 { "rejectfont", FcElementRejectfont
},
365 { "glob", FcElementGlob
},
366 { "pattern", FcElementPattern
},
367 { "patelt", FcElementPatelt
},
369 { "test", FcElementTest
},
370 { "edit", FcElementEdit
},
371 { "int", FcElementInt
},
372 { "double", FcElementDouble
},
373 { "string", FcElementString
},
374 { "matrix", FcElementMatrix
},
375 { "bool", FcElementBool
},
376 { "charset", FcElementCharset
},
377 { "name", FcElementName
},
378 { "const", FcElementConst
},
379 { "or", FcElementOr
},
380 { "and", FcElementAnd
},
381 { "eq", FcElementEq
},
382 { "not_eq", FcElementNotEq
},
383 { "less", FcElementLess
},
384 { "less_eq", FcElementLessEq
},
385 { "more", FcElementMore
},
386 { "more_eq", FcElementMoreEq
},
387 { "contains", FcElementContains
},
388 { "not_contains", FcElementNotContains
},
389 { "plus", FcElementPlus
},
390 { "minus", FcElementMinus
},
391 { "times", FcElementTimes
},
392 { "divide", FcElementDivide
},
393 { "not", FcElementNot
},
394 { "if", FcElementIf
},
395 { "floor", FcElementFloor
},
396 { "ceil", FcElementCeil
},
397 { "round", FcElementRound
},
398 { "trunc", FcElementTrunc
},
400 #define NUM_ELEMENT_MAPS (int) (sizeof fcElementMap / sizeof fcElementMap[0])
403 FcElementMap (const XML_Char
*name
)
407 for (i
= 0; i
< NUM_ELEMENT_MAPS
; i
++)
408 if (!strcmp ((char *) name
, fcElementMap
[i
].name
))
409 return fcElementMap
[i
].element
;
410 return FcElementUnknown
;
413 typedef struct _FcPStack
{
414 struct _FcPStack
*prev
;
420 typedef enum _FcVStackTag
{
444 typedef struct _FcVStack
{
445 struct _FcVStack
*prev
;
446 FcPStack
*pstack
; /* related parse element */
466 typedef struct _FcConfigParse
{
475 typedef enum _FcConfigSeverity
{
476 FcSevereInfo
, FcSevereWarning
, FcSevereError
480 FcConfigMessage (FcConfigParse
*parse
, FcConfigSeverity severe
, const char *fmt
, ...)
482 const char *s
= "unknown";
485 va_start (args
, fmt
);
488 case FcSevereInfo
: s
= "info"; break;
489 case FcSevereWarning
: s
= "warning"; break;
490 case FcSevereError
: s
= "error"; break;
495 fprintf (stderr
, "Fontconfig %s: \"%s\", line %d: ", s
,
496 parse
->name
, XML_GetCurrentLineNumber (parse
->parser
));
498 fprintf (stderr
, "Fontconfig %s: line %d: ", s
,
499 XML_GetCurrentLineNumber (parse
->parser
));
500 if (severe
>= FcSevereError
)
501 parse
->error
= FcTrue
;
504 fprintf (stderr
, "Fontconfig %s: ", s
);
505 vfprintf (stderr
, fmt
, args
);
506 fprintf (stderr
, "\n");
512 FcTypeName (FcType type
)
538 FcTypecheckValue (FcConfigParse
*parse
, FcType value
, FcType type
)
540 if (value
== FcTypeInteger
)
541 value
= FcTypeDouble
;
542 if (type
== FcTypeInteger
)
546 if ((value
== FcTypeLangSet
&& type
== FcTypeString
) ||
547 (value
== FcTypeString
&& type
== FcTypeLangSet
))
549 FcConfigMessage (parse
, FcSevereWarning
, "saw %s, expected %s",
550 FcTypeName (value
), FcTypeName (type
));
555 FcTypecheckExpr (FcConfigParse
*parse
, FcExpr
*expr
, FcType type
)
557 const FcObjectType
*o
;
563 FcTypecheckValue (parse
, FcTypeDouble
, type
);
566 FcTypecheckValue (parse
, FcTypeString
, type
);
569 FcTypecheckValue (parse
, FcTypeMatrix
, type
);
572 FcTypecheckValue (parse
, FcTypeBool
, type
);
575 FcTypecheckValue (parse
, FcTypeCharSet
, type
);
580 o
= FcNameGetObjectType (expr
->u
.field
);
582 FcTypecheckValue (parse
, o
->type
, type
);
585 c
= FcNameGetConstant (expr
->u
.constant
);
588 o
= FcNameGetObjectType (c
->object
);
590 FcTypecheckValue (parse
, o
->type
, type
);
593 FcConfigMessage (parse
, FcSevereWarning
,
594 "invalid constant used : %s",
598 FcTypecheckExpr (parse
, expr
->u
.tree
.left
, FcTypeBool
);
599 FcTypecheckExpr (parse
, expr
->u
.tree
.right
->u
.tree
.left
, type
);
600 FcTypecheckExpr (parse
, expr
->u
.tree
.right
->u
.tree
.right
, type
);
603 case FcOpAssignReplace
:
612 case FcOpNotContains
:
614 FcTypecheckValue (parse
, FcTypeBool
, type
);
623 FcTypecheckExpr (parse
, expr
->u
.tree
.left
, type
);
624 FcTypecheckExpr (parse
, expr
->u
.tree
.right
, type
);
627 FcTypecheckValue (parse
, FcTypeBool
, type
);
628 FcTypecheckExpr (parse
, expr
->u
.tree
.left
, FcTypeBool
);
634 FcTypecheckValue (parse
, FcTypeDouble
, type
);
635 FcTypecheckExpr (parse
, expr
->u
.tree
.left
, FcTypeDouble
);
643 FcTestCreate (FcConfigParse
*parse
,
646 const FcChar8
*field
,
650 FcTest
*test
= (FcTest
*) malloc (sizeof (FcTest
));
654 const FcObjectType
*o
;
656 FcMemAlloc (FC_MEM_TEST
, sizeof (FcTest
));
660 test
->field
= (char *) FcStrCopy (field
);
663 o
= FcNameGetObjectType (test
->field
);
665 FcTypecheckExpr (parse
, expr
, o
->type
);
671 FcEditCreate (FcConfigParse
*parse
,
675 FcValueBinding binding
)
677 FcEdit
*e
= (FcEdit
*) malloc (sizeof (FcEdit
));
681 const FcObjectType
*o
;
684 e
->field
= field
; /* already saved in grammar */
687 e
->binding
= binding
;
688 o
= FcNameGetObjectType (e
->field
);
690 FcTypecheckExpr (parse
, expr
, o
->type
);
696 FcVStackPush (FcConfigParse
*parse
, FcVStack
*vstack
)
698 vstack
->prev
= parse
->vstack
;
699 vstack
->pstack
= parse
->pstack
? parse
->pstack
->prev
: 0;
700 parse
->vstack
= vstack
;
704 FcVStackCreate (void)
708 new = malloc (sizeof (FcVStack
));
711 FcMemAlloc (FC_MEM_VSTACK
, sizeof (FcVStack
));
712 new->tag
= FcVStackNone
;
718 FcVStackDestroy (FcVStack
*vstack
)
722 for (; vstack
; vstack
= prev
)
725 switch (vstack
->tag
) {
731 case FcVStackConstant
:
733 FcStrFree (vstack
->u
.string
);
735 case FcVStackPattern
:
736 FcPatternDestroy (vstack
->u
.pattern
);
738 case FcVStackInteger
:
742 FcMatrixFree (vstack
->u
.matrix
);
747 FcTestDestroy (vstack
->u
.test
);
752 case FcVStackDefault
:
753 FcExprDestroy (vstack
->u
.expr
);
756 FcEditDestroy (vstack
->u
.edit
);
759 FcMemFree (FC_MEM_VSTACK
, sizeof (FcVStack
));
765 FcVStackPushString (FcConfigParse
*parse
, FcVStackTag tag
, FcChar8
*string
)
767 FcVStack
*vstack
= FcVStackCreate ();
770 vstack
->u
.string
= string
;
772 FcVStackPush (parse
, vstack
);
777 FcVStackPushInteger (FcConfigParse
*parse
, int integer
)
779 FcVStack
*vstack
= FcVStackCreate ();
782 vstack
->u
.integer
= integer
;
783 vstack
->tag
= FcVStackInteger
;
784 FcVStackPush (parse
, vstack
);
789 FcVStackPushDouble (FcConfigParse
*parse
, double _double
)
791 FcVStack
*vstack
= FcVStackCreate ();
794 vstack
->u
._double
= _double
;
795 vstack
->tag
= FcVStackDouble
;
796 FcVStackPush (parse
, vstack
);
801 FcVStackPushMatrix (FcConfigParse
*parse
, FcMatrix
*matrix
)
803 FcVStack
*vstack
= FcVStackCreate ();
806 matrix
= FcMatrixCopy (matrix
);
809 FcVStackDestroy (vstack
);
812 vstack
->u
.matrix
= matrix
;
813 vstack
->tag
= FcVStackMatrix
;
814 FcVStackPush (parse
, vstack
);
819 FcVStackPushBool (FcConfigParse
*parse
, FcBool
bool)
821 FcVStack
*vstack
= FcVStackCreate ();
824 vstack
->u
.bool = bool;
825 vstack
->tag
= FcVStackBool
;
826 FcVStackPush (parse
, vstack
);
831 FcVStackPushTest (FcConfigParse
*parse
, FcTest
*test
)
833 FcVStack
*vstack
= FcVStackCreate ();
836 vstack
->u
.test
= test
;
837 vstack
->tag
= FcVStackTest
;
838 FcVStackPush (parse
, vstack
);
843 FcVStackPushExpr (FcConfigParse
*parse
, FcVStackTag tag
, FcExpr
*expr
)
845 FcVStack
*vstack
= FcVStackCreate ();
848 vstack
->u
.expr
= expr
;
850 FcVStackPush (parse
, vstack
);
855 FcVStackPushEdit (FcConfigParse
*parse
, FcEdit
*edit
)
857 FcVStack
*vstack
= FcVStackCreate ();
860 vstack
->u
.edit
= edit
;
861 vstack
->tag
= FcVStackEdit
;
862 FcVStackPush (parse
, vstack
);
867 FcVStackPushPattern (FcConfigParse
*parse
, FcPattern
*pattern
)
869 FcVStack
*vstack
= FcVStackCreate ();
872 vstack
->u
.pattern
= pattern
;
873 vstack
->tag
= FcVStackPattern
;
874 FcVStackPush (parse
, vstack
);
879 FcVStackFetch (FcConfigParse
*parse
, int off
)
883 for (vstack
= parse
->vstack
; vstack
&& off
-- > 0; vstack
= vstack
->prev
);
888 FcVStackClear (FcConfigParse
*parse
)
890 while (parse
->vstack
&& parse
->vstack
->pstack
== parse
->pstack
)
892 FcVStack
*vstack
= parse
->vstack
;
893 parse
->vstack
= vstack
->prev
;
895 FcVStackDestroy (vstack
);
900 FcVStackPop (FcConfigParse
*parse
)
902 FcVStack
*vstack
= parse
->vstack
;
904 if (!vstack
|| vstack
->pstack
!= parse
->pstack
)
906 parse
->vstack
= vstack
->prev
;
912 FcVStackElements (FcConfigParse
*parse
)
915 FcVStack
*vstack
= parse
->vstack
;
916 while (vstack
&& vstack
->pstack
== parse
->pstack
)
919 vstack
= vstack
->prev
;
925 FcConfigSaveAttr (const XML_Char
**attr
)
936 for (i
= 0; attr
[i
]; i
++)
937 slen
+= strlen ((char *) attr
[i
]) + 1;
939 new = malloc ((i
+ 1) * sizeof (FcChar8
*) + slen
);
942 FcMemAlloc (FC_MEM_ATTR
, 1); /* size is too expensive */
943 s
= (FcChar8
*) (new + (i
+ 1));
944 for (i
= 0; attr
[i
]; i
++)
947 strcpy ((char *) s
, (char *) attr
[i
]);
948 s
+= strlen ((char *) s
) + 1;
955 FcPStackPush (FcConfigParse
*parse
, FcElement element
, const XML_Char
**attr
)
957 FcPStack
*new = malloc (sizeof (FcPStack
));
961 FcMemAlloc (FC_MEM_PSTACK
, sizeof (FcPStack
));
962 new->prev
= parse
->pstack
;
963 new->element
= element
;
966 new->attr
= FcConfigSaveAttr (attr
);
968 FcConfigMessage (parse
, FcSevereError
, "out of memory");
972 FcStrBufInit (&new->str
, 0, 0);
978 FcPStackPop (FcConfigParse
*parse
)
984 FcConfigMessage (parse
, FcSevereError
, "mismatching element");
987 FcVStackClear (parse
);
989 parse
->pstack
= old
->prev
;
990 FcStrBufDestroy (&old
->str
);
993 FcMemFree (FC_MEM_ATTR
, 1); /* size is to expensive */
996 FcMemFree (FC_MEM_PSTACK
, sizeof (FcPStack
));
1002 FcConfigInit (FcConfigParse
*parse
, const FcChar8
*name
, FcConfig
*config
, XML_Parser parser
)
1006 parse
->error
= FcFalse
;
1008 parse
->config
= config
;
1009 parse
->parser
= parser
;
1014 FcConfigCleanup (FcConfigParse
*parse
)
1016 while (parse
->pstack
)
1017 FcPStackPop (parse
);
1020 static const FcChar8
*
1021 FcConfigGetAttribute (FcConfigParse
*parse
, const char *attr
)
1027 attrs
= parse
->pstack
->attr
;
1033 if (!strcmp ((char *) *attrs
, attr
))
1041 FcStartElement(void *userData
, const XML_Char
*name
, const XML_Char
**attr
)
1043 FcConfigParse
*parse
= userData
;
1046 element
= FcElementMap (name
);
1047 if (element
== FcElementUnknown
)
1048 FcConfigMessage (parse
, FcSevereWarning
, "unknown element \"%s\"", name
);
1050 if (!FcPStackPush (parse
, element
, attr
))
1052 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1059 FcParseBlank (FcConfigParse
*parse
)
1061 int n
= FcVStackElements (parse
);
1064 FcVStack
*v
= FcVStackFetch (parse
, n
);
1065 if (v
->tag
!= FcVStackInteger
)
1066 FcConfigMessage (parse
, FcSevereError
, "non-integer blank");
1069 if (!parse
->config
->blanks
)
1071 parse
->config
->blanks
= FcBlanksCreate ();
1072 if (!parse
->config
->blanks
)
1074 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1078 if (!FcBlanksAdd (parse
->config
->blanks
, v
->u
.integer
))
1080 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1088 FcParseRescan (FcConfigParse
*parse
)
1090 int n
= FcVStackElements (parse
);
1093 FcVStack
*v
= FcVStackFetch (parse
, n
);
1094 if (v
->tag
!= FcVStackInteger
)
1095 FcConfigMessage (parse
, FcSevereWarning
, "non-integer rescan");
1097 parse
->config
->rescanInterval
= v
->u
.integer
;
1102 FcParseInt (FcConfigParse
*parse
)
1109 s
= FcStrBufDone (&parse
->pstack
->str
);
1112 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1116 l
= (int) strtol ((char *) s
, (char **)&end
, 0);
1117 if (end
!= s
+ strlen ((char *) s
))
1118 FcConfigMessage (parse
, FcSevereError
, "\"%s\": not a valid integer", s
);
1120 FcVStackPushInteger (parse
, l
);
1125 * idea copied from glib g_ascii_strtod with
1126 * permission of the author (Alexander Larsson)
1132 FcStrtod (char *s
, char **end
)
1134 struct lconv
*locale_data
;
1139 * Have to swap the decimal point to match the current locale
1140 * if that locale doesn't use 0x2e
1142 if ((dot
= strchr (s
, 0x2e)) &&
1143 (locale_data
= localeconv ()) &&
1144 (locale_data
->decimal_point
[0] != 0x2e ||
1145 locale_data
->decimal_point
[1] != 0))
1148 int slen
= strlen (s
);
1149 int dlen
= strlen (locale_data
->decimal_point
);
1151 if (slen
+ dlen
> (int) sizeof (buf
))
1161 strncpy (buf
, s
, dot
- s
);
1163 strcpy (buf
+ (dot
- s
), locale_data
->decimal_point
);
1164 /* rest of number */
1165 strcpy (buf
+ (dot
- s
) + dlen
, dot
+ 1);
1167 v
= strtod (buf
, &buf_end
);
1169 buf_end
= s
+ (buf_end
- buf
);
1171 buf_end
-= dlen
- 1;
1178 v
= strtod (s
, end
);
1183 FcParseDouble (FcConfigParse
*parse
)
1190 s
= FcStrBufDone (&parse
->pstack
->str
);
1193 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1197 d
= FcStrtod ((char *) s
, (char **)&end
);
1198 if (end
!= s
+ strlen ((char *) s
))
1199 FcConfigMessage (parse
, FcSevereError
, "\"%s\": not a valid double", s
);
1201 FcVStackPushDouble (parse
, d
);
1206 FcParseString (FcConfigParse
*parse
, FcVStackTag tag
)
1212 s
= FcStrBufDone (&parse
->pstack
->str
);
1215 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1218 if (!FcVStackPushString (parse
, tag
, s
))
1223 FcParseMatrix (FcConfigParse
*parse
)
1226 enum { m_done
, m_xx
, m_xy
, m_yx
, m_yy
} matrix_state
= m_yy
;
1229 while ((vstack
= FcVStackPop (parse
)))
1232 switch (vstack
->tag
) {
1233 case FcVStackInteger
:
1234 v
= vstack
->u
.integer
;
1236 case FcVStackDouble
:
1237 v
= vstack
->u
._double
;
1240 FcConfigMessage (parse
, FcSevereError
, "non-double matrix element");
1244 switch (matrix_state
) {
1245 case m_xx
: m
.xx
= v
; break;
1246 case m_xy
: m
.xy
= v
; break;
1247 case m_yx
: m
.yx
= v
; break;
1248 case m_yy
: m
.yy
= v
; break;
1251 FcVStackDestroy (vstack
);
1254 if (matrix_state
!= m_done
)
1255 FcConfigMessage (parse
, FcSevereError
, "wrong number of matrix elements");
1257 FcVStackPushMatrix (parse
, &m
);
1261 FcConfigLexBool (FcConfigParse
*parse
, const FcChar8
*bool)
1263 FcBool result
= FcFalse
;
1265 if (!FcNameBool (bool, &result
))
1266 FcConfigMessage (parse
, FcSevereWarning
, "\"%s\" is not known boolean",
1272 FcParseBool (FcConfigParse
*parse
)
1278 s
= FcStrBufDone (&parse
->pstack
->str
);
1281 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1284 FcVStackPushBool (parse
, FcConfigLexBool (parse
, s
));
1289 FcParseFamilies (FcConfigParse
*parse
, FcVStackTag tag
)
1292 FcExpr
*left
, *expr
= 0, *new;
1294 while ((vstack
= FcVStackPop (parse
)))
1296 if (vstack
->tag
!= FcVStackFamily
)
1298 FcConfigMessage (parse
, FcSevereWarning
, "non-family");
1299 FcVStackDestroy (vstack
);
1302 left
= vstack
->u
.expr
;
1303 vstack
->tag
= FcVStackNone
;
1304 FcVStackDestroy (vstack
);
1307 new = FcExprCreateOp (left
, FcOpComma
, expr
);
1310 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1311 FcExprDestroy (left
);
1312 FcExprDestroy (expr
);
1322 if (!FcVStackPushExpr (parse
, tag
, expr
))
1324 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1326 FcExprDestroy (expr
);
1332 FcParseFamily (FcConfigParse
*parse
)
1339 s
= FcStrBufDone (&parse
->pstack
->str
);
1342 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1345 expr
= FcExprCreateString (s
);
1348 FcVStackPushExpr (parse
, FcVStackFamily
, expr
);
1352 FcParseAlias (FcConfigParse
*parse
)
1354 FcExpr
*family
= 0, *accept
= 0, *prefer
= 0, *def
= 0, *new = 0;
1355 FcEdit
*edit
= 0, *next
;
1359 while ((vstack
= FcVStackPop (parse
)))
1361 switch (vstack
->tag
) {
1362 case FcVStackFamily
:
1365 new = FcExprCreateOp (vstack
->u
.expr
, FcOpComma
, family
);
1367 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1372 new = vstack
->u
.expr
;
1376 vstack
->tag
= FcVStackNone
;
1379 case FcVStackPrefer
:
1381 FcExprDestroy (prefer
);
1382 prefer
= vstack
->u
.expr
;
1383 vstack
->tag
= FcVStackNone
;
1385 case FcVStackAccept
:
1387 FcExprDestroy (accept
);
1388 accept
= vstack
->u
.expr
;
1389 vstack
->tag
= FcVStackNone
;
1391 case FcVStackDefault
:
1393 FcExprDestroy (def
);
1394 def
= vstack
->u
.expr
;
1395 vstack
->tag
= FcVStackNone
;
1398 FcConfigMessage (parse
, FcSevereWarning
, "bad alias");
1401 FcVStackDestroy (vstack
);
1405 FcConfigMessage (parse
, FcSevereError
, "missing family in alias");
1407 FcExprDestroy (prefer
);
1409 FcExprDestroy (accept
);
1411 FcExprDestroy (def
);
1416 edit
= FcEditCreate (parse
,
1417 FcConfigSaveField ("family"),
1420 FcValueBindingWeak
);
1424 FcExprDestroy (prefer
);
1429 edit
= FcEditCreate (parse
,
1430 FcConfigSaveField ("family"),
1433 FcValueBindingWeak
);
1437 FcExprDestroy (accept
);
1442 edit
= FcEditCreate (parse
,
1443 FcConfigSaveField ("family"),
1446 FcValueBindingWeak
);
1450 FcExprDestroy (def
);
1454 test
= FcTestCreate (parse
, FcMatchPattern
,
1456 (FcChar8
*) FC_FAMILY
,
1460 if (!FcConfigAddEdit (parse
->config
, test
, edit
, FcMatchPattern
))
1461 FcTestDestroy (test
);
1464 FcExprDestroy (family
);
1468 FcPopExpr (FcConfigParse
*parse
)
1470 FcVStack
*vstack
= FcVStackPop (parse
);
1474 switch (vstack
->tag
) {
1477 case FcVStackString
:
1478 case FcVStackFamily
:
1479 expr
= FcExprCreateString (vstack
->u
.string
);
1482 expr
= FcExprCreateField ((char *) vstack
->u
.string
);
1484 case FcVStackConstant
:
1485 expr
= FcExprCreateConst (vstack
->u
.string
);
1488 /* XXX: What's the correct action here? (CDW) */
1490 case FcVStackPrefer
:
1491 case FcVStackAccept
:
1492 case FcVStackDefault
:
1493 expr
= vstack
->u
.expr
;
1494 vstack
->tag
= FcVStackNone
;
1496 case FcVStackInteger
:
1497 expr
= FcExprCreateInteger (vstack
->u
.integer
);
1499 case FcVStackDouble
:
1500 expr
= FcExprCreateDouble (vstack
->u
._double
);
1502 case FcVStackMatrix
:
1503 expr
= FcExprCreateMatrix (vstack
->u
.matrix
);
1506 expr
= FcExprCreateBool (vstack
->u
.bool);
1511 expr
= vstack
->u
.expr
;
1512 vstack
->tag
= FcVStackNone
;
1519 FcVStackDestroy (vstack
);
1524 * This builds a tree of binary operations. Note
1525 * that every operator is defined so that if only
1526 * a single operand is contained, the value of the
1527 * whole expression is the value of the operand.
1529 * This code reduces in that case to returning that
1533 FcPopBinary (FcConfigParse
*parse
, FcOp op
)
1535 FcExpr
*left
, *expr
= 0, *new;
1537 while ((left
= FcPopExpr (parse
)))
1541 new = FcExprCreateOp (left
, op
, expr
);
1544 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1545 FcExprDestroy (left
);
1546 FcExprDestroy (expr
);
1558 FcParseBinary (FcConfigParse
*parse
, FcOp op
)
1560 FcExpr
*expr
= FcPopBinary (parse
, op
);
1562 FcVStackPushExpr (parse
, FcVStackExpr
, expr
);
1566 * This builds a a unary operator, it consumes only
1571 FcPopUnary (FcConfigParse
*parse
, FcOp op
)
1573 FcExpr
*operand
, *new = 0;
1575 if ((operand
= FcPopExpr (parse
)))
1577 new = FcExprCreateOp (operand
, op
, 0);
1580 FcExprDestroy (operand
);
1581 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1588 FcParseUnary (FcConfigParse
*parse
, FcOp op
)
1590 FcExpr
*expr
= FcPopUnary (parse
, op
);
1592 FcVStackPushExpr (parse
, FcVStackExpr
, expr
);
1596 FcParseInclude (FcConfigParse
*parse
)
1600 FcBool ignore_missing
= FcFalse
;
1602 s
= FcStrBufDone (&parse
->pstack
->str
);
1605 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1608 i
= FcConfigGetAttribute (parse
, "ignore_missing");
1609 if (i
&& FcConfigLexBool (parse
, (FcChar8
*) i
) == FcTrue
)
1610 ignore_missing
= FcTrue
;
1611 if (!FcConfigParseAndLoad (parse
->config
, s
, !ignore_missing
))
1612 parse
->error
= FcTrue
;
1616 typedef struct _FcOpMap
{
1622 FcConfigLexOp (const FcChar8
*op
, const FcOpMap
*map
, int nmap
)
1626 for (i
= 0; i
< nmap
; i
++)
1627 if (!strcmp ((char *) op
, map
[i
].name
))
1632 static const FcOpMap fcCompareOps
[] = {
1633 { "eq", FcOpEqual
},
1634 { "not_eq", FcOpNotEqual
},
1635 { "less", FcOpLess
},
1636 { "less_eq", FcOpLessEqual
},
1637 { "more", FcOpMore
},
1638 { "more_eq", FcOpMoreEqual
},
1639 { "contains", FcOpContains
},
1640 { "not_contains", FcOpNotContains
}
1643 #define NUM_COMPARE_OPS (int) (sizeof fcCompareOps / sizeof fcCompareOps[0])
1646 FcConfigLexCompare (const FcChar8
*compare
)
1648 return FcConfigLexOp (compare
, fcCompareOps
, NUM_COMPARE_OPS
);
1653 FcParseTest (FcConfigParse
*parse
)
1655 const FcChar8
*kind_string
;
1657 const FcChar8
*qual_string
;
1659 const FcChar8
*name
;
1660 const FcChar8
*compare_string
;
1665 kind_string
= FcConfigGetAttribute (parse
, "target");
1667 kind
= FcMatchDefault
;
1670 if (!strcmp ((char *) kind_string
, "pattern"))
1671 kind
= FcMatchPattern
;
1672 else if (!strcmp ((char *) kind_string
, "font"))
1674 else if (!strcmp ((char *) kind_string
, "default"))
1675 kind
= FcMatchDefault
;
1678 FcConfigMessage (parse
, FcSevereWarning
, "invalid test target \"%s\"", kind_string
);
1682 qual_string
= FcConfigGetAttribute (parse
, "qual");
1687 if (!strcmp ((char *) qual_string
, "any"))
1689 else if (!strcmp ((char *) qual_string
, "all"))
1691 else if (!strcmp ((char *) qual_string
, "first"))
1693 else if (!strcmp ((char *) qual_string
, "not_first"))
1694 qual
= FcQualNotFirst
;
1697 FcConfigMessage (parse
, FcSevereWarning
, "invalid test qual \"%s\"", qual_string
);
1701 name
= FcConfigGetAttribute (parse
, "name");
1704 FcConfigMessage (parse
, FcSevereWarning
, "missing test name");
1707 compare_string
= FcConfigGetAttribute (parse
, "compare");
1708 if (!compare_string
)
1709 compare
= FcOpEqual
;
1712 compare
= FcConfigLexCompare (compare_string
);
1713 if (compare
== FcOpInvalid
)
1715 FcConfigMessage (parse
, FcSevereWarning
, "invalid test compare \"%s\"", compare_string
);
1719 expr
= FcPopBinary (parse
, FcOpComma
);
1722 FcConfigMessage (parse
, FcSevereWarning
, "missing test expression");
1725 test
= FcTestCreate (parse
, kind
, qual
, name
, compare
, expr
);
1728 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1731 FcVStackPushTest (parse
, test
);
1734 static const FcOpMap fcModeOps
[] = {
1735 { "assign", FcOpAssign
},
1736 { "assign_replace", FcOpAssignReplace
},
1737 { "prepend", FcOpPrepend
},
1738 { "prepend_first", FcOpPrependFirst
},
1739 { "append", FcOpAppend
},
1740 { "append_last", FcOpAppendLast
},
1743 #define NUM_MODE_OPS (int) (sizeof fcModeOps / sizeof fcModeOps[0])
1746 FcConfigLexMode (const FcChar8
*mode
)
1748 return FcConfigLexOp (mode
, fcModeOps
, NUM_MODE_OPS
);
1752 FcParseEdit (FcConfigParse
*parse
)
1754 const FcChar8
*name
;
1755 const FcChar8
*mode_string
;
1756 const FcChar8
*binding_string
;
1758 FcValueBinding binding
;
1762 name
= FcConfigGetAttribute (parse
, "name");
1765 FcConfigMessage (parse
, FcSevereWarning
, "missing edit name");
1768 mode_string
= FcConfigGetAttribute (parse
, "mode");
1773 mode
= FcConfigLexMode (mode_string
);
1774 if (mode
== FcOpInvalid
)
1776 FcConfigMessage (parse
, FcSevereWarning
, "invalid edit mode \"%s\"", mode_string
);
1780 binding_string
= FcConfigGetAttribute (parse
, "binding");
1781 if (!binding_string
)
1782 binding
= FcValueBindingWeak
;
1785 if (!strcmp ((char *) binding_string
, "weak"))
1786 binding
= FcValueBindingWeak
;
1787 else if (!strcmp ((char *) binding_string
, "strong"))
1788 binding
= FcValueBindingStrong
;
1789 else if (!strcmp ((char *) binding_string
, "same"))
1790 binding
= FcValueBindingSame
;
1793 FcConfigMessage (parse
, FcSevereWarning
, "invalid edit binding \"%s\"", binding_string
);
1797 expr
= FcPopBinary (parse
, FcOpComma
);
1798 edit
= FcEditCreate (parse
, (char *) FcStrCopy (name
), mode
, expr
, binding
);
1801 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1802 FcExprDestroy (expr
);
1805 if (!FcVStackPushEdit (parse
, edit
))
1806 FcEditDestroy (edit
);
1810 FcParseMatch (FcConfigParse
*parse
)
1812 const FcChar8
*kind_name
;
1818 kind_name
= FcConfigGetAttribute (parse
, "target");
1820 kind
= FcMatchPattern
;
1823 if (!strcmp ((char *) kind_name
, "pattern"))
1824 kind
= FcMatchPattern
;
1825 else if (!strcmp ((char *) kind_name
, "font"))
1829 FcConfigMessage (parse
, FcSevereWarning
, "invalid match target \"%s\"", kind_name
);
1833 while ((vstack
= FcVStackPop (parse
)))
1835 switch (vstack
->tag
) {
1837 vstack
->u
.test
->next
= test
;
1838 test
= vstack
->u
.test
;
1839 vstack
->tag
= FcVStackNone
;
1842 vstack
->u
.edit
->next
= edit
;
1843 edit
= vstack
->u
.edit
;
1844 vstack
->tag
= FcVStackNone
;
1847 FcConfigMessage (parse
, FcSevereWarning
, "invalid match element");
1850 FcVStackDestroy (vstack
);
1852 if (!FcConfigAddEdit (parse
->config
, test
, edit
, kind
))
1853 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1857 FcParseAcceptRejectFont (FcConfigParse
*parse
, FcElement element
)
1861 while ((vstack
= FcVStackPop (parse
)))
1863 switch (vstack
->tag
) {
1865 if (!FcConfigGlobAdd (parse
->config
,
1867 element
== FcElementAcceptfont
))
1869 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1872 case FcVStackPattern
:
1873 if (!FcConfigPatternsAdd (parse
->config
,
1875 element
== FcElementAcceptfont
))
1877 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1880 vstack
->tag
= FcVStackNone
;
1883 FcConfigMessage (parse
, FcSevereWarning
, "bad font selector");
1886 FcVStackDestroy (vstack
);
1892 FcPopValue (FcConfigParse
*parse
)
1894 FcVStack
*vstack
= FcVStackPop (parse
);
1897 value
.type
= FcTypeVoid
;
1902 switch (vstack
->tag
) {
1903 case FcVStackString
:
1904 value
.u
.s
= FcStrCopy (vstack
->u
.string
);
1906 value
.type
= FcTypeString
;
1908 case FcVStackConstant
:
1909 if (FcNameConstant (vstack
->u
.string
, &value
.u
.i
))
1910 value
.type
= FcTypeInteger
;
1912 case FcVStackInteger
:
1913 value
.u
.i
= vstack
->u
.integer
;
1914 value
.type
= FcTypeInteger
;
1916 case FcVStackDouble
:
1917 value
.u
.d
= vstack
->u
._double
;
1918 value
.type
= FcTypeInteger
;
1920 case FcVStackMatrix
:
1921 value
.u
.m
= FcMatrixCopy (vstack
->u
.matrix
);
1923 value
.type
= FcTypeMatrix
;
1926 value
.u
.b
= vstack
->u
.bool;
1927 value
.type
= FcTypeBool
;
1930 FcConfigMessage (parse
, FcSevereWarning
, "unknown pattern element %d",
1934 FcVStackDestroy (vstack
);
1940 FcParsePatelt (FcConfigParse
*parse
)
1943 FcPattern
*pattern
= FcPatternCreate ();
1948 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1952 name
= (char *) FcConfigGetAttribute (parse
, "name");
1955 FcConfigMessage (parse
, FcSevereWarning
, "missing pattern element name");
1961 value
= FcPopValue (parse
);
1962 if (value
.type
== FcTypeVoid
)
1964 if (!FcPatternAdd (pattern
, name
, value
, FcTrue
))
1966 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1971 FcVStackPushPattern (parse
, pattern
);
1975 FcParsePattern (FcConfigParse
*parse
)
1978 FcPattern
*pattern
= FcPatternCreate ();
1982 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1986 while ((vstack
= FcVStackPop (parse
)))
1988 switch (vstack
->tag
) {
1989 case FcVStackPattern
:
1990 if (!FcPatternAppend (pattern
, vstack
->u
.pattern
))
1992 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1997 FcConfigMessage (parse
, FcSevereWarning
, "unknown pattern element");
2000 FcVStackDestroy (vstack
);
2003 FcVStackPushPattern (parse
, pattern
);
2007 FcEndElement(void *userData
, const XML_Char
*name
)
2009 FcConfigParse
*parse
= userData
;
2014 switch (parse
->pstack
->element
) {
2017 case FcElementFontconfig
:
2020 data
= FcStrBufDone (&parse
->pstack
->str
);
2023 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2027 if (strcmp (data
, "WINDOWSFONTDIR") == 0)
2031 data
= malloc (1000);
2034 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2037 FcMemAlloc (FC_MEM_STRING
, 1000);
2038 rc
= GetWindowsDirectory (data
, 800);
2039 if (rc
== 0 || rc
> 800)
2041 FcConfigMessage (parse
, FcSevereError
, "GetWindowsDirectory failed");
2045 if (data
[strlen (data
) - 1] != '\\')
2046 strcat (data
, "\\");
2047 strcat (data
, "fonts");
2050 if (!FcStrUsesHome (data
) || FcConfigHome ())
2052 if (!FcConfigAddDir (parse
->config
, data
))
2053 FcConfigMessage (parse
, FcSevereError
, "out of memory; cannot add directory %s", data
);
2057 case FcElementCache
:
2058 data
= FcStrBufDone (&parse
->pstack
->str
);
2061 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2064 if (!FcStrUsesHome (data
) || FcConfigHome ())
2066 if (!FcConfigSetCache (parse
->config
, data
))
2067 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2071 case FcElementInclude
:
2072 FcParseInclude (parse
);
2074 case FcElementConfig
:
2076 case FcElementMatch
:
2077 FcParseMatch (parse
);
2079 case FcElementAlias
:
2080 FcParseAlias (parse
);
2083 case FcElementBlank
:
2084 FcParseBlank (parse
);
2086 case FcElementRescan
:
2087 FcParseRescan (parse
);
2090 case FcElementPrefer
:
2091 FcParseFamilies (parse
, FcVStackPrefer
);
2093 case FcElementAccept
:
2094 FcParseFamilies (parse
, FcVStackAccept
);
2096 case FcElementDefault
:
2097 FcParseFamilies (parse
, FcVStackDefault
);
2099 case FcElementFamily
:
2100 FcParseFamily (parse
);
2104 FcParseTest (parse
);
2107 FcParseEdit (parse
);
2113 case FcElementDouble
:
2114 FcParseDouble (parse
);
2116 case FcElementString
:
2117 FcParseString (parse
, FcVStackString
);
2119 case FcElementMatrix
:
2120 FcParseMatrix (parse
);
2123 FcParseBool (parse
);
2125 case FcElementCharset
:
2126 /* FcParseCharset (parse); */
2128 case FcElementSelectfont
:
2130 case FcElementAcceptfont
:
2131 case FcElementRejectfont
:
2132 FcParseAcceptRejectFont (parse
, parse
->pstack
->element
);
2135 FcParseString (parse
, FcVStackGlob
);
2137 case FcElementPattern
:
2138 FcParsePattern (parse
);
2140 case FcElementPatelt
:
2141 FcParsePatelt (parse
);
2144 FcParseString (parse
, FcVStackField
);
2146 case FcElementConst
:
2147 FcParseString (parse
, FcVStackConstant
);
2150 FcParseBinary (parse
, FcOpOr
);
2153 FcParseBinary (parse
, FcOpAnd
);
2156 FcParseBinary (parse
, FcOpEqual
);
2158 case FcElementNotEq
:
2159 FcParseBinary (parse
, FcOpNotEqual
);
2162 FcParseBinary (parse
, FcOpLess
);
2164 case FcElementLessEq
:
2165 FcParseBinary (parse
, FcOpLessEqual
);
2168 FcParseBinary (parse
, FcOpMore
);
2170 case FcElementMoreEq
:
2171 FcParseBinary (parse
, FcOpMoreEqual
);
2173 case FcElementContains
:
2174 FcParseBinary (parse
, FcOpContains
);
2176 case FcElementNotContains
:
2177 FcParseBinary (parse
, FcOpNotContains
);
2180 FcParseBinary (parse
, FcOpPlus
);
2182 case FcElementMinus
:
2183 FcParseBinary (parse
, FcOpMinus
);
2185 case FcElementTimes
:
2186 FcParseBinary (parse
, FcOpTimes
);
2188 case FcElementDivide
:
2189 FcParseBinary (parse
, FcOpDivide
);
2192 FcParseUnary (parse
, FcOpNot
);
2195 FcParseBinary (parse
, FcOpQuest
);
2197 case FcElementFloor
:
2198 FcParseUnary (parse
, FcOpFloor
);
2201 FcParseUnary (parse
, FcOpCeil
);
2203 case FcElementRound
:
2204 FcParseUnary (parse
, FcOpRound
);
2206 case FcElementTrunc
:
2207 FcParseUnary (parse
, FcOpTrunc
);
2209 case FcElementUnknown
:
2212 (void) FcPStackPop (parse
);
2216 FcCharacterData (void *userData
, const XML_Char
*s
, int len
)
2218 FcConfigParse
*parse
= userData
;
2222 if (!FcStrBufData (&parse
->pstack
->str
, (FcChar8
*) s
, len
))
2223 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2227 FcStartDoctypeDecl (void *userData
,
2228 const XML_Char
*doctypeName
,
2229 const XML_Char
*sysid
,
2230 const XML_Char
*pubid
,
2231 int has_internal_subset
)
2233 FcConfigParse
*parse
= userData
;
2235 if (strcmp ((char *) doctypeName
, "fontconfig") != 0)
2236 FcConfigMessage (parse
, FcSevereError
, "invalid doctype \"%s\"", doctypeName
);
2242 FcInternalSubsetDecl (void *userData
,
2243 const XML_Char
*doctypeName
,
2244 const XML_Char
*sysid
,
2245 const XML_Char
*pubid
)
2247 FcStartDoctypeDecl (userData
, doctypeName
, sysid
, pubid
, 1);
2251 FcExternalSubsetDecl (void *userData
,
2252 const XML_Char
*doctypeName
,
2253 const XML_Char
*sysid
,
2254 const XML_Char
*pubid
)
2256 FcStartDoctypeDecl (userData
, doctypeName
, sysid
, pubid
, 0);
2259 #else /* ENABLE_LIBXML2 */
2262 FcEndDoctypeDecl (void *userData
)
2266 #endif /* ENABLE_LIBXML2 */
2269 FcConfigParseAndLoadDir (FcConfig
*config
,
2270 const FcChar8
*name
,
2276 FcBool ret
= FcTrue
;
2281 d
= opendir ((char *) dir
);
2285 FcConfigMessage (0, FcSevereError
, "Cannot open config dir \"%s\"",
2291 file
= (FcChar8
*) malloc (strlen ((char *) dir
) + 1 + FC_MAX_FILE_LEN
+ 1);
2298 strcpy ((char *) file
, (char *) dir
);
2299 strcat ((char *) file
, "/");
2300 base
= file
+ strlen ((char *) file
);
2302 files
= FcStrSetCreate ();
2309 if (FcDebug () & FC_DBG_CONFIG
)
2310 printf ("\tScanning config dir %s\n", dir
);
2312 while (ret
&& (e
= readdir (d
)))
2315 #define TAIL ".conf"
2318 * Add all files of the form [0-9]*.conf
2320 if ('0' <= e
->d_name
[0] && e
->d_name
[0] <= '9' &&
2321 (d_len
= strlen (e
->d_name
)) < FC_MAX_FILE_LEN
&&
2323 strcmp (e
->d_name
+ d_len
- TAIL_LEN
, TAIL
) == 0)
2325 strcpy ((char *) base
, (char *) e
->d_name
);
2326 if (!FcStrSetAdd (files
, file
))
2336 qsort (files
->strs
, files
->num
, sizeof (FcChar8
*),
2337 (int (*)(const void *, const void *)) FcStrCmp
);
2338 for (i
= 0; ret
&& i
< files
->num
; i
++)
2339 ret
= FcConfigParseAndLoad (config
, files
->strs
[i
], complain
);
2342 FcStrSetDestroy (files
);
2348 return ret
|| !complain
;
2352 FcConfigParseAndLoad (FcConfig
*config
,
2353 const FcChar8
*name
,
2361 FcConfigParse parse
;
2362 FcBool error
= FcTrue
;
2371 filename
= FcConfigFilename (name
);
2375 if (FcStrSetMember (config
->configFiles
, filename
))
2377 FcStrFree (filename
);
2381 if (!FcStrSetAdd (config
->configFiles
, filename
))
2383 FcStrFree (filename
);
2387 if (FcFileIsDir (filename
))
2389 FcBool ret
= FcConfigParseAndLoadDir (config
, name
, filename
, complain
);
2390 FcStrFree (filename
);
2394 if (FcDebug () & FC_DBG_CONFIG
)
2395 printf ("\tLoading config file %s\n", filename
);
2397 fd
= open ((char *) filename
, O_RDONLY
);
2399 FcStrFree (filename
);
2404 memset(&sax
, 0, sizeof(sax
));
2406 sax
.internalSubset
= FcInternalSubsetDecl
;
2407 sax
.externalSubset
= FcExternalSubsetDecl
;
2408 sax
.startElement
= FcStartElement
;
2409 sax
.endElement
= FcEndElement
;
2410 sax
.characters
= FcCharacterData
;
2412 p
= xmlCreatePushParserCtxt (&sax
, &parse
, NULL
, 0, (const char *) filename
);
2414 p
= XML_ParserCreate ("UTF-8");
2416 FcStrFree (filename
);
2421 if (!FcConfigInit (&parse
, name
, config
, p
))
2426 XML_SetUserData (p
, &parse
);
2428 XML_SetDoctypeDeclHandler (p
, FcStartDoctypeDecl
, FcEndDoctypeDecl
);
2429 XML_SetElementHandler (p
, FcStartElement
, FcEndElement
);
2430 XML_SetCharacterDataHandler (p
, FcCharacterData
);
2432 #endif /* ENABLE_LIBXML2 */
2436 buf
= XML_GetBuffer (p
, BUFSIZ
);
2439 FcConfigMessage (&parse
, FcSevereError
, "cannot get parse buffer");
2443 len
= read (fd
, buf
, BUFSIZ
);
2446 FcConfigMessage (&parse
, FcSevereError
, "failed reading config file");
2451 if (xmlParseChunk (p
, buf
, len
, len
== 0))
2453 if (!XML_ParseBuffer (p
, len
, len
== 0))
2456 FcConfigMessage (&parse
, FcSevereError
, "%s",
2457 XML_ErrorString (XML_GetErrorCode (p
)));
2461 error
= parse
.error
;
2463 FcConfigCleanup (&parse
);
2470 if (error
&& complain
)
2473 FcConfigMessage (0, FcSevereError
, "Cannot load config file \"%s\"", name
);
2475 FcConfigMessage (0, FcSevereError
, "Cannot load default config file");