]>
git.wh0rd.org - fontconfig.git/blob - src/fcxml.c
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 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 * 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 */
62 FcExprDestroy (FcExpr
*e
);
65 FcTestDestroy (FcTest
*test
)
68 FcTestDestroy (test
->next
);
69 FcExprDestroy (test
->expr
);
70 FcMemFree (FC_MEM_TEST
, sizeof (FcTest
));
75 FcExprCreateInteger (FcConfig
*config
, int i
)
77 FcExpr
*e
= FcConfigAllocExpr (config
);
87 FcExprCreateDouble (FcConfig
*config
, double d
)
89 FcExpr
*e
= FcConfigAllocExpr (config
);
99 FcExprCreateString (FcConfig
*config
, const FcChar8
*s
)
101 FcExpr
*e
= FcConfigAllocExpr (config
);
105 e
->u
.sval
= FcStrCopy (s
);
111 FcExprCreateMatrix (FcConfig
*config
, const FcMatrix
*m
)
113 FcExpr
*e
= FcConfigAllocExpr (config
);
117 e
->u
.mval
= FcMatrixCopy (m
);
123 FcExprCreateBool (FcConfig
*config
, FcBool b
)
125 FcExpr
*e
= FcConfigAllocExpr (config
);
135 FcExprCreateNil (FcConfig
*config
)
137 FcExpr
*e
= FcConfigAllocExpr (config
);
140 FcMemAlloc (FC_MEM_EXPR
, sizeof (FcExpr
));
147 FcExprCreateField (FcConfig
*config
, const char *field
)
149 FcExpr
*e
= FcConfigAllocExpr (config
);
153 e
->u
.object
= FcObjectFromName (field
);
159 FcExprCreateConst (FcConfig
*config
, const FcChar8
*constant
)
161 FcExpr
*e
= FcConfigAllocExpr (config
);
165 e
->u
.constant
= FcStrCopy (constant
);
171 FcExprCreateOp (FcConfig
*config
, FcExpr
*left
, FcOp op
, FcExpr
*right
)
173 FcExpr
*e
= FcConfigAllocExpr (config
);
177 e
->u
.tree
.left
= left
;
178 e
->u
.tree
.right
= right
;
184 FcExprDestroy (FcExpr
*e
)
194 FcStrFree (e
->u
.sval
);
197 FcMatrixFree (e
->u
.mval
);
200 FcCharSetDestroy (e
->u
.cval
);
207 FcStrFree (e
->u
.constant
);
210 case FcOpAssignReplace
:
212 case FcOpPrependFirst
:
226 case FcOpNotContains
:
233 FcExprDestroy (e
->u
.tree
.right
);
240 FcExprDestroy (e
->u
.tree
.left
);
251 FcEditDestroy (FcEdit
*e
)
254 FcEditDestroy (e
->next
);
256 FcExprDestroy (e
->expr
);
260 typedef enum _FcElement
{
305 FcElementNotContains
,
319 static const struct {
323 { "fontconfig", FcElementFontconfig
},
324 { "dir", FcElementDir
},
325 { "cachedir", FcElementCacheDir
},
326 { "cache", FcElementCache
},
327 { "include", FcElementInclude
},
328 { "config", FcElementConfig
},
329 { "match", FcElementMatch
},
330 { "alias", FcElementAlias
},
332 { "blank", FcElementBlank
},
333 { "rescan", FcElementRescan
},
335 { "prefer", FcElementPrefer
},
336 { "accept", FcElementAccept
},
337 { "default", FcElementDefault
},
338 { "family", FcElementFamily
},
340 { "selectfont", FcElementSelectfont
},
341 { "acceptfont", FcElementAcceptfont
},
342 { "rejectfont", FcElementRejectfont
},
343 { "glob", FcElementGlob
},
344 { "pattern", FcElementPattern
},
345 { "patelt", FcElementPatelt
},
347 { "test", FcElementTest
},
348 { "edit", FcElementEdit
},
349 { "int", FcElementInt
},
350 { "double", FcElementDouble
},
351 { "string", FcElementString
},
352 { "matrix", FcElementMatrix
},
353 { "bool", FcElementBool
},
354 { "charset", FcElementCharset
},
355 { "name", FcElementName
},
356 { "const", FcElementConst
},
357 { "or", FcElementOr
},
358 { "and", FcElementAnd
},
359 { "eq", FcElementEq
},
360 { "not_eq", FcElementNotEq
},
361 { "less", FcElementLess
},
362 { "less_eq", FcElementLessEq
},
363 { "more", FcElementMore
},
364 { "more_eq", FcElementMoreEq
},
365 { "contains", FcElementContains
},
366 { "not_contains", FcElementNotContains
},
367 { "plus", FcElementPlus
},
368 { "minus", FcElementMinus
},
369 { "times", FcElementTimes
},
370 { "divide", FcElementDivide
},
371 { "not", FcElementNot
},
372 { "if", FcElementIf
},
373 { "floor", FcElementFloor
},
374 { "ceil", FcElementCeil
},
375 { "round", FcElementRound
},
376 { "trunc", FcElementTrunc
},
378 #define NUM_ELEMENT_MAPS (int) (sizeof fcElementMap / sizeof fcElementMap[0])
381 FcElementMap (const XML_Char
*name
)
385 for (i
= 0; i
< NUM_ELEMENT_MAPS
; i
++)
386 if (!strcmp ((char *) name
, fcElementMap
[i
].name
))
387 return fcElementMap
[i
].element
;
388 return FcElementUnknown
;
391 typedef struct _FcPStack
{
392 struct _FcPStack
*prev
;
396 FcChar8
*attr_buf_static
[16];
399 typedef enum _FcVStackTag
{
423 typedef struct _FcVStack
{
424 struct _FcVStack
*prev
;
425 FcPStack
*pstack
; /* related parse element */
445 typedef struct _FcConfigParse
{
452 int pstack_static_used
;
453 FcPStack pstack_static
[8];
454 int vstack_static_used
;
455 FcVStack vstack_static
[64];
458 typedef enum _FcConfigSeverity
{
459 FcSevereInfo
, FcSevereWarning
, FcSevereError
463 FcConfigMessage (FcConfigParse
*parse
, FcConfigSeverity severe
, const char *fmt
, ...)
465 const char *s
= "unknown";
468 va_start (args
, fmt
);
471 case FcSevereInfo
: s
= "info"; break;
472 case FcSevereWarning
: s
= "warning"; break;
473 case FcSevereError
: s
= "error"; break;
478 fprintf (stderr
, "Fontconfig %s: \"%s\", line %d: ", s
,
479 parse
->name
, (int)XML_GetCurrentLineNumber (parse
->parser
));
481 fprintf (stderr
, "Fontconfig %s: line %d: ", s
,
482 (int)XML_GetCurrentLineNumber (parse
->parser
));
483 if (severe
>= FcSevereError
)
484 parse
->error
= FcTrue
;
487 fprintf (stderr
, "Fontconfig %s: ", s
);
488 vfprintf (stderr
, fmt
, args
);
489 fprintf (stderr
, "\n");
495 FcTypeName (FcType type
)
521 FcTypecheckValue (FcConfigParse
*parse
, FcType value
, FcType type
)
523 if (value
== FcTypeInteger
)
524 value
= FcTypeDouble
;
525 if (type
== FcTypeInteger
)
529 if ((value
== FcTypeLangSet
&& type
== FcTypeString
) ||
530 (value
== FcTypeString
&& type
== FcTypeLangSet
))
532 if (type
== (FcType
) -1)
534 FcConfigMessage (parse
, FcSevereWarning
, "saw %s, expected %s",
535 FcTypeName (value
), FcTypeName (type
));
540 FcTypecheckExpr (FcConfigParse
*parse
, FcExpr
*expr
, FcType type
)
542 const FcObjectType
*o
;
545 /* If parsing the expression failed, some nodes may be NULL */
552 FcTypecheckValue (parse
, FcTypeDouble
, type
);
555 FcTypecheckValue (parse
, FcTypeString
, type
);
558 FcTypecheckValue (parse
, FcTypeMatrix
, type
);
561 FcTypecheckValue (parse
, FcTypeBool
, type
);
564 FcTypecheckValue (parse
, FcTypeCharSet
, type
);
569 o
= FcNameGetObjectType (FcObjectName (expr
->u
.object
));
571 FcTypecheckValue (parse
, o
->type
, type
);
574 c
= FcNameGetConstant (expr
->u
.constant
);
577 o
= FcNameGetObjectType (c
->object
);
579 FcTypecheckValue (parse
, o
->type
, type
);
582 FcConfigMessage (parse
, FcSevereWarning
,
583 "invalid constant used : %s",
587 FcTypecheckExpr (parse
, expr
->u
.tree
.left
, FcTypeBool
);
588 FcTypecheckExpr (parse
, expr
->u
.tree
.right
->u
.tree
.left
, type
);
589 FcTypecheckExpr (parse
, expr
->u
.tree
.right
->u
.tree
.right
, type
);
592 case FcOpAssignReplace
:
601 case FcOpNotContains
:
603 FcTypecheckValue (parse
, FcTypeBool
, type
);
612 FcTypecheckExpr (parse
, expr
->u
.tree
.left
, type
);
613 FcTypecheckExpr (parse
, expr
->u
.tree
.right
, type
);
616 FcTypecheckValue (parse
, FcTypeBool
, type
);
617 FcTypecheckExpr (parse
, expr
->u
.tree
.left
, FcTypeBool
);
623 FcTypecheckValue (parse
, FcTypeDouble
, type
);
624 FcTypecheckExpr (parse
, expr
->u
.tree
.left
, FcTypeDouble
);
632 FcTestCreate (FcConfigParse
*parse
,
635 const FcChar8
*field
,
639 FcTest
*test
= (FcTest
*) malloc (sizeof (FcTest
));
643 const FcObjectType
*o
;
645 FcMemAlloc (FC_MEM_TEST
, sizeof (FcTest
));
649 test
->object
= FcObjectFromName ((const char *) field
);
652 o
= FcNameGetObjectType (FcObjectName (test
->object
));
654 FcTypecheckExpr (parse
, expr
, o
->type
);
660 FcEditCreate (FcConfigParse
*parse
,
664 FcValueBinding binding
)
666 FcEdit
*e
= (FcEdit
*) malloc (sizeof (FcEdit
));
670 const FcObjectType
*o
;
676 e
->binding
= binding
;
677 o
= FcNameGetObjectType (FcObjectName (e
->object
));
679 FcTypecheckExpr (parse
, expr
, o
->type
);
685 FcVStackCreateAndPush (FcConfigParse
*parse
)
689 if (parse
->vstack_static_used
< sizeof (parse
->vstack_static
) / sizeof (parse
->vstack_static
[0]))
690 new = &parse
->vstack_static
[parse
->vstack_static_used
++];
693 new = malloc (sizeof (FcVStack
));
696 FcMemAlloc (FC_MEM_VSTACK
, sizeof (FcVStack
));
698 new->tag
= FcVStackNone
;
701 new->prev
= parse
->vstack
;
702 new->pstack
= parse
->pstack
? parse
->pstack
->prev
: 0;
709 FcVStackPushString (FcConfigParse
*parse
, FcVStackTag tag
, FcChar8
*string
)
711 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
714 vstack
->u
.string
= string
;
720 FcVStackPushInteger (FcConfigParse
*parse
, int integer
)
722 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
725 vstack
->u
.integer
= integer
;
726 vstack
->tag
= FcVStackInteger
;
731 FcVStackPushDouble (FcConfigParse
*parse
, double _double
)
733 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
736 vstack
->u
._double
= _double
;
737 vstack
->tag
= FcVStackDouble
;
742 FcVStackPushMatrix (FcConfigParse
*parse
, FcMatrix
*matrix
)
745 matrix
= FcMatrixCopy (matrix
);
748 vstack
= FcVStackCreateAndPush (parse
);
751 vstack
->u
.matrix
= matrix
;
752 vstack
->tag
= FcVStackMatrix
;
757 FcVStackPushBool (FcConfigParse
*parse
, FcBool bool_
)
759 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
762 vstack
->u
.bool_
= bool_
;
763 vstack
->tag
= FcVStackBool
;
768 FcVStackPushTest (FcConfigParse
*parse
, FcTest
*test
)
770 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
773 vstack
->u
.test
= test
;
774 vstack
->tag
= FcVStackTest
;
779 FcVStackPushExpr (FcConfigParse
*parse
, FcVStackTag tag
, FcExpr
*expr
)
781 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
784 vstack
->u
.expr
= expr
;
790 FcVStackPushEdit (FcConfigParse
*parse
, FcEdit
*edit
)
792 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
795 vstack
->u
.edit
= edit
;
796 vstack
->tag
= FcVStackEdit
;
801 FcVStackPushPattern (FcConfigParse
*parse
, FcPattern
*pattern
)
803 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
806 vstack
->u
.pattern
= pattern
;
807 vstack
->tag
= FcVStackPattern
;
812 FcVStackFetch (FcConfigParse
*parse
, int off
)
816 for (vstack
= parse
->vstack
; vstack
&& off
-- > 0; vstack
= vstack
->prev
);
821 FcVStackPeek (FcConfigParse
*parse
)
823 FcVStack
*vstack
= parse
->vstack
;
825 return vstack
&& vstack
->pstack
== parse
->pstack
? vstack
: 0;
829 FcVStackPopAndDestroy (FcConfigParse
*parse
)
831 FcVStack
*vstack
= parse
->vstack
;
833 if (!vstack
|| vstack
->pstack
!= parse
->pstack
)
836 parse
->vstack
= vstack
->prev
;
838 switch (vstack
->tag
) {
844 case FcVStackConstant
:
846 FcStrFree (vstack
->u
.string
);
848 case FcVStackPattern
:
849 FcPatternDestroy (vstack
->u
.pattern
);
851 case FcVStackInteger
:
855 FcMatrixFree (vstack
->u
.matrix
);
860 FcTestDestroy (vstack
->u
.test
);
865 case FcVStackDefault
:
866 FcExprDestroy (vstack
->u
.expr
);
869 FcEditDestroy (vstack
->u
.edit
);
873 if (vstack
== &parse
->vstack_static
[parse
->vstack_static_used
- 1])
874 parse
->vstack_static_used
--;
877 FcMemFree (FC_MEM_VSTACK
, sizeof (FcVStack
));
883 FcVStackClear (FcConfigParse
*parse
)
885 while (FcVStackPeek (parse
))
886 FcVStackPopAndDestroy (parse
);
890 FcVStackElements (FcConfigParse
*parse
)
893 FcVStack
*vstack
= parse
->vstack
;
894 while (vstack
&& vstack
->pstack
== parse
->pstack
)
897 vstack
= vstack
->prev
;
903 FcConfigSaveAttr (const XML_Char
**attr
, FcChar8
**buf
, int size_bytes
)
913 for (i
= 0; attr
[i
]; i
++)
914 slen
+= strlen ((char *) attr
[i
]) + 1;
917 slen
+= (i
+ 1) * sizeof (FcChar8
*);
918 if (slen
<= size_bytes
)
925 FcConfigMessage (0, FcSevereError
, "out of memory");
928 FcMemAlloc (FC_MEM_ATTR
, 1); /* size is too expensive */
930 s
= (FcChar8
*) (new + (i
+ 1));
931 for (i
= 0; attr
[i
]; i
++)
934 strcpy ((char *) s
, (char *) attr
[i
]);
935 s
+= strlen ((char *) s
) + 1;
942 FcPStackPush (FcConfigParse
*parse
, FcElement element
, const XML_Char
**attr
)
946 if (parse
->pstack_static_used
< sizeof (parse
->pstack_static
) / sizeof (parse
->pstack_static
[0]))
947 new = &parse
->pstack_static
[parse
->pstack_static_used
++];
950 new = malloc (sizeof (FcPStack
));
953 FcMemAlloc (FC_MEM_PSTACK
, sizeof (FcPStack
));
956 new->prev
= parse
->pstack
;
957 new->element
= element
;
958 new->attr
= FcConfigSaveAttr (attr
, new->attr_buf_static
, sizeof (new->attr_buf_static
));
959 FcStrBufInit (&new->str
, 0, 0);
965 FcPStackPop (FcConfigParse
*parse
)
971 FcConfigMessage (parse
, FcSevereError
, "mismatching element");
974 FcVStackClear (parse
);
976 parse
->pstack
= old
->prev
;
977 FcStrBufDestroy (&old
->str
);
978 if (old
->attr
&& old
->attr
!= old
->attr_buf_static
)
980 FcMemFree (FC_MEM_ATTR
, 1); /* size is to expensive */
984 if (old
== &parse
->pstack_static
[parse
->pstack_static_used
- 1])
985 parse
->pstack_static_used
--;
988 FcMemFree (FC_MEM_PSTACK
, sizeof (FcPStack
));
995 FcConfigInit (FcConfigParse
*parse
, const FcChar8
*name
, FcConfig
*config
, XML_Parser parser
)
998 parse
->pstack_static_used
= 0;
1000 parse
->vstack_static_used
= 0;
1001 parse
->error
= FcFalse
;
1003 parse
->config
= config
;
1004 parse
->parser
= parser
;
1009 FcConfigCleanup (FcConfigParse
*parse
)
1011 while (parse
->pstack
)
1012 FcPStackPop (parse
);
1015 static const FcChar8
*
1016 FcConfigGetAttribute (FcConfigParse
*parse
, const char *attr
)
1022 attrs
= parse
->pstack
->attr
;
1028 if (!strcmp ((char *) *attrs
, attr
))
1036 FcStartElement(void *userData
, const XML_Char
*name
, const XML_Char
**attr
)
1038 FcConfigParse
*parse
= userData
;
1041 element
= FcElementMap (name
);
1042 if (element
== FcElementUnknown
)
1043 FcConfigMessage (parse
, FcSevereWarning
, "unknown element \"%s\"", name
);
1045 if (!FcPStackPush (parse
, element
, attr
))
1047 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1054 FcParseBlank (FcConfigParse
*parse
)
1056 int n
= FcVStackElements (parse
);
1059 FcVStack
*v
= FcVStackFetch (parse
, n
);
1060 if (v
->tag
!= FcVStackInteger
)
1061 FcConfigMessage (parse
, FcSevereError
, "non-integer blank");
1064 if (!parse
->config
->blanks
)
1066 parse
->config
->blanks
= FcBlanksCreate ();
1067 if (!parse
->config
->blanks
)
1069 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1073 if (!FcBlanksAdd (parse
->config
->blanks
, v
->u
.integer
))
1075 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1083 FcParseRescan (FcConfigParse
*parse
)
1085 int n
= FcVStackElements (parse
);
1088 FcVStack
*v
= FcVStackFetch (parse
, n
);
1089 if (v
->tag
!= FcVStackInteger
)
1090 FcConfigMessage (parse
, FcSevereWarning
, "non-integer rescan");
1092 parse
->config
->rescanInterval
= v
->u
.integer
;
1097 FcParseInt (FcConfigParse
*parse
)
1104 s
= FcStrBufDoneStatic (&parse
->pstack
->str
);
1107 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1111 l
= (int) strtol ((char *) s
, (char **)&end
, 0);
1112 if (end
!= s
+ strlen ((char *) s
))
1113 FcConfigMessage (parse
, FcSevereError
, "\"%s\": not a valid integer", s
);
1115 FcVStackPushInteger (parse
, l
);
1116 FcStrBufDestroy (&parse
->pstack
->str
);
1120 * idea copied from glib g_ascii_strtod with
1121 * permission of the author (Alexander Larsson)
1127 FcStrtod (char *s
, char **end
)
1129 struct lconv
*locale_data
;
1134 * Have to swap the decimal point to match the current locale
1135 * if that locale doesn't use 0x2e
1137 if ((dot
= strchr (s
, 0x2e)) &&
1138 (locale_data
= localeconv ()) &&
1139 (locale_data
->decimal_point
[0] != 0x2e ||
1140 locale_data
->decimal_point
[1] != 0))
1143 int slen
= strlen (s
);
1144 int dlen
= strlen (locale_data
->decimal_point
);
1146 if (slen
+ dlen
> (int) sizeof (buf
))
1156 strncpy (buf
, s
, dot
- s
);
1158 strcpy (buf
+ (dot
- s
), locale_data
->decimal_point
);
1159 /* rest of number */
1160 strcpy (buf
+ (dot
- s
) + dlen
, dot
+ 1);
1162 v
= strtod (buf
, &buf_end
);
1164 buf_end
= s
+ (buf_end
- buf
);
1166 buf_end
-= dlen
- 1;
1173 v
= strtod (s
, end
);
1178 FcParseDouble (FcConfigParse
*parse
)
1185 s
= FcStrBufDoneStatic (&parse
->pstack
->str
);
1188 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1192 d
= FcStrtod ((char *) s
, (char **)&end
);
1193 if (end
!= s
+ strlen ((char *) s
))
1194 FcConfigMessage (parse
, FcSevereError
, "\"%s\": not a valid double", s
);
1196 FcVStackPushDouble (parse
, d
);
1197 FcStrBufDestroy (&parse
->pstack
->str
);
1201 FcParseString (FcConfigParse
*parse
, FcVStackTag tag
)
1207 s
= FcStrBufDone (&parse
->pstack
->str
);
1210 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1213 if (!FcVStackPushString (parse
, tag
, s
))
1218 FcParseMatrix (FcConfigParse
*parse
)
1221 enum { m_done
, m_xx
, m_xy
, m_yx
, m_yy
} matrix_state
= m_yy
;
1224 while ((vstack
= FcVStackPeek (parse
)))
1227 switch (vstack
->tag
) {
1228 case FcVStackInteger
:
1229 v
= vstack
->u
.integer
;
1231 case FcVStackDouble
:
1232 v
= vstack
->u
._double
;
1235 FcConfigMessage (parse
, FcSevereError
, "non-double matrix element");
1239 switch (matrix_state
) {
1240 case m_xx
: m
.xx
= v
; break;
1241 case m_xy
: m
.xy
= v
; break;
1242 case m_yx
: m
.yx
= v
; break;
1243 case m_yy
: m
.yy
= v
; break;
1246 FcVStackPopAndDestroy (parse
);
1249 if (matrix_state
!= m_done
)
1250 FcConfigMessage (parse
, FcSevereError
, "wrong number of matrix elements");
1252 FcVStackPushMatrix (parse
, &m
);
1256 FcConfigLexBool (FcConfigParse
*parse
, const FcChar8
*bool_
)
1258 FcBool result
= FcFalse
;
1260 if (!FcNameBool (bool_
, &result
))
1261 FcConfigMessage (parse
, FcSevereWarning
, "\"%s\" is not known boolean",
1267 FcParseBool (FcConfigParse
*parse
)
1273 s
= FcStrBufDoneStatic (&parse
->pstack
->str
);
1276 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1279 FcVStackPushBool (parse
, FcConfigLexBool (parse
, s
));
1280 FcStrBufDestroy (&parse
->pstack
->str
);
1284 FcConfigLexBinding (FcConfigParse
*parse
,
1285 const FcChar8
*binding_string
,
1286 FcValueBinding
*binding_ret
)
1288 FcValueBinding binding
;
1290 if (!binding_string
)
1291 binding
= FcValueBindingWeak
;
1294 if (!strcmp ((char *) binding_string
, "weak"))
1295 binding
= FcValueBindingWeak
;
1296 else if (!strcmp ((char *) binding_string
, "strong"))
1297 binding
= FcValueBindingStrong
;
1298 else if (!strcmp ((char *) binding_string
, "same"))
1299 binding
= FcValueBindingSame
;
1302 FcConfigMessage (parse
, FcSevereWarning
, "invalid binding \"%s\"", binding_string
);
1306 *binding_ret
= binding
;
1311 FcParseFamilies (FcConfigParse
*parse
, FcVStackTag tag
)
1314 FcExpr
*left
, *expr
= 0, *new;
1316 while ((vstack
= FcVStackPeek (parse
)))
1318 if (vstack
->tag
!= FcVStackFamily
)
1320 FcConfigMessage (parse
, FcSevereWarning
, "non-family");
1321 FcVStackPopAndDestroy (parse
);
1324 left
= vstack
->u
.expr
;
1325 vstack
->tag
= FcVStackNone
;
1326 FcVStackPopAndDestroy (parse
);
1329 new = FcExprCreateOp (parse
->config
, left
, FcOpComma
, expr
);
1332 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1333 FcExprDestroy (left
);
1334 FcExprDestroy (expr
);
1344 if (!FcVStackPushExpr (parse
, tag
, expr
))
1346 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1347 FcExprDestroy (expr
);
1353 FcParseFamily (FcConfigParse
*parse
)
1360 s
= FcStrBufDoneStatic (&parse
->pstack
->str
);
1363 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1366 expr
= FcExprCreateString (parse
->config
, s
);
1367 FcStrBufDestroy (&parse
->pstack
->str
);
1369 FcVStackPushExpr (parse
, FcVStackFamily
, expr
);
1373 FcParseAlias (FcConfigParse
*parse
)
1375 FcExpr
*family
= 0, *accept
= 0, *prefer
= 0, *def
= 0, *new = 0;
1376 FcEdit
*edit
= 0, *next
;
1379 FcValueBinding binding
;
1381 if (!FcConfigLexBinding (parse
, FcConfigGetAttribute (parse
, "binding"), &binding
))
1383 while ((vstack
= FcVStackPeek (parse
)))
1385 switch (vstack
->tag
) {
1386 case FcVStackFamily
:
1389 new = FcExprCreateOp (parse
->config
, vstack
->u
.expr
, FcOpComma
, family
);
1391 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1396 new = vstack
->u
.expr
;
1400 vstack
->tag
= FcVStackNone
;
1403 case FcVStackPrefer
:
1405 FcExprDestroy (prefer
);
1406 prefer
= vstack
->u
.expr
;
1407 vstack
->tag
= FcVStackNone
;
1409 case FcVStackAccept
:
1411 FcExprDestroy (accept
);
1412 accept
= vstack
->u
.expr
;
1413 vstack
->tag
= FcVStackNone
;
1415 case FcVStackDefault
:
1417 FcExprDestroy (def
);
1418 def
= vstack
->u
.expr
;
1419 vstack
->tag
= FcVStackNone
;
1422 FcConfigMessage (parse
, FcSevereWarning
, "bad alias");
1425 FcVStackPopAndDestroy (parse
);
1429 FcConfigMessage (parse
, FcSevereError
, "missing family in alias");
1431 FcExprDestroy (prefer
);
1433 FcExprDestroy (accept
);
1435 FcExprDestroy (def
);
1440 edit
= FcEditCreate (parse
,
1448 FcExprDestroy (prefer
);
1453 edit
= FcEditCreate (parse
,
1461 FcExprDestroy (accept
);
1466 edit
= FcEditCreate (parse
,
1474 FcExprDestroy (def
);
1478 test
= FcTestCreate (parse
, FcMatchPattern
,
1480 (FcChar8
*) FC_FAMILY
,
1484 if (!FcConfigAddEdit (parse
->config
, test
, edit
, FcMatchPattern
))
1485 FcTestDestroy (test
);
1488 FcExprDestroy (family
);
1492 FcPopExpr (FcConfigParse
*parse
)
1494 FcVStack
*vstack
= FcVStackPeek (parse
);
1498 switch (vstack
->tag
) {
1501 case FcVStackString
:
1502 case FcVStackFamily
:
1503 expr
= FcExprCreateString (parse
->config
, vstack
->u
.string
);
1506 expr
= FcExprCreateField (parse
->config
, (char *) vstack
->u
.string
);
1508 case FcVStackConstant
:
1509 expr
= FcExprCreateConst (parse
->config
, vstack
->u
.string
);
1512 /* XXX: What's the correct action here? (CDW) */
1514 case FcVStackPrefer
:
1515 case FcVStackAccept
:
1516 case FcVStackDefault
:
1517 expr
= vstack
->u
.expr
;
1518 vstack
->tag
= FcVStackNone
;
1520 case FcVStackInteger
:
1521 expr
= FcExprCreateInteger (parse
->config
, vstack
->u
.integer
);
1523 case FcVStackDouble
:
1524 expr
= FcExprCreateDouble (parse
->config
, vstack
->u
._double
);
1526 case FcVStackMatrix
:
1527 expr
= FcExprCreateMatrix (parse
->config
, vstack
->u
.matrix
);
1530 expr
= FcExprCreateBool (parse
->config
, vstack
->u
.bool_
);
1535 expr
= vstack
->u
.expr
;
1536 vstack
->tag
= FcVStackNone
;
1543 FcVStackPopAndDestroy (parse
);
1548 * This builds a tree of binary operations. Note
1549 * that every operator is defined so that if only
1550 * a single operand is contained, the value of the
1551 * whole expression is the value of the operand.
1553 * This code reduces in that case to returning that
1557 FcPopBinary (FcConfigParse
*parse
, FcOp op
)
1559 FcExpr
*left
, *expr
= 0, *new;
1561 while ((left
= FcPopExpr (parse
)))
1565 new = FcExprCreateOp (parse
->config
, left
, op
, expr
);
1568 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1569 FcExprDestroy (left
);
1570 FcExprDestroy (expr
);
1582 FcParseBinary (FcConfigParse
*parse
, FcOp op
)
1584 FcExpr
*expr
= FcPopBinary (parse
, op
);
1586 FcVStackPushExpr (parse
, FcVStackExpr
, expr
);
1590 * This builds a a unary operator, it consumes only
1595 FcPopUnary (FcConfigParse
*parse
, FcOp op
)
1597 FcExpr
*operand
, *new = 0;
1599 if ((operand
= FcPopExpr (parse
)))
1601 new = FcExprCreateOp (parse
->config
, operand
, op
, 0);
1604 FcExprDestroy (operand
);
1605 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1612 FcParseUnary (FcConfigParse
*parse
, FcOp op
)
1614 FcExpr
*expr
= FcPopUnary (parse
, op
);
1616 FcVStackPushExpr (parse
, FcVStackExpr
, expr
);
1620 FcParseInclude (FcConfigParse
*parse
)
1624 FcBool ignore_missing
= FcFalse
;
1626 s
= FcStrBufDoneStatic (&parse
->pstack
->str
);
1629 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1632 i
= FcConfigGetAttribute (parse
, "ignore_missing");
1633 if (i
&& FcConfigLexBool (parse
, (FcChar8
*) i
) == FcTrue
)
1634 ignore_missing
= FcTrue
;
1635 if (!FcConfigParseAndLoad (parse
->config
, s
, !ignore_missing
))
1636 parse
->error
= FcTrue
;
1637 FcStrBufDestroy (&parse
->pstack
->str
);
1640 typedef struct _FcOpMap
{
1646 FcConfigLexOp (const FcChar8
*op
, const FcOpMap
*map
, int nmap
)
1650 for (i
= 0; i
< nmap
; i
++)
1651 if (!strcmp ((char *) op
, map
[i
].name
))
1656 static const FcOpMap fcCompareOps
[] = {
1657 { "eq", FcOpEqual
},
1658 { "not_eq", FcOpNotEqual
},
1659 { "less", FcOpLess
},
1660 { "less_eq", FcOpLessEqual
},
1661 { "more", FcOpMore
},
1662 { "more_eq", FcOpMoreEqual
},
1663 { "contains", FcOpContains
},
1664 { "not_contains", FcOpNotContains
}
1667 #define NUM_COMPARE_OPS (int) (sizeof fcCompareOps / sizeof fcCompareOps[0])
1670 FcConfigLexCompare (const FcChar8
*compare
)
1672 return FcConfigLexOp (compare
, fcCompareOps
, NUM_COMPARE_OPS
);
1676 FcParseTest (FcConfigParse
*parse
)
1678 const FcChar8
*kind_string
;
1680 const FcChar8
*qual_string
;
1682 const FcChar8
*name
;
1683 const FcChar8
*compare_string
;
1688 kind_string
= FcConfigGetAttribute (parse
, "target");
1690 kind
= FcMatchDefault
;
1693 if (!strcmp ((char *) kind_string
, "pattern"))
1694 kind
= FcMatchPattern
;
1695 else if (!strcmp ((char *) kind_string
, "font"))
1697 else if (!strcmp ((char *) kind_string
, "scan"))
1699 else if (!strcmp ((char *) kind_string
, "default"))
1700 kind
= FcMatchDefault
;
1703 FcConfigMessage (parse
, FcSevereWarning
, "invalid test target \"%s\"", kind_string
);
1707 qual_string
= FcConfigGetAttribute (parse
, "qual");
1712 if (!strcmp ((char *) qual_string
, "any"))
1714 else if (!strcmp ((char *) qual_string
, "all"))
1716 else if (!strcmp ((char *) qual_string
, "first"))
1718 else if (!strcmp ((char *) qual_string
, "not_first"))
1719 qual
= FcQualNotFirst
;
1722 FcConfigMessage (parse
, FcSevereWarning
, "invalid test qual \"%s\"", qual_string
);
1726 name
= FcConfigGetAttribute (parse
, "name");
1729 FcConfigMessage (parse
, FcSevereWarning
, "missing test name");
1732 compare_string
= FcConfigGetAttribute (parse
, "compare");
1733 if (!compare_string
)
1734 compare
= FcOpEqual
;
1737 compare
= FcConfigLexCompare (compare_string
);
1738 if (compare
== FcOpInvalid
)
1740 FcConfigMessage (parse
, FcSevereWarning
, "invalid test compare \"%s\"", compare_string
);
1744 expr
= FcPopBinary (parse
, FcOpComma
);
1747 FcConfigMessage (parse
, FcSevereWarning
, "missing test expression");
1750 test
= FcTestCreate (parse
, kind
, qual
, name
, compare
, expr
);
1753 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1756 FcVStackPushTest (parse
, test
);
1759 static const FcOpMap fcModeOps
[] = {
1760 { "assign", FcOpAssign
},
1761 { "assign_replace", FcOpAssignReplace
},
1762 { "prepend", FcOpPrepend
},
1763 { "prepend_first", FcOpPrependFirst
},
1764 { "append", FcOpAppend
},
1765 { "append_last", FcOpAppendLast
},
1768 #define NUM_MODE_OPS (int) (sizeof fcModeOps / sizeof fcModeOps[0])
1771 FcConfigLexMode (const FcChar8
*mode
)
1773 return FcConfigLexOp (mode
, fcModeOps
, NUM_MODE_OPS
);
1777 FcParseEdit (FcConfigParse
*parse
)
1779 const FcChar8
*name
;
1780 const FcChar8
*mode_string
;
1782 FcValueBinding binding
;
1786 name
= FcConfigGetAttribute (parse
, "name");
1789 FcConfigMessage (parse
, FcSevereWarning
, "missing edit name");
1792 mode_string
= FcConfigGetAttribute (parse
, "mode");
1797 mode
= FcConfigLexMode (mode_string
);
1798 if (mode
== FcOpInvalid
)
1800 FcConfigMessage (parse
, FcSevereWarning
, "invalid edit mode \"%s\"", mode_string
);
1804 if (!FcConfigLexBinding (parse
, FcConfigGetAttribute (parse
, "binding"), &binding
))
1807 expr
= FcPopBinary (parse
, FcOpComma
);
1808 edit
= FcEditCreate (parse
, FcObjectFromName ((char *) name
),
1809 mode
, expr
, binding
);
1812 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1813 FcExprDestroy (expr
);
1816 if (!FcVStackPushEdit (parse
, edit
))
1817 FcEditDestroy (edit
);
1821 FcParseMatch (FcConfigParse
*parse
)
1823 const FcChar8
*kind_name
;
1829 kind_name
= FcConfigGetAttribute (parse
, "target");
1831 kind
= FcMatchPattern
;
1834 if (!strcmp ((char *) kind_name
, "pattern"))
1835 kind
= FcMatchPattern
;
1836 else if (!strcmp ((char *) kind_name
, "font"))
1838 else if (!strcmp ((char *) kind_name
, "scan"))
1842 FcConfigMessage (parse
, FcSevereWarning
, "invalid match target \"%s\"", kind_name
);
1846 while ((vstack
= FcVStackPeek (parse
)))
1848 switch (vstack
->tag
) {
1850 vstack
->u
.test
->next
= test
;
1851 test
= vstack
->u
.test
;
1852 vstack
->tag
= FcVStackNone
;
1855 vstack
->u
.edit
->next
= edit
;
1856 edit
= vstack
->u
.edit
;
1857 vstack
->tag
= FcVStackNone
;
1858 if (kind
== FcMatchScan
&& edit
->object
> FC_MAX_BASE_OBJECT
)
1860 FcConfigMessage (parse
, FcSevereError
,
1861 "<match target=\"scan\"> cannot edit user-defined object \"%s\"",
1862 FcObjectName(edit
->object
));
1866 FcConfigMessage (parse
, FcSevereWarning
, "invalid match element");
1869 FcVStackPopAndDestroy (parse
);
1871 if (!FcConfigAddEdit (parse
->config
, test
, edit
, kind
))
1872 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1876 FcParseAcceptRejectFont (FcConfigParse
*parse
, FcElement element
)
1880 while ((vstack
= FcVStackPeek (parse
)))
1882 switch (vstack
->tag
) {
1884 if (!FcConfigGlobAdd (parse
->config
,
1886 element
== FcElementAcceptfont
))
1888 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1891 case FcVStackPattern
:
1892 if (!FcConfigPatternsAdd (parse
->config
,
1894 element
== FcElementAcceptfont
))
1896 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1899 vstack
->tag
= FcVStackNone
;
1902 FcConfigMessage (parse
, FcSevereWarning
, "bad font selector");
1905 FcVStackPopAndDestroy (parse
);
1911 FcPopValue (FcConfigParse
*parse
)
1913 FcVStack
*vstack
= FcVStackPeek (parse
);
1916 value
.type
= FcTypeVoid
;
1921 switch (vstack
->tag
) {
1922 case FcVStackString
:
1923 value
.u
.s
= FcStrCopy (vstack
->u
.string
);
1925 value
.type
= FcTypeString
;
1927 case FcVStackConstant
:
1928 if (FcNameConstant (vstack
->u
.string
, &value
.u
.i
))
1929 value
.type
= FcTypeInteger
;
1931 case FcVStackInteger
:
1932 value
.u
.i
= vstack
->u
.integer
;
1933 value
.type
= FcTypeInteger
;
1935 case FcVStackDouble
:
1936 value
.u
.d
= vstack
->u
._double
;
1937 value
.type
= FcTypeInteger
;
1939 case FcVStackMatrix
:
1940 value
.u
.m
= FcMatrixCopy (vstack
->u
.matrix
);
1942 value
.type
= FcTypeMatrix
;
1945 value
.u
.b
= vstack
->u
.bool_
;
1946 value
.type
= FcTypeBool
;
1949 FcConfigMessage (parse
, FcSevereWarning
, "unknown pattern element %d",
1953 FcVStackPopAndDestroy (parse
);
1959 FcParsePatelt (FcConfigParse
*parse
)
1962 FcPattern
*pattern
= FcPatternCreate ();
1967 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1971 name
= (char *) FcConfigGetAttribute (parse
, "name");
1974 FcConfigMessage (parse
, FcSevereWarning
, "missing pattern element name");
1975 FcPatternDestroy (pattern
);
1981 value
= FcPopValue (parse
);
1982 if (value
.type
== FcTypeVoid
)
1984 if (!FcPatternAdd (pattern
, name
, value
, FcTrue
))
1986 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1987 FcValueDestroy(value
);
1990 FcValueDestroy(value
);
1993 FcVStackPushPattern (parse
, pattern
);
1997 FcParsePattern (FcConfigParse
*parse
)
2000 FcPattern
*pattern
= FcPatternCreate ();
2004 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2008 while ((vstack
= FcVStackPeek (parse
)))
2010 switch (vstack
->tag
) {
2011 case FcVStackPattern
:
2012 if (!FcPatternAppend (pattern
, vstack
->u
.pattern
))
2014 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2015 FcPatternDestroy (pattern
);
2020 FcConfigMessage (parse
, FcSevereWarning
, "unknown pattern element");
2023 FcVStackPopAndDestroy (parse
);
2026 FcVStackPushPattern (parse
, pattern
);
2030 FcEndElement(void *userData
, const XML_Char
*name
)
2032 FcConfigParse
*parse
= userData
;
2037 switch (parse
->pstack
->element
) {
2040 case FcElementFontconfig
:
2043 data
= FcStrBufDoneStatic (&parse
->pstack
->str
);
2046 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2050 if (strcmp (data
, "CUSTOMFONTDIR") == 0)
2054 data
= malloc (1000);
2057 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2060 FcMemAlloc (FC_MEM_STRING
, 1000);
2061 if(!GetModuleFileName(NULL
, data
, 1000))
2063 FcConfigMessage (parse
, FcSevereError
, "GetModuleFileName failed");
2067 p
= strrchr (data
, '\\');
2069 strcat (data
, "\\fonts");
2071 else if (strcmp (data
, "APPSHAREFONTDIR") == 0)
2075 data
= malloc (1000);
2078 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2081 FcMemAlloc (FC_MEM_STRING
, 1000);
2082 if(!GetModuleFileName(NULL
, data
, 1000))
2084 FcConfigMessage (parse
, FcSevereError
, "GetModuleFileName failed");
2088 p
= strrchr (data
, '\\');
2090 strcat (data
, "\\..\\share\\fonts");
2092 else if (strcmp (data
, "WINDOWSFONTDIR") == 0)
2096 data
= malloc (1000);
2099 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2102 FcMemAlloc (FC_MEM_STRING
, 1000);
2103 rc
= GetWindowsDirectory (data
, 800);
2104 if (rc
== 0 || rc
> 800)
2106 FcConfigMessage (parse
, FcSevereError
, "GetWindowsDirectory failed");
2110 if (data
[strlen (data
) - 1] != '\\')
2111 strcat (data
, "\\");
2112 strcat (data
, "fonts");
2115 if (strlen ((char *) data
) == 0)
2116 FcConfigMessage (parse
, FcSevereWarning
, "empty font directory name ignored");
2117 else if (!FcStrUsesHome (data
) || FcConfigHome ())
2119 if (!FcConfigAddDir (parse
->config
, data
))
2120 FcConfigMessage (parse
, FcSevereError
, "out of memory; cannot add directory %s", data
);
2122 FcStrBufDestroy (&parse
->pstack
->str
);
2124 case FcElementCacheDir
:
2125 data
= FcStrBufDone (&parse
->pstack
->str
);
2128 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2132 if (strcmp (data
, "WINDOWSTEMPDIR_FONTCONFIG_CACHE") == 0)
2136 data
= malloc (1000);
2139 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2142 FcMemAlloc (FC_MEM_STRING
, 1000);
2143 rc
= GetTempPath (800, data
);
2144 if (rc
== 0 || rc
> 800)
2146 FcConfigMessage (parse
, FcSevereError
, "GetWindowsDirectory failed");
2150 if (data
[strlen (data
) - 1] != '\\')
2151 strcat (data
, "\\");
2152 strcat (data
, "fontconfig\\cache");
2155 if (!FcStrUsesHome (data
) || FcConfigHome ())
2157 if (!FcConfigAddCacheDir (parse
->config
, data
))
2158 FcConfigMessage (parse
, FcSevereError
, "out of memory; cannot add cache directory %s", data
);
2163 case FcElementCache
:
2164 data
= FcStrBufDoneStatic (&parse
->pstack
->str
);
2167 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2170 /* discard this data; no longer used */
2171 FcStrBufDestroy (&parse
->pstack
->str
);
2173 case FcElementInclude
:
2174 FcParseInclude (parse
);
2176 case FcElementConfig
:
2178 case FcElementMatch
:
2179 FcParseMatch (parse
);
2181 case FcElementAlias
:
2182 FcParseAlias (parse
);
2185 case FcElementBlank
:
2186 FcParseBlank (parse
);
2188 case FcElementRescan
:
2189 FcParseRescan (parse
);
2192 case FcElementPrefer
:
2193 FcParseFamilies (parse
, FcVStackPrefer
);
2195 case FcElementAccept
:
2196 FcParseFamilies (parse
, FcVStackAccept
);
2198 case FcElementDefault
:
2199 FcParseFamilies (parse
, FcVStackDefault
);
2201 case FcElementFamily
:
2202 FcParseFamily (parse
);
2206 FcParseTest (parse
);
2209 FcParseEdit (parse
);
2215 case FcElementDouble
:
2216 FcParseDouble (parse
);
2218 case FcElementString
:
2219 FcParseString (parse
, FcVStackString
);
2221 case FcElementMatrix
:
2222 FcParseMatrix (parse
);
2225 FcParseBool (parse
);
2227 case FcElementCharset
:
2228 /* FcParseCharset (parse); */
2230 case FcElementSelectfont
:
2232 case FcElementAcceptfont
:
2233 case FcElementRejectfont
:
2234 FcParseAcceptRejectFont (parse
, parse
->pstack
->element
);
2237 FcParseString (parse
, FcVStackGlob
);
2239 case FcElementPattern
:
2240 FcParsePattern (parse
);
2242 case FcElementPatelt
:
2243 FcParsePatelt (parse
);
2246 FcParseString (parse
, FcVStackField
);
2248 case FcElementConst
:
2249 FcParseString (parse
, FcVStackConstant
);
2252 FcParseBinary (parse
, FcOpOr
);
2255 FcParseBinary (parse
, FcOpAnd
);
2258 FcParseBinary (parse
, FcOpEqual
);
2260 case FcElementNotEq
:
2261 FcParseBinary (parse
, FcOpNotEqual
);
2264 FcParseBinary (parse
, FcOpLess
);
2266 case FcElementLessEq
:
2267 FcParseBinary (parse
, FcOpLessEqual
);
2270 FcParseBinary (parse
, FcOpMore
);
2272 case FcElementMoreEq
:
2273 FcParseBinary (parse
, FcOpMoreEqual
);
2275 case FcElementContains
:
2276 FcParseBinary (parse
, FcOpContains
);
2278 case FcElementNotContains
:
2279 FcParseBinary (parse
, FcOpNotContains
);
2282 FcParseBinary (parse
, FcOpPlus
);
2284 case FcElementMinus
:
2285 FcParseBinary (parse
, FcOpMinus
);
2287 case FcElementTimes
:
2288 FcParseBinary (parse
, FcOpTimes
);
2290 case FcElementDivide
:
2291 FcParseBinary (parse
, FcOpDivide
);
2294 FcParseUnary (parse
, FcOpNot
);
2297 FcParseBinary (parse
, FcOpQuest
);
2299 case FcElementFloor
:
2300 FcParseUnary (parse
, FcOpFloor
);
2303 FcParseUnary (parse
, FcOpCeil
);
2305 case FcElementRound
:
2306 FcParseUnary (parse
, FcOpRound
);
2308 case FcElementTrunc
:
2309 FcParseUnary (parse
, FcOpTrunc
);
2311 case FcElementUnknown
:
2314 (void) FcPStackPop (parse
);
2318 FcCharacterData (void *userData
, const XML_Char
*s
, int len
)
2320 FcConfigParse
*parse
= userData
;
2324 if (!FcStrBufData (&parse
->pstack
->str
, (FcChar8
*) s
, len
))
2325 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2329 FcStartDoctypeDecl (void *userData
,
2330 const XML_Char
*doctypeName
,
2331 const XML_Char
*sysid
,
2332 const XML_Char
*pubid
,
2333 int has_internal_subset
)
2335 FcConfigParse
*parse
= userData
;
2337 if (strcmp ((char *) doctypeName
, "fontconfig") != 0)
2338 FcConfigMessage (parse
, FcSevereError
, "invalid doctype \"%s\"", doctypeName
);
2341 #ifdef ENABLE_LIBXML2
2344 FcInternalSubsetDecl (void *userData
,
2345 const XML_Char
*doctypeName
,
2346 const XML_Char
*sysid
,
2347 const XML_Char
*pubid
)
2349 FcStartDoctypeDecl (userData
, doctypeName
, sysid
, pubid
, 1);
2353 FcExternalSubsetDecl (void *userData
,
2354 const XML_Char
*doctypeName
,
2355 const XML_Char
*sysid
,
2356 const XML_Char
*pubid
)
2358 FcStartDoctypeDecl (userData
, doctypeName
, sysid
, pubid
, 0);
2361 #else /* ENABLE_LIBXML2 */
2364 FcEndDoctypeDecl (void *userData
)
2368 #endif /* ENABLE_LIBXML2 */
2371 FcSortCmpStr (const void *a
, const void *b
)
2373 const FcChar8
*as
= *((FcChar8
**) a
);
2374 const FcChar8
*bs
= *((FcChar8
**) b
);
2375 return FcStrCmp (as
, bs
);
2379 FcConfigParseAndLoadDir (FcConfig
*config
,
2380 const FcChar8
*name
,
2386 FcBool ret
= FcTrue
;
2391 d
= opendir ((char *) dir
);
2395 FcConfigMessage (0, FcSevereError
, "Cannot open config dir \"%s\"",
2401 file
= (FcChar8
*) malloc (strlen ((char *) dir
) + 1 + FC_MAX_FILE_LEN
+ 1);
2408 strcpy ((char *) file
, (char *) dir
);
2409 strcat ((char *) file
, "/");
2410 base
= file
+ strlen ((char *) file
);
2412 files
= FcStrSetCreate ();
2419 if (FcDebug () & FC_DBG_CONFIG
)
2420 printf ("\tScanning config dir %s\n", dir
);
2422 while (ret
&& (e
= readdir (d
)))
2425 #define TAIL ".conf"
2428 * Add all files of the form [0-9]*.conf
2430 if ('0' <= e
->d_name
[0] && e
->d_name
[0] <= '9' &&
2431 (d_len
= strlen (e
->d_name
)) < FC_MAX_FILE_LEN
&&
2433 strcmp (e
->d_name
+ d_len
- TAIL_LEN
, TAIL
) == 0)
2435 strcpy ((char *) base
, (char *) e
->d_name
);
2436 if (!FcStrSetAdd (files
, file
))
2446 qsort (files
->strs
, files
->num
, sizeof (FcChar8
*),
2447 (int (*)(const void *, const void *)) FcSortCmpStr
);
2448 for (i
= 0; ret
&& i
< files
->num
; i
++)
2449 ret
= FcConfigParseAndLoad (config
, files
->strs
[i
], complain
);
2452 FcStrSetDestroy (files
);
2458 return ret
|| !complain
;
2462 FcConfigParseAndLoad (FcConfig
*config
,
2463 const FcChar8
*name
,
2471 FcConfigParse parse
;
2472 FcBool error
= FcTrue
;
2474 #ifdef ENABLE_LIBXML2
2481 filename
= FcConfigFilename (name
);
2485 if (FcStrSetMember (config
->configFiles
, filename
))
2487 FcStrFree (filename
);
2491 if (!FcStrSetAdd (config
->configFiles
, filename
))
2493 FcStrFree (filename
);
2497 if (FcFileIsDir (filename
))
2499 FcBool ret
= FcConfigParseAndLoadDir (config
, name
, filename
, complain
);
2500 FcStrFree (filename
);
2504 if (FcDebug () & FC_DBG_CONFIG
)
2505 printf ("\tLoading config file %s\n", filename
);
2507 fd
= open ((char *) filename
, O_RDONLY
);
2509 FcStrFree (filename
);
2513 #ifdef ENABLE_LIBXML2
2514 memset(&sax
, 0, sizeof(sax
));
2516 sax
.internalSubset
= FcInternalSubsetDecl
;
2517 sax
.externalSubset
= FcExternalSubsetDecl
;
2518 sax
.startElement
= FcStartElement
;
2519 sax
.endElement
= FcEndElement
;
2520 sax
.characters
= FcCharacterData
;
2522 p
= xmlCreatePushParserCtxt (&sax
, &parse
, NULL
, 0, (const char *) filename
);
2524 p
= XML_ParserCreate ("UTF-8");
2526 FcStrFree (filename
);
2531 if (!FcConfigInit (&parse
, name
, config
, p
))
2534 #ifndef ENABLE_LIBXML2
2536 XML_SetUserData (p
, &parse
);
2538 XML_SetDoctypeDeclHandler (p
, FcStartDoctypeDecl
, FcEndDoctypeDecl
);
2539 XML_SetElementHandler (p
, FcStartElement
, FcEndElement
);
2540 XML_SetCharacterDataHandler (p
, FcCharacterData
);
2542 #endif /* ENABLE_LIBXML2 */
2545 #ifndef ENABLE_LIBXML2
2546 buf
= XML_GetBuffer (p
, BUFSIZ
);
2549 FcConfigMessage (&parse
, FcSevereError
, "cannot get parse buffer");
2553 len
= read (fd
, buf
, BUFSIZ
);
2556 FcConfigMessage (&parse
, FcSevereError
, "failed reading config file");
2560 #ifdef ENABLE_LIBXML2
2561 if (xmlParseChunk (p
, buf
, len
, len
== 0))
2563 if (!XML_ParseBuffer (p
, len
, len
== 0))
2566 FcConfigMessage (&parse
, FcSevereError
, "%s",
2567 XML_ErrorString (XML_GetErrorCode (p
)));
2571 error
= parse
.error
;
2573 FcConfigCleanup (&parse
);
2580 if (error
&& complain
)
2583 FcConfigMessage (0, FcSevereError
, "Cannot load config file \"%s\"", name
);
2585 FcConfigMessage (0, FcSevereError
, "Cannot load default config file");
2591 #include "fcaliastail.h"