]>
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 */
56 #define _WIN32_WINNT 0x0500
64 FcExprDestroy (FcExpr
*e
);
67 FcTestDestroy (FcTest
*test
)
70 FcTestDestroy (test
->next
);
71 FcExprDestroy (test
->expr
);
72 FcMemFree (FC_MEM_TEST
, sizeof (FcTest
));
77 FcExprCreateInteger (FcConfig
*config
, int i
)
79 FcExpr
*e
= FcConfigAllocExpr (config
);
89 FcExprCreateDouble (FcConfig
*config
, double d
)
91 FcExpr
*e
= FcConfigAllocExpr (config
);
101 FcExprCreateString (FcConfig
*config
, const FcChar8
*s
)
103 FcExpr
*e
= FcConfigAllocExpr (config
);
107 e
->u
.sval
= FcStrStaticName (s
);
113 FcExprCreateMatrix (FcConfig
*config
, const FcMatrix
*m
)
115 FcExpr
*e
= FcConfigAllocExpr (config
);
119 e
->u
.mval
= FcMatrixCopy (m
);
125 FcExprCreateBool (FcConfig
*config
, FcBool b
)
127 FcExpr
*e
= FcConfigAllocExpr (config
);
137 FcExprCreateField (FcConfig
*config
, const char *field
)
139 FcExpr
*e
= FcConfigAllocExpr (config
);
143 e
->u
.object
= FcObjectFromName (field
);
149 FcExprCreateConst (FcConfig
*config
, const FcChar8
*constant
)
151 FcExpr
*e
= FcConfigAllocExpr (config
);
155 e
->u
.constant
= FcStrStaticName (constant
);
161 FcExprCreateOp (FcConfig
*config
, FcExpr
*left
, FcOp op
, FcExpr
*right
)
163 FcExpr
*e
= FcConfigAllocExpr (config
);
167 e
->u
.tree
.left
= left
;
168 e
->u
.tree
.right
= right
;
174 FcExprDestroy (FcExpr
*e
)
186 FcMatrixFree (e
->u
.mval
);
189 FcCharSetDestroy (e
->u
.cval
);
198 case FcOpAssignReplace
:
200 case FcOpPrependFirst
:
214 case FcOpNotContains
:
221 FcExprDestroy (e
->u
.tree
.right
);
228 FcExprDestroy (e
->u
.tree
.left
);
239 FcEditDestroy (FcEdit
*e
)
242 FcEditDestroy (e
->next
);
244 FcExprDestroy (e
->expr
);
248 typedef enum _FcElement
{
293 FcElementNotContains
,
307 static const struct {
311 { "fontconfig", FcElementFontconfig
},
312 { "dir", FcElementDir
},
313 { "cachedir", FcElementCacheDir
},
314 { "cache", FcElementCache
},
315 { "include", FcElementInclude
},
316 { "config", FcElementConfig
},
317 { "match", FcElementMatch
},
318 { "alias", FcElementAlias
},
320 { "blank", FcElementBlank
},
321 { "rescan", FcElementRescan
},
323 { "prefer", FcElementPrefer
},
324 { "accept", FcElementAccept
},
325 { "default", FcElementDefault
},
326 { "family", FcElementFamily
},
328 { "selectfont", FcElementSelectfont
},
329 { "acceptfont", FcElementAcceptfont
},
330 { "rejectfont", FcElementRejectfont
},
331 { "glob", FcElementGlob
},
332 { "pattern", FcElementPattern
},
333 { "patelt", FcElementPatelt
},
335 { "test", FcElementTest
},
336 { "edit", FcElementEdit
},
337 { "int", FcElementInt
},
338 { "double", FcElementDouble
},
339 { "string", FcElementString
},
340 { "matrix", FcElementMatrix
},
341 { "bool", FcElementBool
},
342 { "charset", FcElementCharset
},
343 { "name", FcElementName
},
344 { "const", FcElementConst
},
345 { "or", FcElementOr
},
346 { "and", FcElementAnd
},
347 { "eq", FcElementEq
},
348 { "not_eq", FcElementNotEq
},
349 { "less", FcElementLess
},
350 { "less_eq", FcElementLessEq
},
351 { "more", FcElementMore
},
352 { "more_eq", FcElementMoreEq
},
353 { "contains", FcElementContains
},
354 { "not_contains", FcElementNotContains
},
355 { "plus", FcElementPlus
},
356 { "minus", FcElementMinus
},
357 { "times", FcElementTimes
},
358 { "divide", FcElementDivide
},
359 { "not", FcElementNot
},
360 { "if", FcElementIf
},
361 { "floor", FcElementFloor
},
362 { "ceil", FcElementCeil
},
363 { "round", FcElementRound
},
364 { "trunc", FcElementTrunc
},
366 #define NUM_ELEMENT_MAPS (int) (sizeof fcElementMap / sizeof fcElementMap[0])
369 FcElementMap (const XML_Char
*name
)
373 for (i
= 0; i
< NUM_ELEMENT_MAPS
; i
++)
374 if (!strcmp ((char *) name
, fcElementMap
[i
].name
))
375 return fcElementMap
[i
].element
;
376 return FcElementUnknown
;
379 typedef struct _FcPStack
{
380 struct _FcPStack
*prev
;
384 FcChar8
*attr_buf_static
[16];
387 typedef enum _FcVStackTag
{
411 typedef struct _FcVStack
{
412 struct _FcVStack
*prev
;
413 FcPStack
*pstack
; /* related parse element */
433 typedef struct _FcConfigParse
{
440 int pstack_static_used
;
441 FcPStack pstack_static
[8];
442 int vstack_static_used
;
443 FcVStack vstack_static
[64];
446 typedef enum _FcConfigSeverity
{
447 FcSevereInfo
, FcSevereWarning
, FcSevereError
451 FcConfigMessage (FcConfigParse
*parse
, FcConfigSeverity severe
, const char *fmt
, ...)
453 const char *s
= "unknown";
456 va_start (args
, fmt
);
459 case FcSevereInfo
: s
= "info"; break;
460 case FcSevereWarning
: s
= "warning"; break;
461 case FcSevereError
: s
= "error"; break;
466 fprintf (stderr
, "Fontconfig %s: \"%s\", line %d: ", s
,
467 parse
->name
, (int)XML_GetCurrentLineNumber (parse
->parser
));
469 fprintf (stderr
, "Fontconfig %s: line %d: ", s
,
470 (int)XML_GetCurrentLineNumber (parse
->parser
));
471 if (severe
>= FcSevereError
)
472 parse
->error
= FcTrue
;
475 fprintf (stderr
, "Fontconfig %s: ", s
);
476 vfprintf (stderr
, fmt
, args
);
477 fprintf (stderr
, "\n");
483 FcTypeName (FcType type
)
509 FcTypecheckValue (FcConfigParse
*parse
, FcType value
, FcType type
)
511 if (value
== FcTypeInteger
)
512 value
= FcTypeDouble
;
513 if (type
== FcTypeInteger
)
517 if ((value
== FcTypeLangSet
&& type
== FcTypeString
) ||
518 (value
== FcTypeString
&& type
== FcTypeLangSet
))
520 if (type
== (FcType
) -1)
522 FcConfigMessage (parse
, FcSevereWarning
, "saw %s, expected %s",
523 FcTypeName (value
), FcTypeName (type
));
528 FcTypecheckExpr (FcConfigParse
*parse
, FcExpr
*expr
, FcType type
)
530 const FcObjectType
*o
;
533 /* If parsing the expression failed, some nodes may be NULL */
540 FcTypecheckValue (parse
, FcTypeDouble
, type
);
543 FcTypecheckValue (parse
, FcTypeString
, type
);
546 FcTypecheckValue (parse
, FcTypeMatrix
, type
);
549 FcTypecheckValue (parse
, FcTypeBool
, type
);
552 FcTypecheckValue (parse
, FcTypeCharSet
, type
);
557 o
= FcNameGetObjectType (FcObjectName (expr
->u
.object
));
559 FcTypecheckValue (parse
, o
->type
, type
);
562 c
= FcNameGetConstant (expr
->u
.constant
);
565 o
= FcNameGetObjectType (c
->object
);
567 FcTypecheckValue (parse
, o
->type
, type
);
570 FcConfigMessage (parse
, FcSevereWarning
,
571 "invalid constant used : %s",
575 FcTypecheckExpr (parse
, expr
->u
.tree
.left
, FcTypeBool
);
576 FcTypecheckExpr (parse
, expr
->u
.tree
.right
->u
.tree
.left
, type
);
577 FcTypecheckExpr (parse
, expr
->u
.tree
.right
->u
.tree
.right
, type
);
580 case FcOpAssignReplace
:
589 case FcOpNotContains
:
591 FcTypecheckValue (parse
, FcTypeBool
, type
);
600 FcTypecheckExpr (parse
, expr
->u
.tree
.left
, type
);
601 FcTypecheckExpr (parse
, expr
->u
.tree
.right
, type
);
604 FcTypecheckValue (parse
, FcTypeBool
, type
);
605 FcTypecheckExpr (parse
, expr
->u
.tree
.left
, FcTypeBool
);
611 FcTypecheckValue (parse
, FcTypeDouble
, type
);
612 FcTypecheckExpr (parse
, expr
->u
.tree
.left
, FcTypeDouble
);
620 FcTestCreate (FcConfigParse
*parse
,
623 const FcChar8
*field
,
627 FcTest
*test
= (FcTest
*) malloc (sizeof (FcTest
));
631 const FcObjectType
*o
;
633 FcMemAlloc (FC_MEM_TEST
, sizeof (FcTest
));
637 test
->object
= FcObjectFromName ((const char *) field
);
640 o
= FcNameGetObjectType (FcObjectName (test
->object
));
642 FcTypecheckExpr (parse
, expr
, o
->type
);
648 FcEditCreate (FcConfigParse
*parse
,
652 FcValueBinding binding
)
654 FcEdit
*e
= (FcEdit
*) malloc (sizeof (FcEdit
));
658 const FcObjectType
*o
;
664 e
->binding
= binding
;
665 o
= FcNameGetObjectType (FcObjectName (e
->object
));
667 FcTypecheckExpr (parse
, expr
, o
->type
);
673 FcVStackCreateAndPush (FcConfigParse
*parse
)
677 if (parse
->vstack_static_used
< sizeof (parse
->vstack_static
) / sizeof (parse
->vstack_static
[0]))
678 new = &parse
->vstack_static
[parse
->vstack_static_used
++];
681 new = malloc (sizeof (FcVStack
));
684 FcMemAlloc (FC_MEM_VSTACK
, sizeof (FcVStack
));
686 new->tag
= FcVStackNone
;
689 new->prev
= parse
->vstack
;
690 new->pstack
= parse
->pstack
? parse
->pstack
->prev
: 0;
697 FcVStackPushString (FcConfigParse
*parse
, FcVStackTag tag
, FcChar8
*string
)
699 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
702 vstack
->u
.string
= string
;
708 FcVStackPushInteger (FcConfigParse
*parse
, int integer
)
710 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
713 vstack
->u
.integer
= integer
;
714 vstack
->tag
= FcVStackInteger
;
719 FcVStackPushDouble (FcConfigParse
*parse
, double _double
)
721 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
724 vstack
->u
._double
= _double
;
725 vstack
->tag
= FcVStackDouble
;
730 FcVStackPushMatrix (FcConfigParse
*parse
, FcMatrix
*matrix
)
733 matrix
= FcMatrixCopy (matrix
);
736 vstack
= FcVStackCreateAndPush (parse
);
739 vstack
->u
.matrix
= matrix
;
740 vstack
->tag
= FcVStackMatrix
;
745 FcVStackPushBool (FcConfigParse
*parse
, FcBool bool_
)
747 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
750 vstack
->u
.bool_
= bool_
;
751 vstack
->tag
= FcVStackBool
;
756 FcVStackPushTest (FcConfigParse
*parse
, FcTest
*test
)
758 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
761 vstack
->u
.test
= test
;
762 vstack
->tag
= FcVStackTest
;
767 FcVStackPushExpr (FcConfigParse
*parse
, FcVStackTag tag
, FcExpr
*expr
)
769 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
772 vstack
->u
.expr
= expr
;
778 FcVStackPushEdit (FcConfigParse
*parse
, FcEdit
*edit
)
780 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
783 vstack
->u
.edit
= edit
;
784 vstack
->tag
= FcVStackEdit
;
789 FcVStackPushPattern (FcConfigParse
*parse
, FcPattern
*pattern
)
791 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
794 vstack
->u
.pattern
= pattern
;
795 vstack
->tag
= FcVStackPattern
;
800 FcVStackFetch (FcConfigParse
*parse
, int off
)
804 for (vstack
= parse
->vstack
; vstack
&& off
-- > 0; vstack
= vstack
->prev
);
809 FcVStackPeek (FcConfigParse
*parse
)
811 FcVStack
*vstack
= parse
->vstack
;
813 return vstack
&& vstack
->pstack
== parse
->pstack
? vstack
: 0;
817 FcVStackPopAndDestroy (FcConfigParse
*parse
)
819 FcVStack
*vstack
= parse
->vstack
;
821 if (!vstack
|| vstack
->pstack
!= parse
->pstack
)
824 parse
->vstack
= vstack
->prev
;
826 switch (vstack
->tag
) {
833 case FcVStackConstant
:
835 FcStrFree (vstack
->u
.string
);
837 case FcVStackPattern
:
838 FcPatternDestroy (vstack
->u
.pattern
);
840 case FcVStackInteger
:
844 FcMatrixFree (vstack
->u
.matrix
);
849 FcTestDestroy (vstack
->u
.test
);
854 case FcVStackDefault
:
855 FcExprDestroy (vstack
->u
.expr
);
858 FcEditDestroy (vstack
->u
.edit
);
862 if (vstack
== &parse
->vstack_static
[parse
->vstack_static_used
- 1])
863 parse
->vstack_static_used
--;
866 FcMemFree (FC_MEM_VSTACK
, sizeof (FcVStack
));
872 FcVStackClear (FcConfigParse
*parse
)
874 while (FcVStackPeek (parse
))
875 FcVStackPopAndDestroy (parse
);
879 FcVStackElements (FcConfigParse
*parse
)
882 FcVStack
*vstack
= parse
->vstack
;
883 while (vstack
&& vstack
->pstack
== parse
->pstack
)
886 vstack
= vstack
->prev
;
892 FcConfigSaveAttr (const XML_Char
**attr
, FcChar8
**buf
, int size_bytes
)
902 for (i
= 0; attr
[i
]; i
++)
903 slen
+= strlen ((char *) attr
[i
]) + 1;
906 slen
+= (i
+ 1) * sizeof (FcChar8
*);
907 if (slen
<= size_bytes
)
914 FcConfigMessage (0, FcSevereError
, "out of memory");
917 FcMemAlloc (FC_MEM_ATTR
, 1); /* size is too expensive */
919 s
= (FcChar8
*) (new + (i
+ 1));
920 for (i
= 0; attr
[i
]; i
++)
923 strcpy ((char *) s
, (char *) attr
[i
]);
924 s
+= strlen ((char *) s
) + 1;
931 FcPStackPush (FcConfigParse
*parse
, FcElement element
, const XML_Char
**attr
)
935 if (parse
->pstack_static_used
< sizeof (parse
->pstack_static
) / sizeof (parse
->pstack_static
[0]))
936 new = &parse
->pstack_static
[parse
->pstack_static_used
++];
939 new = malloc (sizeof (FcPStack
));
942 FcMemAlloc (FC_MEM_PSTACK
, sizeof (FcPStack
));
945 new->prev
= parse
->pstack
;
946 new->element
= element
;
947 new->attr
= FcConfigSaveAttr (attr
, new->attr_buf_static
, sizeof (new->attr_buf_static
));
948 FcStrBufInit (&new->str
, 0, 0);
954 FcPStackPop (FcConfigParse
*parse
)
960 FcConfigMessage (parse
, FcSevereError
, "mismatching element");
963 FcVStackClear (parse
);
965 parse
->pstack
= old
->prev
;
966 FcStrBufDestroy (&old
->str
);
967 if (old
->attr
&& old
->attr
!= old
->attr_buf_static
)
969 FcMemFree (FC_MEM_ATTR
, 1); /* size is to expensive */
973 if (old
== &parse
->pstack_static
[parse
->pstack_static_used
- 1])
974 parse
->pstack_static_used
--;
977 FcMemFree (FC_MEM_PSTACK
, sizeof (FcPStack
));
984 FcConfigInit (FcConfigParse
*parse
, const FcChar8
*name
, FcConfig
*config
, XML_Parser parser
)
987 parse
->pstack_static_used
= 0;
989 parse
->vstack_static_used
= 0;
990 parse
->error
= FcFalse
;
992 parse
->config
= config
;
993 parse
->parser
= parser
;
998 FcConfigCleanup (FcConfigParse
*parse
)
1000 while (parse
->pstack
)
1001 FcPStackPop (parse
);
1004 static const FcChar8
*
1005 FcConfigGetAttribute (FcConfigParse
*parse
, const char *attr
)
1011 attrs
= parse
->pstack
->attr
;
1017 if (!strcmp ((char *) *attrs
, attr
))
1025 FcStartElement(void *userData
, const XML_Char
*name
, const XML_Char
**attr
)
1027 FcConfigParse
*parse
= userData
;
1030 element
= FcElementMap (name
);
1031 if (element
== FcElementUnknown
)
1032 FcConfigMessage (parse
, FcSevereWarning
, "unknown element \"%s\"", name
);
1034 if (!FcPStackPush (parse
, element
, attr
))
1036 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1043 FcParseBlank (FcConfigParse
*parse
)
1045 int n
= FcVStackElements (parse
);
1048 FcVStack
*v
= FcVStackFetch (parse
, n
);
1049 if (v
->tag
!= FcVStackInteger
)
1050 FcConfigMessage (parse
, FcSevereError
, "non-integer blank");
1053 if (!parse
->config
->blanks
)
1055 parse
->config
->blanks
= FcBlanksCreate ();
1056 if (!parse
->config
->blanks
)
1058 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1062 if (!FcBlanksAdd (parse
->config
->blanks
, v
->u
.integer
))
1064 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1072 FcParseRescan (FcConfigParse
*parse
)
1074 int n
= FcVStackElements (parse
);
1077 FcVStack
*v
= FcVStackFetch (parse
, n
);
1078 if (v
->tag
!= FcVStackInteger
)
1079 FcConfigMessage (parse
, FcSevereWarning
, "non-integer rescan");
1081 parse
->config
->rescanInterval
= v
->u
.integer
;
1086 FcParseInt (FcConfigParse
*parse
)
1093 s
= FcStrBufDoneStatic (&parse
->pstack
->str
);
1096 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1100 l
= (int) strtol ((char *) s
, (char **)&end
, 0);
1101 if (end
!= s
+ strlen ((char *) s
))
1102 FcConfigMessage (parse
, FcSevereError
, "\"%s\": not a valid integer", s
);
1104 FcVStackPushInteger (parse
, l
);
1105 FcStrBufDestroy (&parse
->pstack
->str
);
1109 * idea copied from glib g_ascii_strtod with
1110 * permission of the author (Alexander Larsson)
1116 FcStrtod (char *s
, char **end
)
1118 struct lconv
*locale_data
;
1123 * Have to swap the decimal point to match the current locale
1124 * if that locale doesn't use 0x2e
1126 if ((dot
= strchr (s
, 0x2e)) &&
1127 (locale_data
= localeconv ()) &&
1128 (locale_data
->decimal_point
[0] != 0x2e ||
1129 locale_data
->decimal_point
[1] != 0))
1132 int slen
= strlen (s
);
1133 int dlen
= strlen (locale_data
->decimal_point
);
1135 if (slen
+ dlen
> (int) sizeof (buf
))
1145 strncpy (buf
, s
, dot
- s
);
1147 strcpy (buf
+ (dot
- s
), locale_data
->decimal_point
);
1148 /* rest of number */
1149 strcpy (buf
+ (dot
- s
) + dlen
, dot
+ 1);
1151 v
= strtod (buf
, &buf_end
);
1153 buf_end
= s
+ (buf_end
- buf
);
1155 buf_end
-= dlen
- 1;
1162 v
= strtod (s
, end
);
1167 FcParseDouble (FcConfigParse
*parse
)
1174 s
= FcStrBufDoneStatic (&parse
->pstack
->str
);
1177 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1181 d
= FcStrtod ((char *) s
, (char **)&end
);
1182 if (end
!= s
+ strlen ((char *) s
))
1183 FcConfigMessage (parse
, FcSevereError
, "\"%s\": not a valid double", s
);
1185 FcVStackPushDouble (parse
, d
);
1186 FcStrBufDestroy (&parse
->pstack
->str
);
1190 FcParseString (FcConfigParse
*parse
, FcVStackTag tag
)
1196 s
= FcStrBufDone (&parse
->pstack
->str
);
1199 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1202 if (!FcVStackPushString (parse
, tag
, s
))
1207 FcParseMatrix (FcConfigParse
*parse
)
1210 enum { m_done
, m_xx
, m_xy
, m_yx
, m_yy
} matrix_state
= m_yy
;
1213 while ((vstack
= FcVStackPeek (parse
)))
1216 switch (vstack
->tag
) {
1217 case FcVStackInteger
:
1218 v
= vstack
->u
.integer
;
1220 case FcVStackDouble
:
1221 v
= vstack
->u
._double
;
1224 FcConfigMessage (parse
, FcSevereError
, "non-double matrix element");
1228 switch (matrix_state
) {
1229 case m_xx
: m
.xx
= v
; break;
1230 case m_xy
: m
.xy
= v
; break;
1231 case m_yx
: m
.yx
= v
; break;
1232 case m_yy
: m
.yy
= v
; break;
1235 FcVStackPopAndDestroy (parse
);
1238 if (matrix_state
!= m_done
)
1239 FcConfigMessage (parse
, FcSevereError
, "wrong number of matrix elements");
1241 FcVStackPushMatrix (parse
, &m
);
1245 FcConfigLexBool (FcConfigParse
*parse
, const FcChar8
*bool_
)
1247 FcBool result
= FcFalse
;
1249 if (!FcNameBool (bool_
, &result
))
1250 FcConfigMessage (parse
, FcSevereWarning
, "\"%s\" is not known boolean",
1256 FcParseBool (FcConfigParse
*parse
)
1262 s
= FcStrBufDoneStatic (&parse
->pstack
->str
);
1265 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1268 FcVStackPushBool (parse
, FcConfigLexBool (parse
, s
));
1269 FcStrBufDestroy (&parse
->pstack
->str
);
1273 FcConfigLexBinding (FcConfigParse
*parse
,
1274 const FcChar8
*binding_string
,
1275 FcValueBinding
*binding_ret
)
1277 FcValueBinding binding
;
1279 if (!binding_string
)
1280 binding
= FcValueBindingWeak
;
1283 if (!strcmp ((char *) binding_string
, "weak"))
1284 binding
= FcValueBindingWeak
;
1285 else if (!strcmp ((char *) binding_string
, "strong"))
1286 binding
= FcValueBindingStrong
;
1287 else if (!strcmp ((char *) binding_string
, "same"))
1288 binding
= FcValueBindingSame
;
1291 FcConfigMessage (parse
, FcSevereWarning
, "invalid binding \"%s\"", binding_string
);
1295 *binding_ret
= binding
;
1300 FcParseFamilies (FcConfigParse
*parse
, FcVStackTag tag
)
1303 FcExpr
*left
, *expr
= 0, *new;
1305 while ((vstack
= FcVStackPeek (parse
)))
1307 if (vstack
->tag
!= FcVStackFamily
)
1309 FcConfigMessage (parse
, FcSevereWarning
, "non-family");
1310 FcVStackPopAndDestroy (parse
);
1313 left
= vstack
->u
.expr
;
1314 vstack
->tag
= FcVStackNone
;
1315 FcVStackPopAndDestroy (parse
);
1318 new = FcExprCreateOp (parse
->config
, left
, FcOpComma
, expr
);
1321 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1322 FcExprDestroy (left
);
1323 FcExprDestroy (expr
);
1333 if (!FcVStackPushExpr (parse
, tag
, expr
))
1335 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1336 FcExprDestroy (expr
);
1342 FcParseFamily (FcConfigParse
*parse
)
1349 s
= FcStrBufDoneStatic (&parse
->pstack
->str
);
1352 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1355 expr
= FcExprCreateString (parse
->config
, s
);
1356 FcStrBufDestroy (&parse
->pstack
->str
);
1358 FcVStackPushExpr (parse
, FcVStackFamily
, expr
);
1362 FcParseAlias (FcConfigParse
*parse
)
1364 FcExpr
*family
= 0, *accept
= 0, *prefer
= 0, *def
= 0, *new = 0;
1365 FcEdit
*edit
= 0, *next
;
1368 FcValueBinding binding
;
1370 if (!FcConfigLexBinding (parse
, FcConfigGetAttribute (parse
, "binding"), &binding
))
1372 while ((vstack
= FcVStackPeek (parse
)))
1374 switch (vstack
->tag
) {
1375 case FcVStackFamily
:
1378 new = FcExprCreateOp (parse
->config
, vstack
->u
.expr
, FcOpComma
, family
);
1380 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1385 new = vstack
->u
.expr
;
1389 vstack
->tag
= FcVStackNone
;
1392 case FcVStackPrefer
:
1394 FcExprDestroy (prefer
);
1395 prefer
= vstack
->u
.expr
;
1396 vstack
->tag
= FcVStackNone
;
1398 case FcVStackAccept
:
1400 FcExprDestroy (accept
);
1401 accept
= vstack
->u
.expr
;
1402 vstack
->tag
= FcVStackNone
;
1404 case FcVStackDefault
:
1406 FcExprDestroy (def
);
1407 def
= vstack
->u
.expr
;
1408 vstack
->tag
= FcVStackNone
;
1411 FcConfigMessage (parse
, FcSevereWarning
, "bad alias");
1414 FcVStackPopAndDestroy (parse
);
1418 FcConfigMessage (parse
, FcSevereError
, "missing family in alias");
1420 FcExprDestroy (prefer
);
1422 FcExprDestroy (accept
);
1424 FcExprDestroy (def
);
1429 edit
= FcEditCreate (parse
,
1437 FcExprDestroy (prefer
);
1442 edit
= FcEditCreate (parse
,
1450 FcExprDestroy (accept
);
1455 edit
= FcEditCreate (parse
,
1463 FcExprDestroy (def
);
1467 test
= FcTestCreate (parse
, FcMatchPattern
,
1469 (FcChar8
*) FC_FAMILY
,
1473 if (!FcConfigAddEdit (parse
->config
, test
, edit
, FcMatchPattern
))
1474 FcTestDestroy (test
);
1477 FcExprDestroy (family
);
1481 FcPopExpr (FcConfigParse
*parse
)
1483 FcVStack
*vstack
= FcVStackPeek (parse
);
1487 switch (vstack
->tag
) {
1490 case FcVStackString
:
1491 case FcVStackFamily
:
1492 expr
= FcExprCreateString (parse
->config
, vstack
->u
.string
);
1495 expr
= FcExprCreateField (parse
->config
, (char *) vstack
->u
.string
);
1497 case FcVStackConstant
:
1498 expr
= FcExprCreateConst (parse
->config
, vstack
->u
.string
);
1501 /* XXX: What's the correct action here? (CDW) */
1503 case FcVStackPrefer
:
1504 case FcVStackAccept
:
1505 case FcVStackDefault
:
1506 expr
= vstack
->u
.expr
;
1507 vstack
->tag
= FcVStackNone
;
1509 case FcVStackInteger
:
1510 expr
= FcExprCreateInteger (parse
->config
, vstack
->u
.integer
);
1512 case FcVStackDouble
:
1513 expr
= FcExprCreateDouble (parse
->config
, vstack
->u
._double
);
1515 case FcVStackMatrix
:
1516 expr
= FcExprCreateMatrix (parse
->config
, vstack
->u
.matrix
);
1519 expr
= FcExprCreateBool (parse
->config
, vstack
->u
.bool_
);
1524 expr
= vstack
->u
.expr
;
1525 vstack
->tag
= FcVStackNone
;
1532 FcVStackPopAndDestroy (parse
);
1537 * This builds a tree of binary operations. Note
1538 * that every operator is defined so that if only
1539 * a single operand is contained, the value of the
1540 * whole expression is the value of the operand.
1542 * This code reduces in that case to returning that
1546 FcPopBinary (FcConfigParse
*parse
, FcOp op
)
1548 FcExpr
*left
, *expr
= 0, *new;
1550 while ((left
= FcPopExpr (parse
)))
1554 new = FcExprCreateOp (parse
->config
, left
, op
, expr
);
1557 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1558 FcExprDestroy (left
);
1559 FcExprDestroy (expr
);
1571 FcParseBinary (FcConfigParse
*parse
, FcOp op
)
1573 FcExpr
*expr
= FcPopBinary (parse
, op
);
1575 FcVStackPushExpr (parse
, FcVStackExpr
, expr
);
1579 * This builds a a unary operator, it consumes only
1584 FcPopUnary (FcConfigParse
*parse
, FcOp op
)
1586 FcExpr
*operand
, *new = 0;
1588 if ((operand
= FcPopExpr (parse
)))
1590 new = FcExprCreateOp (parse
->config
, operand
, op
, 0);
1593 FcExprDestroy (operand
);
1594 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1601 FcParseUnary (FcConfigParse
*parse
, FcOp op
)
1603 FcExpr
*expr
= FcPopUnary (parse
, op
);
1605 FcVStackPushExpr (parse
, FcVStackExpr
, expr
);
1609 FcParseInclude (FcConfigParse
*parse
)
1613 FcBool ignore_missing
= FcFalse
;
1615 s
= FcStrBufDoneStatic (&parse
->pstack
->str
);
1618 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1621 i
= FcConfigGetAttribute (parse
, "ignore_missing");
1622 if (i
&& FcConfigLexBool (parse
, (FcChar8
*) i
) == FcTrue
)
1623 ignore_missing
= FcTrue
;
1624 if (!FcConfigParseAndLoad (parse
->config
, s
, !ignore_missing
))
1625 parse
->error
= FcTrue
;
1626 FcStrBufDestroy (&parse
->pstack
->str
);
1629 typedef struct _FcOpMap
{
1635 FcConfigLexOp (const FcChar8
*op
, const FcOpMap
*map
, int nmap
)
1639 for (i
= 0; i
< nmap
; i
++)
1640 if (!strcmp ((char *) op
, map
[i
].name
))
1645 static const FcOpMap fcCompareOps
[] = {
1646 { "eq", FcOpEqual
},
1647 { "not_eq", FcOpNotEqual
},
1648 { "less", FcOpLess
},
1649 { "less_eq", FcOpLessEqual
},
1650 { "more", FcOpMore
},
1651 { "more_eq", FcOpMoreEqual
},
1652 { "contains", FcOpContains
},
1653 { "not_contains", FcOpNotContains
}
1656 #define NUM_COMPARE_OPS (int) (sizeof fcCompareOps / sizeof fcCompareOps[0])
1659 FcConfigLexCompare (const FcChar8
*compare
)
1661 return FcConfigLexOp (compare
, fcCompareOps
, NUM_COMPARE_OPS
);
1665 FcParseTest (FcConfigParse
*parse
)
1667 const FcChar8
*kind_string
;
1669 const FcChar8
*qual_string
;
1671 const FcChar8
*name
;
1672 const FcChar8
*compare_string
;
1677 kind_string
= FcConfigGetAttribute (parse
, "target");
1679 kind
= FcMatchDefault
;
1682 if (!strcmp ((char *) kind_string
, "pattern"))
1683 kind
= FcMatchPattern
;
1684 else if (!strcmp ((char *) kind_string
, "font"))
1686 else if (!strcmp ((char *) kind_string
, "scan"))
1688 else if (!strcmp ((char *) kind_string
, "default"))
1689 kind
= FcMatchDefault
;
1692 FcConfigMessage (parse
, FcSevereWarning
, "invalid test target \"%s\"", kind_string
);
1696 qual_string
= FcConfigGetAttribute (parse
, "qual");
1701 if (!strcmp ((char *) qual_string
, "any"))
1703 else if (!strcmp ((char *) qual_string
, "all"))
1705 else if (!strcmp ((char *) qual_string
, "first"))
1707 else if (!strcmp ((char *) qual_string
, "not_first"))
1708 qual
= FcQualNotFirst
;
1711 FcConfigMessage (parse
, FcSevereWarning
, "invalid test qual \"%s\"", qual_string
);
1715 name
= FcConfigGetAttribute (parse
, "name");
1718 FcConfigMessage (parse
, FcSevereWarning
, "missing test name");
1721 compare_string
= FcConfigGetAttribute (parse
, "compare");
1722 if (!compare_string
)
1723 compare
= FcOpEqual
;
1726 compare
= FcConfigLexCompare (compare_string
);
1727 if (compare
== FcOpInvalid
)
1729 FcConfigMessage (parse
, FcSevereWarning
, "invalid test compare \"%s\"", compare_string
);
1733 expr
= FcPopBinary (parse
, FcOpComma
);
1736 FcConfigMessage (parse
, FcSevereWarning
, "missing test expression");
1739 test
= FcTestCreate (parse
, kind
, qual
, name
, compare
, expr
);
1742 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1745 FcVStackPushTest (parse
, test
);
1748 static const FcOpMap fcModeOps
[] = {
1749 { "assign", FcOpAssign
},
1750 { "assign_replace", FcOpAssignReplace
},
1751 { "prepend", FcOpPrepend
},
1752 { "prepend_first", FcOpPrependFirst
},
1753 { "append", FcOpAppend
},
1754 { "append_last", FcOpAppendLast
},
1757 #define NUM_MODE_OPS (int) (sizeof fcModeOps / sizeof fcModeOps[0])
1760 FcConfigLexMode (const FcChar8
*mode
)
1762 return FcConfigLexOp (mode
, fcModeOps
, NUM_MODE_OPS
);
1766 FcParseEdit (FcConfigParse
*parse
)
1768 const FcChar8
*name
;
1769 const FcChar8
*mode_string
;
1771 FcValueBinding binding
;
1775 name
= FcConfigGetAttribute (parse
, "name");
1778 FcConfigMessage (parse
, FcSevereWarning
, "missing edit name");
1781 mode_string
= FcConfigGetAttribute (parse
, "mode");
1786 mode
= FcConfigLexMode (mode_string
);
1787 if (mode
== FcOpInvalid
)
1789 FcConfigMessage (parse
, FcSevereWarning
, "invalid edit mode \"%s\"", mode_string
);
1793 if (!FcConfigLexBinding (parse
, FcConfigGetAttribute (parse
, "binding"), &binding
))
1796 expr
= FcPopBinary (parse
, FcOpComma
);
1797 edit
= FcEditCreate (parse
, FcObjectFromName ((char *) name
),
1798 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"))
1827 else if (!strcmp ((char *) kind_name
, "scan"))
1831 FcConfigMessage (parse
, FcSevereWarning
, "invalid match target \"%s\"", kind_name
);
1835 while ((vstack
= FcVStackPeek (parse
)))
1837 switch (vstack
->tag
) {
1839 vstack
->u
.test
->next
= test
;
1840 test
= vstack
->u
.test
;
1841 vstack
->tag
= FcVStackNone
;
1844 vstack
->u
.edit
->next
= edit
;
1845 edit
= vstack
->u
.edit
;
1846 vstack
->tag
= FcVStackNone
;
1847 if (kind
== FcMatchScan
&& edit
->object
> FC_MAX_BASE_OBJECT
)
1849 FcConfigMessage (parse
, FcSevereError
,
1850 "<match target=\"scan\"> cannot edit user-defined object \"%s\"",
1851 FcObjectName(edit
->object
));
1855 FcConfigMessage (parse
, FcSevereWarning
, "invalid match element");
1858 FcVStackPopAndDestroy (parse
);
1860 if (!FcConfigAddEdit (parse
->config
, test
, edit
, kind
))
1861 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1865 FcParseAcceptRejectFont (FcConfigParse
*parse
, FcElement element
)
1869 while ((vstack
= FcVStackPeek (parse
)))
1871 switch (vstack
->tag
) {
1873 if (!FcConfigGlobAdd (parse
->config
,
1875 element
== FcElementAcceptfont
))
1877 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1880 case FcVStackPattern
:
1881 if (!FcConfigPatternsAdd (parse
->config
,
1883 element
== FcElementAcceptfont
))
1885 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1888 vstack
->tag
= FcVStackNone
;
1891 FcConfigMessage (parse
, FcSevereWarning
, "bad font selector");
1894 FcVStackPopAndDestroy (parse
);
1900 FcPopValue (FcConfigParse
*parse
)
1902 FcVStack
*vstack
= FcVStackPeek (parse
);
1905 value
.type
= FcTypeVoid
;
1910 switch (vstack
->tag
) {
1911 case FcVStackString
:
1912 value
.u
.s
= FcStrStaticName (vstack
->u
.string
);
1914 value
.type
= FcTypeString
;
1916 case FcVStackConstant
:
1917 if (FcNameConstant (vstack
->u
.string
, &value
.u
.i
))
1918 value
.type
= FcTypeInteger
;
1920 case FcVStackInteger
:
1921 value
.u
.i
= vstack
->u
.integer
;
1922 value
.type
= FcTypeInteger
;
1924 case FcVStackDouble
:
1925 value
.u
.d
= vstack
->u
._double
;
1926 value
.type
= FcTypeInteger
;
1928 case FcVStackMatrix
:
1929 value
.u
.m
= FcMatrixCopy (vstack
->u
.matrix
);
1931 value
.type
= FcTypeMatrix
;
1934 value
.u
.b
= vstack
->u
.bool_
;
1935 value
.type
= FcTypeBool
;
1938 FcConfigMessage (parse
, FcSevereWarning
, "unknown pattern element %d",
1942 FcVStackPopAndDestroy (parse
);
1948 FcParsePatelt (FcConfigParse
*parse
)
1951 FcPattern
*pattern
= FcPatternCreate ();
1956 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1960 name
= (char *) FcConfigGetAttribute (parse
, "name");
1963 FcConfigMessage (parse
, FcSevereWarning
, "missing pattern element name");
1964 FcPatternDestroy (pattern
);
1970 value
= FcPopValue (parse
);
1971 if (value
.type
== FcTypeVoid
)
1973 if (!FcPatternAdd (pattern
, name
, value
, FcTrue
))
1975 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1976 FcValueDestroy(value
);
1979 FcValueDestroy(value
);
1982 FcVStackPushPattern (parse
, pattern
);
1986 FcParsePattern (FcConfigParse
*parse
)
1989 FcPattern
*pattern
= FcPatternCreate ();
1993 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1997 while ((vstack
= FcVStackPeek (parse
)))
1999 switch (vstack
->tag
) {
2000 case FcVStackPattern
:
2001 if (!FcPatternAppend (pattern
, vstack
->u
.pattern
))
2003 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2004 FcPatternDestroy (pattern
);
2009 FcConfigMessage (parse
, FcSevereWarning
, "unknown pattern element");
2012 FcVStackPopAndDestroy (parse
);
2015 FcVStackPushPattern (parse
, pattern
);
2019 FcEndElement(void *userData
, const XML_Char
*name
)
2021 FcConfigParse
*parse
= userData
;
2024 FcChar8 buffer
[1000];
2029 switch (parse
->pstack
->element
) {
2032 case FcElementFontconfig
:
2035 data
= FcStrBufDoneStatic (&parse
->pstack
->str
);
2038 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2042 if (strcmp (data
, "CUSTOMFONTDIR") == 0)
2046 if (!GetModuleFileName (NULL
, buffer
, sizeof (buffer
) - 20))
2048 FcConfigMessage (parse
, FcSevereError
, "GetModuleFileName failed");
2052 * Must use the multi-byte aware function to search
2053 * for backslash because East Asian double-byte code
2054 * pages have characters with backslash as the second
2057 p
= _mbsrchr (data
, '\\');
2059 strcat (data
, "\\fonts");
2061 else if (strcmp (data
, "APPSHAREFONTDIR") == 0)
2065 if (!GetModuleFileName (NULL
, buffer
, sizeof (buffer
) - 20))
2067 FcConfigMessage (parse
, FcSevereError
, "GetModuleFileName failed");
2070 p
= _mbsrchr (data
, '\\');
2072 strcat (data
, "\\..\\share\\fonts");
2074 else if (strcmp (data
, "WINDOWSFONTDIR") == 0)
2078 #if _WIN32_WINNT >= 0x0500
2079 rc
= GetSystemWindowsDirectory (buffer
, sizeof (buffer
) - 20);
2081 rc
= GetWindowsDirectory (buffer
, sizeof (buffer
) - 20);
2083 if (rc
== 0 || rc
> sizeof (buffer
) - 20)
2085 FcConfigMessage (parse
, FcSevereError
, "GetSystemWindowsDirectory failed");
2088 if (data
[strlen (data
) - 1] != '\\')
2089 strcat (data
, "\\");
2090 strcat (data
, "fonts");
2093 if (strlen ((char *) data
) == 0)
2094 FcConfigMessage (parse
, FcSevereWarning
, "empty font directory name ignored");
2095 else if (!FcStrUsesHome (data
) || FcConfigHome ())
2097 if (!FcConfigAddDir (parse
->config
, data
))
2098 FcConfigMessage (parse
, FcSevereError
, "out of memory; cannot add directory %s", data
);
2100 FcStrBufDestroy (&parse
->pstack
->str
);
2102 case FcElementCacheDir
:
2103 data
= FcStrBufDone (&parse
->pstack
->str
);
2106 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2110 if (strcmp (data
, "WINDOWSTEMPDIR_FONTCONFIG_CACHE") == 0)
2114 data
= malloc (1000);
2117 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2120 FcMemAlloc (FC_MEM_STRING
, 1000);
2121 rc
= GetTempPath (800, data
);
2122 if (rc
== 0 || rc
> 800)
2124 FcConfigMessage (parse
, FcSevereError
, "GetTempPath failed");
2128 if (data
[strlen (data
) - 1] != '\\')
2129 strcat (data
, "\\");
2130 strcat (data
, "fontconfig\\cache");
2133 if (!FcStrUsesHome (data
) || FcConfigHome ())
2135 if (!FcConfigAddCacheDir (parse
->config
, data
))
2136 FcConfigMessage (parse
, FcSevereError
, "out of memory; cannot add cache directory %s", data
);
2141 case FcElementCache
:
2142 data
= FcStrBufDoneStatic (&parse
->pstack
->str
);
2145 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2148 /* discard this data; no longer used */
2149 FcStrBufDestroy (&parse
->pstack
->str
);
2151 case FcElementInclude
:
2152 FcParseInclude (parse
);
2154 case FcElementConfig
:
2156 case FcElementMatch
:
2157 FcParseMatch (parse
);
2159 case FcElementAlias
:
2160 FcParseAlias (parse
);
2163 case FcElementBlank
:
2164 FcParseBlank (parse
);
2166 case FcElementRescan
:
2167 FcParseRescan (parse
);
2170 case FcElementPrefer
:
2171 FcParseFamilies (parse
, FcVStackPrefer
);
2173 case FcElementAccept
:
2174 FcParseFamilies (parse
, FcVStackAccept
);
2176 case FcElementDefault
:
2177 FcParseFamilies (parse
, FcVStackDefault
);
2179 case FcElementFamily
:
2180 FcParseFamily (parse
);
2184 FcParseTest (parse
);
2187 FcParseEdit (parse
);
2193 case FcElementDouble
:
2194 FcParseDouble (parse
);
2196 case FcElementString
:
2197 FcParseString (parse
, FcVStackString
);
2199 case FcElementMatrix
:
2200 FcParseMatrix (parse
);
2203 FcParseBool (parse
);
2205 case FcElementCharset
:
2206 /* FcParseCharset (parse); */
2208 case FcElementSelectfont
:
2210 case FcElementAcceptfont
:
2211 case FcElementRejectfont
:
2212 FcParseAcceptRejectFont (parse
, parse
->pstack
->element
);
2215 FcParseString (parse
, FcVStackGlob
);
2217 case FcElementPattern
:
2218 FcParsePattern (parse
);
2220 case FcElementPatelt
:
2221 FcParsePatelt (parse
);
2224 FcParseString (parse
, FcVStackField
);
2226 case FcElementConst
:
2227 FcParseString (parse
, FcVStackConstant
);
2230 FcParseBinary (parse
, FcOpOr
);
2233 FcParseBinary (parse
, FcOpAnd
);
2236 FcParseBinary (parse
, FcOpEqual
);
2238 case FcElementNotEq
:
2239 FcParseBinary (parse
, FcOpNotEqual
);
2242 FcParseBinary (parse
, FcOpLess
);
2244 case FcElementLessEq
:
2245 FcParseBinary (parse
, FcOpLessEqual
);
2248 FcParseBinary (parse
, FcOpMore
);
2250 case FcElementMoreEq
:
2251 FcParseBinary (parse
, FcOpMoreEqual
);
2253 case FcElementContains
:
2254 FcParseBinary (parse
, FcOpContains
);
2256 case FcElementNotContains
:
2257 FcParseBinary (parse
, FcOpNotContains
);
2260 FcParseBinary (parse
, FcOpPlus
);
2262 case FcElementMinus
:
2263 FcParseBinary (parse
, FcOpMinus
);
2265 case FcElementTimes
:
2266 FcParseBinary (parse
, FcOpTimes
);
2268 case FcElementDivide
:
2269 FcParseBinary (parse
, FcOpDivide
);
2272 FcParseUnary (parse
, FcOpNot
);
2275 FcParseBinary (parse
, FcOpQuest
);
2277 case FcElementFloor
:
2278 FcParseUnary (parse
, FcOpFloor
);
2281 FcParseUnary (parse
, FcOpCeil
);
2283 case FcElementRound
:
2284 FcParseUnary (parse
, FcOpRound
);
2286 case FcElementTrunc
:
2287 FcParseUnary (parse
, FcOpTrunc
);
2289 case FcElementUnknown
:
2292 (void) FcPStackPop (parse
);
2296 FcCharacterData (void *userData
, const XML_Char
*s
, int len
)
2298 FcConfigParse
*parse
= userData
;
2302 if (!FcStrBufData (&parse
->pstack
->str
, (FcChar8
*) s
, len
))
2303 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2307 FcStartDoctypeDecl (void *userData
,
2308 const XML_Char
*doctypeName
,
2309 const XML_Char
*sysid
,
2310 const XML_Char
*pubid
,
2311 int has_internal_subset
)
2313 FcConfigParse
*parse
= userData
;
2315 if (strcmp ((char *) doctypeName
, "fontconfig") != 0)
2316 FcConfigMessage (parse
, FcSevereError
, "invalid doctype \"%s\"", doctypeName
);
2319 #ifdef ENABLE_LIBXML2
2322 FcInternalSubsetDecl (void *userData
,
2323 const XML_Char
*doctypeName
,
2324 const XML_Char
*sysid
,
2325 const XML_Char
*pubid
)
2327 FcStartDoctypeDecl (userData
, doctypeName
, sysid
, pubid
, 1);
2331 FcExternalSubsetDecl (void *userData
,
2332 const XML_Char
*doctypeName
,
2333 const XML_Char
*sysid
,
2334 const XML_Char
*pubid
)
2336 FcStartDoctypeDecl (userData
, doctypeName
, sysid
, pubid
, 0);
2339 #else /* ENABLE_LIBXML2 */
2342 FcEndDoctypeDecl (void *userData
)
2346 #endif /* ENABLE_LIBXML2 */
2349 FcSortCmpStr (const void *a
, const void *b
)
2351 const FcChar8
*as
= *((FcChar8
**) a
);
2352 const FcChar8
*bs
= *((FcChar8
**) b
);
2353 return FcStrCmp (as
, bs
);
2357 FcConfigParseAndLoadDir (FcConfig
*config
,
2358 const FcChar8
*name
,
2364 FcBool ret
= FcTrue
;
2369 d
= opendir ((char *) dir
);
2373 FcConfigMessage (0, FcSevereError
, "Cannot open config dir \"%s\"",
2379 file
= (FcChar8
*) malloc (strlen ((char *) dir
) + 1 + FC_MAX_FILE_LEN
+ 1);
2386 strcpy ((char *) file
, (char *) dir
);
2387 strcat ((char *) file
, "/");
2388 base
= file
+ strlen ((char *) file
);
2390 files
= FcStrSetCreate ();
2397 if (FcDebug () & FC_DBG_CONFIG
)
2398 printf ("\tScanning config dir %s\n", dir
);
2400 while (ret
&& (e
= readdir (d
)))
2403 #define TAIL ".conf"
2406 * Add all files of the form [0-9]*.conf
2408 if ('0' <= e
->d_name
[0] && e
->d_name
[0] <= '9' &&
2409 (d_len
= strlen (e
->d_name
)) < FC_MAX_FILE_LEN
&&
2411 strcmp (e
->d_name
+ d_len
- TAIL_LEN
, TAIL
) == 0)
2413 strcpy ((char *) base
, (char *) e
->d_name
);
2414 if (!FcStrSetAdd (files
, file
))
2424 qsort (files
->strs
, files
->num
, sizeof (FcChar8
*),
2425 (int (*)(const void *, const void *)) FcSortCmpStr
);
2426 for (i
= 0; ret
&& i
< files
->num
; i
++)
2427 ret
= FcConfigParseAndLoad (config
, files
->strs
[i
], complain
);
2430 FcStrSetDestroy (files
);
2436 return ret
|| !complain
;
2440 FcConfigParseAndLoad (FcConfig
*config
,
2441 const FcChar8
*name
,
2449 FcConfigParse parse
;
2450 FcBool error
= FcTrue
;
2452 #ifdef ENABLE_LIBXML2
2459 filename
= FcConfigFilename (name
);
2463 if (FcStrSetMember (config
->configFiles
, filename
))
2465 FcStrFree (filename
);
2469 if (!FcStrSetAdd (config
->configFiles
, filename
))
2471 FcStrFree (filename
);
2475 if (FcFileIsDir (filename
))
2477 FcBool ret
= FcConfigParseAndLoadDir (config
, name
, filename
, complain
);
2478 FcStrFree (filename
);
2482 if (FcDebug () & FC_DBG_CONFIG
)
2483 printf ("\tLoading config file %s\n", filename
);
2485 fd
= open ((char *) filename
, O_RDONLY
);
2487 FcStrFree (filename
);
2491 #ifdef ENABLE_LIBXML2
2492 memset(&sax
, 0, sizeof(sax
));
2494 sax
.internalSubset
= FcInternalSubsetDecl
;
2495 sax
.externalSubset
= FcExternalSubsetDecl
;
2496 sax
.startElement
= FcStartElement
;
2497 sax
.endElement
= FcEndElement
;
2498 sax
.characters
= FcCharacterData
;
2500 p
= xmlCreatePushParserCtxt (&sax
, &parse
, NULL
, 0, (const char *) filename
);
2502 p
= XML_ParserCreate ("UTF-8");
2504 FcStrFree (filename
);
2509 if (!FcConfigInit (&parse
, name
, config
, p
))
2512 #ifndef ENABLE_LIBXML2
2514 XML_SetUserData (p
, &parse
);
2516 XML_SetDoctypeDeclHandler (p
, FcStartDoctypeDecl
, FcEndDoctypeDecl
);
2517 XML_SetElementHandler (p
, FcStartElement
, FcEndElement
);
2518 XML_SetCharacterDataHandler (p
, FcCharacterData
);
2520 #endif /* ENABLE_LIBXML2 */
2523 #ifndef ENABLE_LIBXML2
2524 buf
= XML_GetBuffer (p
, BUFSIZ
);
2527 FcConfigMessage (&parse
, FcSevereError
, "cannot get parse buffer");
2531 len
= read (fd
, buf
, BUFSIZ
);
2534 FcConfigMessage (&parse
, FcSevereError
, "failed reading config file");
2538 #ifdef ENABLE_LIBXML2
2539 if (xmlParseChunk (p
, buf
, len
, len
== 0))
2541 if (!XML_ParseBuffer (p
, len
, len
== 0))
2544 FcConfigMessage (&parse
, FcSevereError
, "%s",
2545 XML_ErrorString (XML_GetErrorCode (p
)));
2549 error
= parse
.error
;
2551 FcConfigCleanup (&parse
);
2558 if (error
&& complain
)
2561 FcConfigMessage (0, FcSevereError
, "Cannot load config file \"%s\"", name
);
2563 FcConfigMessage (0, FcSevereError
, "Cannot load default config file");
2569 #include "fcaliastail.h"