]>
git.wh0rd.org - fontconfig.git/blob - src/fcxml.c
2 * $XFree86: xc/lib/fontconfig/src/fcxml.c,v 1.6 2002/02/28 16:51:48 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.
34 FcTestCreate (FcQual qual
, const FcChar8
*field
, FcOp compare
, FcExpr
*expr
)
36 FcTest
*test
= (FcTest
*) malloc (sizeof (FcTest
));
42 test
->field
= (char *) FcStrCopy (field
);
50 FcTestDestroy (FcTest
*test
)
53 FcTestDestroy (test
->next
);
54 FcExprDestroy (test
->expr
);
55 FcStrFree ((FcChar8
*) test
->field
);
60 FcExprCreateInteger (int i
)
62 FcExpr
*e
= (FcExpr
*) malloc (sizeof (FcExpr
));
73 FcExprCreateDouble (double d
)
75 FcExpr
*e
= (FcExpr
*) malloc (sizeof (FcExpr
));
86 FcExprCreateString (const FcChar8
*s
)
88 FcExpr
*e
= (FcExpr
*) malloc (sizeof (FcExpr
));
93 e
->u
.sval
= FcStrCopy (s
);
99 FcExprCreateMatrix (const FcMatrix
*m
)
101 FcExpr
*e
= (FcExpr
*) malloc (sizeof (FcExpr
));
106 e
->u
.mval
= FcMatrixCopy (m
);
112 FcExprCreateBool (FcBool b
)
114 FcExpr
*e
= (FcExpr
*) malloc (sizeof (FcExpr
));
125 FcExprCreateNil (void)
127 FcExpr
*e
= (FcExpr
*) malloc (sizeof (FcExpr
));
137 FcExprCreateField (const char *field
)
139 FcExpr
*e
= (FcExpr
*) malloc (sizeof (FcExpr
));
144 e
->u
.field
= (char *) FcStrCopy ((FcChar8
*) field
);
150 FcExprCreateConst (const FcChar8
*constant
)
152 FcExpr
*e
= (FcExpr
*) malloc (sizeof (FcExpr
));
157 e
->u
.constant
= FcStrCopy (constant
);
163 FcExprCreateOp (FcExpr
*left
, FcOp op
, FcExpr
*right
)
165 FcExpr
*e
= (FcExpr
*) malloc (sizeof (FcExpr
));
170 e
->u
.tree
.left
= left
;
171 e
->u
.tree
.right
= right
;
177 FcExprDestroy (FcExpr
*e
)
185 FcStrFree (e
->u
.sval
);
188 FcMatrixFree (e
->u
.mval
);
191 FcCharSetDestroy (e
->u
.cval
);
196 FcStrFree ((FcChar8
*) e
->u
.field
);
199 FcStrFree (e
->u
.constant
);
202 case FcOpAssignReplace
:
204 case FcOpPrependFirst
:
223 FcExprDestroy (e
->u
.tree
.right
);
226 FcExprDestroy (e
->u
.tree
.left
);
236 FcEditCreate (const char *field
, FcOp op
, FcExpr
*expr
)
238 FcEdit
*e
= (FcEdit
*) malloc (sizeof (FcEdit
));
243 e
->field
= field
; /* already saved in grammar */
251 FcEditDestroy (FcEdit
*e
)
254 FcEditDestroy (e
->next
);
255 FcStrFree ((FcChar8
*) e
->field
);
257 FcExprDestroy (e
->expr
);
261 FcConfigSaveField (const char *field
)
263 return (char *) FcStrCopy ((FcChar8
*) field
);
266 typedef enum _FcElement
{
312 FcElementMap (const XML_Char
*name
)
318 { "fontconfig", FcElementFontconfig
},
319 { "dir", FcElementDir
},
320 { "cache", FcElementCache
},
321 { "include", FcElementInclude
},
322 { "config", FcElementConfig
},
323 { "match", FcElementMatch
},
324 { "alias", FcElementAlias
},
326 { "blank", FcElementBlank
},
327 { "rescan", FcElementRescan
},
329 { "prefer", FcElementPrefer
},
330 { "accept", FcElementAccept
},
331 { "default", FcElementDefault
},
332 { "family", FcElementFamily
},
334 { "test", FcElementTest
},
335 { "edit", FcElementEdit
},
336 { "int", FcElementInt
},
337 { "double", FcElementDouble
},
338 { "string", FcElementString
},
339 { "matrix", FcElementMatrix
},
340 { "bool", FcElementBool
},
341 { "charset", FcElementCharset
},
342 { "name", FcElementName
},
343 { "const", FcElementConst
},
344 { "or", FcElementOr
},
345 { "and", FcElementAnd
},
346 { "eq", FcElementEq
},
347 { "not_eq", FcElementNotEq
},
348 { "less", FcElementLess
},
349 { "less_eq", FcElementLessEq
},
350 { "more", FcElementMore
},
351 { "more_eq", FcElementMoreEq
},
352 { "plus", FcElementPlus
},
353 { "minus", FcElementMinus
},
354 { "times", FcElementTimes
},
355 { "divide", FcElementDivide
},
356 { "not", FcElementNot
},
357 { "if", FcElementIf
},
363 for (i
= 0; fcElementMap
[i
].name
; i
++)
364 if (!strcmp ((char *) name
, fcElementMap
[i
].name
))
365 return fcElementMap
[i
].element
;
366 return FcElementUnknown
;
369 typedef struct _FcPStack
{
370 struct _FcPStack
*prev
;
376 typedef enum _FcVStackTag
{
398 typedef struct _FcVStack
{
399 struct _FcVStack
*prev
;
400 FcPStack
*pstack
; /* related parse element */
418 typedef struct _FcConfigParse
{
427 typedef enum _FcConfigSeverity
{
428 FcSevereInfo
, FcSevereWarning
, FcSevereError
432 FcConfigMessage (FcConfigParse
*parse
, FcConfigSeverity severe
, char *fmt
, ...)
437 va_start (args
, fmt
);
440 case FcSevereInfo
: s
= "info"; break;
441 case FcSevereWarning
: s
= "warning"; break;
442 case FcSevereError
: s
= "error"; break;
447 fprintf (stderr
, "Fontconfig %s: \"%s\", line %d: ", s
,
448 parse
->name
, XML_GetCurrentLineNumber (parse
->parser
));
450 fprintf (stderr
, "Fontconfig %s: line %d: ", s
,
451 XML_GetCurrentLineNumber (parse
->parser
));
452 if (severe
>= FcSevereError
)
453 parse
->error
= FcTrue
;
456 fprintf (stderr
, "Fontconfig %s: ", s
);
457 vfprintf (stderr
, fmt
, args
);
458 fprintf (stderr
, "\n");
463 FcVStackPush (FcConfigParse
*parse
, FcVStack
*vstack
)
465 vstack
->prev
= parse
->vstack
;
466 vstack
->pstack
= parse
->pstack
? parse
->pstack
->prev
: 0;
467 parse
->vstack
= vstack
;
471 FcVStackCreate (void)
475 new = malloc (sizeof (FcVStack
));
478 new->tag
= FcVStackNone
;
484 FcVStackDestroy (FcVStack
*vstack
)
488 for (; vstack
; vstack
= prev
)
491 switch (vstack
->tag
) {
497 case FcVStackConstant
:
498 FcStrFree (vstack
->u
.string
);
500 case FcVStackInteger
:
504 FcMatrixFree (vstack
->u
.matrix
);
509 FcTestDestroy (vstack
->u
.test
);
514 case FcVStackDefault
:
515 FcExprDestroy (vstack
->u
.expr
);
518 FcEditDestroy (vstack
->u
.edit
);
526 FcVStackPushString (FcConfigParse
*parse
, FcVStackTag tag
, FcChar8
*string
)
528 FcVStack
*vstack
= FcVStackCreate ();
531 vstack
->u
.string
= string
;
533 FcVStackPush (parse
, vstack
);
538 FcVStackPushInteger (FcConfigParse
*parse
, int integer
)
540 FcVStack
*vstack
= FcVStackCreate ();
543 vstack
->u
.integer
= integer
;
544 vstack
->tag
= FcVStackInteger
;
545 FcVStackPush (parse
, vstack
);
550 FcVStackPushDouble (FcConfigParse
*parse
, double _double
)
552 FcVStack
*vstack
= FcVStackCreate ();
555 vstack
->u
._double
= _double
;
556 vstack
->tag
= FcVStackDouble
;
557 FcVStackPush (parse
, vstack
);
562 FcVStackPushMatrix (FcConfigParse
*parse
, FcMatrix
*matrix
)
564 FcVStack
*vstack
= FcVStackCreate ();
567 matrix
= FcMatrixCopy (matrix
);
570 FcVStackDestroy (vstack
);
573 vstack
->u
.matrix
= matrix
;
574 vstack
->tag
= FcVStackMatrix
;
575 FcVStackPush (parse
, vstack
);
580 FcVStackPushBool (FcConfigParse
*parse
, FcBool
bool)
582 FcVStack
*vstack
= FcVStackCreate ();
585 vstack
->u
.bool = bool;
586 vstack
->tag
= FcVStackBool
;
587 FcVStackPush (parse
, vstack
);
592 FcVStackPushTest (FcConfigParse
*parse
, FcTest
*test
)
594 FcVStack
*vstack
= FcVStackCreate ();
597 vstack
->u
.test
= test
;
598 vstack
->tag
= FcVStackTest
;
599 FcVStackPush (parse
, vstack
);
604 FcVStackPushExpr (FcConfigParse
*parse
, FcVStackTag tag
, FcExpr
*expr
)
606 FcVStack
*vstack
= FcVStackCreate ();
609 vstack
->u
.expr
= expr
;
611 FcVStackPush (parse
, vstack
);
616 FcVStackPushEdit (FcConfigParse
*parse
, FcEdit
*edit
)
618 FcVStack
*vstack
= FcVStackCreate ();
621 vstack
->u
.edit
= edit
;
622 vstack
->tag
= FcVStackEdit
;
623 FcVStackPush (parse
, vstack
);
628 FcVStackFetch (FcConfigParse
*parse
, int off
)
632 for (vstack
= parse
->vstack
; vstack
&& off
-- > 0; vstack
= vstack
->prev
);
637 FcVStackClear (FcConfigParse
*parse
)
639 while (parse
->vstack
&& parse
->vstack
->pstack
== parse
->pstack
)
641 FcVStack
*vstack
= parse
->vstack
;
642 parse
->vstack
= vstack
->prev
;
644 FcVStackDestroy (vstack
);
649 FcVStackPop (FcConfigParse
*parse
)
651 FcVStack
*vstack
= parse
->vstack
;
653 if (!vstack
|| vstack
->pstack
!= parse
->pstack
)
655 parse
->vstack
= vstack
->prev
;
661 FcVStackElements (FcConfigParse
*parse
)
664 FcVStack
*vstack
= parse
->vstack
;
665 while (vstack
&& vstack
->pstack
== parse
->pstack
)
668 vstack
= vstack
->prev
;
674 FcConfigSaveAttr (const XML_Char
**attr
)
685 for (i
= 0; attr
[i
]; i
++)
686 slen
+= strlen (attr
[i
]) + 1;
688 new = malloc ((i
+ 1) * sizeof (FcChar8
*) + slen
);
691 s
= (FcChar8
*) (new + (i
+ 1));
692 for (i
= 0; attr
[i
]; i
++)
695 strcpy ((char *) s
, (char *) attr
[i
]);
696 s
+= strlen ((char *) s
) + 1;
703 FcPStackPush (FcConfigParse
*parse
, FcElement element
, const XML_Char
**attr
)
705 FcPStack
*new = malloc (sizeof (FcPStack
));
709 new->prev
= parse
->pstack
;
710 new->element
= element
;
713 new->attr
= FcConfigSaveAttr (attr
);
715 FcConfigMessage (parse
, FcSevereError
, "out of memory");
719 FcStrBufInit (&new->str
, 0, 0);
725 FcPStackPop (FcConfigParse
*parse
)
731 FcConfigMessage (parse
, FcSevereError
, "mismatching element");
734 FcVStackClear (parse
);
736 parse
->pstack
= old
->prev
;
737 FcStrBufDestroy (&old
->str
);
745 FcConfigInit (FcConfigParse
*parse
, const FcChar8
*name
, FcConfig
*config
, XML_Parser parser
)
749 parse
->error
= FcFalse
;
751 parse
->config
= config
;
752 parse
->parser
= parser
;
757 FcConfigCleanup (FcConfigParse
*parse
)
759 while (parse
->pstack
)
763 static const FcChar8
*
764 FcConfigGetAttribute (FcConfigParse
*parse
, char *attr
)
770 attrs
= parse
->pstack
->attr
;
773 if (!strcmp ((char *) *attrs
, attr
))
781 FcStartElement(void *userData
, const XML_Char
*name
, const XML_Char
**attr
)
783 FcConfigParse
*parse
= userData
;
786 element
= FcElementMap (name
);
787 if (element
== FcElementUnknown
)
788 FcConfigMessage (parse
, FcSevereWarning
, "unknown element \"%s\"", name
);
790 if (!FcPStackPush (parse
, element
, attr
))
792 FcConfigMessage (parse
, FcSevereError
, "out of memory");
799 FcParseBlank (FcConfigParse
*parse
)
801 int n
= FcVStackElements (parse
);
804 FcVStack
*v
= FcVStackFetch (parse
, n
);
805 if (v
->tag
!= FcVStackInteger
)
806 FcConfigMessage (parse
, FcSevereError
, "non-integer blank");
809 if (!parse
->config
->blanks
)
811 parse
->config
->blanks
= FcBlanksCreate ();
812 if (!parse
->config
->blanks
)
814 FcConfigMessage (parse
, FcSevereError
, "out of memory");
818 if (!FcBlanksAdd (parse
->config
->blanks
, v
->u
.integer
))
820 FcConfigMessage (parse
, FcSevereError
, "out of memory");
828 FcParseRescan (FcConfigParse
*parse
)
830 int n
= FcVStackElements (parse
);
833 FcVStack
*v
= FcVStackFetch (parse
, n
);
834 if (v
->tag
!= FcVStackInteger
)
835 FcConfigMessage (parse
, FcSevereWarning
, "non-integer rescan");
837 parse
->config
->rescanInterval
= v
->u
.integer
;
842 FcParseInt (FcConfigParse
*parse
)
849 s
= FcStrBufDone (&parse
->pstack
->str
);
852 FcConfigMessage (parse
, FcSevereError
, "out of memory");
856 l
= (int) strtol ((char *) s
, (char **)&end
, 0);
857 if (end
!= s
+ strlen ((char *) s
))
858 FcConfigMessage (parse
, FcSevereError
, "\"%s\": not a valid integer", s
);
860 FcVStackPushInteger (parse
, l
);
865 FcParseDouble (FcConfigParse
*parse
)
872 s
= FcStrBufDone (&parse
->pstack
->str
);
875 FcConfigMessage (parse
, FcSevereError
, "out of memory");
879 d
= strtod ((char *) s
, (char **)&end
);
880 if (end
!= s
+ strlen ((char *) s
))
881 FcConfigMessage (parse
, FcSevereError
, "\"%s\": not a valid double", s
);
883 FcVStackPushDouble (parse
, d
);
888 FcParseString (FcConfigParse
*parse
, FcVStackTag tag
)
894 s
= FcStrBufDone (&parse
->pstack
->str
);
897 FcConfigMessage (parse
, FcSevereError
, "out of memory");
900 if (!FcVStackPushString (parse
, tag
, s
))
905 FcParseMatrix (FcConfigParse
*parse
)
908 enum { m_done
, m_xx
, m_xy
, m_yx
, m_yy
} matrix_state
= m_yy
;
911 while ((vstack
= FcVStackPop (parse
)))
914 switch (vstack
->tag
) {
915 case FcVStackInteger
:
916 v
= vstack
->u
.integer
;
919 v
= vstack
->u
._double
;
922 FcConfigMessage (parse
, FcSevereError
, "non-double matrix element");
926 switch (matrix_state
) {
927 case m_xx
: m
.xx
= v
; break;
928 case m_xy
: m
.xy
= v
; break;
929 case m_yx
: m
.yx
= v
; break;
930 case m_yy
: m
.yy
= v
; break;
935 if (matrix_state
!= m_done
)
936 FcConfigMessage (parse
, FcSevereError
, "wrong number of matrix elements");
938 FcVStackPushMatrix (parse
, &m
);
942 FcConfigLexBool (const FcChar8
*bool)
944 if (*bool == 't' || *bool == 'T')
946 if (*bool == 'y' || *bool == 'Y')
954 FcParseBool (FcConfigParse
*parse
)
960 s
= FcStrBufDone (&parse
->pstack
->str
);
963 FcConfigMessage (parse
, FcSevereError
, "out of memory");
966 FcVStackPushBool (parse
, FcConfigLexBool (s
));
971 FcParseFamilies (FcConfigParse
*parse
, FcVStackTag tag
)
974 FcExpr
*left
, *expr
= 0, *new;
976 while ((vstack
= FcVStackPop (parse
)))
978 if (vstack
->tag
!= FcVStackFamily
)
980 FcConfigMessage (parse
, FcSevereWarning
, "non-family");
981 FcVStackDestroy (vstack
);
984 left
= vstack
->u
.expr
;
985 vstack
->tag
= FcVStackNone
;
986 FcVStackDestroy (vstack
);
989 new = FcExprCreateOp (left
, FcOpComma
, expr
);
992 FcConfigMessage (parse
, FcSevereError
, "out of memory");
993 FcExprDestroy (left
);
994 FcExprDestroy (expr
);
1004 if (!FcVStackPushExpr (parse
, tag
, expr
))
1006 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1008 FcExprDestroy (expr
);
1014 FcParseFamily (FcConfigParse
*parse
)
1021 s
= FcStrBufDone (&parse
->pstack
->str
);
1024 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1027 expr
= FcExprCreateString (s
);
1030 FcVStackPushExpr (parse
, FcVStackFamily
, expr
);
1034 FcParseAlias (FcConfigParse
*parse
)
1036 FcExpr
*family
= 0, *accept
= 0, *prefer
= 0, *def
= 0, *new = 0;
1037 FcEdit
*edit
= 0, *next
;
1041 while ((vstack
= FcVStackPop (parse
)))
1043 switch (vstack
->tag
) {
1044 case FcVStackFamily
:
1047 new = FcExprCreateOp (vstack
->u
.expr
, FcOpComma
, family
);
1049 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1054 new = vstack
->u
.expr
;
1058 vstack
->tag
= FcVStackNone
;
1061 case FcVStackPrefer
:
1063 FcExprDestroy (prefer
);
1064 prefer
= vstack
->u
.expr
;
1065 vstack
->tag
= FcVStackNone
;
1067 case FcVStackAccept
:
1069 FcExprDestroy (accept
);
1070 accept
= vstack
->u
.expr
;
1071 vstack
->tag
= FcVStackNone
;
1073 case FcVStackDefault
:
1075 FcExprDestroy (def
);
1076 def
= vstack
->u
.expr
;
1077 vstack
->tag
= FcVStackNone
;
1080 FcConfigMessage (parse
, FcSevereWarning
, "bad alias");
1083 FcVStackDestroy (vstack
);
1087 FcConfigMessage (parse
, FcSevereError
, "missing family in alias");
1089 FcExprDestroy (prefer
);
1091 FcExprDestroy (accept
);
1093 FcExprDestroy (def
);
1098 edit
= FcEditCreate (FcConfigSaveField ("family"),
1104 FcExprDestroy (prefer
);
1109 edit
= FcEditCreate (FcConfigSaveField ("family"),
1115 FcExprDestroy (accept
);
1120 edit
= FcEditCreate (FcConfigSaveField ("family"),
1126 FcExprDestroy (def
);
1130 test
= FcTestCreate (FcQualAny
,
1131 FcStrCopy ((FcChar8
*) "family"),
1135 if (!FcConfigAddEdit (parse
->config
, test
, edit
, FcMatchPattern
))
1136 FcTestDestroy (test
);
1139 FcExprDestroy (family
);
1143 FcPopExpr (FcConfigParse
*parse
)
1145 FcVStack
*vstack
= FcVStackPop (parse
);
1149 switch (vstack
->tag
) {
1152 case FcVStackString
:
1153 case FcVStackFamily
:
1154 expr
= FcExprCreateString (vstack
->u
.string
);
1157 expr
= FcExprCreateField ((char *) vstack
->u
.string
);
1159 case FcVStackConstant
:
1160 expr
= FcExprCreateConst (vstack
->u
.string
);
1162 case FcVStackPrefer
:
1163 case FcVStackAccept
:
1164 case FcVStackDefault
:
1165 expr
= vstack
->u
.expr
;
1166 vstack
->tag
= FcVStackNone
;
1168 case FcVStackInteger
:
1169 expr
= FcExprCreateInteger (vstack
->u
.integer
);
1171 case FcVStackDouble
:
1172 expr
= FcExprCreateDouble (vstack
->u
._double
);
1174 case FcVStackMatrix
:
1175 expr
= FcExprCreateMatrix (vstack
->u
.matrix
);
1178 expr
= FcExprCreateBool (vstack
->u
.bool);
1183 expr
= vstack
->u
.expr
;
1188 FcVStackDestroy (vstack
);
1193 FcPopExprs (FcConfigParse
*parse
, FcOp op
)
1195 FcExpr
*left
, *expr
= 0, *new;
1197 while ((left
= FcPopExpr (parse
)))
1201 new = FcExprCreateOp (left
, op
, expr
);
1204 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1205 FcExprDestroy (left
);
1206 FcExprDestroy (expr
);
1218 FcParseExpr (FcConfigParse
*parse
, FcOp op
)
1220 FcExpr
*expr
= FcPopExprs (parse
, op
);
1222 FcVStackPushExpr (parse
, FcVStackExpr
, expr
);
1226 FcParseInclude (FcConfigParse
*parse
)
1230 FcBool ignore_missing
= FcFalse
;
1232 s
= FcStrBufDone (&parse
->pstack
->str
);
1235 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1238 i
= FcConfigGetAttribute (parse
, "ignore_missing");
1239 if (i
&& FcConfigLexBool ((FcChar8
*) i
) == FcTrue
)
1240 ignore_missing
= FcTrue
;
1241 if (!FcConfigParseAndLoad (parse
->config
, s
, !ignore_missing
))
1242 parse
->error
= FcTrue
;
1246 typedef struct _FcOpMap
{
1252 FcConfigLexOp (const FcChar8
*op
, const FcOpMap
*map
, int nmap
)
1256 for (i
= 0; i
< nmap
; i
++)
1257 if (!strcmp ((char *) op
, map
[i
].name
))
1262 static const FcOpMap fcCompareOps
[] = {
1263 { "eq", FcOpEqual
},
1264 { "not_eq", FcOpNotEqual
},
1265 { "less", FcOpLess
},
1266 { "less_eq", FcOpLessEqual
},
1267 { "more", FcOpMore
},
1268 { "more_eq", FcOpMoreEqual
}
1271 #define NUM_COMPARE_OPS (sizeof fcCompareOps / sizeof fcCompareOps[0])
1274 FcConfigLexCompare (const FcChar8
*compare
)
1276 return FcConfigLexOp (compare
, fcCompareOps
, NUM_COMPARE_OPS
);
1281 FcParseTest (FcConfigParse
*parse
)
1283 const FcChar8
*qual_string
;
1285 const FcChar8
*name
;
1286 const FcChar8
*compare_string
;
1291 qual_string
= FcConfigGetAttribute (parse
, "qual");
1296 if (!strcmp ((char *) qual_string
, "any"))
1298 else if (!strcmp ((char *) qual_string
, "all"))
1302 FcConfigMessage (parse
, FcSevereWarning
, "invalid test qual \"%s\"", qual_string
);
1306 name
= FcConfigGetAttribute (parse
, "name");
1309 FcConfigMessage (parse
, FcSevereWarning
, "missing test name");
1310 name
= (FcChar8
*) FC_FAMILY
;
1312 compare_string
= FcConfigGetAttribute (parse
, "compare");
1313 if (!compare_string
)
1314 compare
= FcOpEqual
;
1317 compare
= FcConfigLexCompare (compare_string
);
1318 if (compare
== FcOpInvalid
)
1320 FcConfigMessage (parse
, FcSevereWarning
, "invalid test compare \"%s\"", compare_string
);
1321 compare
= FcOpEqual
;
1324 expr
= FcPopExprs (parse
, FcOpComma
);
1327 FcConfigMessage (parse
, FcSevereWarning
, "missing test expression");
1330 test
= FcTestCreate (qual
, name
, compare
, expr
);
1333 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1336 FcVStackPushTest (parse
, test
);
1339 static const FcOpMap fcModeOps
[] = {
1340 { "assign", FcOpAssign
},
1341 { "assign_replace", FcOpAssignReplace
},
1342 { "prepend", FcOpPrepend
},
1343 { "prepend_first", FcOpPrependFirst
},
1344 { "append", FcOpAppend
},
1345 { "append_last", FcOpAppendLast
},
1348 #define NUM_MODE_OPS (sizeof fcModeOps / sizeof fcModeOps[0])
1351 FcConfigLexMode (const FcChar8
*mode
)
1353 return FcConfigLexOp (mode
, fcModeOps
, NUM_MODE_OPS
);
1357 FcParseEdit (FcConfigParse
*parse
)
1359 const FcChar8
*name
;
1360 const FcChar8
*mode_string
;
1365 name
= FcConfigGetAttribute (parse
, "name");
1368 FcConfigMessage (parse
, FcSevereWarning
, "missing edit name");
1369 name
= (FcChar8
*) FC_FAMILY
;
1371 mode_string
= FcConfigGetAttribute (parse
, "mode");
1376 mode
= FcConfigLexMode (mode_string
);
1377 if (mode
== FcOpInvalid
)
1379 FcConfigMessage (parse
, FcSevereWarning
, "invalid edit mode \"%s\"", mode_string
);
1383 expr
= FcPopExprs (parse
, FcOpComma
);
1384 edit
= FcEditCreate ((char *) FcStrCopy (name
), mode
, expr
);
1387 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1388 FcExprDestroy (expr
);
1391 if (!FcVStackPushEdit (parse
, edit
))
1392 FcEditDestroy (edit
);
1396 FcParseMatch (FcConfigParse
*parse
)
1398 const FcChar8
*kind_name
;
1404 kind_name
= FcConfigGetAttribute (parse
, "target");
1406 kind
= FcMatchPattern
;
1409 if (!strcmp ((char *) kind_name
, "pattern"))
1410 kind
= FcMatchPattern
;
1411 else if (!strcmp ((char *) kind_name
, "font"))
1415 FcConfigMessage (parse
, FcSevereWarning
, "invalid match target \"%s\"", kind_name
);
1416 kind
= FcMatchPattern
;
1419 while ((vstack
= FcVStackPop (parse
)))
1421 switch (vstack
->tag
) {
1423 vstack
->u
.test
->next
= test
;
1424 test
= vstack
->u
.test
;
1425 vstack
->tag
= FcVStackNone
;
1428 vstack
->u
.edit
->next
= edit
;
1429 edit
= vstack
->u
.edit
;
1430 vstack
->tag
= FcVStackNone
;
1433 FcConfigMessage (parse
, FcSevereWarning
, "invalid match element");
1436 FcVStackDestroy (vstack
);
1438 if (!FcConfigAddEdit (parse
->config
, test
, edit
, kind
))
1439 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1443 FcEndElement(void *userData
, const XML_Char
*name
)
1445 FcConfigParse
*parse
= userData
;
1450 switch (parse
->pstack
->element
) {
1453 case FcElementFontconfig
:
1456 data
= FcStrBufDone (&parse
->pstack
->str
);
1459 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1462 if (!FcConfigAddDir (parse
->config
, data
))
1463 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1466 case FcElementCache
:
1467 data
= FcStrBufDone (&parse
->pstack
->str
);
1470 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1473 if (!FcConfigSetCache (parse
->config
, data
))
1474 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1477 case FcElementInclude
:
1478 FcParseInclude (parse
);
1480 case FcElementConfig
:
1482 case FcElementMatch
:
1483 FcParseMatch (parse
);
1485 case FcElementAlias
:
1486 FcParseAlias (parse
);
1489 case FcElementBlank
:
1490 FcParseBlank (parse
);
1492 case FcElementRescan
:
1493 FcParseRescan (parse
);
1496 case FcElementPrefer
:
1497 FcParseFamilies (parse
, FcVStackPrefer
);
1499 case FcElementAccept
:
1500 FcParseFamilies (parse
, FcVStackAccept
);
1502 case FcElementDefault
:
1503 FcParseFamilies (parse
, FcVStackDefault
);
1505 case FcElementFamily
:
1506 FcParseFamily (parse
);
1510 FcParseTest (parse
);
1513 FcParseEdit (parse
);
1519 case FcElementDouble
:
1520 FcParseDouble (parse
);
1522 case FcElementString
:
1523 FcParseString (parse
, FcVStackString
);
1525 case FcElementMatrix
:
1526 FcParseMatrix (parse
);
1529 FcParseBool (parse
);
1531 case FcElementCharset
:
1532 /* FcParseCharset (parse); */
1536 FcParseString (parse
, FcVStackField
);
1538 case FcElementConst
:
1539 FcParseString (parse
, FcVStackConstant
);
1542 FcParseExpr (parse
, FcOpOr
);
1545 FcParseExpr (parse
, FcOpAnd
);
1548 FcParseExpr (parse
, FcOpEqual
);
1550 case FcElementNotEq
:
1551 FcParseExpr (parse
, FcOpNotEqual
);
1554 FcParseExpr (parse
, FcOpLess
);
1556 case FcElementLessEq
:
1557 FcParseExpr (parse
, FcOpLessEqual
);
1560 FcParseExpr (parse
, FcOpMore
);
1562 case FcElementMoreEq
:
1563 FcParseExpr (parse
, FcOpMoreEqual
);
1566 FcParseExpr (parse
, FcOpPlus
);
1568 case FcElementMinus
:
1569 FcParseExpr (parse
, FcOpMinus
);
1571 case FcElementTimes
:
1572 FcParseExpr (parse
, FcOpTimes
);
1574 case FcElementDivide
:
1575 FcParseExpr (parse
, FcOpDivide
);
1578 FcParseExpr (parse
, FcOpNot
);
1581 FcParseExpr (parse
, FcOpQuest
);
1583 case FcElementUnknown
:
1586 (void) FcPStackPop (parse
);
1590 FcCharacterData (void *userData
, const XML_Char
*s
, int len
)
1592 FcConfigParse
*parse
= userData
;
1596 if (!FcStrBufData (&parse
->pstack
->str
, (FcChar8
*) s
, len
))
1597 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1601 FcStartDoctypeDecl (void *userData
,
1602 const XML_Char
*doctypeName
,
1603 const XML_Char
*sysid
,
1604 const XML_Char
*pubid
,
1605 int has_internal_subset
)
1607 FcConfigParse
*parse
= userData
;
1609 if (strcmp ((char *) doctypeName
, "fontconfig") != 0)
1610 FcConfigMessage (parse
, FcSevereError
, "invalid doctype \"%s\"", doctypeName
);
1614 FcEndDoctypeDecl (void *userData
)
1619 FcConfigParseAndLoad (FcConfig
*config
,
1620 const FcChar8
*name
,
1629 FcConfigParse parse
;
1630 FcBool error
= FcTrue
;
1632 filename
= FcConfigFilename (name
);
1635 f
= fopen ((char *) filename
, "r");
1640 p
= XML_ParserCreate ("UTF-8");
1644 if (!FcConfigInit (&parse
, name
, config
, p
))
1647 XML_SetUserData (p
, &parse
);
1649 XML_SetDoctypeDeclHandler (p
, FcStartDoctypeDecl
, FcEndDoctypeDecl
);
1650 XML_SetElementHandler (p
, FcStartElement
, FcEndElement
);
1651 XML_SetCharacterDataHandler (p
, FcCharacterData
);
1654 buf
= XML_GetBuffer (p
, BUFSIZ
);
1657 FcConfigMessage (&parse
, FcSevereError
, "cannot get parse buffer");
1660 len
= fread (buf
, 1, BUFSIZ
, f
);
1663 FcConfigMessage (&parse
, FcSevereError
, "failed reading config file");
1666 if (!XML_ParseBuffer (p
, len
, len
== 0))
1668 FcConfigMessage (&parse
, FcSevereError
, "%s",
1669 XML_ErrorString (XML_GetErrorCode (p
)));
1673 error
= parse
.error
;
1675 FcConfigCleanup (&parse
);
1681 if (error
&& complain
)
1684 FcConfigMessage (0, FcSevereError
, "Cannot load config file \"%s\"", name
);
1686 FcConfigMessage (0, FcSevereError
, "Cannot load default config file");