]>
git.wh0rd.org - fontconfig.git/blob - src/fcxml.c
2 * fontconfig/src/fcxml.c
4 * Copyright © 2002 Keith Packard
6 * Permission to use, copy, modify, distribute, and sell this software and its
7 * documentation for any purpose is hereby granted without fee, provided that
8 * the above copyright notice appear in all copies and that both that
9 * copyright notice and this permission notice appear in supporting
10 * documentation, and that the name of 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 FcExprCreateLangSet (FcConfig
*config
, FcLangSet
*langset
)
151 FcExpr
*e
= FcConfigAllocExpr (config
);
155 e
->u
.lval
= FcLangSetCopy (langset
);
161 FcExprCreateField (FcConfig
*config
, const char *field
)
163 FcExpr
*e
= FcConfigAllocExpr (config
);
167 e
->u
.object
= FcObjectFromName (field
);
173 FcExprCreateConst (FcConfig
*config
, const FcChar8
*constant
)
175 FcExpr
*e
= FcConfigAllocExpr (config
);
179 e
->u
.constant
= FcStrStaticName (constant
);
185 FcExprCreateOp (FcConfig
*config
, FcExpr
*left
, FcOp op
, FcExpr
*right
)
187 FcExpr
*e
= FcConfigAllocExpr (config
);
191 e
->u
.tree
.left
= left
;
192 e
->u
.tree
.right
= right
;
198 FcExprDestroy (FcExpr
*e
)
210 FcMatrixFree (e
->u
.mval
);
215 FcCharSetDestroy (e
->u
.cval
);
218 FcLangSetDestroy (e
->u
.lval
);
227 case FcOpAssignReplace
:
229 case FcOpPrependFirst
:
243 case FcOpNotContains
:
250 FcExprDestroy (e
->u
.tree
.right
);
257 FcExprDestroy (e
->u
.tree
.left
);
268 FcEditDestroy (FcEdit
*e
)
271 FcEditDestroy (e
->next
);
273 FcExprDestroy (e
->expr
);
277 typedef enum _FcElement
{
324 FcElementNotContains
,
338 static const struct {
342 { "fontconfig", FcElementFontconfig
},
343 { "dir", FcElementDir
},
344 { "cachedir", FcElementCacheDir
},
345 { "cache", FcElementCache
},
346 { "include", FcElementInclude
},
347 { "config", FcElementConfig
},
348 { "match", FcElementMatch
},
349 { "alias", FcElementAlias
},
351 { "blank", FcElementBlank
},
352 { "rescan", FcElementRescan
},
354 { "prefer", FcElementPrefer
},
355 { "accept", FcElementAccept
},
356 { "default", FcElementDefault
},
357 { "family", FcElementFamily
},
359 { "selectfont", FcElementSelectfont
},
360 { "acceptfont", FcElementAcceptfont
},
361 { "rejectfont", FcElementRejectfont
},
362 { "glob", FcElementGlob
},
363 { "pattern", FcElementPattern
},
364 { "patelt", FcElementPatelt
},
366 { "test", FcElementTest
},
367 { "edit", FcElementEdit
},
368 { "int", FcElementInt
},
369 { "double", FcElementDouble
},
370 { "string", FcElementString
},
371 { "matrix", FcElementMatrix
},
372 { "range", FcElementRange
},
373 { "bool", FcElementBool
},
374 { "charset", FcElementCharSet
},
375 { "langset", FcElementLangSet
},
376 { "name", FcElementName
},
377 { "const", FcElementConst
},
378 { "or", FcElementOr
},
379 { "and", FcElementAnd
},
380 { "eq", FcElementEq
},
381 { "not_eq", FcElementNotEq
},
382 { "less", FcElementLess
},
383 { "less_eq", FcElementLessEq
},
384 { "more", FcElementMore
},
385 { "more_eq", FcElementMoreEq
},
386 { "contains", FcElementContains
},
387 { "not_contains", FcElementNotContains
},
388 { "plus", FcElementPlus
},
389 { "minus", FcElementMinus
},
390 { "times", FcElementTimes
},
391 { "divide", FcElementDivide
},
392 { "not", FcElementNot
},
393 { "if", FcElementIf
},
394 { "floor", FcElementFloor
},
395 { "ceil", FcElementCeil
},
396 { "round", FcElementRound
},
397 { "trunc", FcElementTrunc
},
399 #define NUM_ELEMENT_MAPS (int) (sizeof fcElementMap / sizeof fcElementMap[0])
402 FcElementMap (const XML_Char
*name
)
406 for (i
= 0; i
< NUM_ELEMENT_MAPS
; i
++)
407 if (!strcmp ((char *) name
, fcElementMap
[i
].name
))
408 return fcElementMap
[i
].element
;
409 return FcElementUnknown
;
412 typedef struct _FcPStack
{
413 struct _FcPStack
*prev
;
417 FcChar8
*attr_buf_static
[16];
420 typedef enum _FcVStackTag
{
447 typedef struct _FcVStack
{
448 struct _FcVStack
*prev
;
449 FcPStack
*pstack
; /* related parse element */
472 typedef struct _FcConfigParse
{
479 int pstack_static_used
;
480 FcPStack pstack_static
[8];
481 int vstack_static_used
;
482 FcVStack vstack_static
[64];
485 typedef enum _FcConfigSeverity
{
486 FcSevereInfo
, FcSevereWarning
, FcSevereError
490 FcConfigMessage (FcConfigParse
*parse
, FcConfigSeverity severe
, const char *fmt
, ...)
492 const char *s
= "unknown";
495 va_start (args
, fmt
);
498 case FcSevereInfo
: s
= "info"; break;
499 case FcSevereWarning
: s
= "warning"; break;
500 case FcSevereError
: s
= "error"; break;
505 fprintf (stderr
, "Fontconfig %s: \"%s\", line %d: ", s
,
506 parse
->name
, (int)XML_GetCurrentLineNumber (parse
->parser
));
508 fprintf (stderr
, "Fontconfig %s: line %d: ", s
,
509 (int)XML_GetCurrentLineNumber (parse
->parser
));
510 if (severe
>= FcSevereError
)
511 parse
->error
= FcTrue
;
514 fprintf (stderr
, "Fontconfig %s: ", s
);
515 vfprintf (stderr
, fmt
, args
);
516 fprintf (stderr
, "\n");
522 FcTypeName (FcType type
)
548 FcTypecheckValue (FcConfigParse
*parse
, FcType value
, FcType type
)
550 if (value
== FcTypeInteger
)
551 value
= FcTypeDouble
;
552 if (type
== FcTypeInteger
)
556 if ((value
== FcTypeLangSet
&& type
== FcTypeString
) ||
557 (value
== FcTypeString
&& type
== FcTypeLangSet
))
559 if (type
== (FcType
) -1)
561 FcConfigMessage (parse
, FcSevereWarning
, "saw %s, expected %s",
562 FcTypeName (value
), FcTypeName (type
));
567 FcTypecheckExpr (FcConfigParse
*parse
, FcExpr
*expr
, FcType type
)
569 const FcObjectType
*o
;
572 /* If parsing the expression failed, some nodes may be NULL */
579 FcTypecheckValue (parse
, FcTypeDouble
, type
);
582 FcTypecheckValue (parse
, FcTypeString
, type
);
585 FcTypecheckValue (parse
, FcTypeMatrix
, type
);
588 FcTypecheckValue (parse
, FcTypeBool
, type
);
591 FcTypecheckValue (parse
, FcTypeCharSet
, type
);
594 FcTypecheckValue (parse
, FcTypeLangSet
, type
);
599 o
= FcNameGetObjectType (FcObjectName (expr
->u
.object
));
601 FcTypecheckValue (parse
, o
->type
, type
);
604 c
= FcNameGetConstant (expr
->u
.constant
);
607 o
= FcNameGetObjectType (c
->object
);
609 FcTypecheckValue (parse
, o
->type
, type
);
612 FcConfigMessage (parse
, FcSevereWarning
,
613 "invalid constant used : %s",
617 FcTypecheckExpr (parse
, expr
->u
.tree
.left
, FcTypeBool
);
618 FcTypecheckExpr (parse
, expr
->u
.tree
.right
->u
.tree
.left
, type
);
619 FcTypecheckExpr (parse
, expr
->u
.tree
.right
->u
.tree
.right
, type
);
622 case FcOpAssignReplace
:
631 case FcOpNotContains
:
633 FcTypecheckValue (parse
, FcTypeBool
, type
);
642 FcTypecheckExpr (parse
, expr
->u
.tree
.left
, type
);
643 FcTypecheckExpr (parse
, expr
->u
.tree
.right
, type
);
646 FcTypecheckValue (parse
, FcTypeBool
, type
);
647 FcTypecheckExpr (parse
, expr
->u
.tree
.left
, FcTypeBool
);
653 FcTypecheckValue (parse
, FcTypeDouble
, type
);
654 FcTypecheckExpr (parse
, expr
->u
.tree
.left
, FcTypeDouble
);
662 FcTestCreate (FcConfigParse
*parse
,
665 const FcChar8
*field
,
669 FcTest
*test
= (FcTest
*) malloc (sizeof (FcTest
));
673 const FcObjectType
*o
;
675 FcMemAlloc (FC_MEM_TEST
, sizeof (FcTest
));
679 test
->object
= FcObjectFromName ((const char *) field
);
682 o
= FcNameGetObjectType (FcObjectName (test
->object
));
684 FcTypecheckExpr (parse
, expr
, o
->type
);
690 FcEditCreate (FcConfigParse
*parse
,
694 FcValueBinding binding
)
696 FcEdit
*e
= (FcEdit
*) malloc (sizeof (FcEdit
));
700 const FcObjectType
*o
;
706 e
->binding
= binding
;
707 o
= FcNameGetObjectType (FcObjectName (e
->object
));
709 FcTypecheckExpr (parse
, expr
, o
->type
);
715 FcVStackCreateAndPush (FcConfigParse
*parse
)
719 if (parse
->vstack_static_used
< sizeof (parse
->vstack_static
) / sizeof (parse
->vstack_static
[0]))
720 new = &parse
->vstack_static
[parse
->vstack_static_used
++];
723 new = malloc (sizeof (FcVStack
));
726 FcMemAlloc (FC_MEM_VSTACK
, sizeof (FcVStack
));
728 new->tag
= FcVStackNone
;
731 new->prev
= parse
->vstack
;
732 new->pstack
= parse
->pstack
? parse
->pstack
->prev
: 0;
739 FcVStackPushString (FcConfigParse
*parse
, FcVStackTag tag
, FcChar8
*string
)
741 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
744 vstack
->u
.string
= string
;
750 FcVStackPushInteger (FcConfigParse
*parse
, int integer
)
752 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
755 vstack
->u
.integer
= integer
;
756 vstack
->tag
= FcVStackInteger
;
761 FcVStackPushDouble (FcConfigParse
*parse
, double _double
)
763 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
766 vstack
->u
._double
= _double
;
767 vstack
->tag
= FcVStackDouble
;
772 FcVStackPushMatrix (FcConfigParse
*parse
, FcMatrix
*matrix
)
775 matrix
= FcMatrixCopy (matrix
);
778 vstack
= FcVStackCreateAndPush (parse
);
781 vstack
->u
.matrix
= matrix
;
782 vstack
->tag
= FcVStackMatrix
;
787 FcVStackPushRange (FcConfigParse
*parse
, FcRange
*range
)
789 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
792 vstack
->u
.range
.begin
= range
->begin
;
793 vstack
->u
.range
.end
= range
->end
;
794 vstack
->tag
= FcVStackRange
;
799 FcVStackPushBool (FcConfigParse
*parse
, FcBool bool_
)
801 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
804 vstack
->u
.bool_
= bool_
;
805 vstack
->tag
= FcVStackBool
;
810 FcVStackPushCharSet (FcConfigParse
*parse
, FcCharSet
*charset
)
815 vstack
= FcVStackCreateAndPush (parse
);
818 vstack
->u
.charset
= charset
;
819 vstack
->tag
= FcVStackCharSet
;
824 FcVStackPushLangSet (FcConfigParse
*parse
, FcLangSet
*langset
)
829 vstack
= FcVStackCreateAndPush (parse
);
832 vstack
->u
.langset
= langset
;
833 vstack
->tag
= FcVStackLangSet
;
838 FcVStackPushTest (FcConfigParse
*parse
, FcTest
*test
)
840 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
843 vstack
->u
.test
= test
;
844 vstack
->tag
= FcVStackTest
;
849 FcVStackPushExpr (FcConfigParse
*parse
, FcVStackTag tag
, FcExpr
*expr
)
851 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
854 vstack
->u
.expr
= expr
;
860 FcVStackPushEdit (FcConfigParse
*parse
, FcEdit
*edit
)
862 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
865 vstack
->u
.edit
= edit
;
866 vstack
->tag
= FcVStackEdit
;
871 FcVStackPushPattern (FcConfigParse
*parse
, FcPattern
*pattern
)
873 FcVStack
*vstack
= FcVStackCreateAndPush (parse
);
876 vstack
->u
.pattern
= pattern
;
877 vstack
->tag
= FcVStackPattern
;
882 FcVStackFetch (FcConfigParse
*parse
, int off
)
886 for (vstack
= parse
->vstack
; vstack
&& off
-- > 0; vstack
= vstack
->prev
);
891 FcVStackPeek (FcConfigParse
*parse
)
893 FcVStack
*vstack
= parse
->vstack
;
895 return vstack
&& vstack
->pstack
== parse
->pstack
? vstack
: 0;
899 FcVStackPopAndDestroy (FcConfigParse
*parse
)
901 FcVStack
*vstack
= parse
->vstack
;
903 if (!vstack
|| vstack
->pstack
!= parse
->pstack
)
906 parse
->vstack
= vstack
->prev
;
908 switch (vstack
->tag
) {
915 case FcVStackConstant
:
917 FcStrFree (vstack
->u
.string
);
919 case FcVStackPattern
:
920 FcPatternDestroy (vstack
->u
.pattern
);
922 case FcVStackInteger
:
926 FcMatrixFree (vstack
->u
.matrix
);
931 case FcVStackCharSet
:
932 FcCharSetDestroy (vstack
->u
.charset
);
934 case FcVStackLangSet
:
935 FcLangSetDestroy (vstack
->u
.langset
);
938 FcTestDestroy (vstack
->u
.test
);
943 case FcVStackDefault
:
944 FcExprDestroy (vstack
->u
.expr
);
947 FcEditDestroy (vstack
->u
.edit
);
951 if (vstack
== &parse
->vstack_static
[parse
->vstack_static_used
- 1])
952 parse
->vstack_static_used
--;
955 FcMemFree (FC_MEM_VSTACK
, sizeof (FcVStack
));
961 FcVStackClear (FcConfigParse
*parse
)
963 while (FcVStackPeek (parse
))
964 FcVStackPopAndDestroy (parse
);
968 FcVStackElements (FcConfigParse
*parse
)
971 FcVStack
*vstack
= parse
->vstack
;
972 while (vstack
&& vstack
->pstack
== parse
->pstack
)
975 vstack
= vstack
->prev
;
981 FcConfigSaveAttr (const XML_Char
**attr
, FcChar8
**buf
, int size_bytes
)
991 for (i
= 0; attr
[i
]; i
++)
992 slen
+= strlen ((char *) attr
[i
]) + 1;
995 slen
+= (i
+ 1) * sizeof (FcChar8
*);
996 if (slen
<= size_bytes
)
1000 new = malloc (slen
);
1003 FcConfigMessage (0, FcSevereError
, "out of memory");
1006 FcMemAlloc (FC_MEM_ATTR
, 1); /* size is too expensive */
1008 s
= (FcChar8
*) (new + (i
+ 1));
1009 for (i
= 0; attr
[i
]; i
++)
1012 strcpy ((char *) s
, (char *) attr
[i
]);
1013 s
+= strlen ((char *) s
) + 1;
1020 FcPStackPush (FcConfigParse
*parse
, FcElement element
, const XML_Char
**attr
)
1024 if (parse
->pstack_static_used
< sizeof (parse
->pstack_static
) / sizeof (parse
->pstack_static
[0]))
1025 new = &parse
->pstack_static
[parse
->pstack_static_used
++];
1028 new = malloc (sizeof (FcPStack
));
1031 FcMemAlloc (FC_MEM_PSTACK
, sizeof (FcPStack
));
1034 new->prev
= parse
->pstack
;
1035 new->element
= element
;
1036 new->attr
= FcConfigSaveAttr (attr
, new->attr_buf_static
, sizeof (new->attr_buf_static
));
1037 FcStrBufInit (&new->str
, 0, 0);
1038 parse
->pstack
= new;
1043 FcPStackPop (FcConfigParse
*parse
)
1049 FcConfigMessage (parse
, FcSevereError
, "mismatching element");
1052 FcVStackClear (parse
);
1053 old
= parse
->pstack
;
1054 parse
->pstack
= old
->prev
;
1055 FcStrBufDestroy (&old
->str
);
1056 if (old
->attr
&& old
->attr
!= old
->attr_buf_static
)
1058 FcMemFree (FC_MEM_ATTR
, 1); /* size is to expensive */
1062 if (old
== &parse
->pstack_static
[parse
->pstack_static_used
- 1])
1063 parse
->pstack_static_used
--;
1066 FcMemFree (FC_MEM_PSTACK
, sizeof (FcPStack
));
1073 FcConfigInit (FcConfigParse
*parse
, const FcChar8
*name
, FcConfig
*config
, XML_Parser parser
)
1076 parse
->pstack_static_used
= 0;
1078 parse
->vstack_static_used
= 0;
1079 parse
->error
= FcFalse
;
1081 parse
->config
= config
;
1082 parse
->parser
= parser
;
1087 FcConfigCleanup (FcConfigParse
*parse
)
1089 while (parse
->pstack
)
1090 FcPStackPop (parse
);
1093 static const FcChar8
*
1094 FcConfigGetAttribute (FcConfigParse
*parse
, const char *attr
)
1100 attrs
= parse
->pstack
->attr
;
1106 if (!strcmp ((char *) *attrs
, attr
))
1114 FcStartElement(void *userData
, const XML_Char
*name
, const XML_Char
**attr
)
1116 FcConfigParse
*parse
= userData
;
1119 element
= FcElementMap (name
);
1120 if (element
== FcElementUnknown
)
1121 FcConfigMessage (parse
, FcSevereWarning
, "unknown element \"%s\"", name
);
1123 if (!FcPStackPush (parse
, element
, attr
))
1125 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1132 FcParseBlank (FcConfigParse
*parse
)
1134 int n
= FcVStackElements (parse
);
1138 FcVStack
*v
= FcVStackFetch (parse
, n
);
1139 if (!parse
->config
->blanks
)
1141 parse
->config
->blanks
= FcBlanksCreate ();
1142 if (!parse
->config
->blanks
)
1146 case FcVStackInteger
:
1147 if (!FcBlanksAdd (parse
->config
->blanks
, v
->u
.integer
))
1151 if (v
->u
.range
.begin
<= v
->u
.range
.end
)
1153 for (i
= v
->u
.range
.begin
; i
<= v
->u
.range
.end
; i
++)
1155 if (!FcBlanksAdd (parse
->config
->blanks
, i
))
1161 FcConfigMessage (parse
, FcSevereError
, "invalid element in blank");
1167 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1171 FcParseRescan (FcConfigParse
*parse
)
1173 int n
= FcVStackElements (parse
);
1176 FcVStack
*v
= FcVStackFetch (parse
, n
);
1177 if (v
->tag
!= FcVStackInteger
)
1178 FcConfigMessage (parse
, FcSevereWarning
, "non-integer rescan");
1180 parse
->config
->rescanInterval
= v
->u
.integer
;
1185 FcParseInt (FcConfigParse
*parse
)
1192 s
= FcStrBufDoneStatic (&parse
->pstack
->str
);
1195 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1199 l
= (int) strtol ((char *) s
, (char **)&end
, 0);
1200 if (end
!= s
+ strlen ((char *) s
))
1201 FcConfigMessage (parse
, FcSevereError
, "\"%s\": not a valid integer", s
);
1203 FcVStackPushInteger (parse
, l
);
1204 FcStrBufDestroy (&parse
->pstack
->str
);
1208 * idea copied from glib g_ascii_strtod with
1209 * permission of the author (Alexander Larsson)
1215 FcStrtod (char *s
, char **end
)
1217 struct lconv
*locale_data
;
1222 * Have to swap the decimal point to match the current locale
1223 * if that locale doesn't use 0x2e
1225 if ((dot
= strchr (s
, 0x2e)) &&
1226 (locale_data
= localeconv ()) &&
1227 (locale_data
->decimal_point
[0] != 0x2e ||
1228 locale_data
->decimal_point
[1] != 0))
1231 int slen
= strlen (s
);
1232 int dlen
= strlen (locale_data
->decimal_point
);
1234 if (slen
+ dlen
> (int) sizeof (buf
))
1244 strncpy (buf
, s
, dot
- s
);
1246 strcpy (buf
+ (dot
- s
), locale_data
->decimal_point
);
1247 /* rest of number */
1248 strcpy (buf
+ (dot
- s
) + dlen
, dot
+ 1);
1250 v
= strtod (buf
, &buf_end
);
1252 buf_end
= s
+ (buf_end
- buf
);
1254 buf_end
-= dlen
- 1;
1261 v
= strtod (s
, end
);
1266 FcParseDouble (FcConfigParse
*parse
)
1273 s
= FcStrBufDoneStatic (&parse
->pstack
->str
);
1276 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1280 d
= FcStrtod ((char *) s
, (char **)&end
);
1281 if (end
!= s
+ strlen ((char *) s
))
1282 FcConfigMessage (parse
, FcSevereError
, "\"%s\": not a valid double", s
);
1284 FcVStackPushDouble (parse
, d
);
1285 FcStrBufDestroy (&parse
->pstack
->str
);
1289 FcParseString (FcConfigParse
*parse
, FcVStackTag tag
)
1295 s
= FcStrBufDone (&parse
->pstack
->str
);
1298 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1301 if (!FcVStackPushString (parse
, tag
, s
))
1306 FcParseMatrix (FcConfigParse
*parse
)
1309 enum { m_done
, m_xx
, m_xy
, m_yx
, m_yy
} matrix_state
= m_yy
;
1312 while ((vstack
= FcVStackPeek (parse
)))
1315 switch (vstack
->tag
) {
1316 case FcVStackInteger
:
1317 v
= vstack
->u
.integer
;
1319 case FcVStackDouble
:
1320 v
= vstack
->u
._double
;
1323 FcConfigMessage (parse
, FcSevereError
, "non-double matrix element");
1327 switch (matrix_state
) {
1328 case m_xx
: m
.xx
= v
; break;
1329 case m_xy
: m
.xy
= v
; break;
1330 case m_yx
: m
.yx
= v
; break;
1331 case m_yy
: m
.yy
= v
; break;
1334 FcVStackPopAndDestroy (parse
);
1337 if (matrix_state
!= m_done
)
1338 FcConfigMessage (parse
, FcSevereError
, "wrong number of matrix elements");
1340 FcVStackPushMatrix (parse
, &m
);
1344 FcParseRange (FcConfigParse
*parse
)
1351 while ((vstack
= FcVStackPeek (parse
)))
1355 FcConfigMessage (parse
, FcSevereError
, "too many elements in range");
1358 switch (vstack
->tag
) {
1359 case FcVStackInteger
:
1360 n
= vstack
->u
.integer
;
1363 FcConfigMessage (parse
, FcSevereError
, "invalid element in range");
1371 FcVStackPopAndDestroy (parse
);
1375 if (r
.begin
> r
.end
)
1377 FcConfigMessage (parse
, FcSevereError
, "invalid range");
1380 FcVStackPushRange (parse
, &r
);
1383 FcConfigMessage (parse
, FcSevereError
, "invalid range");
1387 FcConfigLexBool (FcConfigParse
*parse
, const FcChar8
*bool_
)
1389 FcBool result
= FcFalse
;
1391 if (!FcNameBool (bool_
, &result
))
1392 FcConfigMessage (parse
, FcSevereWarning
, "\"%s\" is not known boolean",
1398 FcParseBool (FcConfigParse
*parse
)
1404 s
= FcStrBufDoneStatic (&parse
->pstack
->str
);
1407 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1410 FcVStackPushBool (parse
, FcConfigLexBool (parse
, s
));
1411 FcStrBufDestroy (&parse
->pstack
->str
);
1415 FcParseCharSet (FcConfigParse
*parse
)
1418 FcCharSet
*charset
= FcCharSetCreate ();
1422 while ((vstack
= FcVStackPeek (parse
)))
1424 switch (vstack
->tag
) {
1425 case FcVStackInteger
:
1426 if (!FcCharSetAddChar (charset
, vstack
->u
.integer
))
1428 FcConfigMessage (parse
, FcSevereWarning
, "invalid character: 0x%04x", vstack
->u
.integer
);
1434 if (vstack
->u
.range
.begin
<= vstack
->u
.range
.end
)
1436 for (i
= vstack
->u
.range
.begin
; i
<= vstack
->u
.range
.end
; i
++)
1438 if (!FcCharSetAddChar (charset
, i
))
1440 FcConfigMessage (parse
, FcSevereWarning
, "invalid character: 0x%04x", i
);
1448 FcConfigMessage (parse
, FcSevereError
, "invalid element in charset");
1451 FcVStackPopAndDestroy (parse
);
1454 FcVStackPushCharSet (parse
, charset
);
1456 FcCharSetDestroy (charset
);
1460 FcParseLangSet (FcConfigParse
*parse
)
1463 FcLangSet
*langset
= FcLangSetCreate ();
1466 while ((vstack
= FcVStackPeek (parse
)))
1468 switch (vstack
->tag
) {
1469 case FcVStackString
:
1470 if (!FcLangSetAdd (langset
, vstack
->u
.string
))
1472 FcConfigMessage (parse
, FcSevereWarning
, "invalid langset: %s", vstack
->u
.string
);
1478 FcConfigMessage (parse
, FcSevereError
, "invalid element in langset");
1481 FcVStackPopAndDestroy (parse
);
1484 FcVStackPushLangSet (parse
, langset
);
1486 FcLangSetDestroy (langset
);
1490 FcConfigLexBinding (FcConfigParse
*parse
,
1491 const FcChar8
*binding_string
,
1492 FcValueBinding
*binding_ret
)
1494 FcValueBinding binding
;
1496 if (!binding_string
)
1497 binding
= FcValueBindingWeak
;
1500 if (!strcmp ((char *) binding_string
, "weak"))
1501 binding
= FcValueBindingWeak
;
1502 else if (!strcmp ((char *) binding_string
, "strong"))
1503 binding
= FcValueBindingStrong
;
1504 else if (!strcmp ((char *) binding_string
, "same"))
1505 binding
= FcValueBindingSame
;
1508 FcConfigMessage (parse
, FcSevereWarning
, "invalid binding \"%s\"", binding_string
);
1512 *binding_ret
= binding
;
1517 FcParseFamilies (FcConfigParse
*parse
, FcVStackTag tag
)
1520 FcExpr
*left
, *expr
= 0, *new;
1522 while ((vstack
= FcVStackPeek (parse
)))
1524 if (vstack
->tag
!= FcVStackFamily
)
1526 FcConfigMessage (parse
, FcSevereWarning
, "non-family");
1527 FcVStackPopAndDestroy (parse
);
1530 left
= vstack
->u
.expr
;
1531 vstack
->tag
= FcVStackNone
;
1532 FcVStackPopAndDestroy (parse
);
1535 new = FcExprCreateOp (parse
->config
, left
, FcOpComma
, expr
);
1538 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1539 FcExprDestroy (left
);
1540 FcExprDestroy (expr
);
1550 if (!FcVStackPushExpr (parse
, tag
, expr
))
1552 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1553 FcExprDestroy (expr
);
1559 FcParseFamily (FcConfigParse
*parse
)
1566 s
= FcStrBufDoneStatic (&parse
->pstack
->str
);
1569 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1572 expr
= FcExprCreateString (parse
->config
, s
);
1573 FcStrBufDestroy (&parse
->pstack
->str
);
1575 FcVStackPushExpr (parse
, FcVStackFamily
, expr
);
1579 FcParseAlias (FcConfigParse
*parse
)
1581 FcExpr
*family
= 0, *accept
= 0, *prefer
= 0, *def
= 0, *new = 0;
1582 FcEdit
*edit
= 0, *next
;
1585 FcValueBinding binding
;
1587 if (!FcConfigLexBinding (parse
, FcConfigGetAttribute (parse
, "binding"), &binding
))
1589 while ((vstack
= FcVStackPeek (parse
)))
1591 switch (vstack
->tag
) {
1592 case FcVStackFamily
:
1595 new = FcExprCreateOp (parse
->config
, vstack
->u
.expr
, FcOpComma
, family
);
1597 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1602 new = vstack
->u
.expr
;
1606 vstack
->tag
= FcVStackNone
;
1609 case FcVStackPrefer
:
1611 FcExprDestroy (prefer
);
1612 prefer
= vstack
->u
.expr
;
1613 vstack
->tag
= FcVStackNone
;
1615 case FcVStackAccept
:
1617 FcExprDestroy (accept
);
1618 accept
= vstack
->u
.expr
;
1619 vstack
->tag
= FcVStackNone
;
1621 case FcVStackDefault
:
1623 FcExprDestroy (def
);
1624 def
= vstack
->u
.expr
;
1625 vstack
->tag
= FcVStackNone
;
1628 FcConfigMessage (parse
, FcSevereWarning
, "bad alias");
1631 FcVStackPopAndDestroy (parse
);
1635 FcConfigMessage (parse
, FcSevereError
, "missing family in alias");
1637 FcExprDestroy (prefer
);
1639 FcExprDestroy (accept
);
1641 FcExprDestroy (def
);
1646 edit
= FcEditCreate (parse
,
1654 FcExprDestroy (prefer
);
1659 edit
= FcEditCreate (parse
,
1667 FcExprDestroy (accept
);
1672 edit
= FcEditCreate (parse
,
1680 FcExprDestroy (def
);
1684 test
= FcTestCreate (parse
, FcMatchPattern
,
1686 (FcChar8
*) FC_FAMILY
,
1690 if (!FcConfigAddEdit (parse
->config
, test
, edit
, FcMatchPattern
))
1691 FcTestDestroy (test
);
1694 FcExprDestroy (family
);
1698 FcPopExpr (FcConfigParse
*parse
)
1700 FcVStack
*vstack
= FcVStackPeek (parse
);
1704 switch (vstack
->tag
) {
1707 case FcVStackString
:
1708 case FcVStackFamily
:
1709 expr
= FcExprCreateString (parse
->config
, vstack
->u
.string
);
1712 expr
= FcExprCreateField (parse
->config
, (char *) vstack
->u
.string
);
1714 case FcVStackConstant
:
1715 expr
= FcExprCreateConst (parse
->config
, vstack
->u
.string
);
1718 /* XXX: What's the correct action here? (CDW) */
1720 case FcVStackPrefer
:
1721 case FcVStackAccept
:
1722 case FcVStackDefault
:
1723 expr
= vstack
->u
.expr
;
1724 vstack
->tag
= FcVStackNone
;
1726 case FcVStackInteger
:
1727 expr
= FcExprCreateInteger (parse
->config
, vstack
->u
.integer
);
1729 case FcVStackDouble
:
1730 expr
= FcExprCreateDouble (parse
->config
, vstack
->u
._double
);
1732 case FcVStackMatrix
:
1733 expr
= FcExprCreateMatrix (parse
->config
, vstack
->u
.matrix
);
1738 expr
= FcExprCreateBool (parse
->config
, vstack
->u
.bool_
);
1740 case FcVStackCharSet
:
1741 expr
= FcExprCreateCharSet (parse
->config
, vstack
->u
.charset
);
1743 case FcVStackLangSet
:
1744 expr
= FcExprCreateLangSet (parse
->config
, vstack
->u
.langset
);
1749 expr
= vstack
->u
.expr
;
1750 vstack
->tag
= FcVStackNone
;
1757 FcVStackPopAndDestroy (parse
);
1762 * This builds a tree of binary operations. Note
1763 * that every operator is defined so that if only
1764 * a single operand is contained, the value of the
1765 * whole expression is the value of the operand.
1767 * This code reduces in that case to returning that
1771 FcPopBinary (FcConfigParse
*parse
, FcOp op
)
1773 FcExpr
*left
, *expr
= 0, *new;
1775 while ((left
= FcPopExpr (parse
)))
1779 new = FcExprCreateOp (parse
->config
, left
, op
, expr
);
1782 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1783 FcExprDestroy (left
);
1784 FcExprDestroy (expr
);
1796 FcParseBinary (FcConfigParse
*parse
, FcOp op
)
1798 FcExpr
*expr
= FcPopBinary (parse
, op
);
1800 FcVStackPushExpr (parse
, FcVStackExpr
, expr
);
1804 * This builds a a unary operator, it consumes only
1809 FcPopUnary (FcConfigParse
*parse
, FcOp op
)
1811 FcExpr
*operand
, *new = 0;
1813 if ((operand
= FcPopExpr (parse
)))
1815 new = FcExprCreateOp (parse
->config
, operand
, op
, 0);
1818 FcExprDestroy (operand
);
1819 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1826 FcParseUnary (FcConfigParse
*parse
, FcOp op
)
1828 FcExpr
*expr
= FcPopUnary (parse
, op
);
1830 FcVStackPushExpr (parse
, FcVStackExpr
, expr
);
1834 FcParseInclude (FcConfigParse
*parse
)
1838 FcBool ignore_missing
= FcFalse
;
1840 s
= FcStrBufDoneStatic (&parse
->pstack
->str
);
1843 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1846 i
= FcConfigGetAttribute (parse
, "ignore_missing");
1847 if (i
&& FcConfigLexBool (parse
, (FcChar8
*) i
) == FcTrue
)
1848 ignore_missing
= FcTrue
;
1849 if (!FcConfigParseAndLoad (parse
->config
, s
, !ignore_missing
))
1850 parse
->error
= FcTrue
;
1851 FcStrBufDestroy (&parse
->pstack
->str
);
1854 typedef struct _FcOpMap
{
1860 FcConfigLexOp (const FcChar8
*op
, const FcOpMap
*map
, int nmap
)
1864 for (i
= 0; i
< nmap
; i
++)
1865 if (!strcmp ((char *) op
, map
[i
].name
))
1870 static const FcOpMap fcCompareOps
[] = {
1871 { "eq", FcOpEqual
},
1872 { "not_eq", FcOpNotEqual
},
1873 { "less", FcOpLess
},
1874 { "less_eq", FcOpLessEqual
},
1875 { "more", FcOpMore
},
1876 { "more_eq", FcOpMoreEqual
},
1877 { "contains", FcOpContains
},
1878 { "not_contains", FcOpNotContains
}
1881 #define NUM_COMPARE_OPS (int) (sizeof fcCompareOps / sizeof fcCompareOps[0])
1884 FcConfigLexCompare (const FcChar8
*compare
)
1886 return FcConfigLexOp (compare
, fcCompareOps
, NUM_COMPARE_OPS
);
1890 FcParseTest (FcConfigParse
*parse
)
1892 const FcChar8
*kind_string
;
1894 const FcChar8
*qual_string
;
1896 const FcChar8
*name
;
1897 const FcChar8
*compare_string
;
1902 kind_string
= FcConfigGetAttribute (parse
, "target");
1904 kind
= FcMatchDefault
;
1907 if (!strcmp ((char *) kind_string
, "pattern"))
1908 kind
= FcMatchPattern
;
1909 else if (!strcmp ((char *) kind_string
, "font"))
1911 else if (!strcmp ((char *) kind_string
, "scan"))
1913 else if (!strcmp ((char *) kind_string
, "default"))
1914 kind
= FcMatchDefault
;
1917 FcConfigMessage (parse
, FcSevereWarning
, "invalid test target \"%s\"", kind_string
);
1921 qual_string
= FcConfigGetAttribute (parse
, "qual");
1926 if (!strcmp ((char *) qual_string
, "any"))
1928 else if (!strcmp ((char *) qual_string
, "all"))
1930 else if (!strcmp ((char *) qual_string
, "first"))
1932 else if (!strcmp ((char *) qual_string
, "not_first"))
1933 qual
= FcQualNotFirst
;
1936 FcConfigMessage (parse
, FcSevereWarning
, "invalid test qual \"%s\"", qual_string
);
1940 name
= FcConfigGetAttribute (parse
, "name");
1943 FcConfigMessage (parse
, FcSevereWarning
, "missing test name");
1946 compare_string
= FcConfigGetAttribute (parse
, "compare");
1947 if (!compare_string
)
1948 compare
= FcOpEqual
;
1951 compare
= FcConfigLexCompare (compare_string
);
1952 if (compare
== FcOpInvalid
)
1954 FcConfigMessage (parse
, FcSevereWarning
, "invalid test compare \"%s\"", compare_string
);
1958 expr
= FcPopBinary (parse
, FcOpComma
);
1961 FcConfigMessage (parse
, FcSevereWarning
, "missing test expression");
1964 test
= FcTestCreate (parse
, kind
, qual
, name
, compare
, expr
);
1967 FcConfigMessage (parse
, FcSevereError
, "out of memory");
1970 FcVStackPushTest (parse
, test
);
1973 static const FcOpMap fcModeOps
[] = {
1974 { "assign", FcOpAssign
},
1975 { "assign_replace", FcOpAssignReplace
},
1976 { "prepend", FcOpPrepend
},
1977 { "prepend_first", FcOpPrependFirst
},
1978 { "append", FcOpAppend
},
1979 { "append_last", FcOpAppendLast
},
1982 #define NUM_MODE_OPS (int) (sizeof fcModeOps / sizeof fcModeOps[0])
1985 FcConfigLexMode (const FcChar8
*mode
)
1987 return FcConfigLexOp (mode
, fcModeOps
, NUM_MODE_OPS
);
1991 FcParseEdit (FcConfigParse
*parse
)
1993 const FcChar8
*name
;
1994 const FcChar8
*mode_string
;
1996 FcValueBinding binding
;
2000 name
= FcConfigGetAttribute (parse
, "name");
2003 FcConfigMessage (parse
, FcSevereWarning
, "missing edit name");
2006 mode_string
= FcConfigGetAttribute (parse
, "mode");
2011 mode
= FcConfigLexMode (mode_string
);
2012 if (mode
== FcOpInvalid
)
2014 FcConfigMessage (parse
, FcSevereWarning
, "invalid edit mode \"%s\"", mode_string
);
2018 if (!FcConfigLexBinding (parse
, FcConfigGetAttribute (parse
, "binding"), &binding
))
2021 expr
= FcPopBinary (parse
, FcOpComma
);
2022 edit
= FcEditCreate (parse
, FcObjectFromName ((char *) name
),
2023 mode
, expr
, binding
);
2026 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2027 FcExprDestroy (expr
);
2030 if (!FcVStackPushEdit (parse
, edit
))
2031 FcEditDestroy (edit
);
2035 FcParseMatch (FcConfigParse
*parse
)
2037 const FcChar8
*kind_name
;
2043 kind_name
= FcConfigGetAttribute (parse
, "target");
2045 kind
= FcMatchPattern
;
2048 if (!strcmp ((char *) kind_name
, "pattern"))
2049 kind
= FcMatchPattern
;
2050 else if (!strcmp ((char *) kind_name
, "font"))
2052 else if (!strcmp ((char *) kind_name
, "scan"))
2056 FcConfigMessage (parse
, FcSevereWarning
, "invalid match target \"%s\"", kind_name
);
2060 while ((vstack
= FcVStackPeek (parse
)))
2062 switch (vstack
->tag
) {
2064 vstack
->u
.test
->next
= test
;
2065 test
= vstack
->u
.test
;
2066 vstack
->tag
= FcVStackNone
;
2069 vstack
->u
.edit
->next
= edit
;
2070 edit
= vstack
->u
.edit
;
2071 vstack
->tag
= FcVStackNone
;
2072 if (kind
== FcMatchScan
&& edit
->object
> FC_MAX_BASE_OBJECT
)
2074 FcConfigMessage (parse
, FcSevereError
,
2075 "<match target=\"scan\"> cannot edit user-defined object \"%s\"",
2076 FcObjectName(edit
->object
));
2080 FcConfigMessage (parse
, FcSevereWarning
, "invalid match element");
2083 FcVStackPopAndDestroy (parse
);
2085 if (!FcConfigAddEdit (parse
->config
, test
, edit
, kind
))
2086 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2090 FcParseAcceptRejectFont (FcConfigParse
*parse
, FcElement element
)
2094 while ((vstack
= FcVStackPeek (parse
)))
2096 switch (vstack
->tag
) {
2098 if (!FcConfigGlobAdd (parse
->config
,
2100 element
== FcElementAcceptfont
))
2102 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2105 case FcVStackPattern
:
2106 if (!FcConfigPatternsAdd (parse
->config
,
2108 element
== FcElementAcceptfont
))
2110 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2113 vstack
->tag
= FcVStackNone
;
2116 FcConfigMessage (parse
, FcSevereWarning
, "bad font selector");
2119 FcVStackPopAndDestroy (parse
);
2125 FcPopValue (FcConfigParse
*parse
)
2127 FcVStack
*vstack
= FcVStackPeek (parse
);
2130 value
.type
= FcTypeVoid
;
2135 switch (vstack
->tag
) {
2136 case FcVStackString
:
2137 value
.u
.s
= FcStrStaticName (vstack
->u
.string
);
2139 value
.type
= FcTypeString
;
2141 case FcVStackConstant
:
2142 if (FcNameConstant (vstack
->u
.string
, &value
.u
.i
))
2143 value
.type
= FcTypeInteger
;
2145 case FcVStackInteger
:
2146 value
.u
.i
= vstack
->u
.integer
;
2147 value
.type
= FcTypeInteger
;
2149 case FcVStackDouble
:
2150 value
.u
.d
= vstack
->u
._double
;
2151 value
.type
= FcTypeInteger
;
2153 case FcVStackMatrix
:
2154 value
.u
.m
= FcMatrixCopy (vstack
->u
.matrix
);
2156 value
.type
= FcTypeMatrix
;
2159 value
.u
.b
= vstack
->u
.bool_
;
2160 value
.type
= FcTypeBool
;
2162 case FcVStackCharSet
:
2163 value
.u
.c
= FcCharSetCopy (vstack
->u
.charset
);
2165 value
.type
= FcTypeCharSet
;
2167 case FcVStackLangSet
:
2168 value
.u
.l
= FcLangSetCopy (vstack
->u
.langset
);
2170 value
.type
= FcTypeLangSet
;
2173 FcConfigMessage (parse
, FcSevereWarning
, "unknown pattern element %d",
2177 FcVStackPopAndDestroy (parse
);
2183 FcParsePatelt (FcConfigParse
*parse
)
2186 FcPattern
*pattern
= FcPatternCreate ();
2191 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2195 name
= (char *) FcConfigGetAttribute (parse
, "name");
2198 FcConfigMessage (parse
, FcSevereWarning
, "missing pattern element name");
2199 FcPatternDestroy (pattern
);
2205 value
= FcPopValue (parse
);
2206 if (value
.type
== FcTypeVoid
)
2208 if (!FcPatternAdd (pattern
, name
, value
, FcTrue
))
2210 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2211 FcValueDestroy(value
);
2214 FcValueDestroy(value
);
2217 FcVStackPushPattern (parse
, pattern
);
2221 FcParsePattern (FcConfigParse
*parse
)
2224 FcPattern
*pattern
= FcPatternCreate ();
2228 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2232 while ((vstack
= FcVStackPeek (parse
)))
2234 switch (vstack
->tag
) {
2235 case FcVStackPattern
:
2236 if (!FcPatternAppend (pattern
, vstack
->u
.pattern
))
2238 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2239 FcPatternDestroy (pattern
);
2244 FcConfigMessage (parse
, FcSevereWarning
, "unknown pattern element");
2247 FcVStackPopAndDestroy (parse
);
2250 FcVStackPushPattern (parse
, pattern
);
2254 FcEndElement(void *userData
, const XML_Char
*name
)
2256 FcConfigParse
*parse
= userData
;
2259 FcChar8 buffer
[1000];
2264 switch (parse
->pstack
->element
) {
2267 case FcElementFontconfig
:
2270 data
= FcStrBufDoneStatic (&parse
->pstack
->str
);
2273 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2277 if (strcmp (data
, "CUSTOMFONTDIR") == 0)
2281 if (!GetModuleFileName (NULL
, buffer
, sizeof (buffer
) - 20))
2283 FcConfigMessage (parse
, FcSevereError
, "GetModuleFileName failed");
2287 * Must use the multi-byte aware function to search
2288 * for backslash because East Asian double-byte code
2289 * pages have characters with backslash as the second
2292 p
= _mbsrchr (data
, '\\');
2294 strcat (data
, "\\fonts");
2296 else if (strcmp (data
, "APPSHAREFONTDIR") == 0)
2300 if (!GetModuleFileName (NULL
, buffer
, sizeof (buffer
) - 20))
2302 FcConfigMessage (parse
, FcSevereError
, "GetModuleFileName failed");
2305 p
= _mbsrchr (data
, '\\');
2307 strcat (data
, "\\..\\share\\fonts");
2309 else if (strcmp (data
, "WINDOWSFONTDIR") == 0)
2313 #if _WIN32_WINNT >= 0x0500
2314 rc
= GetSystemWindowsDirectory (buffer
, sizeof (buffer
) - 20);
2316 rc
= GetWindowsDirectory (buffer
, sizeof (buffer
) - 20);
2318 if (rc
== 0 || rc
> sizeof (buffer
) - 20)
2320 FcConfigMessage (parse
, FcSevereError
, "GetSystemWindowsDirectory failed");
2323 if (data
[strlen (data
) - 1] != '\\')
2324 strcat (data
, "\\");
2325 strcat (data
, "fonts");
2328 if (strlen ((char *) data
) == 0)
2329 FcConfigMessage (parse
, FcSevereWarning
, "empty font directory name ignored");
2330 else if (!FcStrUsesHome (data
) || FcConfigHome ())
2332 if (!FcConfigAddDir (parse
->config
, data
))
2333 FcConfigMessage (parse
, FcSevereError
, "out of memory; cannot add directory %s", data
);
2335 FcStrBufDestroy (&parse
->pstack
->str
);
2337 case FcElementCacheDir
:
2338 data
= FcStrBufDone (&parse
->pstack
->str
);
2341 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2345 if (strcmp (data
, "WINDOWSTEMPDIR_FONTCONFIG_CACHE") == 0)
2349 data
= malloc (1000);
2352 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2355 FcMemAlloc (FC_MEM_STRING
, 1000);
2356 rc
= GetTempPath (800, data
);
2357 if (rc
== 0 || rc
> 800)
2359 FcConfigMessage (parse
, FcSevereError
, "GetTempPath failed");
2363 if (data
[strlen (data
) - 1] != '\\')
2364 strcat (data
, "\\");
2365 strcat (data
, "fontconfig\\cache");
2368 if (!FcStrUsesHome (data
) || FcConfigHome ())
2370 if (!FcConfigAddCacheDir (parse
->config
, data
))
2371 FcConfigMessage (parse
, FcSevereError
, "out of memory; cannot add cache directory %s", data
);
2376 case FcElementCache
:
2377 data
= FcStrBufDoneStatic (&parse
->pstack
->str
);
2380 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2383 /* discard this data; no longer used */
2384 FcStrBufDestroy (&parse
->pstack
->str
);
2386 case FcElementInclude
:
2387 FcParseInclude (parse
);
2389 case FcElementConfig
:
2391 case FcElementMatch
:
2392 FcParseMatch (parse
);
2394 case FcElementAlias
:
2395 FcParseAlias (parse
);
2398 case FcElementBlank
:
2399 FcParseBlank (parse
);
2401 case FcElementRescan
:
2402 FcParseRescan (parse
);
2405 case FcElementPrefer
:
2406 FcParseFamilies (parse
, FcVStackPrefer
);
2408 case FcElementAccept
:
2409 FcParseFamilies (parse
, FcVStackAccept
);
2411 case FcElementDefault
:
2412 FcParseFamilies (parse
, FcVStackDefault
);
2414 case FcElementFamily
:
2415 FcParseFamily (parse
);
2419 FcParseTest (parse
);
2422 FcParseEdit (parse
);
2428 case FcElementDouble
:
2429 FcParseDouble (parse
);
2431 case FcElementString
:
2432 FcParseString (parse
, FcVStackString
);
2434 case FcElementMatrix
:
2435 FcParseMatrix (parse
);
2437 case FcElementRange
:
2438 FcParseRange (parse
);
2441 FcParseBool (parse
);
2443 case FcElementCharSet
:
2444 FcParseCharSet (parse
);
2446 case FcElementLangSet
:
2447 FcParseLangSet (parse
);
2449 case FcElementSelectfont
:
2451 case FcElementAcceptfont
:
2452 case FcElementRejectfont
:
2453 FcParseAcceptRejectFont (parse
, parse
->pstack
->element
);
2456 FcParseString (parse
, FcVStackGlob
);
2458 case FcElementPattern
:
2459 FcParsePattern (parse
);
2461 case FcElementPatelt
:
2462 FcParsePatelt (parse
);
2465 FcParseString (parse
, FcVStackField
);
2467 case FcElementConst
:
2468 FcParseString (parse
, FcVStackConstant
);
2471 FcParseBinary (parse
, FcOpOr
);
2474 FcParseBinary (parse
, FcOpAnd
);
2477 FcParseBinary (parse
, FcOpEqual
);
2479 case FcElementNotEq
:
2480 FcParseBinary (parse
, FcOpNotEqual
);
2483 FcParseBinary (parse
, FcOpLess
);
2485 case FcElementLessEq
:
2486 FcParseBinary (parse
, FcOpLessEqual
);
2489 FcParseBinary (parse
, FcOpMore
);
2491 case FcElementMoreEq
:
2492 FcParseBinary (parse
, FcOpMoreEqual
);
2494 case FcElementContains
:
2495 FcParseBinary (parse
, FcOpContains
);
2497 case FcElementNotContains
:
2498 FcParseBinary (parse
, FcOpNotContains
);
2501 FcParseBinary (parse
, FcOpPlus
);
2503 case FcElementMinus
:
2504 FcParseBinary (parse
, FcOpMinus
);
2506 case FcElementTimes
:
2507 FcParseBinary (parse
, FcOpTimes
);
2509 case FcElementDivide
:
2510 FcParseBinary (parse
, FcOpDivide
);
2513 FcParseUnary (parse
, FcOpNot
);
2516 FcParseBinary (parse
, FcOpQuest
);
2518 case FcElementFloor
:
2519 FcParseUnary (parse
, FcOpFloor
);
2522 FcParseUnary (parse
, FcOpCeil
);
2524 case FcElementRound
:
2525 FcParseUnary (parse
, FcOpRound
);
2527 case FcElementTrunc
:
2528 FcParseUnary (parse
, FcOpTrunc
);
2530 case FcElementUnknown
:
2533 (void) FcPStackPop (parse
);
2537 FcCharacterData (void *userData
, const XML_Char
*s
, int len
)
2539 FcConfigParse
*parse
= userData
;
2543 if (!FcStrBufData (&parse
->pstack
->str
, (FcChar8
*) s
, len
))
2544 FcConfigMessage (parse
, FcSevereError
, "out of memory");
2548 FcStartDoctypeDecl (void *userData
,
2549 const XML_Char
*doctypeName
,
2550 const XML_Char
*sysid
,
2551 const XML_Char
*pubid
,
2552 int has_internal_subset
)
2554 FcConfigParse
*parse
= userData
;
2556 if (strcmp ((char *) doctypeName
, "fontconfig") != 0)
2557 FcConfigMessage (parse
, FcSevereError
, "invalid doctype \"%s\"", doctypeName
);
2560 #ifdef ENABLE_LIBXML2
2563 FcInternalSubsetDecl (void *userData
,
2564 const XML_Char
*doctypeName
,
2565 const XML_Char
*sysid
,
2566 const XML_Char
*pubid
)
2568 FcStartDoctypeDecl (userData
, doctypeName
, sysid
, pubid
, 1);
2572 FcExternalSubsetDecl (void *userData
,
2573 const XML_Char
*doctypeName
,
2574 const XML_Char
*sysid
,
2575 const XML_Char
*pubid
)
2577 FcStartDoctypeDecl (userData
, doctypeName
, sysid
, pubid
, 0);
2580 #else /* ENABLE_LIBXML2 */
2583 FcEndDoctypeDecl (void *userData
)
2587 #endif /* ENABLE_LIBXML2 */
2590 FcSortCmpStr (const void *a
, const void *b
)
2592 const FcChar8
*as
= *((FcChar8
**) a
);
2593 const FcChar8
*bs
= *((FcChar8
**) b
);
2594 return FcStrCmp (as
, bs
);
2598 FcConfigParseAndLoadDir (FcConfig
*config
,
2599 const FcChar8
*name
,
2605 FcBool ret
= FcTrue
;
2610 d
= opendir ((char *) dir
);
2614 FcConfigMessage (0, FcSevereError
, "Cannot open config dir \"%s\"",
2620 file
= (FcChar8
*) malloc (strlen ((char *) dir
) + 1 + FC_MAX_FILE_LEN
+ 1);
2627 strcpy ((char *) file
, (char *) dir
);
2628 strcat ((char *) file
, "/");
2629 base
= file
+ strlen ((char *) file
);
2631 files
= FcStrSetCreate ();
2638 if (FcDebug () & FC_DBG_CONFIG
)
2639 printf ("\tScanning config dir %s\n", dir
);
2641 while (ret
&& (e
= readdir (d
)))
2644 #define TAIL ".conf"
2647 * Add all files of the form [0-9]*.conf
2649 if ('0' <= e
->d_name
[0] && e
->d_name
[0] <= '9' &&
2650 (d_len
= strlen (e
->d_name
)) < FC_MAX_FILE_LEN
&&
2652 strcmp (e
->d_name
+ d_len
- TAIL_LEN
, TAIL
) == 0)
2654 strcpy ((char *) base
, (char *) e
->d_name
);
2655 if (!FcStrSetAdd (files
, file
))
2665 qsort (files
->strs
, files
->num
, sizeof (FcChar8
*),
2666 (int (*)(const void *, const void *)) FcSortCmpStr
);
2667 for (i
= 0; ret
&& i
< files
->num
; i
++)
2668 ret
= FcConfigParseAndLoad (config
, files
->strs
[i
], complain
);
2671 FcStrSetDestroy (files
);
2677 return ret
|| !complain
;
2681 FcConfigParseAndLoad (FcConfig
*config
,
2682 const FcChar8
*name
,
2690 FcConfigParse parse
;
2691 FcBool error
= FcTrue
;
2693 #ifdef ENABLE_LIBXML2
2700 filename
= FcConfigFilename (name
);
2704 if (FcStrSetMember (config
->configFiles
, filename
))
2706 FcStrFree (filename
);
2710 if (!FcStrSetAdd (config
->configFiles
, filename
))
2712 FcStrFree (filename
);
2716 if (FcFileIsDir (filename
))
2718 FcBool ret
= FcConfigParseAndLoadDir (config
, name
, filename
, complain
);
2719 FcStrFree (filename
);
2723 if (FcDebug () & FC_DBG_CONFIG
)
2724 printf ("\tLoading config file %s\n", filename
);
2726 fd
= open ((char *) filename
, O_RDONLY
);
2728 FcStrFree (filename
);
2732 #ifdef ENABLE_LIBXML2
2733 memset(&sax
, 0, sizeof(sax
));
2735 sax
.internalSubset
= FcInternalSubsetDecl
;
2736 sax
.externalSubset
= FcExternalSubsetDecl
;
2737 sax
.startElement
= FcStartElement
;
2738 sax
.endElement
= FcEndElement
;
2739 sax
.characters
= FcCharacterData
;
2741 p
= xmlCreatePushParserCtxt (&sax
, &parse
, NULL
, 0, (const char *) filename
);
2743 p
= XML_ParserCreate ("UTF-8");
2745 FcStrFree (filename
);
2750 if (!FcConfigInit (&parse
, name
, config
, p
))
2753 #ifndef ENABLE_LIBXML2
2755 XML_SetUserData (p
, &parse
);
2757 XML_SetDoctypeDeclHandler (p
, FcStartDoctypeDecl
, FcEndDoctypeDecl
);
2758 XML_SetElementHandler (p
, FcStartElement
, FcEndElement
);
2759 XML_SetCharacterDataHandler (p
, FcCharacterData
);
2761 #endif /* ENABLE_LIBXML2 */
2764 #ifndef ENABLE_LIBXML2
2765 buf
= XML_GetBuffer (p
, BUFSIZ
);
2768 FcConfigMessage (&parse
, FcSevereError
, "cannot get parse buffer");
2772 len
= read (fd
, buf
, BUFSIZ
);
2775 FcConfigMessage (&parse
, FcSevereError
, "failed reading config file");
2779 #ifdef ENABLE_LIBXML2
2780 if (xmlParseChunk (p
, buf
, len
, len
== 0))
2782 if (!XML_ParseBuffer (p
, len
, len
== 0))
2785 FcConfigMessage (&parse
, FcSevereError
, "%s",
2786 XML_ErrorString (XML_GetErrorCode (p
)));
2790 error
= parse
.error
;
2792 FcConfigCleanup (&parse
);
2799 if (error
&& complain
)
2802 FcConfigMessage (0, FcSevereError
, "Cannot load config file \"%s\"", name
);
2804 FcConfigMessage (0, FcSevereError
, "Cannot load default config file");
2810 #include "fcaliastail.h"