]>
git.wh0rd.org - fontconfig.git/blob - src/fcxml.c
32b8be12cf009b3f05a14f9556a01dcd1b065fec
2 * fontconfig/src/fcxml.c
4 * Copyright © 2002 Keith Packard
6 * Permission to use, copy, modify, distribute, and sell this software and its
7 * documentation for any purpose is hereby granted without fee, provided that
8 * the above copyright notice appear in all copies and that both that
9 * copyright notice and this permission notice appear in supporting
10 * documentation, and that the name of Keith Packard not be used in
11 * advertising or publicity pertaining to distribution of the software without
12 * specific, written prior permission. Keith Packard makes no
13 * representations about the suitability of this software for any purpose. It
14 * is provided "as is" without express or implied warranty.
16 * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
17 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
18 * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR
19 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
20 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
21 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
22 * PERFORMANCE OF THIS SOFTWARE.
32 #include <libxml/parser.h>
34 #define XML_Char xmlChar
35 #define XML_Parser xmlParserCtxtPtr
36 #define XML_ParserFree xmlFreeParserCtxt
37 #define XML_GetCurrentLineNumber xmlSAX2GetLineNumber
38 #define XML_GetErrorCode xmlCtxtGetLastError
39 #define XML_ErrorString(Error) (Error)->message
41 #else /* ENABLE_LIBXML2 */
43 #ifndef HAVE_XMLPARSE_H
44 #define HAVE_XMLPARSE_H 0
53 #endif /* ENABLE_LIBXML2 */
62 FcExprDestroy (FcExpr
*e
);
65 FcTestDestroy (FcTest
*test
)
68 FcTestDestroy (test
->next
);
69 FcExprDestroy (test
->expr
);
70 FcMemFree (FC_MEM_TEST
, sizeof (FcTest
));
77 FcExpr
*e
= (FcExpr
*) malloc (sizeof (FcExpr
));
80 FcMemAlloc (FC_MEM_EXPR
, sizeof (FcExpr
));
86 FcExprCreateInteger (int i
)
88 FcExpr
*e
= FcExprAlloc ();
98 FcExprCreateDouble (double d
)
100 FcExpr
*e
= FcExprAlloc ();
110 FcExprCreateString (const FcChar8
*s
)
112 FcExpr
*e
= FcExprAlloc ();
116 e
->u
.sval
= FcStrCopy (s
);
122 FcExprCreateMatrix (const FcMatrix
*m
)
124 FcExpr
*e
= FcExprAlloc ();
128 e
->u
.mval
= FcMatrixCopy (m
);
134 FcExprCreateBool (FcBool b
)
136 FcExpr
*e
= FcExprAlloc ();
146 FcExprCreateNil (void)
148 FcExpr
*e
= FcExprAlloc ();
151 FcMemAlloc (FC_MEM_EXPR
, sizeof (FcExpr
));
158 FcExprCreateField (const char *field
)
160 FcExpr
*e
= FcExprAlloc ();
164 e
->u
.object
= FcObjectFromName (field
);
170 FcExprCreateConst (const FcChar8
*constant
)
172 FcExpr
*e
= FcExprAlloc ();
176 e
->u
.constant
= FcStrCopy (constant
);
182 FcExprCreateOp (FcExpr
*left
, FcOp op
, FcExpr
*right
)
184 FcExpr
*e
= FcExprAlloc ();
188 e
->u
.tree
.left
= left
;
189 e
->u
.tree
.right
= right
;
195 FcExprDestroy (FcExpr
*e
)
205 FcStrFree (e
->u
.sval
);
208 FcMatrixFree (e
->u
.mval
);
211 FcCharSetDestroy (e
->u
.cval
);
218 FcStrFree (e
->u
.constant
);
221 case FcOpAssignReplace
:
223 case FcOpPrependFirst
:
237 case FcOpNotContains
:
244 FcExprDestroy (e
->u
.tree
.right
);
251 FcExprDestroy (e
->u
.tree
.left
);
257 FcMemFree (FC_MEM_EXPR
, sizeof (FcExpr
));
262 FcEditDestroy (FcEdit
*e
)
265 FcEditDestroy (e
->next
);
267 FcExprDestroy (e
->expr
);
271 typedef enum _FcElement
{
316 FcElementNotContains
,
330 static const struct {
334 { "fontconfig", FcElementFontconfig
},
335 { "dir", FcElementDir
},
336 { "cachedir", FcElementCacheDir
},
337 { "cache", FcElementCache
},
338 { "include", FcElementInclude
},
339 { "config", FcElementConfig
},
340 { "match", FcElementMatch
},
341 { "alias", FcElementAlias
},
343 { "blank", FcElementBlank
},
344 { "rescan", FcElementRescan
},
346 { "prefer", FcElementPrefer
},
347 { "accept", FcElementAccept
},
348 { "default", FcElementDefault
},
349 { "family", FcElementFamily
},
351 { "selectfont", FcElementSelectfont
},
352 { "acceptfont", FcElementAcceptfont
},
353 { "rejectfont", FcElementRejectfont
},
354 { "glob", FcElementGlob
},
355 { "pattern", FcElementPattern
},
356 { "patelt", FcElementPatelt
},
358 { "test", FcElementTest
},
359 { "edit", FcElementEdit
},
360 { "int", FcElementInt
},
361 { "double", FcElementDouble
},
362 { "string", FcElementString
},
363 { "matrix", FcElementMatrix
},
364 { "bool", FcElementBool
},
365 { "charset", FcElementCharset
},
366 { "name", FcElementName
},
367 { "const", FcElementConst
},
368 { "or", FcElementOr
},
369 { "and", FcElementAnd
},
370 { "eq", FcElementEq
},
371 { "not_eq", FcElementNotEq
},
372 { "less", FcElementLess
},
373 { "less_eq", FcElementLessEq
},
374 { "more", FcElementMore
},
375 { "more_eq", FcElementMoreEq
},
376 { "contains", FcElementContains
},
377 { "not_contains", FcElementNotContains
},
378 { "plus", FcElementPlus
},
379 { "minus", FcElementMinus
},
380 { "times", FcElementTimes
},
381 { "divide", FcElementDivide
},
382 { "not", FcElementNot
},
383 { "if", FcElementIf
},
384 { "floor", FcElementFloor
},
385 { "ceil", FcElementCeil
},
386 { "round", FcElementRound
},
387 { "trunc", FcElementTrunc
},
389 #define NUM_ELEMENT_MAPS (int) (sizeof fcElementMap / sizeof fcElementMap[0])
392 FcElementMap (const XML_Char
*name
)
396 for (i
= 0; i
< NUM_ELEMENT_MAPS
; i
++)
397 if (!strcmp ((char *) name
, fcElementMap
[i
].name
))
398 return fcElementMap
[i
].element
;
399 return FcElementUnknown
;
402 typedef struct _FcPStack
{
403 struct _FcPStack
*prev
;
407 FcChar8
*attr_buf_static
[16];
410 typedef enum _FcVStackTag
{
434 typedef struct _FcVStack
{
435 struct _FcVStack
*prev
;
436 FcPStack
*pstack
; /* related parse element */
456 typedef struct _FcConfigParse
{
463 int pstack_static_used
;
464 FcPStack pstack_static
[8];
465 int vstack_static_used
;
466 FcVStack vstack_static
[64];
469 typedef enum _FcConfigSeverity
{
470 FcSevereInfo
, FcSevereWarning
, FcSevereError
474 FcConfigMessage (FcConfigParse
*parse
, FcConfigSeverity severe
, const char *fmt
, ...)
476 const char *s
= "unknown";
479 va_start (args
, fmt
);
482 case FcSevereInfo
: s
= "info"; break;
483 case FcSevereWarning
: s
= "warning"; break;
484 case FcSevereError
: s
= "error"; break;
489 fprintf (stderr
, "Fontconfig %s: \"%s\", line %d: ", s
,
490 parse
->name
, (int)XML_GetCurrentLineNumber (parse
->parser
));
492 fprintf (stderr
, "Fontconfig %s: line %d: ", s
,
493 (int)XML_GetCurrentLineNumber (parse
->parser
));
494 if (severe
>= FcSevereError
)
495 parse
->error
= FcTrue
;
498 fprintf (stderr
, "Fontconfig %s: ", s
);
499 vfprintf (stderr
, fmt
, args
);
500 fprintf (stderr
, "\n");
506 FcTypeName (FcType type
)
532 FcTypecheckValue (FcConfigParse
*parse
, FcType value
, FcType type
)
534 if (value
== FcTypeInteger
)
535 value
= FcTypeDouble
;
536 if (type
== FcTypeInteger
)
540 if ((value
== FcTypeLangSet
&& type
== FcTypeString
) ||
541 (value
== FcTypeString
&& type
== FcTypeLangSet
))
543 if (type
== (FcType
) -1)
545 FcConfigMessage (parse
, FcSevereWarning
, "saw %s, expected %s",
546 FcTypeName (value
), FcTypeName (type
));
551 FcTypecheckExpr (FcConfigParse
*parse
, FcExpr
*expr
, FcType type
)
553 const FcObjectType
*o
;
556 /* If parsing the expression failed, some nodes may be NULL */
563 FcTypecheckValue (parse
, FcTypeDouble
, type
);
566 FcTypecheckValue (parse
, FcTypeString
, type
);
569 FcTypecheckValue (parse
, FcTypeMatrix
, type
);
572 FcTypecheckValue (parse
, FcTypeBool
, type
);
575 FcTypecheckValue (parse
, FcTypeCharSet
, type
);
580 o
= FcNameGetObjectType (FcObjectName (expr
->u
.object
));
582 FcTypecheckValue (parse
, o
->type
, type
);
585 c
= FcNameGetConstant (expr
->u
.constant
);
588 o
= FcNameGetObjectType (c
->object
);
590 FcTypecheckValue (parse
, o
->type
, type
);
593 FcConfigMessage (parse
, FcSevereWarning
,
594 "invalid constant used : %s",
598 FcTypecheckExpr (parse
, expr
->u
.tree
.left
, FcTypeBool
);
599 FcTypecheckExpr (parse
, expr
->u
.tree
.right
->u
.tree
.left
, type
);
600 FcTypecheckExpr (parse
, expr
->u
.tree
.right
->u
.tree
.right
, type
);
603 case FcOpAssignReplace
:
612 case FcOpNotContains
:
614 FcTypecheckValue (parse
, FcTypeBool
, type
);
623 FcTypecheckExpr (parse
, expr
->u
.tree
.left
, type
);
624 FcTypecheckExpr (parse
, expr
->u
.tree
.right
, type
);
627 FcTypecheckValue (parse
, FcTypeBool
, type
);
628 FcTypecheckExpr (parse
, expr
->u
.tree
.left
, FcTypeBool
);
634 FcTypecheckValue (parse
, FcTypeDouble
, type
);
635 FcTypecheckExpr (parse
, expr
->u
.tree
.left
, FcTypeDouble
);
643 FcTestCreate (FcConfigParse
*parse
,
646 const FcChar8
*field
,
650 FcTest
*test
= (FcTest
*) malloc (sizeof (FcTest
));
654 const FcObjectType
*o
;
656 FcMemAlloc (FC_MEM_TEST
, sizeof (FcTest
));
660 test
->object
= FcObjectFromName ((const char *) field
);
663 o
= FcNameGetObjectType (FcObjectName (test
->object
));
665 FcTypecheckExpr (parse
, expr
, o
->type
);
671 FcEditCreate (FcConfigParse
*parse
,
675 FcValueBinding binding
)
677 FcEdit
*e
= (FcEdit
*) malloc (sizeof (FcEdit
));
681 const FcObjectType
*o
;
687 e
->binding
= binding
;
688 o
= FcNameGetObjectType (FcObjectName (e
->object
));
690 FcTypecheckExpr (parse
, expr
, o
->type
);
696 FcVStackCreateAndPush (FcConfigParse
*parse
)
700 if (parse
->vstack_static_used
< sizeof (parse
->vstack_static
) / sizeof (parse
->vstack_static
[0]))
701 new = &parse
->vstack_static
[parse
->vstack_static_used
++];
704 new = malloc (sizeof (FcVStack
));
707 FcMemAlloc (FC_MEM_VSTACK
, sizeof (FcVStack
));
709 new->tag
= FcVStackNone
;
712 new->prev
= parse
->vstack
;
713 new->pstack
= parse
->pstack
? parse
->pstack
->prev
: 0;
720 FcVStackPushString (FcConfigParse
*parse
, FcVStackTag tag
, FcChar8
*string
)
722 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
725 vstack
->u
.string
= string
;
731 FcVStackPushInteger (FcConfigParse
*parse
, int integer
)
733 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
736 vstack
->u
.integer
= integer
;
737 vstack
->tag
= FcVStackInteger
;
742 FcVStackPushDouble (FcConfigParse
*parse
, double _double
)
744 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
747 vstack
->u
._double
= _double
;
748 vstack
->tag
= FcVStackDouble
;
753 FcVStackPushMatrix (FcConfigParse
*parse
, FcMatrix
*matrix
)
756 matrix
= FcMatrixCopy (matrix
);
759 vstack
= FcVStackCreateAndPush (parse
);
762 vstack
->u
.matrix
= matrix
;
763 vstack
->tag
= FcVStackMatrix
;
768 FcVStackPushBool (FcConfigParse
*parse
, FcBool bool_
)
770 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
773 vstack
->u
.bool_
= bool_
;
774 vstack
->tag
= FcVStackBool
;
779 FcVStackPushTest (FcConfigParse
*parse
, FcTest
*test
)
781 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
784 vstack
->u
.test
= test
;
785 vstack
->tag
= FcVStackTest
;
790 FcVStackPushExpr (FcConfigParse
*parse
, FcVStackTag tag
, FcExpr
*expr
)
792 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
795 vstack
->u
.expr
= expr
;
801 FcVStackPushEdit (FcConfigParse
*parse
, FcEdit
*edit
)
803 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
806 vstack
->u
.edit
= edit
;
807 vstack
->tag
= FcVStackEdit
;
812 FcVStackPushPattern (FcConfigParse
*parse
, FcPattern
*pattern
)
814 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
817 vstack
->u
.pattern
= pattern
;
818 vstack
->tag
= FcVStackPattern
;
823 FcVStackFetch (FcConfigParse
*parse
, int off
)
827 for (vstack
= parse
->vstack
; vstack
&& off
-- > 0; vstack
= vstack
->prev
);
832 FcVStackPeek (FcConfigParse
*parse
)
834 FcVStack
*vstack
= parse
->vstack
;
836 return vstack
&& vstack
->pstack
== parse
->pstack
? vstack
: 0;
840 FcVStackPopAndDestroy (FcConfigParse
*parse
)
842 FcVStack
*vstack
= parse
->vstack
;
844 if (!vstack
|| vstack
->pstack
!= parse
->pstack
)
847 parse
->vstack
= vstack
->prev
;
849 switch (vstack
->tag
) {
855 case FcVStackConstant
:
857 FcStrFree (vstack
->u
.string
);
859 case FcVStackPattern
:
860 FcPatternDestroy (vstack
->u
.pattern
);
862 case FcVStackInteger
:
866 FcMatrixFree (vstack
->u
.matrix
);
871 FcTestDestroy (vstack
->u
.test
);
876 case FcVStackDefault
:
877 FcExprDestroy (vstack
->u
.expr
);
880 FcEditDestroy (vstack
->u
.edit
);
884 if (vstack
== &parse
->vstack_static
[parse
->vstack_static_used
- 1])
885 parse
->vstack_static_used
--;
888 FcMemFree (FC_MEM_VSTACK
, sizeof (FcVStack
));
894 FcVStackClear (FcConfigParse
*parse
)
896 while (FcVStackPeek (parse
))
897 FcVStackPopAndDestroy (parse
);
901 FcVStackElements (FcConfigParse
*parse
)
904 FcVStack
*vstack
= parse
->vstack
;
905 while (vstack
&& vstack
->pstack
== parse
->pstack
)
908 vstack
= vstack
->prev
;
914 FcConfigSaveAttr (const XML_Char
**attr
, FcChar8
**buf
, int size_bytes
)
924 for (i
= 0; attr
[i
]; i
++)
925 slen
+= strlen ((char *) attr
[i
]) + 1;
928 slen
+= (i
+ 1) * sizeof (FcChar8
*);
929 if (slen
<= size_bytes
)
936 FcConfigMessage (0, FcSevereError
, "out of memory");
939 FcMemAlloc (FC_MEM_ATTR
, 1); /* size is too expensive */
941 s
= (FcChar8
*) (new + (i
+ 1));
942 for (i
= 0; attr
[i
]; i
++)
945 strcpy ((char *) s
, (char *) attr
[i
]);
946 s
+= strlen ((char *) s
) + 1;
953 FcPStackPush (FcConfigParse
*parse
, FcElement element
, const XML_Char
**attr
)
957 if (parse
->pstack_static_used
< sizeof (parse
->pstack_static
) / sizeof (parse
->pstack_static
[0]))
958 new = &parse
->pstack_static
[parse
->pstack_static_used
++];
961 new = malloc (sizeof (FcPStack
));
964 FcMemAlloc (FC_MEM_PSTACK
, sizeof (FcPStack
));
967 new->prev
= parse
->pstack
;
968 new->element
= element
;
969 new->attr
= FcConfigSaveAttr (attr
, new->attr_buf_static
, sizeof (new->attr_buf_static
));
970 FcStrBufInit (&new->str
, 0, 0);
976 FcPStackPop (FcConfigParse
*parse
)
982 FcConfigMessage (parse
, FcSevereError
, "mismatching element");
985 FcVStackClear (parse
);
987 parse
->pstack
= old
->prev
;
988 FcStrBufDestroy (&old
->str
);
989 if (old
->attr
&& old
->attr
!= old
->attr_buf_static
)
991 FcMemFree (FC_MEM_ATTR
, 1); /* size is to expensive */
995 if (old
== &parse
->pstack_static
[parse
->pstack_static_used
- 1])
996 parse
->pstack_static_used
--;
999 FcMemFree (FC_MEM_PSTACK
, sizeof (FcPStack
));
1006 FcConfigInit (FcConfigParse
*parse
, const FcChar8
*name
, FcConfig
*config
, XML_Parser parser
)
1009 parse
->pstack_static_used
= 0;
1011 parse
->vstack_static_used
= 0;
1012 parse
->error
= FcFalse
;
1014 parse
->config
= config
;
1015 parse
->parser
= parser
;
1020 FcConfigCleanup (FcConfigParse
*parse
)
1022 while (parse
->pstack
)
1023 FcPStackPop (parse
);
1026 static const FcChar8
*
1027 FcConfigGetAttribute (FcConfigParse
*parse
, const char *attr
)
1033 attrs
= parse
->pstack
->attr
;
1039 if (!strcmp ((char *) *attrs
, attr
))
1047 FcStartElement(void *userData
, const XML_Char
*name
, const XML_Char
**attr
)
1049 FcConfigParse
*parse
= userData
;
1052 element
= FcElementMap (name
);
1053 if (element
== FcElementUnknown
)
1054 FcConfigMessage (parse
, FcSevereWarning
, "unknown element \"%s\"", name
);
1056 if (!FcPStackPush (parse
, element
, attr
))
1058 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1065 FcParseBlank (FcConfigParse
*parse
)
1067 int n
= FcVStackElements (parse
);
1070 FcVStack
*v
= FcVStackFetch (parse
, n
);
1071 if (v
->tag
!= FcVStackInteger
)
1072 FcConfigMessage (parse
, FcSevereError
, "non-integer blank");
1075 if (!parse
->config
->blanks
)
1077 parse
->config
->blanks
= FcBlanksCreate ();
1078 if (!parse
->config
->blanks
)
1080 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1084 if (!FcBlanksAdd (parse
->config
->blanks
, v
->u
.integer
))
1086 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1094 FcParseRescan (FcConfigParse
*parse
)
1096 int n
= FcVStackElements (parse
);
1099 FcVStack
*v
= FcVStackFetch (parse
, n
);
1100 if (v
->tag
!= FcVStackInteger
)
1101 FcConfigMessage (parse
, FcSevereWarning
, "non-integer rescan");
1103 parse
->config
->rescanInterval
= v
->u
.integer
;
1108 FcParseInt (FcConfigParse
*parse
)
1115 s
= FcStrBufDoneStatic (&parse
->pstack
->str
);
1118 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1122 l
= (int) strtol ((char *) s
, (char **)&end
, 0);
1123 if (end
!= s
+ strlen ((char *) s
))
1124 FcConfigMessage (parse
, FcSevereError
, "\"%s\": not a valid integer", s
);
1126 FcVStackPushInteger (parse
, l
);
1127 FcStrBufDestroy (&parse
->pstack
->str
);
1131 * idea copied from glib g_ascii_strtod with
1132 * permission of the author (Alexander Larsson)
1138 FcStrtod (char *s
, char **end
)
1140 struct lconv
*locale_data
;
1145 * Have to swap the decimal point to match the current locale
1146 * if that locale doesn't use 0x2e
1148 if ((dot
= strchr (s
, 0x2e)) &&
1149 (locale_data
= localeconv ()) &&
1150 (locale_data
->decimal_point
[0] != 0x2e ||
1151 locale_data
->decimal_point
[1] != 0))
1154 int slen
= strlen (s
);
1155 int dlen
= strlen (locale_data
->decimal_point
);
1157 if (slen
+ dlen
> (int) sizeof (buf
))
1167 strncpy (buf
, s
, dot
- s
);
1169 strcpy (buf
+ (dot
- s
), locale_data
->decimal_point
);
1170 /* rest of number */
1171 strcpy (buf
+ (dot
- s
) + dlen
, dot
+ 1);
1173 v
= strtod (buf
, &buf_end
);
1175 buf_end
= s
+ (buf_end
- buf
);
1177 buf_end
-= dlen
- 1;
1184 v
= strtod (s
, end
);
1189 FcParseDouble (FcConfigParse
*parse
)
1196 s
= FcStrBufDoneStatic (&parse
->pstack
->str
);
1199 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1203 d
= FcStrtod ((char *) s
, (char **)&end
);
1204 if (end
!= s
+ strlen ((char *) s
))
1205 FcConfigMessage (parse
, FcSevereError
, "\"%s\": not a valid double", s
);
1207 FcVStackPushDouble (parse
, d
);
1208 FcStrBufDestroy (&parse
->pstack
->str
);
1212 FcParseString (FcConfigParse
*parse
, FcVStackTag tag
)
1218 s
= FcStrBufDone (&parse
->pstack
->str
);
1221 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1224 if (!FcVStackPushString (parse
, tag
, s
))
1229 FcParseMatrix (FcConfigParse
*parse
)
1232 enum { m_done
, m_xx
, m_xy
, m_yx
, m_yy
} matrix_state
= m_yy
;
1235 while ((vstack
= FcVStackPeek (parse
)))
1238 switch (vstack
->tag
) {
1239 case FcVStackInteger
:
1240 v
= vstack
->u
.integer
;
1242 case FcVStackDouble
:
1243 v
= vstack
->u
._double
;
1246 FcConfigMessage (parse
, FcSevereError
, "non-double matrix element");
1250 switch (matrix_state
) {
1251 case m_xx
: m
.xx
= v
; break;
1252 case m_xy
: m
.xy
= v
; break;
1253 case m_yx
: m
.yx
= v
; break;
1254 case m_yy
: m
.yy
= v
; break;
1257 FcVStackPopAndDestroy (parse
);
1260 if (matrix_state
!= m_done
)
1261 FcConfigMessage (parse
, FcSevereError
, "wrong number of matrix elements");
1263 FcVStackPushMatrix (parse
, &m
);
1267 FcConfigLexBool (FcConfigParse
*parse
, const FcChar8
*bool_
)
1269 FcBool result
= FcFalse
;
1271 if (!FcNameBool (bool_
, &result
))
1272 FcConfigMessage (parse
, FcSevereWarning
, "\"%s\" is not known boolean",
1278 FcParseBool (FcConfigParse
*parse
)
1284 s
= FcStrBufDoneStatic (&parse
->pstack
->str
);
1287 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1290 FcVStackPushBool (parse
, FcConfigLexBool (parse
, s
));
1291 FcStrBufDestroy (&parse
->pstack
->str
);
1295 FcConfigLexBinding (FcConfigParse
*parse
,
1296 const FcChar8
*binding_string
,
1297 FcValueBinding
*binding_ret
)
1299 FcValueBinding binding
;
1301 if (!binding_string
)
1302 binding
= FcValueBindingWeak
;
1305 if (!strcmp ((char *) binding_string
, "weak"))
1306 binding
= FcValueBindingWeak
;
1307 else if (!strcmp ((char *) binding_string
, "strong"))
1308 binding
= FcValueBindingStrong
;
1309 else if (!strcmp ((char *) binding_string
, "same"))
1310 binding
= FcValueBindingSame
;
1313 FcConfigMessage (parse
, FcSevereWarning
, "invalid binding \"%s\"", binding_string
);
1317 *binding_ret
= binding
;
1322 FcParseFamilies (FcConfigParse
*parse
, FcVStackTag tag
)
1325 FcExpr
*left
, *expr
= 0, *new;
1327 while ((vstack
= FcVStackPeek (parse
)))
1329 if (vstack
->tag
!= FcVStackFamily
)
1331 FcConfigMessage (parse
, FcSevereWarning
, "non-family");
1332 FcVStackPopAndDestroy (parse
);
1335 left
= vstack
->u
.expr
;
1336 vstack
->tag
= FcVStackNone
;
1337 FcVStackPopAndDestroy (parse
);
1340 new = FcExprCreateOp (left
, FcOpComma
, expr
);
1343 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1344 FcExprDestroy (left
);
1345 FcExprDestroy (expr
);
1355 if (!FcVStackPushExpr (parse
, tag
, expr
))
1357 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1358 FcExprDestroy (expr
);
1364 FcParseFamily (FcConfigParse
*parse
)
1371 s
= FcStrBufDoneStatic (&parse
->pstack
->str
);
1374 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1377 expr
= FcExprCreateString (s
);
1378 FcStrBufDestroy (&parse
->pstack
->str
);
1380 FcVStackPushExpr (parse
, FcVStackFamily
, expr
);
1384 FcParseAlias (FcConfigParse
*parse
)
1386 FcExpr
*family
= 0, *accept
= 0, *prefer
= 0, *def
= 0, *new = 0;
1387 FcEdit
*edit
= 0, *next
;
1390 FcValueBinding binding
;
1392 if (!FcConfigLexBinding (parse
, FcConfigGetAttribute (parse
, "binding"), &binding
))
1394 while ((vstack
= FcVStackPeek (parse
)))
1396 switch (vstack
->tag
) {
1397 case FcVStackFamily
:
1400 new = FcExprCreateOp (vstack
->u
.expr
, FcOpComma
, family
);
1402 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1407 new = vstack
->u
.expr
;
1411 vstack
->tag
= FcVStackNone
;
1414 case FcVStackPrefer
:
1416 FcExprDestroy (prefer
);
1417 prefer
= vstack
->u
.expr
;
1418 vstack
->tag
= FcVStackNone
;
1420 case FcVStackAccept
:
1422 FcExprDestroy (accept
);
1423 accept
= vstack
->u
.expr
;
1424 vstack
->tag
= FcVStackNone
;
1426 case FcVStackDefault
:
1428 FcExprDestroy (def
);
1429 def
= vstack
->u
.expr
;
1430 vstack
->tag
= FcVStackNone
;
1433 FcConfigMessage (parse
, FcSevereWarning
, "bad alias");
1436 FcVStackPopAndDestroy (parse
);
1440 FcConfigMessage (parse
, FcSevereError
, "missing family in alias");
1442 FcExprDestroy (prefer
);
1444 FcExprDestroy (accept
);
1446 FcExprDestroy (def
);
1451 edit
= FcEditCreate (parse
,
1459 FcExprDestroy (prefer
);
1464 edit
= FcEditCreate (parse
,
1472 FcExprDestroy (accept
);
1477 edit
= FcEditCreate (parse
,
1485 FcExprDestroy (def
);
1489 test
= FcTestCreate (parse
, FcMatchPattern
,
1491 (FcChar8
*) FC_FAMILY
,
1495 if (!FcConfigAddEdit (parse
->config
, test
, edit
, FcMatchPattern
))
1496 FcTestDestroy (test
);
1499 FcExprDestroy (family
);
1503 FcPopExpr (FcConfigParse
*parse
)
1505 FcVStack
*vstack
= FcVStackPeek (parse
);
1509 switch (vstack
->tag
) {
1512 case FcVStackString
:
1513 case FcVStackFamily
:
1514 expr
= FcExprCreateString (vstack
->u
.string
);
1517 expr
= FcExprCreateField ((char *) vstack
->u
.string
);
1519 case FcVStackConstant
:
1520 expr
= FcExprCreateConst (vstack
->u
.string
);
1523 /* XXX: What's the correct action here? (CDW) */
1525 case FcVStackPrefer
:
1526 case FcVStackAccept
:
1527 case FcVStackDefault
:
1528 expr
= vstack
->u
.expr
;
1529 vstack
->tag
= FcVStackNone
;
1531 case FcVStackInteger
:
1532 expr
= FcExprCreateInteger (vstack
->u
.integer
);
1534 case FcVStackDouble
:
1535 expr
= FcExprCreateDouble (vstack
->u
._double
);
1537 case FcVStackMatrix
:
1538 expr
= FcExprCreateMatrix (vstack
->u
.matrix
);
1541 expr
= FcExprCreateBool (vstack
->u
.bool_
);
1546 expr
= vstack
->u
.expr
;
1547 vstack
->tag
= FcVStackNone
;
1554 FcVStackPopAndDestroy (parse
);
1559 * This builds a tree of binary operations. Note
1560 * that every operator is defined so that if only
1561 * a single operand is contained, the value of the
1562 * whole expression is the value of the operand.
1564 * This code reduces in that case to returning that
1568 FcPopBinary (FcConfigParse
*parse
, FcOp op
)
1570 FcExpr
*left
, *expr
= 0, *new;
1572 while ((left
= FcPopExpr (parse
)))
1576 new = FcExprCreateOp (left
, op
, expr
);
1579 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1580 FcExprDestroy (left
);
1581 FcExprDestroy (expr
);
1593 FcParseBinary (FcConfigParse
*parse
, FcOp op
)
1595 FcExpr
*expr
= FcPopBinary (parse
, op
);
1597 FcVStackPushExpr (parse
, FcVStackExpr
, expr
);
1601 * This builds a a unary operator, it consumes only
1606 FcPopUnary (FcConfigParse
*parse
, FcOp op
)
1608 FcExpr
*operand
, *new = 0;
1610 if ((operand
= FcPopExpr (parse
)))
1612 new = FcExprCreateOp (operand
, op
, 0);
1615 FcExprDestroy (operand
);
1616 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1623 FcParseUnary (FcConfigParse
*parse
, FcOp op
)
1625 FcExpr
*expr
= FcPopUnary (parse
, op
);
1627 FcVStackPushExpr (parse
, FcVStackExpr
, expr
);
1631 FcParseInclude (FcConfigParse
*parse
)
1635 FcBool ignore_missing
= FcFalse
;
1637 s
= FcStrBufDoneStatic (&parse
->pstack
->str
);
1640 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1643 i
= FcConfigGetAttribute (parse
, "ignore_missing");
1644 if (i
&& FcConfigLexBool (parse
, (FcChar8
*) i
) == FcTrue
)
1645 ignore_missing
= FcTrue
;
1646 if (!FcConfigParseAndLoad (parse
->config
, s
, !ignore_missing
))
1647 parse
->error
= FcTrue
;
1648 FcStrBufDestroy (&parse
->pstack
->str
);
1651 typedef struct _FcOpMap
{
1657 FcConfigLexOp (const FcChar8
*op
, const FcOpMap
*map
, int nmap
)
1661 for (i
= 0; i
< nmap
; i
++)
1662 if (!strcmp ((char *) op
, map
[i
].name
))
1667 static const FcOpMap fcCompareOps
[] = {
1668 { "eq", FcOpEqual
},
1669 { "not_eq", FcOpNotEqual
},
1670 { "less", FcOpLess
},
1671 { "less_eq", FcOpLessEqual
},
1672 { "more", FcOpMore
},
1673 { "more_eq", FcOpMoreEqual
},
1674 { "contains", FcOpContains
},
1675 { "not_contains", FcOpNotContains
}
1678 #define NUM_COMPARE_OPS (int) (sizeof fcCompareOps / sizeof fcCompareOps[0])
1681 FcConfigLexCompare (const FcChar8
*compare
)
1683 return FcConfigLexOp (compare
, fcCompareOps
, NUM_COMPARE_OPS
);
1687 FcParseTest (FcConfigParse
*parse
)
1689 const FcChar8
*kind_string
;
1691 const FcChar8
*qual_string
;
1693 const FcChar8
*name
;
1694 const FcChar8
*compare_string
;
1699 kind_string
= FcConfigGetAttribute (parse
, "target");
1701 kind
= FcMatchDefault
;
1704 if (!strcmp ((char *) kind_string
, "pattern"))
1705 kind
= FcMatchPattern
;
1706 else if (!strcmp ((char *) kind_string
, "font"))
1708 else if (!strcmp ((char *) kind_string
, "scan"))
1710 else if (!strcmp ((char *) kind_string
, "default"))
1711 kind
= FcMatchDefault
;
1714 FcConfigMessage (parse
, FcSevereWarning
, "invalid test target \"%s\"", kind_string
);
1718 qual_string
= FcConfigGetAttribute (parse
, "qual");
1723 if (!strcmp ((char *) qual_string
, "any"))
1725 else if (!strcmp ((char *) qual_string
, "all"))
1727 else if (!strcmp ((char *) qual_string
, "first"))
1729 else if (!strcmp ((char *) qual_string
, "not_first"))
1730 qual
= FcQualNotFirst
;
1733 FcConfigMessage (parse
, FcSevereWarning
, "invalid test qual \"%s\"", qual_string
);
1737 name
= FcConfigGetAttribute (parse
, "name");
1740 FcConfigMessage (parse
, FcSevereWarning
, "missing test name");
1743 compare_string
= FcConfigGetAttribute (parse
, "compare");
1744 if (!compare_string
)
1745 compare
= FcOpEqual
;
1748 compare
= FcConfigLexCompare (compare_string
);
1749 if (compare
== FcOpInvalid
)
1751 FcConfigMessage (parse
, FcSevereWarning
, "invalid test compare \"%s\"", compare_string
);
1755 expr
= FcPopBinary (parse
, FcOpComma
);
1758 FcConfigMessage (parse
, FcSevereWarning
, "missing test expression");
1761 test
= FcTestCreate (parse
, kind
, qual
, name
, compare
, expr
);
1764 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1767 FcVStackPushTest (parse
, test
);
1770 static const FcOpMap fcModeOps
[] = {
1771 { "assign", FcOpAssign
},
1772 { "assign_replace", FcOpAssignReplace
},
1773 { "prepend", FcOpPrepend
},
1774 { "prepend_first", FcOpPrependFirst
},
1775 { "append", FcOpAppend
},
1776 { "append_last", FcOpAppendLast
},
1779 #define NUM_MODE_OPS (int) (sizeof fcModeOps / sizeof fcModeOps[0])
1782 FcConfigLexMode (const FcChar8
*mode
)
1784 return FcConfigLexOp (mode
, fcModeOps
, NUM_MODE_OPS
);
1788 FcParseEdit (FcConfigParse
*parse
)
1790 const FcChar8
*name
;
1791 const FcChar8
*mode_string
;
1793 FcValueBinding binding
;
1797 name
= FcConfigGetAttribute (parse
, "name");
1800 FcConfigMessage (parse
, FcSevereWarning
, "missing edit name");
1803 mode_string
= FcConfigGetAttribute (parse
, "mode");
1808 mode
= FcConfigLexMode (mode_string
);
1809 if (mode
== FcOpInvalid
)
1811 FcConfigMessage (parse
, FcSevereWarning
, "invalid edit mode \"%s\"", mode_string
);
1815 if (!FcConfigLexBinding (parse
, FcConfigGetAttribute (parse
, "binding"), &binding
))
1818 expr
= FcPopBinary (parse
, FcOpComma
);
1819 edit
= FcEditCreate (parse
, FcObjectFromName ((char *) name
),
1820 mode
, expr
, binding
);
1823 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1824 FcExprDestroy (expr
);
1827 if (!FcVStackPushEdit (parse
, edit
))
1828 FcEditDestroy (edit
);
1832 FcParseMatch (FcConfigParse
*parse
)
1834 const FcChar8
*kind_name
;
1840 kind_name
= FcConfigGetAttribute (parse
, "target");
1842 kind
= FcMatchPattern
;
1845 if (!strcmp ((char *) kind_name
, "pattern"))
1846 kind
= FcMatchPattern
;
1847 else if (!strcmp ((char *) kind_name
, "font"))
1849 else if (!strcmp ((char *) kind_name
, "scan"))
1853 FcConfigMessage (parse
, FcSevereWarning
, "invalid match target \"%s\"", kind_name
);
1857 while ((vstack
= FcVStackPeek (parse
)))
1859 switch (vstack
->tag
) {
1861 vstack
->u
.test
->next
= test
;
1862 test
= vstack
->u
.test
;
1863 vstack
->tag
= FcVStackNone
;
1866 vstack
->u
.edit
->next
= edit
;
1867 edit
= vstack
->u
.edit
;
1868 vstack
->tag
= FcVStackNone
;
1869 if (kind
== FcMatchScan
&& edit
->object
> FC_MAX_BASE_OBJECT
)
1871 FcConfigMessage (parse
, FcSevereError
,
1872 "<match target=\"scan\"> cannot edit user-defined object \"%s\"",
1873 FcObjectName(edit
->object
));
1877 FcConfigMessage (parse
, FcSevereWarning
, "invalid match element");
1880 FcVStackPopAndDestroy (parse
);
1882 if (!FcConfigAddEdit (parse
->config
, test
, edit
, kind
))
1883 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1887 FcParseAcceptRejectFont (FcConfigParse
*parse
, FcElement element
)
1891 while ((vstack
= FcVStackPeek (parse
)))
1893 switch (vstack
->tag
) {
1895 if (!FcConfigGlobAdd (parse
->config
,
1897 element
== FcElementAcceptfont
))
1899 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1902 case FcVStackPattern
:
1903 if (!FcConfigPatternsAdd (parse
->config
,
1905 element
== FcElementAcceptfont
))
1907 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1910 vstack
->tag
= FcVStackNone
;
1913 FcConfigMessage (parse
, FcSevereWarning
, "bad font selector");
1916 FcVStackPopAndDestroy (parse
);
1922 FcPopValue (FcConfigParse
*parse
)
1924 FcVStack
*vstack
= FcVStackPeek (parse
);
1927 value
.type
= FcTypeVoid
;
1932 switch (vstack
->tag
) {
1933 case FcVStackString
:
1934 value
.u
.s
= FcStrCopy (vstack
->u
.string
);
1936 value
.type
= FcTypeString
;
1938 case FcVStackConstant
:
1939 if (FcNameConstant (vstack
->u
.string
, &value
.u
.i
))
1940 value
.type
= FcTypeInteger
;
1942 case FcVStackInteger
:
1943 value
.u
.i
= vstack
->u
.integer
;
1944 value
.type
= FcTypeInteger
;
1946 case FcVStackDouble
:
1947 value
.u
.d
= vstack
->u
._double
;
1948 value
.type
= FcTypeInteger
;
1950 case FcVStackMatrix
:
1951 value
.u
.m
= FcMatrixCopy (vstack
->u
.matrix
);
1953 value
.type
= FcTypeMatrix
;
1956 value
.u
.b
= vstack
->u
.bool_
;
1957 value
.type
= FcTypeBool
;
1960 FcConfigMessage (parse
, FcSevereWarning
, "unknown pattern element %d",
1964 FcVStackPopAndDestroy (parse
);
1970 FcParsePatelt (FcConfigParse
*parse
)
1973 FcPattern
*pattern
= FcPatternCreate ();
1978 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1982 name
= (char *) FcConfigGetAttribute (parse
, "name");
1985 FcConfigMessage (parse
, FcSevereWarning
, "missing pattern element name");
1986 FcPatternDestroy (pattern
);
1992 value
= FcPopValue (parse
);
1993 if (value
.type
== FcTypeVoid
)
1995 if (!FcPatternAdd (pattern
, name
, value
, FcTrue
))
1997 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1998 FcValueDestroy(value
);
2001 FcValueDestroy(value
);
2004 FcVStackPushPattern (parse
, pattern
);
2008 FcParsePattern (FcConfigParse
*parse
)
2011 FcPattern
*pattern
= FcPatternCreate ();
2015 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2019 while ((vstack
= FcVStackPeek (parse
)))
2021 switch (vstack
->tag
) {
2022 case FcVStackPattern
:
2023 if (!FcPatternAppend (pattern
, vstack
->u
.pattern
))
2025 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2026 FcPatternDestroy (pattern
);
2031 FcConfigMessage (parse
, FcSevereWarning
, "unknown pattern element");
2034 FcVStackPopAndDestroy (parse
);
2037 FcVStackPushPattern (parse
, pattern
);
2041 FcEndElement(void *userData
, const XML_Char
*name
)
2043 FcConfigParse
*parse
= userData
;
2048 switch (parse
->pstack
->element
) {
2051 case FcElementFontconfig
:
2054 data
= FcStrBufDoneStatic (&parse
->pstack
->str
);
2057 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2061 if (strcmp (data
, "CUSTOMFONTDIR") == 0)
2065 data
= malloc (1000);
2068 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2071 FcMemAlloc (FC_MEM_STRING
, 1000);
2072 if(!GetModuleFileName(NULL
, data
, 1000))
2074 FcConfigMessage (parse
, FcSevereError
, "GetModuleFileName failed");
2078 p
= strrchr (data
, '\\');
2080 strcat (data
, "\\fonts");
2082 else if (strcmp (data
, "APPSHAREFONTDIR") == 0)
2086 data
= malloc (1000);
2089 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2092 FcMemAlloc (FC_MEM_STRING
, 1000);
2093 if(!GetModuleFileName(NULL
, data
, 1000))
2095 FcConfigMessage (parse
, FcSevereError
, "GetModuleFileName failed");
2099 p
= strrchr (data
, '\\');
2101 strcat (data
, "\\..\\share\\fonts");
2103 else if (strcmp (data
, "WINDOWSFONTDIR") == 0)
2107 data
= malloc (1000);
2110 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2113 FcMemAlloc (FC_MEM_STRING
, 1000);
2114 rc
= GetWindowsDirectory (data
, 800);
2115 if (rc
== 0 || rc
> 800)
2117 FcConfigMessage (parse
, FcSevereError
, "GetWindowsDirectory failed");
2121 if (data
[strlen (data
) - 1] != '\\')
2122 strcat (data
, "\\");
2123 strcat (data
, "fonts");
2126 if (strlen ((char *) data
) == 0)
2127 FcConfigMessage (parse
, FcSevereWarning
, "empty font directory name ignored");
2128 else if (!FcStrUsesHome (data
) || FcConfigHome ())
2130 if (!FcConfigAddDir (parse
->config
, data
))
2131 FcConfigMessage (parse
, FcSevereError
, "out of memory; cannot add directory %s", data
);
2133 FcStrBufDestroy (&parse
->pstack
->str
);
2135 case FcElementCacheDir
:
2136 data
= FcStrBufDone (&parse
->pstack
->str
);
2139 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2143 if (strcmp (data
, "WINDOWSTEMPDIR_FONTCONFIG_CACHE") == 0)
2147 data
= malloc (1000);
2150 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2153 FcMemAlloc (FC_MEM_STRING
, 1000);
2154 rc
= GetTempPath (800, data
);
2155 if (rc
== 0 || rc
> 800)
2157 FcConfigMessage (parse
, FcSevereError
, "GetWindowsDirectory failed");
2161 if (data
[strlen (data
) - 1] != '\\')
2162 strcat (data
, "\\");
2163 strcat (data
, "fontconfig\\cache");
2166 if (!FcStrUsesHome (data
) || FcConfigHome ())
2168 if (!FcConfigAddCacheDir (parse
->config
, data
))
2169 FcConfigMessage (parse
, FcSevereError
, "out of memory; cannot add cache directory %s", data
);
2174 case FcElementCache
:
2175 data
= FcStrBufDoneStatic (&parse
->pstack
->str
);
2178 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2181 /* discard this data; no longer used */
2182 FcStrBufDestroy (&parse
->pstack
->str
);
2184 case FcElementInclude
:
2185 FcParseInclude (parse
);
2187 case FcElementConfig
:
2189 case FcElementMatch
:
2190 FcParseMatch (parse
);
2192 case FcElementAlias
:
2193 FcParseAlias (parse
);
2196 case FcElementBlank
:
2197 FcParseBlank (parse
);
2199 case FcElementRescan
:
2200 FcParseRescan (parse
);
2203 case FcElementPrefer
:
2204 FcParseFamilies (parse
, FcVStackPrefer
);
2206 case FcElementAccept
:
2207 FcParseFamilies (parse
, FcVStackAccept
);
2209 case FcElementDefault
:
2210 FcParseFamilies (parse
, FcVStackDefault
);
2212 case FcElementFamily
:
2213 FcParseFamily (parse
);
2217 FcParseTest (parse
);
2220 FcParseEdit (parse
);
2226 case FcElementDouble
:
2227 FcParseDouble (parse
);
2229 case FcElementString
:
2230 FcParseString (parse
, FcVStackString
);
2232 case FcElementMatrix
:
2233 FcParseMatrix (parse
);
2236 FcParseBool (parse
);
2238 case FcElementCharset
:
2239 /* FcParseCharset (parse); */
2241 case FcElementSelectfont
:
2243 case FcElementAcceptfont
:
2244 case FcElementRejectfont
:
2245 FcParseAcceptRejectFont (parse
, parse
->pstack
->element
);
2248 FcParseString (parse
, FcVStackGlob
);
2250 case FcElementPattern
:
2251 FcParsePattern (parse
);
2253 case FcElementPatelt
:
2254 FcParsePatelt (parse
);
2257 FcParseString (parse
, FcVStackField
);
2259 case FcElementConst
:
2260 FcParseString (parse
, FcVStackConstant
);
2263 FcParseBinary (parse
, FcOpOr
);
2266 FcParseBinary (parse
, FcOpAnd
);
2269 FcParseBinary (parse
, FcOpEqual
);
2271 case FcElementNotEq
:
2272 FcParseBinary (parse
, FcOpNotEqual
);
2275 FcParseBinary (parse
, FcOpLess
);
2277 case FcElementLessEq
:
2278 FcParseBinary (parse
, FcOpLessEqual
);
2281 FcParseBinary (parse
, FcOpMore
);
2283 case FcElementMoreEq
:
2284 FcParseBinary (parse
, FcOpMoreEqual
);
2286 case FcElementContains
:
2287 FcParseBinary (parse
, FcOpContains
);
2289 case FcElementNotContains
:
2290 FcParseBinary (parse
, FcOpNotContains
);
2293 FcParseBinary (parse
, FcOpPlus
);
2295 case FcElementMinus
:
2296 FcParseBinary (parse
, FcOpMinus
);
2298 case FcElementTimes
:
2299 FcParseBinary (parse
, FcOpTimes
);
2301 case FcElementDivide
:
2302 FcParseBinary (parse
, FcOpDivide
);
2305 FcParseUnary (parse
, FcOpNot
);
2308 FcParseBinary (parse
, FcOpQuest
);
2310 case FcElementFloor
:
2311 FcParseUnary (parse
, FcOpFloor
);
2314 FcParseUnary (parse
, FcOpCeil
);
2316 case FcElementRound
:
2317 FcParseUnary (parse
, FcOpRound
);
2319 case FcElementTrunc
:
2320 FcParseUnary (parse
, FcOpTrunc
);
2322 case FcElementUnknown
:
2325 (void) FcPStackPop (parse
);
2329 FcCharacterData (void *userData
, const XML_Char
*s
, int len
)
2331 FcConfigParse
*parse
= userData
;
2335 if (!FcStrBufData (&parse
->pstack
->str
, (FcChar8
*) s
, len
))
2336 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2340 FcStartDoctypeDecl (void *userData
,
2341 const XML_Char
*doctypeName
,
2342 const XML_Char
*sysid
,
2343 const XML_Char
*pubid
,
2344 int has_internal_subset
)
2346 FcConfigParse
*parse
= userData
;
2348 if (strcmp ((char *) doctypeName
, "fontconfig") != 0)
2349 FcConfigMessage (parse
, FcSevereError
, "invalid doctype \"%s\"", doctypeName
);
2352 #ifdef ENABLE_LIBXML2
2355 FcInternalSubsetDecl (void *userData
,
2356 const XML_Char
*doctypeName
,
2357 const XML_Char
*sysid
,
2358 const XML_Char
*pubid
)
2360 FcStartDoctypeDecl (userData
, doctypeName
, sysid
, pubid
, 1);
2364 FcExternalSubsetDecl (void *userData
,
2365 const XML_Char
*doctypeName
,
2366 const XML_Char
*sysid
,
2367 const XML_Char
*pubid
)
2369 FcStartDoctypeDecl (userData
, doctypeName
, sysid
, pubid
, 0);
2372 #else /* ENABLE_LIBXML2 */
2375 FcEndDoctypeDecl (void *userData
)
2379 #endif /* ENABLE_LIBXML2 */
2382 FcSortCmpStr (const void *a
, const void *b
)
2384 const FcChar8
*as
= *((FcChar8
**) a
);
2385 const FcChar8
*bs
= *((FcChar8
**) b
);
2386 return FcStrCmp (as
, bs
);
2390 FcConfigParseAndLoadDir (FcConfig
*config
,
2391 const FcChar8
*name
,
2397 FcBool ret
= FcTrue
;
2402 d
= opendir ((char *) dir
);
2406 FcConfigMessage (0, FcSevereError
, "Cannot open config dir \"%s\"",
2412 file
= (FcChar8
*) malloc (strlen ((char *) dir
) + 1 + FC_MAX_FILE_LEN
+ 1);
2419 strcpy ((char *) file
, (char *) dir
);
2420 strcat ((char *) file
, "/");
2421 base
= file
+ strlen ((char *) file
);
2423 files
= FcStrSetCreate ();
2430 if (FcDebug () & FC_DBG_CONFIG
)
2431 printf ("\tScanning config dir %s\n", dir
);
2433 while (ret
&& (e
= readdir (d
)))
2436 #define TAIL ".conf"
2439 * Add all files of the form [0-9]*.conf
2441 if ('0' <= e
->d_name
[0] && e
->d_name
[0] <= '9' &&
2442 (d_len
= strlen (e
->d_name
)) < FC_MAX_FILE_LEN
&&
2444 strcmp (e
->d_name
+ d_len
- TAIL_LEN
, TAIL
) == 0)
2446 strcpy ((char *) base
, (char *) e
->d_name
);
2447 if (!FcStrSetAdd (files
, file
))
2457 qsort (files
->strs
, files
->num
, sizeof (FcChar8
*),
2458 (int (*)(const void *, const void *)) FcSortCmpStr
);
2459 for (i
= 0; ret
&& i
< files
->num
; i
++)
2460 ret
= FcConfigParseAndLoad (config
, files
->strs
[i
], complain
);
2463 FcStrSetDestroy (files
);
2469 return ret
|| !complain
;
2473 FcConfigParseAndLoad (FcConfig
*config
,
2474 const FcChar8
*name
,
2482 FcConfigParse parse
;
2483 FcBool error
= FcTrue
;
2485 #ifdef ENABLE_LIBXML2
2492 filename
= FcConfigFilename (name
);
2496 if (FcStrSetMember (config
->configFiles
, filename
))
2498 FcStrFree (filename
);
2502 if (!FcStrSetAdd (config
->configFiles
, filename
))
2504 FcStrFree (filename
);
2508 if (FcFileIsDir (filename
))
2510 FcBool ret
= FcConfigParseAndLoadDir (config
, name
, filename
, complain
);
2511 FcStrFree (filename
);
2515 if (FcDebug () & FC_DBG_CONFIG
)
2516 printf ("\tLoading config file %s\n", filename
);
2518 fd
= open ((char *) filename
, O_RDONLY
);
2520 FcStrFree (filename
);
2524 #ifdef ENABLE_LIBXML2
2525 memset(&sax
, 0, sizeof(sax
));
2527 sax
.internalSubset
= FcInternalSubsetDecl
;
2528 sax
.externalSubset
= FcExternalSubsetDecl
;
2529 sax
.startElement
= FcStartElement
;
2530 sax
.endElement
= FcEndElement
;
2531 sax
.characters
= FcCharacterData
;
2533 p
= xmlCreatePushParserCtxt (&sax
, &parse
, NULL
, 0, (const char *) filename
);
2535 p
= XML_ParserCreate ("UTF-8");
2537 FcStrFree (filename
);
2542 if (!FcConfigInit (&parse
, name
, config
, p
))
2545 #ifndef ENABLE_LIBXML2
2547 XML_SetUserData (p
, &parse
);
2549 XML_SetDoctypeDeclHandler (p
, FcStartDoctypeDecl
, FcEndDoctypeDecl
);
2550 XML_SetElementHandler (p
, FcStartElement
, FcEndElement
);
2551 XML_SetCharacterDataHandler (p
, FcCharacterData
);
2553 #endif /* ENABLE_LIBXML2 */
2556 #ifndef ENABLE_LIBXML2
2557 buf
= XML_GetBuffer (p
, BUFSIZ
);
2560 FcConfigMessage (&parse
, FcSevereError
, "cannot get parse buffer");
2564 len
= read (fd
, buf
, BUFSIZ
);
2567 FcConfigMessage (&parse
, FcSevereError
, "failed reading config file");
2571 #ifdef ENABLE_LIBXML2
2572 if (xmlParseChunk (p
, buf
, len
, len
== 0))
2574 if (!XML_ParseBuffer (p
, len
, len
== 0))
2577 FcConfigMessage (&parse
, FcSevereError
, "%s",
2578 XML_ErrorString (XML_GetErrorCode (p
)));
2582 error
= parse
.error
;
2584 FcConfigCleanup (&parse
);
2591 if (error
&& complain
)
2594 FcConfigMessage (0, FcSevereError
, "Cannot load config file \"%s\"", name
);
2596 FcConfigMessage (0, FcSevereError
, "Cannot load default config file");
2602 #include "fcaliastail.h"