]>
git.wh0rd.org - fontconfig.git/blob - src/fcxml.c
2 * $XFree86: xc/lib/fontconfig/src/fcxml.c,v 1.21 2002/08/22 18:53:22 keithp Exp $
4 * Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc.
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.
28 #ifndef HAVE_XMLPARSE_H
29 #define HAVE_XMLPARSE_H 0
39 FcTestCreate (FcMatchKind kind
,
45 FcTest
*test
= (FcTest
*) malloc (sizeof (FcTest
));
49 FcMemAlloc (FC_MEM_TEST
, sizeof (FcTest
));
53 test
->field
= (char *) FcStrCopy (field
);
61 FcTestDestroy (FcTest
*test
)
64 FcTestDestroy (test
->next
);
65 FcExprDestroy (test
->expr
);
66 FcStrFree ((FcChar8
*) test
->field
);
67 FcMemFree (FC_MEM_TEST
, sizeof (FcTest
));
72 FcExprCreateInteger (int i
)
74 FcExpr
*e
= (FcExpr
*) malloc (sizeof (FcExpr
));
78 FcMemAlloc (FC_MEM_EXPR
, sizeof (FcExpr
));
86 FcExprCreateDouble (double d
)
88 FcExpr
*e
= (FcExpr
*) malloc (sizeof (FcExpr
));
92 FcMemAlloc (FC_MEM_EXPR
, sizeof (FcExpr
));
100 FcExprCreateString (const FcChar8
*s
)
102 FcExpr
*e
= (FcExpr
*) malloc (sizeof (FcExpr
));
106 FcMemAlloc (FC_MEM_EXPR
, sizeof (FcExpr
));
108 e
->u
.sval
= FcStrCopy (s
);
114 FcExprCreateMatrix (const FcMatrix
*m
)
116 FcExpr
*e
= (FcExpr
*) malloc (sizeof (FcExpr
));
120 FcMemAlloc (FC_MEM_EXPR
, sizeof (FcExpr
));
122 e
->u
.mval
= FcMatrixCopy (m
);
128 FcExprCreateBool (FcBool b
)
130 FcExpr
*e
= (FcExpr
*) malloc (sizeof (FcExpr
));
134 FcMemAlloc (FC_MEM_EXPR
, sizeof (FcExpr
));
142 FcExprCreateNil (void)
144 FcExpr
*e
= (FcExpr
*) malloc (sizeof (FcExpr
));
148 FcMemAlloc (FC_MEM_EXPR
, sizeof (FcExpr
));
155 FcExprCreateField (const char *field
)
157 FcExpr
*e
= (FcExpr
*) malloc (sizeof (FcExpr
));
161 FcMemAlloc (FC_MEM_EXPR
, sizeof (FcExpr
));
163 e
->u
.field
= (char *) FcStrCopy ((FcChar8
*) field
);
169 FcExprCreateConst (const FcChar8
*constant
)
171 FcExpr
*e
= (FcExpr
*) malloc (sizeof (FcExpr
));
175 FcMemAlloc (FC_MEM_EXPR
, sizeof (FcExpr
));
177 e
->u
.constant
= FcStrCopy (constant
);
183 FcExprCreateOp (FcExpr
*left
, FcOp op
, FcExpr
*right
)
185 FcExpr
*e
= (FcExpr
*) malloc (sizeof (FcExpr
));
189 FcMemAlloc (FC_MEM_EXPR
, sizeof (FcExpr
));
191 e
->u
.tree
.left
= left
;
192 e
->u
.tree
.right
= right
;
198 FcExprDestroy (FcExpr
*e
)
206 FcStrFree (e
->u
.sval
);
209 FcMatrixFree (e
->u
.mval
);
212 FcCharSetDestroy (e
->u
.cval
);
217 FcStrFree ((FcChar8
*) e
->u
.field
);
220 FcStrFree (e
->u
.constant
);
223 case FcOpAssignReplace
:
225 case FcOpPrependFirst
:
238 case FcOpNotContains
:
245 FcExprDestroy (e
->u
.tree
.right
);
248 FcExprDestroy (e
->u
.tree
.left
);
254 FcMemFree (FC_MEM_EXPR
, sizeof (FcExpr
));
259 FcEditCreate (const char *field
, FcOp op
, FcExpr
*expr
, FcValueBinding binding
)
261 FcEdit
*e
= (FcEdit
*) malloc (sizeof (FcEdit
));
266 e
->field
= field
; /* already saved in grammar */
269 e
->binding
= binding
;
275 FcEditDestroy (FcEdit
*e
)
278 FcEditDestroy (e
->next
);
279 FcStrFree ((FcChar8
*) e
->field
);
281 FcExprDestroy (e
->expr
);
285 FcConfigSaveField (const char *field
)
287 return (char *) FcStrCopy ((FcChar8
*) field
);
290 typedef enum _FcElement
{
327 FcElementNotContains
,
338 FcElementMap (const XML_Char
*name
)
344 { "fontconfig", FcElementFontconfig
},
345 { "dir", FcElementDir
},
346 { "cache", FcElementCache
},
347 { "include", FcElementInclude
},
348 { "config", FcElementConfig
},
349 { "match", FcElementMatch
},
350 { "alias", FcElementAlias
},
352 { "blank", FcElementBlank
},
353 { "rescan", FcElementRescan
},
355 { "prefer", FcElementPrefer
},
356 { "accept", FcElementAccept
},
357 { "default", FcElementDefault
},
358 { "family", FcElementFamily
},
360 { "test", FcElementTest
},
361 { "edit", FcElementEdit
},
362 { "int", FcElementInt
},
363 { "double", FcElementDouble
},
364 { "string", FcElementString
},
365 { "matrix", FcElementMatrix
},
366 { "bool", FcElementBool
},
367 { "charset", FcElementCharset
},
368 { "name", FcElementName
},
369 { "const", FcElementConst
},
370 { "or", FcElementOr
},
371 { "and", FcElementAnd
},
372 { "eq", FcElementEq
},
373 { "not_eq", FcElementNotEq
},
374 { "less", FcElementLess
},
375 { "less_eq", FcElementLessEq
},
376 { "more", FcElementMore
},
377 { "more_eq", FcElementMoreEq
},
378 { "contains", FcElementContains
},
379 { "not_contains",FcElementNotContains
},
380 { "plus", FcElementPlus
},
381 { "minus", FcElementMinus
},
382 { "times", FcElementTimes
},
383 { "divide", FcElementDivide
},
384 { "not", FcElementNot
},
385 { "if", FcElementIf
},
391 for (i
= 0; fcElementMap
[i
].name
; i
++)
392 if (!strcmp ((char *) name
, fcElementMap
[i
].name
))
393 return fcElementMap
[i
].element
;
394 return FcElementUnknown
;
397 typedef struct _FcPStack
{
398 struct _FcPStack
*prev
;
404 typedef enum _FcVStackTag
{
426 typedef struct _FcVStack
{
427 struct _FcVStack
*prev
;
428 FcPStack
*pstack
; /* related parse element */
446 typedef struct _FcConfigParse
{
455 typedef enum _FcConfigSeverity
{
456 FcSevereInfo
, FcSevereWarning
, FcSevereError
460 FcConfigMessage (FcConfigParse
*parse
, FcConfigSeverity severe
, char *fmt
, ...)
465 va_start (args
, fmt
);
468 case FcSevereInfo
: s
= "info"; break;
469 case FcSevereWarning
: s
= "warning"; break;
470 case FcSevereError
: s
= "error"; break;
475 fprintf (stderr
, "Fontconfig %s: \"%s\", line %d: ", s
,
476 parse
->name
, XML_GetCurrentLineNumber (parse
->parser
));
478 fprintf (stderr
, "Fontconfig %s: line %d: ", s
,
479 XML_GetCurrentLineNumber (parse
->parser
));
480 if (severe
>= FcSevereError
)
481 parse
->error
= FcTrue
;
484 fprintf (stderr
, "Fontconfig %s: ", s
);
485 vfprintf (stderr
, fmt
, args
);
486 fprintf (stderr
, "\n");
491 FcVStackPush (FcConfigParse
*parse
, FcVStack
*vstack
)
493 vstack
->prev
= parse
->vstack
;
494 vstack
->pstack
= parse
->pstack
? parse
->pstack
->prev
: 0;
495 parse
->vstack
= vstack
;
499 FcVStackCreate (void)
503 new = malloc (sizeof (FcVStack
));
506 FcMemAlloc (FC_MEM_VSTACK
, sizeof (FcVStack
));
507 new->tag
= FcVStackNone
;
513 FcVStackDestroy (FcVStack
*vstack
)
517 for (; vstack
; vstack
= prev
)
520 switch (vstack
->tag
) {
526 case FcVStackConstant
:
527 FcStrFree (vstack
->u
.string
);
529 case FcVStackInteger
:
533 FcMatrixFree (vstack
->u
.matrix
);
538 FcTestDestroy (vstack
->u
.test
);
543 case FcVStackDefault
:
544 FcExprDestroy (vstack
->u
.expr
);
547 FcEditDestroy (vstack
->u
.edit
);
550 FcMemFree (FC_MEM_VSTACK
, sizeof (FcVStack
));
556 FcVStackPushString (FcConfigParse
*parse
, FcVStackTag tag
, FcChar8
*string
)
558 FcVStack
*vstack
= FcVStackCreate ();
561 vstack
->u
.string
= string
;
563 FcVStackPush (parse
, vstack
);
568 FcVStackPushInteger (FcConfigParse
*parse
, int integer
)
570 FcVStack
*vstack
= FcVStackCreate ();
573 vstack
->u
.integer
= integer
;
574 vstack
->tag
= FcVStackInteger
;
575 FcVStackPush (parse
, vstack
);
580 FcVStackPushDouble (FcConfigParse
*parse
, double _double
)
582 FcVStack
*vstack
= FcVStackCreate ();
585 vstack
->u
._double
= _double
;
586 vstack
->tag
= FcVStackDouble
;
587 FcVStackPush (parse
, vstack
);
592 FcVStackPushMatrix (FcConfigParse
*parse
, FcMatrix
*matrix
)
594 FcVStack
*vstack
= FcVStackCreate ();
597 matrix
= FcMatrixCopy (matrix
);
600 FcVStackDestroy (vstack
);
603 vstack
->u
.matrix
= matrix
;
604 vstack
->tag
= FcVStackMatrix
;
605 FcVStackPush (parse
, vstack
);
610 FcVStackPushBool (FcConfigParse
*parse
, FcBool
bool)
612 FcVStack
*vstack
= FcVStackCreate ();
615 vstack
->u
.bool = bool;
616 vstack
->tag
= FcVStackBool
;
617 FcVStackPush (parse
, vstack
);
622 FcVStackPushTest (FcConfigParse
*parse
, FcTest
*test
)
624 FcVStack
*vstack
= FcVStackCreate ();
627 vstack
->u
.test
= test
;
628 vstack
->tag
= FcVStackTest
;
629 FcVStackPush (parse
, vstack
);
634 FcVStackPushExpr (FcConfigParse
*parse
, FcVStackTag tag
, FcExpr
*expr
)
636 FcVStack
*vstack
= FcVStackCreate ();
639 vstack
->u
.expr
= expr
;
641 FcVStackPush (parse
, vstack
);
646 FcVStackPushEdit (FcConfigParse
*parse
, FcEdit
*edit
)
648 FcVStack
*vstack
= FcVStackCreate ();
651 vstack
->u
.edit
= edit
;
652 vstack
->tag
= FcVStackEdit
;
653 FcVStackPush (parse
, vstack
);
658 FcVStackFetch (FcConfigParse
*parse
, int off
)
662 for (vstack
= parse
->vstack
; vstack
&& off
-- > 0; vstack
= vstack
->prev
);
667 FcVStackClear (FcConfigParse
*parse
)
669 while (parse
->vstack
&& parse
->vstack
->pstack
== parse
->pstack
)
671 FcVStack
*vstack
= parse
->vstack
;
672 parse
->vstack
= vstack
->prev
;
674 FcVStackDestroy (vstack
);
679 FcVStackPop (FcConfigParse
*parse
)
681 FcVStack
*vstack
= parse
->vstack
;
683 if (!vstack
|| vstack
->pstack
!= parse
->pstack
)
685 parse
->vstack
= vstack
->prev
;
691 FcVStackElements (FcConfigParse
*parse
)
694 FcVStack
*vstack
= parse
->vstack
;
695 while (vstack
&& vstack
->pstack
== parse
->pstack
)
698 vstack
= vstack
->prev
;
704 FcConfigSaveAttr (const XML_Char
**attr
)
715 for (i
= 0; attr
[i
]; i
++)
716 slen
+= strlen (attr
[i
]) + 1;
718 new = malloc ((i
+ 1) * sizeof (FcChar8
*) + slen
);
721 FcMemAlloc (FC_MEM_ATTR
, 1); /* size is too expensive */
722 s
= (FcChar8
*) (new + (i
+ 1));
723 for (i
= 0; attr
[i
]; i
++)
726 strcpy ((char *) s
, (char *) attr
[i
]);
727 s
+= strlen ((char *) s
) + 1;
734 FcPStackPush (FcConfigParse
*parse
, FcElement element
, const XML_Char
**attr
)
736 FcPStack
*new = malloc (sizeof (FcPStack
));
740 FcMemAlloc (FC_MEM_PSTACK
, sizeof (FcPStack
));
741 new->prev
= parse
->pstack
;
742 new->element
= element
;
745 new->attr
= FcConfigSaveAttr (attr
);
747 FcConfigMessage (parse
, FcSevereError
, "out of memory");
751 FcStrBufInit (&new->str
, 0, 0);
757 FcPStackPop (FcConfigParse
*parse
)
763 FcConfigMessage (parse
, FcSevereError
, "mismatching element");
766 FcVStackClear (parse
);
768 parse
->pstack
= old
->prev
;
769 FcStrBufDestroy (&old
->str
);
772 FcMemFree (FC_MEM_ATTR
, 1); /* size is to expensive */
775 FcMemFree (FC_MEM_PSTACK
, sizeof (FcPStack
));
781 FcConfigInit (FcConfigParse
*parse
, const FcChar8
*name
, FcConfig
*config
, XML_Parser parser
)
785 parse
->error
= FcFalse
;
787 parse
->config
= config
;
788 parse
->parser
= parser
;
793 FcConfigCleanup (FcConfigParse
*parse
)
795 while (parse
->pstack
)
799 static const FcChar8
*
800 FcConfigGetAttribute (FcConfigParse
*parse
, char *attr
)
806 attrs
= parse
->pstack
->attr
;
809 if (!strcmp ((char *) *attrs
, attr
))
817 FcStartElement(void *userData
, const XML_Char
*name
, const XML_Char
**attr
)
819 FcConfigParse
*parse
= userData
;
822 element
= FcElementMap (name
);
823 if (element
== FcElementUnknown
)
824 FcConfigMessage (parse
, FcSevereWarning
, "unknown element \"%s\"", name
);
826 if (!FcPStackPush (parse
, element
, attr
))
828 FcConfigMessage (parse
, FcSevereError
, "out of memory");
835 FcParseBlank (FcConfigParse
*parse
)
837 int n
= FcVStackElements (parse
);
840 FcVStack
*v
= FcVStackFetch (parse
, n
);
841 if (v
->tag
!= FcVStackInteger
)
842 FcConfigMessage (parse
, FcSevereError
, "non-integer blank");
845 if (!parse
->config
->blanks
)
847 parse
->config
->blanks
= FcBlanksCreate ();
848 if (!parse
->config
->blanks
)
850 FcConfigMessage (parse
, FcSevereError
, "out of memory");
854 if (!FcBlanksAdd (parse
->config
->blanks
, v
->u
.integer
))
856 FcConfigMessage (parse
, FcSevereError
, "out of memory");
864 FcParseRescan (FcConfigParse
*parse
)
866 int n
= FcVStackElements (parse
);
869 FcVStack
*v
= FcVStackFetch (parse
, n
);
870 if (v
->tag
!= FcVStackInteger
)
871 FcConfigMessage (parse
, FcSevereWarning
, "non-integer rescan");
873 parse
->config
->rescanInterval
= v
->u
.integer
;
878 FcParseInt (FcConfigParse
*parse
)
885 s
= FcStrBufDone (&parse
->pstack
->str
);
888 FcConfigMessage (parse
, FcSevereError
, "out of memory");
892 l
= (int) strtol ((char *) s
, (char **)&end
, 0);
893 if (end
!= s
+ strlen ((char *) s
))
894 FcConfigMessage (parse
, FcSevereError
, "\"%s\": not a valid integer", s
);
896 FcVStackPushInteger (parse
, l
);
901 * idea copied from glib g_ascii_strtod with
902 * permission of the author (Alexander Larsson)
908 FcStrtod (char *s
, char **end
)
910 struct lconv
*locale_data
;
915 * Have to swap the decimal point to match the current locale
916 * if that locale doesn't use 0x2e
918 if ((dot
= strchr (s
, 0x2e)) &&
919 (locale_data
= localeconv ()) &&
920 (locale_data
->decimal_point
[0] != 0x2e ||
921 locale_data
->decimal_point
[1] != 0))
924 int slen
= strlen (s
);
925 int dlen
= strlen (locale_data
->decimal_point
);
927 if (slen
+ dlen
> sizeof (buf
))
937 strncpy (buf
, s
, dot
- s
);
939 strcpy (buf
+ (dot
- s
), locale_data
->decimal_point
);
941 strcpy (buf
+ (dot
- s
) + dlen
, dot
+ 1);
943 v
= strtod (buf
, &buf_end
);
945 buf_end
= s
+ (buf_end
- buf
);
956 FcParseDouble (FcConfigParse
*parse
)
963 s
= FcStrBufDone (&parse
->pstack
->str
);
966 FcConfigMessage (parse
, FcSevereError
, "out of memory");
970 d
= FcStrtod ((char *) s
, (char **)&end
);
971 if (end
!= s
+ strlen ((char *) s
))
972 FcConfigMessage (parse
, FcSevereError
, "\"%s\": not a valid double", s
);
974 FcVStackPushDouble (parse
, d
);
979 FcParseString (FcConfigParse
*parse
, FcVStackTag tag
)
985 s
= FcStrBufDone (&parse
->pstack
->str
);
988 FcConfigMessage (parse
, FcSevereError
, "out of memory");
991 if (!FcVStackPushString (parse
, tag
, s
))
996 FcParseMatrix (FcConfigParse
*parse
)
999 enum { m_done
, m_xx
, m_xy
, m_yx
, m_yy
} matrix_state
= m_yy
;
1002 while ((vstack
= FcVStackPop (parse
)))
1005 switch (vstack
->tag
) {
1006 case FcVStackInteger
:
1007 v
= vstack
->u
.integer
;
1009 case FcVStackDouble
:
1010 v
= vstack
->u
._double
;
1013 FcConfigMessage (parse
, FcSevereError
, "non-double matrix element");
1017 switch (matrix_state
) {
1018 case m_xx
: m
.xx
= v
; break;
1019 case m_xy
: m
.xy
= v
; break;
1020 case m_yx
: m
.yx
= v
; break;
1021 case m_yy
: m
.yy
= v
; break;
1024 FcVStackDestroy (vstack
);
1027 if (matrix_state
!= m_done
)
1028 FcConfigMessage (parse
, FcSevereError
, "wrong number of matrix elements");
1030 FcVStackPushMatrix (parse
, &m
);
1034 FcConfigLexBool (const FcChar8
*bool)
1036 if (*bool == 't' || *bool == 'T')
1038 if (*bool == 'y' || *bool == 'Y')
1046 FcParseBool (FcConfigParse
*parse
)
1052 s
= FcStrBufDone (&parse
->pstack
->str
);
1055 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1058 FcVStackPushBool (parse
, FcConfigLexBool (s
));
1063 FcParseFamilies (FcConfigParse
*parse
, FcVStackTag tag
)
1066 FcExpr
*left
, *expr
= 0, *new;
1068 while ((vstack
= FcVStackPop (parse
)))
1070 if (vstack
->tag
!= FcVStackFamily
)
1072 FcConfigMessage (parse
, FcSevereWarning
, "non-family");
1073 FcVStackDestroy (vstack
);
1076 left
= vstack
->u
.expr
;
1077 vstack
->tag
= FcVStackNone
;
1078 FcVStackDestroy (vstack
);
1081 new = FcExprCreateOp (left
, FcOpComma
, expr
);
1084 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1085 FcExprDestroy (left
);
1086 FcExprDestroy (expr
);
1096 if (!FcVStackPushExpr (parse
, tag
, expr
))
1098 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1100 FcExprDestroy (expr
);
1106 FcParseFamily (FcConfigParse
*parse
)
1113 s
= FcStrBufDone (&parse
->pstack
->str
);
1116 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1119 expr
= FcExprCreateString (s
);
1122 FcVStackPushExpr (parse
, FcVStackFamily
, expr
);
1126 FcParseAlias (FcConfigParse
*parse
)
1128 FcExpr
*family
= 0, *accept
= 0, *prefer
= 0, *def
= 0, *new = 0;
1129 FcEdit
*edit
= 0, *next
;
1133 while ((vstack
= FcVStackPop (parse
)))
1135 switch (vstack
->tag
) {
1136 case FcVStackFamily
:
1139 new = FcExprCreateOp (vstack
->u
.expr
, FcOpComma
, family
);
1141 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1146 new = vstack
->u
.expr
;
1150 vstack
->tag
= FcVStackNone
;
1153 case FcVStackPrefer
:
1155 FcExprDestroy (prefer
);
1156 prefer
= vstack
->u
.expr
;
1157 vstack
->tag
= FcVStackNone
;
1159 case FcVStackAccept
:
1161 FcExprDestroy (accept
);
1162 accept
= vstack
->u
.expr
;
1163 vstack
->tag
= FcVStackNone
;
1165 case FcVStackDefault
:
1167 FcExprDestroy (def
);
1168 def
= vstack
->u
.expr
;
1169 vstack
->tag
= FcVStackNone
;
1172 FcConfigMessage (parse
, FcSevereWarning
, "bad alias");
1175 FcVStackDestroy (vstack
);
1179 FcConfigMessage (parse
, FcSevereError
, "missing family in alias");
1181 FcExprDestroy (prefer
);
1183 FcExprDestroy (accept
);
1185 FcExprDestroy (def
);
1190 edit
= FcEditCreate (FcConfigSaveField ("family"),
1193 FcValueBindingWeak
);
1197 FcExprDestroy (prefer
);
1202 edit
= FcEditCreate (FcConfigSaveField ("family"),
1205 FcValueBindingWeak
);
1209 FcExprDestroy (accept
);
1214 edit
= FcEditCreate (FcConfigSaveField ("family"),
1217 FcValueBindingWeak
);
1221 FcExprDestroy (def
);
1225 test
= FcTestCreate (FcMatchPattern
,
1227 (FcChar8
*) FC_FAMILY
,
1231 if (!FcConfigAddEdit (parse
->config
, test
, edit
, FcMatchPattern
))
1232 FcTestDestroy (test
);
1235 FcExprDestroy (family
);
1239 FcPopExpr (FcConfigParse
*parse
)
1241 FcVStack
*vstack
= FcVStackPop (parse
);
1245 switch (vstack
->tag
) {
1248 case FcVStackString
:
1249 case FcVStackFamily
:
1250 expr
= FcExprCreateString (vstack
->u
.string
);
1253 expr
= FcExprCreateField ((char *) vstack
->u
.string
);
1255 case FcVStackConstant
:
1256 expr
= FcExprCreateConst (vstack
->u
.string
);
1258 case FcVStackPrefer
:
1259 case FcVStackAccept
:
1260 case FcVStackDefault
:
1261 expr
= vstack
->u
.expr
;
1262 vstack
->tag
= FcVStackNone
;
1264 case FcVStackInteger
:
1265 expr
= FcExprCreateInteger (vstack
->u
.integer
);
1267 case FcVStackDouble
:
1268 expr
= FcExprCreateDouble (vstack
->u
._double
);
1270 case FcVStackMatrix
:
1271 expr
= FcExprCreateMatrix (vstack
->u
.matrix
);
1274 expr
= FcExprCreateBool (vstack
->u
.bool);
1279 expr
= vstack
->u
.expr
;
1280 vstack
->tag
= FcVStackNone
;
1285 FcVStackDestroy (vstack
);
1290 FcPopExprs (FcConfigParse
*parse
, FcOp op
)
1292 FcExpr
*left
, *expr
= 0, *new;
1294 while ((left
= FcPopExpr (parse
)))
1298 new = FcExprCreateOp (left
, op
, expr
);
1301 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1302 FcExprDestroy (left
);
1303 FcExprDestroy (expr
);
1315 FcParseExpr (FcConfigParse
*parse
, FcOp op
)
1317 FcExpr
*expr
= FcPopExprs (parse
, op
);
1319 FcVStackPushExpr (parse
, FcVStackExpr
, expr
);
1323 FcParseInclude (FcConfigParse
*parse
)
1327 FcBool ignore_missing
= FcFalse
;
1329 s
= FcStrBufDone (&parse
->pstack
->str
);
1332 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1335 i
= FcConfigGetAttribute (parse
, "ignore_missing");
1336 if (i
&& FcConfigLexBool ((FcChar8
*) i
) == FcTrue
)
1337 ignore_missing
= FcTrue
;
1338 if (!FcConfigParseAndLoad (parse
->config
, s
, !ignore_missing
))
1339 parse
->error
= FcTrue
;
1343 typedef struct _FcOpMap
{
1349 FcConfigLexOp (const FcChar8
*op
, const FcOpMap
*map
, int nmap
)
1353 for (i
= 0; i
< nmap
; i
++)
1354 if (!strcmp ((char *) op
, map
[i
].name
))
1359 static const FcOpMap fcCompareOps
[] = {
1360 { "eq", FcOpEqual
},
1361 { "not_eq", FcOpNotEqual
},
1362 { "less", FcOpLess
},
1363 { "less_eq", FcOpLessEqual
},
1364 { "more", FcOpMore
},
1365 { "more_eq", FcOpMoreEqual
},
1366 { "contains", FcOpContains
},
1367 { "not_contains", FcOpNotContains
}
1370 #define NUM_COMPARE_OPS (sizeof fcCompareOps / sizeof fcCompareOps[0])
1373 FcConfigLexCompare (const FcChar8
*compare
)
1375 return FcConfigLexOp (compare
, fcCompareOps
, NUM_COMPARE_OPS
);
1380 FcParseTest (FcConfigParse
*parse
)
1382 const FcChar8
*kind_string
;
1384 const FcChar8
*qual_string
;
1386 const FcChar8
*name
;
1387 const FcChar8
*compare_string
;
1392 kind_string
= FcConfigGetAttribute (parse
, "target");
1394 kind
= FcMatchDefault
;
1397 if (!strcmp ((char *) kind_string
, "pattern"))
1398 kind
= FcMatchPattern
;
1399 else if (!strcmp ((char *) kind_string
, "font"))
1401 else if (!strcmp ((char *) kind_string
, "default"))
1402 kind
= FcMatchDefault
;
1405 FcConfigMessage (parse
, FcSevereWarning
, "invalid test target \"%s\"", kind_string
);
1409 qual_string
= FcConfigGetAttribute (parse
, "qual");
1414 if (!strcmp ((char *) qual_string
, "any"))
1416 else if (!strcmp ((char *) qual_string
, "all"))
1418 else if (!strcmp ((char *) qual_string
, "first"))
1420 else if (!strcmp ((char *) qual_string
, "not_first"))
1421 qual
= FcQualNotFirst
;
1424 FcConfigMessage (parse
, FcSevereWarning
, "invalid test qual \"%s\"", qual_string
);
1428 name
= FcConfigGetAttribute (parse
, "name");
1431 FcConfigMessage (parse
, FcSevereWarning
, "missing test name");
1434 compare_string
= FcConfigGetAttribute (parse
, "compare");
1435 if (!compare_string
)
1436 compare
= FcOpEqual
;
1439 compare
= FcConfigLexCompare (compare_string
);
1440 if (compare
== FcOpInvalid
)
1442 FcConfigMessage (parse
, FcSevereWarning
, "invalid test compare \"%s\"", compare_string
);
1446 expr
= FcPopExprs (parse
, FcOpComma
);
1449 FcConfigMessage (parse
, FcSevereWarning
, "missing test expression");
1452 test
= FcTestCreate (kind
, qual
, name
, compare
, expr
);
1455 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1458 FcVStackPushTest (parse
, test
);
1461 static const FcOpMap fcModeOps
[] = {
1462 { "assign", FcOpAssign
},
1463 { "assign_replace", FcOpAssignReplace
},
1464 { "prepend", FcOpPrepend
},
1465 { "prepend_first", FcOpPrependFirst
},
1466 { "append", FcOpAppend
},
1467 { "append_last", FcOpAppendLast
},
1470 #define NUM_MODE_OPS (sizeof fcModeOps / sizeof fcModeOps[0])
1473 FcConfigLexMode (const FcChar8
*mode
)
1475 return FcConfigLexOp (mode
, fcModeOps
, NUM_MODE_OPS
);
1479 FcParseEdit (FcConfigParse
*parse
)
1481 const FcChar8
*name
;
1482 const FcChar8
*mode_string
;
1483 const FcChar8
*binding_string
;
1485 FcValueBinding binding
;
1489 name
= FcConfigGetAttribute (parse
, "name");
1492 FcConfigMessage (parse
, FcSevereWarning
, "missing edit name");
1495 mode_string
= FcConfigGetAttribute (parse
, "mode");
1500 mode
= FcConfigLexMode (mode_string
);
1501 if (mode
== FcOpInvalid
)
1503 FcConfigMessage (parse
, FcSevereWarning
, "invalid edit mode \"%s\"", mode_string
);
1507 binding_string
= FcConfigGetAttribute (parse
, "binding");
1508 if (!binding_string
)
1509 binding
= FcValueBindingWeak
;
1512 if (!strcmp ((char *) binding_string
, "weak"))
1513 binding
= FcValueBindingWeak
;
1514 else if (!strcmp ((char *) binding_string
, "strong"))
1515 binding
= FcValueBindingStrong
;
1516 else if (!strcmp ((char *) binding_string
, "same"))
1517 binding
= FcValueBindingSame
;
1520 FcConfigMessage (parse
, FcSevereWarning
, "invalid edit binding \"%s\"", binding_string
);
1524 expr
= FcPopExprs (parse
, FcOpComma
);
1525 edit
= FcEditCreate ((char *) FcStrCopy (name
), mode
, expr
, binding
);
1528 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1529 FcExprDestroy (expr
);
1532 if (!FcVStackPushEdit (parse
, edit
))
1533 FcEditDestroy (edit
);
1537 FcParseMatch (FcConfigParse
*parse
)
1539 const FcChar8
*kind_name
;
1545 kind_name
= FcConfigGetAttribute (parse
, "target");
1547 kind
= FcMatchPattern
;
1550 if (!strcmp ((char *) kind_name
, "pattern"))
1551 kind
= FcMatchPattern
;
1552 else if (!strcmp ((char *) kind_name
, "font"))
1556 FcConfigMessage (parse
, FcSevereWarning
, "invalid match target \"%s\"", kind_name
);
1560 while ((vstack
= FcVStackPop (parse
)))
1562 switch (vstack
->tag
) {
1564 vstack
->u
.test
->next
= test
;
1565 test
= vstack
->u
.test
;
1566 vstack
->tag
= FcVStackNone
;
1569 vstack
->u
.edit
->next
= edit
;
1570 edit
= vstack
->u
.edit
;
1571 vstack
->tag
= FcVStackNone
;
1574 FcConfigMessage (parse
, FcSevereWarning
, "invalid match element");
1577 FcVStackDestroy (vstack
);
1579 if (!FcConfigAddEdit (parse
->config
, test
, edit
, kind
))
1580 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1584 FcEndElement(void *userData
, const XML_Char
*name
)
1586 FcConfigParse
*parse
= userData
;
1591 switch (parse
->pstack
->element
) {
1594 case FcElementFontconfig
:
1597 data
= FcStrBufDone (&parse
->pstack
->str
);
1600 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1603 if (!FcStrUsesHome (data
) || FcConfigHome ())
1605 if (!FcConfigAddDir (parse
->config
, data
))
1606 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1610 case FcElementCache
:
1611 data
= FcStrBufDone (&parse
->pstack
->str
);
1614 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1617 if (!FcStrUsesHome (data
) || FcConfigHome ())
1619 if (!FcConfigSetCache (parse
->config
, data
))
1620 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1624 case FcElementInclude
:
1625 FcParseInclude (parse
);
1627 case FcElementConfig
:
1629 case FcElementMatch
:
1630 FcParseMatch (parse
);
1632 case FcElementAlias
:
1633 FcParseAlias (parse
);
1636 case FcElementBlank
:
1637 FcParseBlank (parse
);
1639 case FcElementRescan
:
1640 FcParseRescan (parse
);
1643 case FcElementPrefer
:
1644 FcParseFamilies (parse
, FcVStackPrefer
);
1646 case FcElementAccept
:
1647 FcParseFamilies (parse
, FcVStackAccept
);
1649 case FcElementDefault
:
1650 FcParseFamilies (parse
, FcVStackDefault
);
1652 case FcElementFamily
:
1653 FcParseFamily (parse
);
1657 FcParseTest (parse
);
1660 FcParseEdit (parse
);
1666 case FcElementDouble
:
1667 FcParseDouble (parse
);
1669 case FcElementString
:
1670 FcParseString (parse
, FcVStackString
);
1672 case FcElementMatrix
:
1673 FcParseMatrix (parse
);
1676 FcParseBool (parse
);
1678 case FcElementCharset
:
1679 /* FcParseCharset (parse); */
1683 FcParseString (parse
, FcVStackField
);
1685 case FcElementConst
:
1686 FcParseString (parse
, FcVStackConstant
);
1689 FcParseExpr (parse
, FcOpOr
);
1692 FcParseExpr (parse
, FcOpAnd
);
1695 FcParseExpr (parse
, FcOpEqual
);
1697 case FcElementNotEq
:
1698 FcParseExpr (parse
, FcOpNotEqual
);
1701 FcParseExpr (parse
, FcOpLess
);
1703 case FcElementLessEq
:
1704 FcParseExpr (parse
, FcOpLessEqual
);
1707 FcParseExpr (parse
, FcOpMore
);
1709 case FcElementMoreEq
:
1710 FcParseExpr (parse
, FcOpMoreEqual
);
1712 case FcElementContains
:
1713 FcParseExpr (parse
, FcOpContains
);
1715 case FcElementNotContains
:
1716 FcParseExpr (parse
, FcOpNotContains
);
1719 FcParseExpr (parse
, FcOpPlus
);
1721 case FcElementMinus
:
1722 FcParseExpr (parse
, FcOpMinus
);
1724 case FcElementTimes
:
1725 FcParseExpr (parse
, FcOpTimes
);
1727 case FcElementDivide
:
1728 FcParseExpr (parse
, FcOpDivide
);
1731 FcParseExpr (parse
, FcOpNot
);
1734 FcParseExpr (parse
, FcOpQuest
);
1736 case FcElementUnknown
:
1739 (void) FcPStackPop (parse
);
1743 FcCharacterData (void *userData
, const XML_Char
*s
, int len
)
1745 FcConfigParse
*parse
= userData
;
1749 if (!FcStrBufData (&parse
->pstack
->str
, (FcChar8
*) s
, len
))
1750 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1754 FcStartDoctypeDecl (void *userData
,
1755 const XML_Char
*doctypeName
,
1756 const XML_Char
*sysid
,
1757 const XML_Char
*pubid
,
1758 int has_internal_subset
)
1760 FcConfigParse
*parse
= userData
;
1762 if (strcmp ((char *) doctypeName
, "fontconfig") != 0)
1763 FcConfigMessage (parse
, FcSevereError
, "invalid doctype \"%s\"", doctypeName
);
1767 FcEndDoctypeDecl (void *userData
)
1772 FcConfigParseAndLoad (FcConfig
*config
,
1773 const FcChar8
*name
,
1782 FcConfigParse parse
;
1783 FcBool error
= FcTrue
;
1785 filename
= FcConfigFilename (name
);
1789 if (!FcStrSetAdd (config
->configFiles
, filename
))
1791 FcStrFree (filename
);
1795 f
= fopen ((char *) filename
, "r");
1796 FcStrFree (filename
);
1800 p
= XML_ParserCreate ("UTF-8");
1804 if (!FcConfigInit (&parse
, name
, config
, p
))
1807 XML_SetUserData (p
, &parse
);
1809 XML_SetDoctypeDeclHandler (p
, FcStartDoctypeDecl
, FcEndDoctypeDecl
);
1810 XML_SetElementHandler (p
, FcStartElement
, FcEndElement
);
1811 XML_SetCharacterDataHandler (p
, FcCharacterData
);
1814 buf
= XML_GetBuffer (p
, BUFSIZ
);
1817 FcConfigMessage (&parse
, FcSevereError
, "cannot get parse buffer");
1820 len
= fread (buf
, 1, BUFSIZ
, f
);
1823 FcConfigMessage (&parse
, FcSevereError
, "failed reading config file");
1826 if (!XML_ParseBuffer (p
, len
, len
== 0))
1828 FcConfigMessage (&parse
, FcSevereError
, "%s",
1829 XML_ErrorString (XML_GetErrorCode (p
)));
1833 error
= parse
.error
;
1835 FcConfigCleanup (&parse
);
1841 if (error
&& complain
)
1844 FcConfigMessage (0, FcSevereError
, "Cannot load config file \"%s\"", name
);
1846 FcConfigMessage (0, FcSevereError
, "Cannot load default config file");