]>
git.wh0rd.org - fontconfig.git/blob - src/fcxml.c
4d07f9d6cdfec1d76628163baa83c5330ec1fa50
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 the author(s) not be used in
11 * advertising or publicity pertaining to distribution of the software without
12 * specific, written prior permission. The authors make no
13 * representations about the suitability of this software for any purpose. It
14 * is provided "as is" without express or implied warranty.
16 * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
17 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
18 * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR
19 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
20 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
21 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
22 * PERFORMANCE OF THIS SOFTWARE.
32 #include <libxml/parser.h>
34 #define XML_Char xmlChar
35 #define XML_Parser xmlParserCtxtPtr
36 #define XML_ParserFree xmlFreeParserCtxt
37 #define XML_GetCurrentLineNumber xmlSAX2GetLineNumber
38 #define XML_GetErrorCode xmlCtxtGetLastError
39 #define XML_ErrorString(Error) (Error)->message
41 #else /* ENABLE_LIBXML2 */
43 #ifndef HAVE_XMLPARSE_H
44 #define HAVE_XMLPARSE_H 0
53 #endif /* ENABLE_LIBXML2 */
56 #define _WIN32_WINNT 0x0500
64 FcExprDestroy (FcExpr
*e
);
67 FcTestDestroy (FcTest
*test
)
70 FcTestDestroy (test
->next
);
71 FcExprDestroy (test
->expr
);
72 FcMemFree (FC_MEM_TEST
, sizeof (FcTest
));
77 FcExprCreateInteger (FcConfig
*config
, int i
)
79 FcExpr
*e
= FcConfigAllocExpr (config
);
89 FcExprCreateDouble (FcConfig
*config
, double d
)
91 FcExpr
*e
= FcConfigAllocExpr (config
);
101 FcExprCreateString (FcConfig
*config
, const FcChar8
*s
)
103 FcExpr
*e
= FcConfigAllocExpr (config
);
107 e
->u
.sval
= FcStrStaticName (s
);
113 FcExprCreateMatrix (FcConfig
*config
, const FcMatrix
*m
)
115 FcExpr
*e
= FcConfigAllocExpr (config
);
119 e
->u
.mval
= FcMatrixCopy (m
);
125 FcExprCreateBool (FcConfig
*config
, FcBool b
)
127 FcExpr
*e
= FcConfigAllocExpr (config
);
137 FcExprCreateCharSet (FcConfig
*config
, FcCharSet
*charset
)
139 FcExpr
*e
= FcConfigAllocExpr (config
);
143 e
->u
.cval
= FcCharSetCopy (charset
);
149 FcExprCreateField (FcConfig
*config
, const char *field
)
151 FcExpr
*e
= FcConfigAllocExpr (config
);
155 e
->u
.object
= FcObjectFromName (field
);
161 FcExprCreateConst (FcConfig
*config
, const FcChar8
*constant
)
163 FcExpr
*e
= FcConfigAllocExpr (config
);
167 e
->u
.constant
= FcStrStaticName (constant
);
173 FcExprCreateOp (FcConfig
*config
, FcExpr
*left
, FcOp op
, FcExpr
*right
)
175 FcExpr
*e
= FcConfigAllocExpr (config
);
179 e
->u
.tree
.left
= left
;
180 e
->u
.tree
.right
= right
;
186 FcExprDestroy (FcExpr
*e
)
198 FcMatrixFree (e
->u
.mval
);
203 FcCharSetDestroy (e
->u
.cval
);
212 case FcOpAssignReplace
:
214 case FcOpPrependFirst
:
228 case FcOpNotContains
:
235 FcExprDestroy (e
->u
.tree
.right
);
242 FcExprDestroy (e
->u
.tree
.left
);
253 FcEditDestroy (FcEdit
*e
)
256 FcEditDestroy (e
->next
);
258 FcExprDestroy (e
->expr
);
262 typedef enum _FcElement
{
308 FcElementNotContains
,
322 static const struct {
326 { "fontconfig", FcElementFontconfig
},
327 { "dir", FcElementDir
},
328 { "cachedir", FcElementCacheDir
},
329 { "cache", FcElementCache
},
330 { "include", FcElementInclude
},
331 { "config", FcElementConfig
},
332 { "match", FcElementMatch
},
333 { "alias", FcElementAlias
},
335 { "blank", FcElementBlank
},
336 { "rescan", FcElementRescan
},
338 { "prefer", FcElementPrefer
},
339 { "accept", FcElementAccept
},
340 { "default", FcElementDefault
},
341 { "family", FcElementFamily
},
343 { "selectfont", FcElementSelectfont
},
344 { "acceptfont", FcElementAcceptfont
},
345 { "rejectfont", FcElementRejectfont
},
346 { "glob", FcElementGlob
},
347 { "pattern", FcElementPattern
},
348 { "patelt", FcElementPatelt
},
350 { "test", FcElementTest
},
351 { "edit", FcElementEdit
},
352 { "int", FcElementInt
},
353 { "double", FcElementDouble
},
354 { "string", FcElementString
},
355 { "matrix", FcElementMatrix
},
356 { "range", FcElementRange
},
357 { "bool", FcElementBool
},
358 { "charset", FcElementCharSet
},
359 { "name", FcElementName
},
360 { "const", FcElementConst
},
361 { "or", FcElementOr
},
362 { "and", FcElementAnd
},
363 { "eq", FcElementEq
},
364 { "not_eq", FcElementNotEq
},
365 { "less", FcElementLess
},
366 { "less_eq", FcElementLessEq
},
367 { "more", FcElementMore
},
368 { "more_eq", FcElementMoreEq
},
369 { "contains", FcElementContains
},
370 { "not_contains", FcElementNotContains
},
371 { "plus", FcElementPlus
},
372 { "minus", FcElementMinus
},
373 { "times", FcElementTimes
},
374 { "divide", FcElementDivide
},
375 { "not", FcElementNot
},
376 { "if", FcElementIf
},
377 { "floor", FcElementFloor
},
378 { "ceil", FcElementCeil
},
379 { "round", FcElementRound
},
380 { "trunc", FcElementTrunc
},
382 #define NUM_ELEMENT_MAPS (int) (sizeof fcElementMap / sizeof fcElementMap[0])
385 FcElementMap (const XML_Char
*name
)
389 for (i
= 0; i
< NUM_ELEMENT_MAPS
; i
++)
390 if (!strcmp ((char *) name
, fcElementMap
[i
].name
))
391 return fcElementMap
[i
].element
;
392 return FcElementUnknown
;
395 typedef struct _FcPStack
{
396 struct _FcPStack
*prev
;
400 FcChar8
*attr_buf_static
[16];
403 typedef enum _FcVStackTag
{
429 typedef struct _FcVStack
{
430 struct _FcVStack
*prev
;
431 FcPStack
*pstack
; /* related parse element */
453 typedef struct _FcConfigParse
{
460 int pstack_static_used
;
461 FcPStack pstack_static
[8];
462 int vstack_static_used
;
463 FcVStack vstack_static
[64];
466 typedef enum _FcConfigSeverity
{
467 FcSevereInfo
, FcSevereWarning
, FcSevereError
471 FcConfigMessage (FcConfigParse
*parse
, FcConfigSeverity severe
, const char *fmt
, ...)
473 const char *s
= "unknown";
476 va_start (args
, fmt
);
479 case FcSevereInfo
: s
= "info"; break;
480 case FcSevereWarning
: s
= "warning"; break;
481 case FcSevereError
: s
= "error"; break;
486 fprintf (stderr
, "Fontconfig %s: \"%s\", line %d: ", s
,
487 parse
->name
, (int)XML_GetCurrentLineNumber (parse
->parser
));
489 fprintf (stderr
, "Fontconfig %s: line %d: ", s
,
490 (int)XML_GetCurrentLineNumber (parse
->parser
));
491 if (severe
>= FcSevereError
)
492 parse
->error
= FcTrue
;
495 fprintf (stderr
, "Fontconfig %s: ", s
);
496 vfprintf (stderr
, fmt
, args
);
497 fprintf (stderr
, "\n");
503 FcTypeName (FcType type
)
529 FcTypecheckValue (FcConfigParse
*parse
, FcType value
, FcType type
)
531 if (value
== FcTypeInteger
)
532 value
= FcTypeDouble
;
533 if (type
== FcTypeInteger
)
537 if ((value
== FcTypeLangSet
&& type
== FcTypeString
) ||
538 (value
== FcTypeString
&& type
== FcTypeLangSet
))
540 if (type
== (FcType
) -1)
542 FcConfigMessage (parse
, FcSevereWarning
, "saw %s, expected %s",
543 FcTypeName (value
), FcTypeName (type
));
548 FcTypecheckExpr (FcConfigParse
*parse
, FcExpr
*expr
, FcType type
)
550 const FcObjectType
*o
;
553 /* If parsing the expression failed, some nodes may be NULL */
560 FcTypecheckValue (parse
, FcTypeDouble
, type
);
563 FcTypecheckValue (parse
, FcTypeString
, type
);
566 FcTypecheckValue (parse
, FcTypeMatrix
, type
);
569 FcTypecheckValue (parse
, FcTypeBool
, type
);
572 FcTypecheckValue (parse
, FcTypeCharSet
, type
);
577 o
= FcNameGetObjectType (FcObjectName (expr
->u
.object
));
579 FcTypecheckValue (parse
, o
->type
, type
);
582 c
= FcNameGetConstant (expr
->u
.constant
);
585 o
= FcNameGetObjectType (c
->object
);
587 FcTypecheckValue (parse
, o
->type
, type
);
590 FcConfigMessage (parse
, FcSevereWarning
,
591 "invalid constant used : %s",
595 FcTypecheckExpr (parse
, expr
->u
.tree
.left
, FcTypeBool
);
596 FcTypecheckExpr (parse
, expr
->u
.tree
.right
->u
.tree
.left
, type
);
597 FcTypecheckExpr (parse
, expr
->u
.tree
.right
->u
.tree
.right
, type
);
600 case FcOpAssignReplace
:
609 case FcOpNotContains
:
611 FcTypecheckValue (parse
, FcTypeBool
, type
);
620 FcTypecheckExpr (parse
, expr
->u
.tree
.left
, type
);
621 FcTypecheckExpr (parse
, expr
->u
.tree
.right
, type
);
624 FcTypecheckValue (parse
, FcTypeBool
, type
);
625 FcTypecheckExpr (parse
, expr
->u
.tree
.left
, FcTypeBool
);
631 FcTypecheckValue (parse
, FcTypeDouble
, type
);
632 FcTypecheckExpr (parse
, expr
->u
.tree
.left
, FcTypeDouble
);
640 FcTestCreate (FcConfigParse
*parse
,
643 const FcChar8
*field
,
647 FcTest
*test
= (FcTest
*) malloc (sizeof (FcTest
));
651 const FcObjectType
*o
;
653 FcMemAlloc (FC_MEM_TEST
, sizeof (FcTest
));
657 test
->object
= FcObjectFromName ((const char *) field
);
660 o
= FcNameGetObjectType (FcObjectName (test
->object
));
662 FcTypecheckExpr (parse
, expr
, o
->type
);
668 FcEditCreate (FcConfigParse
*parse
,
672 FcValueBinding binding
)
674 FcEdit
*e
= (FcEdit
*) malloc (sizeof (FcEdit
));
678 const FcObjectType
*o
;
684 e
->binding
= binding
;
685 o
= FcNameGetObjectType (FcObjectName (e
->object
));
687 FcTypecheckExpr (parse
, expr
, o
->type
);
693 FcVStackCreateAndPush (FcConfigParse
*parse
)
697 if (parse
->vstack_static_used
< sizeof (parse
->vstack_static
) / sizeof (parse
->vstack_static
[0]))
698 new = &parse
->vstack_static
[parse
->vstack_static_used
++];
701 new = malloc (sizeof (FcVStack
));
704 FcMemAlloc (FC_MEM_VSTACK
, sizeof (FcVStack
));
706 new->tag
= FcVStackNone
;
709 new->prev
= parse
->vstack
;
710 new->pstack
= parse
->pstack
? parse
->pstack
->prev
: 0;
717 FcVStackPushString (FcConfigParse
*parse
, FcVStackTag tag
, FcChar8
*string
)
719 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
722 vstack
->u
.string
= string
;
728 FcVStackPushInteger (FcConfigParse
*parse
, int integer
)
730 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
733 vstack
->u
.integer
= integer
;
734 vstack
->tag
= FcVStackInteger
;
739 FcVStackPushDouble (FcConfigParse
*parse
, double _double
)
741 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
744 vstack
->u
._double
= _double
;
745 vstack
->tag
= FcVStackDouble
;
750 FcVStackPushMatrix (FcConfigParse
*parse
, FcMatrix
*matrix
)
753 matrix
= FcMatrixCopy (matrix
);
756 vstack
= FcVStackCreateAndPush (parse
);
759 vstack
->u
.matrix
= matrix
;
760 vstack
->tag
= FcVStackMatrix
;
765 FcVStackPushRange (FcConfigParse
*parse
, FcRange
*range
)
767 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
770 vstack
->u
.range
.begin
= range
->begin
;
771 vstack
->u
.range
.end
= range
->end
;
772 vstack
->tag
= FcVStackRange
;
777 FcVStackPushBool (FcConfigParse
*parse
, FcBool bool_
)
779 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
782 vstack
->u
.bool_
= bool_
;
783 vstack
->tag
= FcVStackBool
;
788 FcVStackPushCharSet (FcConfigParse
*parse
, FcCharSet
*charset
)
793 vstack
= FcVStackCreateAndPush (parse
);
796 vstack
->u
.charset
= charset
;
797 vstack
->tag
= FcVStackCharSet
;
802 FcVStackPushTest (FcConfigParse
*parse
, FcTest
*test
)
804 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
807 vstack
->u
.test
= test
;
808 vstack
->tag
= FcVStackTest
;
813 FcVStackPushExpr (FcConfigParse
*parse
, FcVStackTag tag
, FcExpr
*expr
)
815 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
818 vstack
->u
.expr
= expr
;
824 FcVStackPushEdit (FcConfigParse
*parse
, FcEdit
*edit
)
826 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
829 vstack
->u
.edit
= edit
;
830 vstack
->tag
= FcVStackEdit
;
835 FcVStackPushPattern (FcConfigParse
*parse
, FcPattern
*pattern
)
837 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
840 vstack
->u
.pattern
= pattern
;
841 vstack
->tag
= FcVStackPattern
;
846 FcVStackFetch (FcConfigParse
*parse
, int off
)
850 for (vstack
= parse
->vstack
; vstack
&& off
-- > 0; vstack
= vstack
->prev
);
855 FcVStackPeek (FcConfigParse
*parse
)
857 FcVStack
*vstack
= parse
->vstack
;
859 return vstack
&& vstack
->pstack
== parse
->pstack
? vstack
: 0;
863 FcVStackPopAndDestroy (FcConfigParse
*parse
)
865 FcVStack
*vstack
= parse
->vstack
;
867 if (!vstack
|| vstack
->pstack
!= parse
->pstack
)
870 parse
->vstack
= vstack
->prev
;
872 switch (vstack
->tag
) {
879 case FcVStackConstant
:
881 FcStrFree (vstack
->u
.string
);
883 case FcVStackPattern
:
884 FcPatternDestroy (vstack
->u
.pattern
);
886 case FcVStackInteger
:
890 FcMatrixFree (vstack
->u
.matrix
);
895 case FcVStackCharSet
:
896 FcCharSetDestroy (vstack
->u
.charset
);
899 FcTestDestroy (vstack
->u
.test
);
904 case FcVStackDefault
:
905 FcExprDestroy (vstack
->u
.expr
);
908 FcEditDestroy (vstack
->u
.edit
);
912 if (vstack
== &parse
->vstack_static
[parse
->vstack_static_used
- 1])
913 parse
->vstack_static_used
--;
916 FcMemFree (FC_MEM_VSTACK
, sizeof (FcVStack
));
922 FcVStackClear (FcConfigParse
*parse
)
924 while (FcVStackPeek (parse
))
925 FcVStackPopAndDestroy (parse
);
929 FcVStackElements (FcConfigParse
*parse
)
932 FcVStack
*vstack
= parse
->vstack
;
933 while (vstack
&& vstack
->pstack
== parse
->pstack
)
936 vstack
= vstack
->prev
;
942 FcConfigSaveAttr (const XML_Char
**attr
, FcChar8
**buf
, int size_bytes
)
952 for (i
= 0; attr
[i
]; i
++)
953 slen
+= strlen ((char *) attr
[i
]) + 1;
956 slen
+= (i
+ 1) * sizeof (FcChar8
*);
957 if (slen
<= size_bytes
)
964 FcConfigMessage (0, FcSevereError
, "out of memory");
967 FcMemAlloc (FC_MEM_ATTR
, 1); /* size is too expensive */
969 s
= (FcChar8
*) (new + (i
+ 1));
970 for (i
= 0; attr
[i
]; i
++)
973 strcpy ((char *) s
, (char *) attr
[i
]);
974 s
+= strlen ((char *) s
) + 1;
981 FcPStackPush (FcConfigParse
*parse
, FcElement element
, const XML_Char
**attr
)
985 if (parse
->pstack_static_used
< sizeof (parse
->pstack_static
) / sizeof (parse
->pstack_static
[0]))
986 new = &parse
->pstack_static
[parse
->pstack_static_used
++];
989 new = malloc (sizeof (FcPStack
));
992 FcMemAlloc (FC_MEM_PSTACK
, sizeof (FcPStack
));
995 new->prev
= parse
->pstack
;
996 new->element
= element
;
997 new->attr
= FcConfigSaveAttr (attr
, new->attr_buf_static
, sizeof (new->attr_buf_static
));
998 FcStrBufInit (&new->str
, 0, 0);
1004 FcPStackPop (FcConfigParse
*parse
)
1010 FcConfigMessage (parse
, FcSevereError
, "mismatching element");
1013 FcVStackClear (parse
);
1014 old
= parse
->pstack
;
1015 parse
->pstack
= old
->prev
;
1016 FcStrBufDestroy (&old
->str
);
1017 if (old
->attr
&& old
->attr
!= old
->attr_buf_static
)
1019 FcMemFree (FC_MEM_ATTR
, 1); /* size is to expensive */
1023 if (old
== &parse
->pstack_static
[parse
->pstack_static_used
- 1])
1024 parse
->pstack_static_used
--;
1027 FcMemFree (FC_MEM_PSTACK
, sizeof (FcPStack
));
1034 FcConfigInit (FcConfigParse
*parse
, const FcChar8
*name
, FcConfig
*config
, XML_Parser parser
)
1037 parse
->pstack_static_used
= 0;
1039 parse
->vstack_static_used
= 0;
1040 parse
->error
= FcFalse
;
1042 parse
->config
= config
;
1043 parse
->parser
= parser
;
1048 FcConfigCleanup (FcConfigParse
*parse
)
1050 while (parse
->pstack
)
1051 FcPStackPop (parse
);
1054 static const FcChar8
*
1055 FcConfigGetAttribute (FcConfigParse
*parse
, const char *attr
)
1061 attrs
= parse
->pstack
->attr
;
1067 if (!strcmp ((char *) *attrs
, attr
))
1075 FcStartElement(void *userData
, const XML_Char
*name
, const XML_Char
**attr
)
1077 FcConfigParse
*parse
= userData
;
1080 element
= FcElementMap (name
);
1081 if (element
== FcElementUnknown
)
1082 FcConfigMessage (parse
, FcSevereWarning
, "unknown element \"%s\"", name
);
1084 if (!FcPStackPush (parse
, element
, attr
))
1086 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1093 FcParseBlank (FcConfigParse
*parse
)
1095 int n
= FcVStackElements (parse
);
1099 FcVStack
*v
= FcVStackFetch (parse
, n
);
1100 if (!parse
->config
->blanks
)
1102 parse
->config
->blanks
= FcBlanksCreate ();
1103 if (!parse
->config
->blanks
)
1107 case FcVStackInteger
:
1108 if (!FcBlanksAdd (parse
->config
->blanks
, v
->u
.integer
))
1112 for (i
= v
->u
.range
.begin
; i
<= v
->u
.range
.end
; i
++)
1114 if (!FcBlanksAdd (parse
->config
->blanks
, i
))
1119 FcConfigMessage (parse
, FcSevereError
, "invalid element in blank");
1125 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1129 FcParseRescan (FcConfigParse
*parse
)
1131 int n
= FcVStackElements (parse
);
1134 FcVStack
*v
= FcVStackFetch (parse
, n
);
1135 if (v
->tag
!= FcVStackInteger
)
1136 FcConfigMessage (parse
, FcSevereWarning
, "non-integer rescan");
1138 parse
->config
->rescanInterval
= v
->u
.integer
;
1143 FcParseInt (FcConfigParse
*parse
)
1150 s
= FcStrBufDoneStatic (&parse
->pstack
->str
);
1153 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1157 l
= (int) strtol ((char *) s
, (char **)&end
, 0);
1158 if (end
!= s
+ strlen ((char *) s
))
1159 FcConfigMessage (parse
, FcSevereError
, "\"%s\": not a valid integer", s
);
1161 FcVStackPushInteger (parse
, l
);
1162 FcStrBufDestroy (&parse
->pstack
->str
);
1166 * idea copied from glib g_ascii_strtod with
1167 * permission of the author (Alexander Larsson)
1173 FcStrtod (char *s
, char **end
)
1175 struct lconv
*locale_data
;
1180 * Have to swap the decimal point to match the current locale
1181 * if that locale doesn't use 0x2e
1183 if ((dot
= strchr (s
, 0x2e)) &&
1184 (locale_data
= localeconv ()) &&
1185 (locale_data
->decimal_point
[0] != 0x2e ||
1186 locale_data
->decimal_point
[1] != 0))
1189 int slen
= strlen (s
);
1190 int dlen
= strlen (locale_data
->decimal_point
);
1192 if (slen
+ dlen
> (int) sizeof (buf
))
1202 strncpy (buf
, s
, dot
- s
);
1204 strcpy (buf
+ (dot
- s
), locale_data
->decimal_point
);
1205 /* rest of number */
1206 strcpy (buf
+ (dot
- s
) + dlen
, dot
+ 1);
1208 v
= strtod (buf
, &buf_end
);
1210 buf_end
= s
+ (buf_end
- buf
);
1212 buf_end
-= dlen
- 1;
1219 v
= strtod (s
, end
);
1224 FcParseDouble (FcConfigParse
*parse
)
1231 s
= FcStrBufDoneStatic (&parse
->pstack
->str
);
1234 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1238 d
= FcStrtod ((char *) s
, (char **)&end
);
1239 if (end
!= s
+ strlen ((char *) s
))
1240 FcConfigMessage (parse
, FcSevereError
, "\"%s\": not a valid double", s
);
1242 FcVStackPushDouble (parse
, d
);
1243 FcStrBufDestroy (&parse
->pstack
->str
);
1247 FcParseString (FcConfigParse
*parse
, FcVStackTag tag
)
1253 s
= FcStrBufDone (&parse
->pstack
->str
);
1256 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1259 if (!FcVStackPushString (parse
, tag
, s
))
1264 FcParseMatrix (FcConfigParse
*parse
)
1267 enum { m_done
, m_xx
, m_xy
, m_yx
, m_yy
} matrix_state
= m_yy
;
1270 while ((vstack
= FcVStackPeek (parse
)))
1273 switch (vstack
->tag
) {
1274 case FcVStackInteger
:
1275 v
= vstack
->u
.integer
;
1277 case FcVStackDouble
:
1278 v
= vstack
->u
._double
;
1281 FcConfigMessage (parse
, FcSevereError
, "non-double matrix element");
1285 switch (matrix_state
) {
1286 case m_xx
: m
.xx
= v
; break;
1287 case m_xy
: m
.xy
= v
; break;
1288 case m_yx
: m
.yx
= v
; break;
1289 case m_yy
: m
.yy
= v
; break;
1292 FcVStackPopAndDestroy (parse
);
1295 if (matrix_state
!= m_done
)
1296 FcConfigMessage (parse
, FcSevereError
, "wrong number of matrix elements");
1298 FcVStackPushMatrix (parse
, &m
);
1302 FcParseRange (FcConfigParse
*parse
)
1309 while ((vstack
= FcVStackPeek (parse
)))
1313 FcConfigMessage (parse
, FcSevereError
, "too many elements in range");
1316 switch (vstack
->tag
) {
1317 case FcVStackInteger
:
1318 n
= vstack
->u
.integer
;
1321 FcConfigMessage (parse
, FcSevereError
, "invalid element in range");
1329 FcVStackPopAndDestroy (parse
);
1333 if (r
.begin
> r
.end
)
1335 FcConfigMessage (parse
, FcSevereError
, "invalid range");
1338 FcVStackPushRange (parse
, &r
);
1341 FcConfigMessage (parse
, FcSevereError
, "invalid range");
1345 FcConfigLexBool (FcConfigParse
*parse
, const FcChar8
*bool_
)
1347 FcBool result
= FcFalse
;
1349 if (!FcNameBool (bool_
, &result
))
1350 FcConfigMessage (parse
, FcSevereWarning
, "\"%s\" is not known boolean",
1356 FcParseBool (FcConfigParse
*parse
)
1362 s
= FcStrBufDoneStatic (&parse
->pstack
->str
);
1365 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1368 FcVStackPushBool (parse
, FcConfigLexBool (parse
, s
));
1369 FcStrBufDestroy (&parse
->pstack
->str
);
1373 FcParseCharSet (FcConfigParse
*parse
)
1376 FcCharSet
*charset
= FcCharSetCreate ();
1380 while ((vstack
= FcVStackPeek (parse
)))
1382 switch (vstack
->tag
) {
1383 case FcVStackInteger
:
1384 if (!FcCharSetAddChar (charset
, vstack
->u
.integer
))
1386 FcConfigMessage (parse
, FcSevereWarning
, "invalid character: 0x%04x", vstack
->u
.integer
);
1392 for (i
= vstack
->u
.range
.begin
; i
<= vstack
->u
.range
.end
; i
++)
1394 if (!FcCharSetAddChar (charset
, i
))
1396 FcConfigMessage (parse
, FcSevereWarning
, "invalid character: 0x%04x", i
);
1403 FcConfigMessage (parse
, FcSevereError
, "invalid element in charset");
1406 FcVStackPopAndDestroy (parse
);
1409 FcVStackPushCharSet (parse
, charset
);
1411 FcCharSetDestroy (charset
);
1415 FcConfigLexBinding (FcConfigParse
*parse
,
1416 const FcChar8
*binding_string
,
1417 FcValueBinding
*binding_ret
)
1419 FcValueBinding binding
;
1421 if (!binding_string
)
1422 binding
= FcValueBindingWeak
;
1425 if (!strcmp ((char *) binding_string
, "weak"))
1426 binding
= FcValueBindingWeak
;
1427 else if (!strcmp ((char *) binding_string
, "strong"))
1428 binding
= FcValueBindingStrong
;
1429 else if (!strcmp ((char *) binding_string
, "same"))
1430 binding
= FcValueBindingSame
;
1433 FcConfigMessage (parse
, FcSevereWarning
, "invalid binding \"%s\"", binding_string
);
1437 *binding_ret
= binding
;
1442 FcParseFamilies (FcConfigParse
*parse
, FcVStackTag tag
)
1445 FcExpr
*left
, *expr
= 0, *new;
1447 while ((vstack
= FcVStackPeek (parse
)))
1449 if (vstack
->tag
!= FcVStackFamily
)
1451 FcConfigMessage (parse
, FcSevereWarning
, "non-family");
1452 FcVStackPopAndDestroy (parse
);
1455 left
= vstack
->u
.expr
;
1456 vstack
->tag
= FcVStackNone
;
1457 FcVStackPopAndDestroy (parse
);
1460 new = FcExprCreateOp (parse
->config
, left
, FcOpComma
, expr
);
1463 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1464 FcExprDestroy (left
);
1465 FcExprDestroy (expr
);
1475 if (!FcVStackPushExpr (parse
, tag
, expr
))
1477 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1478 FcExprDestroy (expr
);
1484 FcParseFamily (FcConfigParse
*parse
)
1491 s
= FcStrBufDoneStatic (&parse
->pstack
->str
);
1494 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1497 expr
= FcExprCreateString (parse
->config
, s
);
1498 FcStrBufDestroy (&parse
->pstack
->str
);
1500 FcVStackPushExpr (parse
, FcVStackFamily
, expr
);
1504 FcParseAlias (FcConfigParse
*parse
)
1506 FcExpr
*family
= 0, *accept
= 0, *prefer
= 0, *def
= 0, *new = 0;
1507 FcEdit
*edit
= 0, *next
;
1510 FcValueBinding binding
;
1512 if (!FcConfigLexBinding (parse
, FcConfigGetAttribute (parse
, "binding"), &binding
))
1514 while ((vstack
= FcVStackPeek (parse
)))
1516 switch (vstack
->tag
) {
1517 case FcVStackFamily
:
1520 new = FcExprCreateOp (parse
->config
, vstack
->u
.expr
, FcOpComma
, family
);
1522 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1527 new = vstack
->u
.expr
;
1531 vstack
->tag
= FcVStackNone
;
1534 case FcVStackPrefer
:
1536 FcExprDestroy (prefer
);
1537 prefer
= vstack
->u
.expr
;
1538 vstack
->tag
= FcVStackNone
;
1540 case FcVStackAccept
:
1542 FcExprDestroy (accept
);
1543 accept
= vstack
->u
.expr
;
1544 vstack
->tag
= FcVStackNone
;
1546 case FcVStackDefault
:
1548 FcExprDestroy (def
);
1549 def
= vstack
->u
.expr
;
1550 vstack
->tag
= FcVStackNone
;
1553 FcConfigMessage (parse
, FcSevereWarning
, "bad alias");
1556 FcVStackPopAndDestroy (parse
);
1560 FcConfigMessage (parse
, FcSevereError
, "missing family in alias");
1562 FcExprDestroy (prefer
);
1564 FcExprDestroy (accept
);
1566 FcExprDestroy (def
);
1571 edit
= FcEditCreate (parse
,
1579 FcExprDestroy (prefer
);
1584 edit
= FcEditCreate (parse
,
1592 FcExprDestroy (accept
);
1597 edit
= FcEditCreate (parse
,
1605 FcExprDestroy (def
);
1609 test
= FcTestCreate (parse
, FcMatchPattern
,
1611 (FcChar8
*) FC_FAMILY
,
1615 if (!FcConfigAddEdit (parse
->config
, test
, edit
, FcMatchPattern
))
1616 FcTestDestroy (test
);
1619 FcExprDestroy (family
);
1623 FcPopExpr (FcConfigParse
*parse
)
1625 FcVStack
*vstack
= FcVStackPeek (parse
);
1629 switch (vstack
->tag
) {
1632 case FcVStackString
:
1633 case FcVStackFamily
:
1634 expr
= FcExprCreateString (parse
->config
, vstack
->u
.string
);
1637 expr
= FcExprCreateField (parse
->config
, (char *) vstack
->u
.string
);
1639 case FcVStackConstant
:
1640 expr
= FcExprCreateConst (parse
->config
, vstack
->u
.string
);
1643 /* XXX: What's the correct action here? (CDW) */
1645 case FcVStackPrefer
:
1646 case FcVStackAccept
:
1647 case FcVStackDefault
:
1648 expr
= vstack
->u
.expr
;
1649 vstack
->tag
= FcVStackNone
;
1651 case FcVStackInteger
:
1652 expr
= FcExprCreateInteger (parse
->config
, vstack
->u
.integer
);
1654 case FcVStackDouble
:
1655 expr
= FcExprCreateDouble (parse
->config
, vstack
->u
._double
);
1657 case FcVStackMatrix
:
1658 expr
= FcExprCreateMatrix (parse
->config
, vstack
->u
.matrix
);
1663 expr
= FcExprCreateBool (parse
->config
, vstack
->u
.bool_
);
1665 case FcVStackCharSet
:
1666 expr
= FcExprCreateCharSet (parse
->config
, vstack
->u
.charset
);
1671 expr
= vstack
->u
.expr
;
1672 vstack
->tag
= FcVStackNone
;
1679 FcVStackPopAndDestroy (parse
);
1684 * This builds a tree of binary operations. Note
1685 * that every operator is defined so that if only
1686 * a single operand is contained, the value of the
1687 * whole expression is the value of the operand.
1689 * This code reduces in that case to returning that
1693 FcPopBinary (FcConfigParse
*parse
, FcOp op
)
1695 FcExpr
*left
, *expr
= 0, *new;
1697 while ((left
= FcPopExpr (parse
)))
1701 new = FcExprCreateOp (parse
->config
, left
, op
, expr
);
1704 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1705 FcExprDestroy (left
);
1706 FcExprDestroy (expr
);
1718 FcParseBinary (FcConfigParse
*parse
, FcOp op
)
1720 FcExpr
*expr
= FcPopBinary (parse
, op
);
1722 FcVStackPushExpr (parse
, FcVStackExpr
, expr
);
1726 * This builds a a unary operator, it consumes only
1731 FcPopUnary (FcConfigParse
*parse
, FcOp op
)
1733 FcExpr
*operand
, *new = 0;
1735 if ((operand
= FcPopExpr (parse
)))
1737 new = FcExprCreateOp (parse
->config
, operand
, op
, 0);
1740 FcExprDestroy (operand
);
1741 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1748 FcParseUnary (FcConfigParse
*parse
, FcOp op
)
1750 FcExpr
*expr
= FcPopUnary (parse
, op
);
1752 FcVStackPushExpr (parse
, FcVStackExpr
, expr
);
1756 FcParseInclude (FcConfigParse
*parse
)
1760 FcBool ignore_missing
= FcFalse
;
1762 s
= FcStrBufDoneStatic (&parse
->pstack
->str
);
1765 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1768 i
= FcConfigGetAttribute (parse
, "ignore_missing");
1769 if (i
&& FcConfigLexBool (parse
, (FcChar8
*) i
) == FcTrue
)
1770 ignore_missing
= FcTrue
;
1771 if (!FcConfigParseAndLoad (parse
->config
, s
, !ignore_missing
))
1772 parse
->error
= FcTrue
;
1773 FcStrBufDestroy (&parse
->pstack
->str
);
1776 typedef struct _FcOpMap
{
1782 FcConfigLexOp (const FcChar8
*op
, const FcOpMap
*map
, int nmap
)
1786 for (i
= 0; i
< nmap
; i
++)
1787 if (!strcmp ((char *) op
, map
[i
].name
))
1792 static const FcOpMap fcCompareOps
[] = {
1793 { "eq", FcOpEqual
},
1794 { "not_eq", FcOpNotEqual
},
1795 { "less", FcOpLess
},
1796 { "less_eq", FcOpLessEqual
},
1797 { "more", FcOpMore
},
1798 { "more_eq", FcOpMoreEqual
},
1799 { "contains", FcOpContains
},
1800 { "not_contains", FcOpNotContains
}
1803 #define NUM_COMPARE_OPS (int) (sizeof fcCompareOps / sizeof fcCompareOps[0])
1806 FcConfigLexCompare (const FcChar8
*compare
)
1808 return FcConfigLexOp (compare
, fcCompareOps
, NUM_COMPARE_OPS
);
1812 FcParseTest (FcConfigParse
*parse
)
1814 const FcChar8
*kind_string
;
1816 const FcChar8
*qual_string
;
1818 const FcChar8
*name
;
1819 const FcChar8
*compare_string
;
1824 kind_string
= FcConfigGetAttribute (parse
, "target");
1826 kind
= FcMatchDefault
;
1829 if (!strcmp ((char *) kind_string
, "pattern"))
1830 kind
= FcMatchPattern
;
1831 else if (!strcmp ((char *) kind_string
, "font"))
1833 else if (!strcmp ((char *) kind_string
, "scan"))
1835 else if (!strcmp ((char *) kind_string
, "default"))
1836 kind
= FcMatchDefault
;
1839 FcConfigMessage (parse
, FcSevereWarning
, "invalid test target \"%s\"", kind_string
);
1843 qual_string
= FcConfigGetAttribute (parse
, "qual");
1848 if (!strcmp ((char *) qual_string
, "any"))
1850 else if (!strcmp ((char *) qual_string
, "all"))
1852 else if (!strcmp ((char *) qual_string
, "first"))
1854 else if (!strcmp ((char *) qual_string
, "not_first"))
1855 qual
= FcQualNotFirst
;
1858 FcConfigMessage (parse
, FcSevereWarning
, "invalid test qual \"%s\"", qual_string
);
1862 name
= FcConfigGetAttribute (parse
, "name");
1865 FcConfigMessage (parse
, FcSevereWarning
, "missing test name");
1868 compare_string
= FcConfigGetAttribute (parse
, "compare");
1869 if (!compare_string
)
1870 compare
= FcOpEqual
;
1873 compare
= FcConfigLexCompare (compare_string
);
1874 if (compare
== FcOpInvalid
)
1876 FcConfigMessage (parse
, FcSevereWarning
, "invalid test compare \"%s\"", compare_string
);
1880 expr
= FcPopBinary (parse
, FcOpComma
);
1883 FcConfigMessage (parse
, FcSevereWarning
, "missing test expression");
1886 test
= FcTestCreate (parse
, kind
, qual
, name
, compare
, expr
);
1889 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1892 FcVStackPushTest (parse
, test
);
1895 static const FcOpMap fcModeOps
[] = {
1896 { "assign", FcOpAssign
},
1897 { "assign_replace", FcOpAssignReplace
},
1898 { "prepend", FcOpPrepend
},
1899 { "prepend_first", FcOpPrependFirst
},
1900 { "append", FcOpAppend
},
1901 { "append_last", FcOpAppendLast
},
1904 #define NUM_MODE_OPS (int) (sizeof fcModeOps / sizeof fcModeOps[0])
1907 FcConfigLexMode (const FcChar8
*mode
)
1909 return FcConfigLexOp (mode
, fcModeOps
, NUM_MODE_OPS
);
1913 FcParseEdit (FcConfigParse
*parse
)
1915 const FcChar8
*name
;
1916 const FcChar8
*mode_string
;
1918 FcValueBinding binding
;
1922 name
= FcConfigGetAttribute (parse
, "name");
1925 FcConfigMessage (parse
, FcSevereWarning
, "missing edit name");
1928 mode_string
= FcConfigGetAttribute (parse
, "mode");
1933 mode
= FcConfigLexMode (mode_string
);
1934 if (mode
== FcOpInvalid
)
1936 FcConfigMessage (parse
, FcSevereWarning
, "invalid edit mode \"%s\"", mode_string
);
1940 if (!FcConfigLexBinding (parse
, FcConfigGetAttribute (parse
, "binding"), &binding
))
1943 expr
= FcPopBinary (parse
, FcOpComma
);
1944 edit
= FcEditCreate (parse
, FcObjectFromName ((char *) name
),
1945 mode
, expr
, binding
);
1948 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1949 FcExprDestroy (expr
);
1952 if (!FcVStackPushEdit (parse
, edit
))
1953 FcEditDestroy (edit
);
1957 FcParseMatch (FcConfigParse
*parse
)
1959 const FcChar8
*kind_name
;
1965 kind_name
= FcConfigGetAttribute (parse
, "target");
1967 kind
= FcMatchPattern
;
1970 if (!strcmp ((char *) kind_name
, "pattern"))
1971 kind
= FcMatchPattern
;
1972 else if (!strcmp ((char *) kind_name
, "font"))
1974 else if (!strcmp ((char *) kind_name
, "scan"))
1978 FcConfigMessage (parse
, FcSevereWarning
, "invalid match target \"%s\"", kind_name
);
1982 while ((vstack
= FcVStackPeek (parse
)))
1984 switch (vstack
->tag
) {
1986 vstack
->u
.test
->next
= test
;
1987 test
= vstack
->u
.test
;
1988 vstack
->tag
= FcVStackNone
;
1991 vstack
->u
.edit
->next
= edit
;
1992 edit
= vstack
->u
.edit
;
1993 vstack
->tag
= FcVStackNone
;
1994 if (kind
== FcMatchScan
&& edit
->object
> FC_MAX_BASE_OBJECT
)
1996 FcConfigMessage (parse
, FcSevereError
,
1997 "<match target=\"scan\"> cannot edit user-defined object \"%s\"",
1998 FcObjectName(edit
->object
));
2002 FcConfigMessage (parse
, FcSevereWarning
, "invalid match element");
2005 FcVStackPopAndDestroy (parse
);
2007 if (!FcConfigAddEdit (parse
->config
, test
, edit
, kind
))
2008 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2012 FcParseAcceptRejectFont (FcConfigParse
*parse
, FcElement element
)
2016 while ((vstack
= FcVStackPeek (parse
)))
2018 switch (vstack
->tag
) {
2020 if (!FcConfigGlobAdd (parse
->config
,
2022 element
== FcElementAcceptfont
))
2024 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2027 case FcVStackPattern
:
2028 if (!FcConfigPatternsAdd (parse
->config
,
2030 element
== FcElementAcceptfont
))
2032 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2035 vstack
->tag
= FcVStackNone
;
2038 FcConfigMessage (parse
, FcSevereWarning
, "bad font selector");
2041 FcVStackPopAndDestroy (parse
);
2047 FcPopValue (FcConfigParse
*parse
)
2049 FcVStack
*vstack
= FcVStackPeek (parse
);
2052 value
.type
= FcTypeVoid
;
2057 switch (vstack
->tag
) {
2058 case FcVStackString
:
2059 value
.u
.s
= FcStrStaticName (vstack
->u
.string
);
2061 value
.type
= FcTypeString
;
2063 case FcVStackConstant
:
2064 if (FcNameConstant (vstack
->u
.string
, &value
.u
.i
))
2065 value
.type
= FcTypeInteger
;
2067 case FcVStackInteger
:
2068 value
.u
.i
= vstack
->u
.integer
;
2069 value
.type
= FcTypeInteger
;
2071 case FcVStackDouble
:
2072 value
.u
.d
= vstack
->u
._double
;
2073 value
.type
= FcTypeInteger
;
2075 case FcVStackMatrix
:
2076 value
.u
.m
= FcMatrixCopy (vstack
->u
.matrix
);
2078 value
.type
= FcTypeMatrix
;
2081 value
.u
.b
= vstack
->u
.bool_
;
2082 value
.type
= FcTypeBool
;
2084 case FcVStackCharSet
:
2085 value
.u
.c
= FcCharSetCopy (vstack
->u
.charset
);
2087 value
.type
= FcTypeCharSet
;
2090 FcConfigMessage (parse
, FcSevereWarning
, "unknown pattern element %d",
2094 FcVStackPopAndDestroy (parse
);
2100 FcParsePatelt (FcConfigParse
*parse
)
2103 FcPattern
*pattern
= FcPatternCreate ();
2108 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2112 name
= (char *) FcConfigGetAttribute (parse
, "name");
2115 FcConfigMessage (parse
, FcSevereWarning
, "missing pattern element name");
2116 FcPatternDestroy (pattern
);
2122 value
= FcPopValue (parse
);
2123 if (value
.type
== FcTypeVoid
)
2125 if (!FcPatternAdd (pattern
, name
, value
, FcTrue
))
2127 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2128 FcValueDestroy(value
);
2131 FcValueDestroy(value
);
2134 FcVStackPushPattern (parse
, pattern
);
2138 FcParsePattern (FcConfigParse
*parse
)
2141 FcPattern
*pattern
= FcPatternCreate ();
2145 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2149 while ((vstack
= FcVStackPeek (parse
)))
2151 switch (vstack
->tag
) {
2152 case FcVStackPattern
:
2153 if (!FcPatternAppend (pattern
, vstack
->u
.pattern
))
2155 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2156 FcPatternDestroy (pattern
);
2161 FcConfigMessage (parse
, FcSevereWarning
, "unknown pattern element");
2164 FcVStackPopAndDestroy (parse
);
2167 FcVStackPushPattern (parse
, pattern
);
2171 FcEndElement(void *userData
, const XML_Char
*name
)
2173 FcConfigParse
*parse
= userData
;
2176 FcChar8 buffer
[1000];
2181 switch (parse
->pstack
->element
) {
2184 case FcElementFontconfig
:
2187 data
= FcStrBufDoneStatic (&parse
->pstack
->str
);
2190 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2194 if (strcmp (data
, "CUSTOMFONTDIR") == 0)
2198 if (!GetModuleFileName (NULL
, buffer
, sizeof (buffer
) - 20))
2200 FcConfigMessage (parse
, FcSevereError
, "GetModuleFileName failed");
2204 * Must use the multi-byte aware function to search
2205 * for backslash because East Asian double-byte code
2206 * pages have characters with backslash as the second
2209 p
= _mbsrchr (data
, '\\');
2211 strcat (data
, "\\fonts");
2213 else if (strcmp (data
, "APPSHAREFONTDIR") == 0)
2217 if (!GetModuleFileName (NULL
, buffer
, sizeof (buffer
) - 20))
2219 FcConfigMessage (parse
, FcSevereError
, "GetModuleFileName failed");
2222 p
= _mbsrchr (data
, '\\');
2224 strcat (data
, "\\..\\share\\fonts");
2226 else if (strcmp (data
, "WINDOWSFONTDIR") == 0)
2230 #if _WIN32_WINNT >= 0x0500
2231 rc
= GetSystemWindowsDirectory (buffer
, sizeof (buffer
) - 20);
2233 rc
= GetWindowsDirectory (buffer
, sizeof (buffer
) - 20);
2235 if (rc
== 0 || rc
> sizeof (buffer
) - 20)
2237 FcConfigMessage (parse
, FcSevereError
, "GetSystemWindowsDirectory failed");
2240 if (data
[strlen (data
) - 1] != '\\')
2241 strcat (data
, "\\");
2242 strcat (data
, "fonts");
2245 if (strlen ((char *) data
) == 0)
2246 FcConfigMessage (parse
, FcSevereWarning
, "empty font directory name ignored");
2247 else if (!FcStrUsesHome (data
) || FcConfigHome ())
2249 if (!FcConfigAddDir (parse
->config
, data
))
2250 FcConfigMessage (parse
, FcSevereError
, "out of memory; cannot add directory %s", data
);
2252 FcStrBufDestroy (&parse
->pstack
->str
);
2254 case FcElementCacheDir
:
2255 data
= FcStrBufDone (&parse
->pstack
->str
);
2258 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2262 if (strcmp (data
, "WINDOWSTEMPDIR_FONTCONFIG_CACHE") == 0)
2266 data
= malloc (1000);
2269 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2272 FcMemAlloc (FC_MEM_STRING
, 1000);
2273 rc
= GetTempPath (800, data
);
2274 if (rc
== 0 || rc
> 800)
2276 FcConfigMessage (parse
, FcSevereError
, "GetTempPath failed");
2280 if (data
[strlen (data
) - 1] != '\\')
2281 strcat (data
, "\\");
2282 strcat (data
, "fontconfig\\cache");
2285 if (!FcStrUsesHome (data
) || FcConfigHome ())
2287 if (!FcConfigAddCacheDir (parse
->config
, data
))
2288 FcConfigMessage (parse
, FcSevereError
, "out of memory; cannot add cache directory %s", data
);
2293 case FcElementCache
:
2294 data
= FcStrBufDoneStatic (&parse
->pstack
->str
);
2297 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2300 /* discard this data; no longer used */
2301 FcStrBufDestroy (&parse
->pstack
->str
);
2303 case FcElementInclude
:
2304 FcParseInclude (parse
);
2306 case FcElementConfig
:
2308 case FcElementMatch
:
2309 FcParseMatch (parse
);
2311 case FcElementAlias
:
2312 FcParseAlias (parse
);
2315 case FcElementBlank
:
2316 FcParseBlank (parse
);
2318 case FcElementRescan
:
2319 FcParseRescan (parse
);
2322 case FcElementPrefer
:
2323 FcParseFamilies (parse
, FcVStackPrefer
);
2325 case FcElementAccept
:
2326 FcParseFamilies (parse
, FcVStackAccept
);
2328 case FcElementDefault
:
2329 FcParseFamilies (parse
, FcVStackDefault
);
2331 case FcElementFamily
:
2332 FcParseFamily (parse
);
2336 FcParseTest (parse
);
2339 FcParseEdit (parse
);
2345 case FcElementDouble
:
2346 FcParseDouble (parse
);
2348 case FcElementString
:
2349 FcParseString (parse
, FcVStackString
);
2351 case FcElementMatrix
:
2352 FcParseMatrix (parse
);
2354 case FcElementRange
:
2355 FcParseRange (parse
);
2358 FcParseBool (parse
);
2360 case FcElementCharSet
:
2361 FcParseCharSet (parse
);
2363 case FcElementSelectfont
:
2365 case FcElementAcceptfont
:
2366 case FcElementRejectfont
:
2367 FcParseAcceptRejectFont (parse
, parse
->pstack
->element
);
2370 FcParseString (parse
, FcVStackGlob
);
2372 case FcElementPattern
:
2373 FcParsePattern (parse
);
2375 case FcElementPatelt
:
2376 FcParsePatelt (parse
);
2379 FcParseString (parse
, FcVStackField
);
2381 case FcElementConst
:
2382 FcParseString (parse
, FcVStackConstant
);
2385 FcParseBinary (parse
, FcOpOr
);
2388 FcParseBinary (parse
, FcOpAnd
);
2391 FcParseBinary (parse
, FcOpEqual
);
2393 case FcElementNotEq
:
2394 FcParseBinary (parse
, FcOpNotEqual
);
2397 FcParseBinary (parse
, FcOpLess
);
2399 case FcElementLessEq
:
2400 FcParseBinary (parse
, FcOpLessEqual
);
2403 FcParseBinary (parse
, FcOpMore
);
2405 case FcElementMoreEq
:
2406 FcParseBinary (parse
, FcOpMoreEqual
);
2408 case FcElementContains
:
2409 FcParseBinary (parse
, FcOpContains
);
2411 case FcElementNotContains
:
2412 FcParseBinary (parse
, FcOpNotContains
);
2415 FcParseBinary (parse
, FcOpPlus
);
2417 case FcElementMinus
:
2418 FcParseBinary (parse
, FcOpMinus
);
2420 case FcElementTimes
:
2421 FcParseBinary (parse
, FcOpTimes
);
2423 case FcElementDivide
:
2424 FcParseBinary (parse
, FcOpDivide
);
2427 FcParseUnary (parse
, FcOpNot
);
2430 FcParseBinary (parse
, FcOpQuest
);
2432 case FcElementFloor
:
2433 FcParseUnary (parse
, FcOpFloor
);
2436 FcParseUnary (parse
, FcOpCeil
);
2438 case FcElementRound
:
2439 FcParseUnary (parse
, FcOpRound
);
2441 case FcElementTrunc
:
2442 FcParseUnary (parse
, FcOpTrunc
);
2444 case FcElementUnknown
:
2447 (void) FcPStackPop (parse
);
2451 FcCharacterData (void *userData
, const XML_Char
*s
, int len
)
2453 FcConfigParse
*parse
= userData
;
2457 if (!FcStrBufData (&parse
->pstack
->str
, (FcChar8
*) s
, len
))
2458 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2462 FcStartDoctypeDecl (void *userData
,
2463 const XML_Char
*doctypeName
,
2464 const XML_Char
*sysid
,
2465 const XML_Char
*pubid
,
2466 int has_internal_subset
)
2468 FcConfigParse
*parse
= userData
;
2470 if (strcmp ((char *) doctypeName
, "fontconfig") != 0)
2471 FcConfigMessage (parse
, FcSevereError
, "invalid doctype \"%s\"", doctypeName
);
2474 #ifdef ENABLE_LIBXML2
2477 FcInternalSubsetDecl (void *userData
,
2478 const XML_Char
*doctypeName
,
2479 const XML_Char
*sysid
,
2480 const XML_Char
*pubid
)
2482 FcStartDoctypeDecl (userData
, doctypeName
, sysid
, pubid
, 1);
2486 FcExternalSubsetDecl (void *userData
,
2487 const XML_Char
*doctypeName
,
2488 const XML_Char
*sysid
,
2489 const XML_Char
*pubid
)
2491 FcStartDoctypeDecl (userData
, doctypeName
, sysid
, pubid
, 0);
2494 #else /* ENABLE_LIBXML2 */
2497 FcEndDoctypeDecl (void *userData
)
2501 #endif /* ENABLE_LIBXML2 */
2504 FcSortCmpStr (const void *a
, const void *b
)
2506 const FcChar8
*as
= *((FcChar8
**) a
);
2507 const FcChar8
*bs
= *((FcChar8
**) b
);
2508 return FcStrCmp (as
, bs
);
2512 FcConfigParseAndLoadDir (FcConfig
*config
,
2513 const FcChar8
*name
,
2519 FcBool ret
= FcTrue
;
2524 d
= opendir ((char *) dir
);
2528 FcConfigMessage (0, FcSevereError
, "Cannot open config dir \"%s\"",
2534 file
= (FcChar8
*) malloc (strlen ((char *) dir
) + 1 + FC_MAX_FILE_LEN
+ 1);
2541 strcpy ((char *) file
, (char *) dir
);
2542 strcat ((char *) file
, "/");
2543 base
= file
+ strlen ((char *) file
);
2545 files
= FcStrSetCreate ();
2552 if (FcDebug () & FC_DBG_CONFIG
)
2553 printf ("\tScanning config dir %s\n", dir
);
2555 while (ret
&& (e
= readdir (d
)))
2558 #define TAIL ".conf"
2561 * Add all files of the form [0-9]*.conf
2563 if ('0' <= e
->d_name
[0] && e
->d_name
[0] <= '9' &&
2564 (d_len
= strlen (e
->d_name
)) < FC_MAX_FILE_LEN
&&
2566 strcmp (e
->d_name
+ d_len
- TAIL_LEN
, TAIL
) == 0)
2568 strcpy ((char *) base
, (char *) e
->d_name
);
2569 if (!FcStrSetAdd (files
, file
))
2579 qsort (files
->strs
, files
->num
, sizeof (FcChar8
*),
2580 (int (*)(const void *, const void *)) FcSortCmpStr
);
2581 for (i
= 0; ret
&& i
< files
->num
; i
++)
2582 ret
= FcConfigParseAndLoad (config
, files
->strs
[i
], complain
);
2585 FcStrSetDestroy (files
);
2591 return ret
|| !complain
;
2595 FcConfigParseAndLoad (FcConfig
*config
,
2596 const FcChar8
*name
,
2604 FcConfigParse parse
;
2605 FcBool error
= FcTrue
;
2607 #ifdef ENABLE_LIBXML2
2614 filename
= FcConfigFilename (name
);
2618 if (FcStrSetMember (config
->configFiles
, filename
))
2620 FcStrFree (filename
);
2624 if (!FcStrSetAdd (config
->configFiles
, filename
))
2626 FcStrFree (filename
);
2630 if (FcFileIsDir (filename
))
2632 FcBool ret
= FcConfigParseAndLoadDir (config
, name
, filename
, complain
);
2633 FcStrFree (filename
);
2637 if (FcDebug () & FC_DBG_CONFIG
)
2638 printf ("\tLoading config file %s\n", filename
);
2640 fd
= open ((char *) filename
, O_RDONLY
);
2642 FcStrFree (filename
);
2646 #ifdef ENABLE_LIBXML2
2647 memset(&sax
, 0, sizeof(sax
));
2649 sax
.internalSubset
= FcInternalSubsetDecl
;
2650 sax
.externalSubset
= FcExternalSubsetDecl
;
2651 sax
.startElement
= FcStartElement
;
2652 sax
.endElement
= FcEndElement
;
2653 sax
.characters
= FcCharacterData
;
2655 p
= xmlCreatePushParserCtxt (&sax
, &parse
, NULL
, 0, (const char *) filename
);
2657 p
= XML_ParserCreate ("UTF-8");
2659 FcStrFree (filename
);
2664 if (!FcConfigInit (&parse
, name
, config
, p
))
2667 #ifndef ENABLE_LIBXML2
2669 XML_SetUserData (p
, &parse
);
2671 XML_SetDoctypeDeclHandler (p
, FcStartDoctypeDecl
, FcEndDoctypeDecl
);
2672 XML_SetElementHandler (p
, FcStartElement
, FcEndElement
);
2673 XML_SetCharacterDataHandler (p
, FcCharacterData
);
2675 #endif /* ENABLE_LIBXML2 */
2678 #ifndef ENABLE_LIBXML2
2679 buf
= XML_GetBuffer (p
, BUFSIZ
);
2682 FcConfigMessage (&parse
, FcSevereError
, "cannot get parse buffer");
2686 len
= read (fd
, buf
, BUFSIZ
);
2689 FcConfigMessage (&parse
, FcSevereError
, "failed reading config file");
2693 #ifdef ENABLE_LIBXML2
2694 if (xmlParseChunk (p
, buf
, len
, len
== 0))
2696 if (!XML_ParseBuffer (p
, len
, len
== 0))
2699 FcConfigMessage (&parse
, FcSevereError
, "%s",
2700 XML_ErrorString (XML_GetErrorCode (p
)));
2704 error
= parse
.error
;
2706 FcConfigCleanup (&parse
);
2713 if (error
&& complain
)
2716 FcConfigMessage (0, FcSevereError
, "Cannot load config file \"%s\"", name
);
2718 FcConfigMessage (0, FcSevereError
, "Cannot load default config file");
2724 #include "fcaliastail.h"