X-Git-Url: https://git.wh0rd.org/?a=blobdiff_plain;f=src%2Ffcxml.c;h=4d07f9d6cdfec1d76628163baa83c5330ec1fa50;hb=d975cdda782bb88c8bb6706889a554b2afb9f939;hp=2928ef9be1a5f142dffce7ed226e81ce8b3bb6ce;hpb=de69ee14d3ed094cd2bc4df603a03675c28d1b5b;p=fontconfig.git

diff --git a/src/fcxml.c b/src/fcxml.c
index 2928ef9..4d07f9d 100644
--- a/src/fcxml.c
+++ b/src/fcxml.c
@@ -7,15 +7,15 @@
  * documentation for any purpose is hereby granted without fee, provided that
  * the above copyright notice appear in all copies and that both that
  * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Keith Packard not be used in
+ * documentation, and that the name of the author(s) not be used in
  * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Keith Packard makes no
+ * specific, written prior permission.  The authors make no
  * representations about the suitability of this software for any purpose.  It
  * is provided "as is" without express or implied warranty.
  *
- * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
@@ -53,11 +53,15 @@
 #endif /* ENABLE_LIBXML2 */
 
 #ifdef _WIN32
+#define _WIN32_WINNT 0x0500
 #define STRICT
 #include <windows.h>
 #undef STRICT
+#include <mbstring.h>
 #endif
 
+static void
+FcExprDestroy (FcExpr *e);
 
 void
 FcTestDestroy (FcTest *test)
@@ -69,125 +73,108 @@ FcTestDestroy (FcTest *test)
     free (test);
 }
 
-FcExpr *
-FcExprCreateInteger (int i)
+static FcExpr *
+FcExprCreateInteger (FcConfig *config, int i)
 {
-    FcExpr *e = (FcExpr *) malloc (sizeof (FcExpr));
-
+    FcExpr *e = FcConfigAllocExpr (config);
     if (e)
     {
-	FcMemAlloc (FC_MEM_EXPR, sizeof (FcExpr));
 	e->op = FcOpInteger;
 	e->u.ival = i;
     }
     return e;
 }
 
-FcExpr *
-FcExprCreateDouble (double d)
+static FcExpr *
+FcExprCreateDouble (FcConfig *config, double d)
 {
-    FcExpr *e = (FcExpr *) malloc (sizeof (FcExpr));
-
+    FcExpr *e = FcConfigAllocExpr (config);
     if (e)
     {
-	FcMemAlloc (FC_MEM_EXPR, sizeof (FcExpr));
 	e->op = FcOpDouble;
 	e->u.dval = d;
     }
     return e;
 }
 
-FcExpr *
-FcExprCreateString (const FcChar8 *s)
+static FcExpr *
+FcExprCreateString (FcConfig *config, const FcChar8 *s)
 {
-    FcExpr *e = (FcExpr *) malloc (sizeof (FcExpr));
-
+    FcExpr *e = FcConfigAllocExpr (config);
     if (e)
     {
-	FcMemAlloc (FC_MEM_EXPR, sizeof (FcExpr));
 	e->op = FcOpString;
-	e->u.sval = FcStrCopy (s);
+	e->u.sval = FcStrStaticName (s);
     }
     return e;
 }
 
-FcExpr *
-FcExprCreateMatrix (const FcMatrix *m)
+static FcExpr *
+FcExprCreateMatrix (FcConfig *config, const FcMatrix *m)
 {
-    FcExpr *e = (FcExpr *) malloc (sizeof (FcExpr));
-
+    FcExpr *e = FcConfigAllocExpr (config);
     if (e)
     {
-	FcMemAlloc (FC_MEM_EXPR, sizeof (FcExpr));
 	e->op = FcOpMatrix;
 	e->u.mval = FcMatrixCopy (m);
     }
     return e;
 }
 
-FcExpr *
-FcExprCreateBool (FcBool b)
+static FcExpr *
+FcExprCreateBool (FcConfig *config, FcBool b)
 {
-    FcExpr *e = (FcExpr *) malloc (sizeof (FcExpr));
-
+    FcExpr *e = FcConfigAllocExpr (config);
     if (e)
     {
-	FcMemAlloc (FC_MEM_EXPR, sizeof (FcExpr));
 	e->op = FcOpBool;
 	e->u.bval = b;
     }
     return e;
 }
 
-FcExpr *
-FcExprCreateNil (void)
+static FcExpr *
+FcExprCreateCharSet (FcConfig *config, FcCharSet *charset)
 {
-    FcExpr *e = (FcExpr *) malloc (sizeof (FcExpr));
-
+    FcExpr *e = FcConfigAllocExpr (config);
     if (e)
     {
-	FcMemAlloc (FC_MEM_EXPR, sizeof (FcExpr));
-	e->op = FcOpNil;
+	e->op = FcOpCharSet;
+	e->u.cval = FcCharSetCopy (charset);
     }
     return e;
 }
 
-FcExpr *
-FcExprCreateField (const char *field)
+static FcExpr *
+FcExprCreateField (FcConfig *config, const char *field)
 {
-    FcExpr *e = (FcExpr *) malloc (sizeof (FcExpr));
-
+    FcExpr *e = FcConfigAllocExpr (config);
     if (e)
     {
-	FcMemAlloc (FC_MEM_EXPR, sizeof (FcExpr));
 	e->op = FcOpField;
 	e->u.object = FcObjectFromName (field);
     }
     return e;
 }
 
-FcExpr *
-FcExprCreateConst (const FcChar8 *constant)
+static FcExpr *
+FcExprCreateConst (FcConfig *config, const FcChar8 *constant)
 {
-    FcExpr *e = (FcExpr *) malloc (sizeof (FcExpr));
-
+    FcExpr *e = FcConfigAllocExpr (config);
     if (e)
     {
-	FcMemAlloc (FC_MEM_EXPR, sizeof (FcExpr));
 	e->op = FcOpConst;
-	e->u.constant = FcStrCopy (constant);
+	e->u.constant = FcStrStaticName (constant);
     }
     return e;
 }
 
-FcExpr *
-FcExprCreateOp (FcExpr *left, FcOp op, FcExpr *right)
+static FcExpr *
+FcExprCreateOp (FcConfig *config, FcExpr *left, FcOp op, FcExpr *right)
 {
-    FcExpr *e = (FcExpr *) malloc (sizeof (FcExpr));
-
+    FcExpr *e = FcConfigAllocExpr (config);
     if (e)
     {
-	FcMemAlloc (FC_MEM_EXPR, sizeof (FcExpr));
 	e->op = op;
 	e->u.tree.left = left;
 	e->u.tree.right = right;
@@ -195,7 +182,7 @@ FcExprCreateOp (FcExpr *left, FcOp op, FcExpr *right)
     return e;
 }
 
-void
+static void
 FcExprDestroy (FcExpr *e)
 {
     if (!e)
@@ -206,11 +193,12 @@ FcExprDestroy (FcExpr *e)
     case FcOpDouble:
 	break;
     case FcOpString:
-	FcStrFree (e->u.sval);
 	break;
     case FcOpMatrix:
 	FcMatrixFree (e->u.mval);
 	break;
+    case FcOpRange:
+	break;
     case FcOpCharSet:
 	FcCharSetDestroy (e->u.cval);
 	break;
@@ -219,7 +207,6 @@ FcExprDestroy (FcExpr *e)
     case FcOpField:
 	break;
     case FcOpConst:
-	FcStrFree (e->u.constant);
 	break;
     case FcOpAssign:
     case FcOpAssignReplace:
@@ -258,8 +245,8 @@ FcExprDestroy (FcExpr *e)
     case FcOpInvalid:
 	break;
     }
-    FcMemFree (FC_MEM_EXPR, sizeof (FcExpr));
-    free (e);
+
+    e->op = FcOpNil;
 }
 
 void
@@ -272,12 +259,6 @@ FcEditDestroy (FcEdit *e)
     free (e);
 }
 
-char *
-FcConfigSaveField (const char *field)
-{
-    return (char *) FcStrCopy ((FcChar8 *) field);
-}
-
 typedef enum _FcElement {
     FcElementNone,
     FcElementFontconfig,
@@ -310,8 +291,9 @@ typedef enum _FcElement {
     FcElementDouble,
     FcElementString,
     FcElementMatrix,
+    FcElementRange,
     FcElementBool,
-    FcElementCharset,
+    FcElementCharSet,
     FcElementName,
     FcElementConst,
     FcElementOr,
@@ -349,7 +331,7 @@ static const struct {
     { "config",		FcElementConfig },
     { "match",		FcElementMatch },
     { "alias",		FcElementAlias },
-    
+
     { "blank",		FcElementBlank },
     { "rescan",		FcElementRescan },
 
@@ -371,8 +353,9 @@ static const struct {
     { "double",		FcElementDouble },
     { "string",		FcElementString },
     { "matrix",		FcElementMatrix },
+    { "range",		FcElementRange },
     { "bool",		FcElementBool },
-    { "charset",	FcElementCharset },
+    { "charset",	FcElementCharSet },
     { "name",		FcElementName },
     { "const",		FcElementConst },
     { "or",		FcElementOr },
@@ -416,7 +399,7 @@ typedef struct _FcPStack {
     FcStrBuf		str;
     FcChar8            *attr_buf_static[16];
 } FcPStack;
-    
+
 typedef enum _FcVStackTag {
     FcVStackNone,
 
@@ -426,16 +409,18 @@ typedef enum _FcVStackTag {
     FcVStackConstant,
     FcVStackGlob,
     FcVStackPattern,
-    
+
     FcVStackPrefer,
     FcVStackAccept,
     FcVStackDefault,
-    
+
     FcVStackInteger,
     FcVStackDouble,
     FcVStackMatrix,
+    FcVStackRange,
     FcVStackBool,
-    
+    FcVStackCharSet,
+
     FcVStackTest,
     FcVStackExpr,
     FcVStackEdit
@@ -451,7 +436,9 @@ typedef struct _FcVStack {
 	int		integer;
 	double		_double;
 	FcMatrix	*matrix;
+	FcRange		range;
 	FcBool		bool_;
+	FcCharSet	*charset;
 
 	FcTest		*test;
 	FcQual		qual;
@@ -562,7 +549,7 @@ FcTypecheckExpr (FcConfigParse *parse, FcExpr *expr, FcType type)
 {
     const FcObjectType	*o;
     const FcConstant	*c;
-    
+
     /* If parsing the expression failed, some nodes may be NULL */
     if (!expr)
 	return;
@@ -599,8 +586,8 @@ FcTypecheckExpr (FcConfigParse *parse, FcExpr *expr, FcType type)
 	    if (o)
 		FcTypecheckValue (parse, o->type, type);
 	}
-        else 
-            FcConfigMessage (parse, FcSevereWarning, 
+        else
+            FcConfigMessage (parse, FcSevereWarning,
                              "invalid constant used : %s",
                              expr->u.constant);
 	break;
@@ -651,7 +638,7 @@ FcTypecheckExpr (FcConfigParse *parse, FcExpr *expr, FcType type)
 
 static FcTest *
 FcTestCreate (FcConfigParse *parse,
-	      FcMatchKind   kind, 
+	      FcMatchKind   kind,
 	      FcQual	    qual,
 	      const FcChar8 *field,
 	      FcOp	    compare,
@@ -774,6 +761,18 @@ FcVStackPushMatrix (FcConfigParse *parse, FcMatrix *matrix)
     return FcTrue;
 }
 
+static FcBool
+FcVStackPushRange (FcConfigParse *parse, FcRange *range)
+{
+    FcVStack	*vstack = FcVStackCreateAndPush (parse);
+    if (!vstack)
+	return FcFalse;
+    vstack->u.range.begin = range->begin;
+    vstack->u.range.end = range->end;
+    vstack->tag = FcVStackRange;
+    return FcTrue;
+}
+
 static FcBool
 FcVStackPushBool (FcConfigParse *parse, FcBool bool_)
 {
@@ -785,6 +784,20 @@ FcVStackPushBool (FcConfigParse *parse, FcBool bool_)
     return FcTrue;
 }
 
+static FcBool
+FcVStackPushCharSet (FcConfigParse *parse, FcCharSet *charset)
+{
+    FcVStack	*vstack;
+    if (!charset)
+	return FcFalse;
+    vstack = FcVStackCreateAndPush (parse);
+    if (!vstack)
+	return FcFalse;
+    vstack->u.charset = charset;
+    vstack->tag = FcVStackCharSet;
+    return FcTrue;
+}
+
 static FcBool
 FcVStackPushTest (FcConfigParse *parse, FcTest *test)
 {
@@ -850,7 +863,7 @@ static void
 FcVStackPopAndDestroy (FcConfigParse *parse)
 {
     FcVStack	*vstack = parse->vstack;
-    
+
     if (!vstack || vstack->pstack != parse->pstack)
 	return;
 
@@ -859,8 +872,9 @@ FcVStackPopAndDestroy (FcConfigParse *parse)
     switch (vstack->tag) {
     case FcVStackNone:
 	break;
-    case FcVStackString:
     case FcVStackFamily:
+	break;
+    case FcVStackString:
     case FcVStackField:
     case FcVStackConstant:
     case FcVStackGlob:
@@ -875,8 +889,12 @@ FcVStackPopAndDestroy (FcConfigParse *parse)
     case FcVStackMatrix:
 	FcMatrixFree (vstack->u.matrix);
 	break;
+    case FcVStackRange:
     case FcVStackBool:
 	break;
+    case FcVStackCharSet:
+	FcCharSetDestroy (vstack->u.charset);
+	break;
     case FcVStackTest:
 	FcTestDestroy (vstack->u.test);
 	break;
@@ -986,8 +1004,8 @@ static FcBool
 FcPStackPop (FcConfigParse *parse)
 {
     FcPStack   *old;
-    
-    if (!parse->pstack) 
+
+    if (!parse->pstack)
     {
 	FcConfigMessage (parse, FcSevereError, "mismatching element");
 	return FcFalse;
@@ -1058,11 +1076,11 @@ FcStartElement(void *userData, const XML_Char *name, const XML_Char **attr)
 {
     FcConfigParse   *parse = userData;
     FcElement	    element;
-    
+
     element = FcElementMap (name);
     if (element == FcElementUnknown)
 	FcConfigMessage (parse, FcSevereWarning, "unknown element \"%s\"", name);
-    
+
     if (!FcPStackPush (parse, element, attr))
     {
 	FcConfigMessage (parse, FcSevereError, "out of memory");
@@ -1074,30 +1092,37 @@ FcStartElement(void *userData, const XML_Char *name, const XML_Char **attr)
 static void
 FcParseBlank (FcConfigParse *parse)
 {
-    int	    n = FcVStackElements (parse);
+    int		n = FcVStackElements (parse);
+    FcChar32	i;
     while (n-- > 0)
     {
 	FcVStack    *v = FcVStackFetch (parse, n);
-	if (v->tag != FcVStackInteger)
-	    FcConfigMessage (parse, FcSevereError, "non-integer blank");
-	else
+	if (!parse->config->blanks)
 	{
+	    parse->config->blanks = FcBlanksCreate ();
 	    if (!parse->config->blanks)
-	    {
-		parse->config->blanks = FcBlanksCreate ();
-		if (!parse->config->blanks)
-		{
-		    FcConfigMessage (parse, FcSevereError, "out of memory");
-		    break;
-		}
-	    }
+		goto bail;
+	}
+	switch (v->tag) {
+	case FcVStackInteger:
 	    if (!FcBlanksAdd (parse->config->blanks, v->u.integer))
+		goto bail;
+	    break;
+	case FcVStackRange:
+	    for (i = v->u.range.begin; i <= v->u.range.end; i++)
 	    {
-		FcConfigMessage (parse, FcSevereError, "out of memory");
-		break;
+		if (!FcBlanksAdd (parse->config->blanks, i))
+		    goto bail;
 	    }
+	    break;
+	default:
+	    FcConfigMessage (parse, FcSevereError, "invalid element in blank");
+	    break;
 	}
     }
+    return;
+  bail:
+    FcConfigMessage (parse, FcSevereError, "out of memory");
 }
 
 static void
@@ -1119,7 +1144,7 @@ FcParseInt (FcConfigParse *parse)
 {
     FcChar8 *s, *end;
     int	    l;
-    
+
     if (!parse->pstack)
 	return;
     s = FcStrBufDoneStatic (&parse->pstack->str);
@@ -1138,13 +1163,13 @@ FcParseInt (FcConfigParse *parse)
 }
 
 /*
- * idea copied from glib g_ascii_strtod with 
- * permission of the author (Alexander Larsson) 
+ * idea copied from glib g_ascii_strtod with
+ * permission of the author (Alexander Larsson)
  */
 
 #include <locale.h>
 
-static double 
+static double
 FcStrtod (char *s, char **end)
 {
     struct lconv    *locale_data;
@@ -1200,7 +1225,7 @@ FcParseDouble (FcConfigParse *parse)
 {
     FcChar8 *s, *end;
     double  d;
-    
+
     if (!parse->pstack)
 	return;
     s = FcStrBufDoneStatic (&parse->pstack->str);
@@ -1222,7 +1247,7 @@ static void
 FcParseString (FcConfigParse *parse, FcVStackTag tag)
 {
     FcChar8 *s;
-    
+
     if (!parse->pstack)
 	return;
     s = FcStrBufDone (&parse->pstack->str);
@@ -1241,7 +1266,7 @@ FcParseMatrix (FcConfigParse *parse)
     FcVStack	*vstack;
     enum { m_done, m_xx, m_xy, m_yx, m_yy } matrix_state = m_yy;
     FcMatrix	m;
-    
+
     while ((vstack = FcVStackPeek (parse)))
     {
 	double	v;
@@ -1273,6 +1298,49 @@ FcParseMatrix (FcConfigParse *parse)
 	FcVStackPushMatrix (parse, &m);
 }
 
+static void
+FcParseRange (FcConfigParse *parse)
+{
+    FcVStack	*vstack;
+    FcRange	r;
+    FcChar32	n;
+    int		count = 1;
+
+    while ((vstack = FcVStackPeek (parse)))
+    {
+	if (count < 0)
+	{
+	    FcConfigMessage (parse, FcSevereError, "too many elements in range");
+	    return;
+	}
+	switch (vstack->tag) {
+	case FcVStackInteger:
+	    n = vstack->u.integer;
+	    break;
+	default:
+	    FcConfigMessage (parse, FcSevereError, "invalid element in range");
+	    break;
+	}
+	if (count == 1)
+	    r.end = n;
+	else
+	    r.begin = n;
+	count--;
+	FcVStackPopAndDestroy (parse);
+    }
+    if (count < 0)
+    {
+	if (r.begin > r.end)
+	{
+	    FcConfigMessage (parse, FcSevereError, "invalid range");
+	    return;
+	}
+	FcVStackPushRange (parse, &r);
+    }
+    else
+	FcConfigMessage (parse, FcSevereError, "invalid range");
+}
+
 static FcBool
 FcConfigLexBool (FcConfigParse *parse, const FcChar8 *bool_)
 {
@@ -1301,13 +1369,55 @@ FcParseBool (FcConfigParse *parse)
     FcStrBufDestroy (&parse->pstack->str);
 }
 
+static void
+FcParseCharSet (FcConfigParse *parse)
+{
+    FcVStack	*vstack;
+    FcCharSet	*charset = FcCharSetCreate ();
+    FcChar32	i;
+    int n = 0;
+
+    while ((vstack = FcVStackPeek (parse)))
+    {
+	switch (vstack->tag) {
+	case FcVStackInteger:
+	    if (!FcCharSetAddChar (charset, vstack->u.integer))
+	    {
+		FcConfigMessage (parse, FcSevereWarning, "invalid character: 0x%04x", vstack->u.integer);
+	    }
+	    else
+		n++;
+	    break;
+	case FcVStackRange:
+	    for (i = vstack->u.range.begin; i <= vstack->u.range.end; i++)
+	    {
+		if (!FcCharSetAddChar (charset, i))
+		{
+		    FcConfigMessage (parse, FcSevereWarning, "invalid character: 0x%04x", i);
+		}
+		else
+		    n++;
+	    }
+	    break;
+	default:
+		FcConfigMessage (parse, FcSevereError, "invalid element in charset");
+		break;
+	}
+	FcVStackPopAndDestroy (parse);
+    }
+    if (n > 0)
+	    FcVStackPushCharSet (parse, charset);
+    else
+	    FcCharSetDestroy (charset);
+}
+
 static FcBool
 FcConfigLexBinding (FcConfigParse   *parse,
 		    const FcChar8   *binding_string,
 		    FcValueBinding  *binding_ret)
 {
     FcValueBinding binding;
-    
+
     if (!binding_string)
 	binding = FcValueBindingWeak;
     else
@@ -1347,7 +1457,7 @@ FcParseFamilies (FcConfigParse *parse, FcVStackTag tag)
 	FcVStackPopAndDestroy (parse);
 	if (expr)
 	{
-	    new = FcExprCreateOp (left, FcOpComma, expr);
+	    new = FcExprCreateOp (parse->config, left, FcOpComma, expr);
 	    if (!new)
 	    {
 		FcConfigMessage (parse, FcSevereError, "out of memory");
@@ -1384,7 +1494,7 @@ FcParseFamily (FcConfigParse *parse)
 	FcConfigMessage (parse, FcSevereError, "out of memory");
 	return;
     }
-    expr = FcExprCreateString (s);
+    expr = FcExprCreateString (parse->config, s);
     FcStrBufDestroy (&parse->pstack->str);
     if (expr)
 	FcVStackPushExpr (parse, FcVStackFamily, expr);
@@ -1407,7 +1517,7 @@ FcParseAlias (FcConfigParse *parse)
 	case FcVStackFamily:
 	    if (family)
 	    {
-		new = FcExprCreateOp (vstack->u.expr, FcOpComma, family);
+		new = FcExprCreateOp (parse->config, vstack->u.expr, FcOpComma, family);
 		if (!new)
 		    FcConfigMessage (parse, FcSevereError, "out of memory");
 		else
@@ -1458,7 +1568,7 @@ FcParseAlias (FcConfigParse *parse)
     }
     if (prefer)
     {
-	edit = FcEditCreate (parse, 
+	edit = FcEditCreate (parse,
 			     FC_FAMILY_OBJECT,
 			     FcOpPrepend,
 			     prefer,
@@ -1521,13 +1631,13 @@ FcPopExpr (FcConfigParse *parse)
 	break;
     case FcVStackString:
     case FcVStackFamily:
-	expr = FcExprCreateString (vstack->u.string);
+	expr = FcExprCreateString (parse->config, vstack->u.string);
 	break;
     case FcVStackField:
-	expr = FcExprCreateField ((char *) vstack->u.string);
+	expr = FcExprCreateField (parse->config, (char *) vstack->u.string);
 	break;
     case FcVStackConstant:
-	expr = FcExprCreateConst (vstack->u.string);
+	expr = FcExprCreateConst (parse->config, vstack->u.string);
 	break;
     case FcVStackGlob:
 	/* XXX: What's the correct action here? (CDW) */
@@ -1539,16 +1649,21 @@ FcPopExpr (FcConfigParse *parse)
 	vstack->tag = FcVStackNone;
 	break;
     case FcVStackInteger:
-	expr = FcExprCreateInteger (vstack->u.integer);
+	expr = FcExprCreateInteger (parse->config, vstack->u.integer);
 	break;
     case FcVStackDouble:
-	expr = FcExprCreateDouble (vstack->u._double);
+	expr = FcExprCreateDouble (parse->config, vstack->u._double);
 	break;
     case FcVStackMatrix:
-	expr = FcExprCreateMatrix (vstack->u.matrix);
+	expr = FcExprCreateMatrix (parse->config, vstack->u.matrix);
+	break;
+    case FcVStackRange:
 	break;
     case FcVStackBool:
-	expr = FcExprCreateBool (vstack->u.bool_);
+	expr = FcExprCreateBool (parse->config, vstack->u.bool_);
+	break;
+    case FcVStackCharSet:
+	expr = FcExprCreateCharSet (parse->config, vstack->u.charset);
 	break;
     case FcVStackTest:
 	break;
@@ -1583,7 +1698,7 @@ FcPopBinary (FcConfigParse *parse, FcOp op)
     {
 	if (expr)
 	{
-	    new = FcExprCreateOp (left, op, expr);
+	    new = FcExprCreateOp (parse->config, left, op, expr);
 	    if (!new)
 	    {
 		FcConfigMessage (parse, FcSevereError, "out of memory");
@@ -1619,7 +1734,7 @@ FcPopUnary (FcConfigParse *parse, FcOp op)
 
     if ((operand = FcPopExpr (parse)))
     {
-	new = FcExprCreateOp (operand, op, 0);
+	new = FcExprCreateOp (parse->config, operand, op, 0);
 	if (!new)
 	{
 	    FcExprDestroy (operand);
@@ -1643,7 +1758,7 @@ FcParseInclude (FcConfigParse *parse)
     FcChar8	    *s;
     const FcChar8   *i;
     FcBool	    ignore_missing = FcFalse;
-    
+
     s = FcStrBufDoneStatic (&parse->pstack->str);
     if (!s)
     {
@@ -1669,7 +1784,7 @@ FcConfigLexOp (const FcChar8 *op, const FcOpMap	*map, int nmap)
     int	i;
 
     for (i = 0; i < nmap; i++)
-	if (!strcmp ((char *) op, map[i].name)) 
+	if (!strcmp ((char *) op, map[i].name))
 	    return map[i].op;
     return FcOpInvalid;
 }
@@ -1878,7 +1993,7 @@ FcParseMatch (FcConfigParse *parse)
 	    vstack->tag = FcVStackNone;
 	    if (kind == FcMatchScan && edit->object > FC_MAX_BASE_OBJECT)
 	    {
-		FcConfigMessage (parse, FcSevereError, 
+		FcConfigMessage (parse, FcSevereError,
 				 "<match target=\"scan\"> cannot edit user-defined object \"%s\"",
 				 FcObjectName(edit->object));
 	    }
@@ -1902,7 +2017,7 @@ FcParseAcceptRejectFont (FcConfigParse *parse, FcElement element)
     {
 	switch (vstack->tag) {
 	case FcVStackGlob:
-	    if (!FcConfigGlobAdd (parse->config, 
+	    if (!FcConfigGlobAdd (parse->config,
 				  vstack->u.string,
 				  element == FcElementAcceptfont))
 	    {
@@ -1933,15 +2048,15 @@ FcPopValue (FcConfigParse *parse)
 {
     FcVStack	*vstack = FcVStackPeek (parse);
     FcValue	value;
-    
+
     value.type = FcTypeVoid;
-    
+
     if (!vstack)
 	return value;
-    
+
     switch (vstack->tag) {
     case FcVStackString:
-	value.u.s = FcStrCopy (vstack->u.string);
+	value.u.s = FcStrStaticName (vstack->u.string);
 	if (value.u.s)
 	    value.type = FcTypeString;
 	break;
@@ -1966,13 +2081,18 @@ FcPopValue (FcConfigParse *parse)
 	value.u.b = vstack->u.bool_;
 	value.type = FcTypeBool;
 	break;
+    case FcVStackCharSet:
+	value.u.c = FcCharSetCopy (vstack->u.charset);
+	if (value.u.c)
+	    value.type = FcTypeCharSet;
+	break;
     default:
-	FcConfigMessage (parse, FcSevereWarning, "unknown pattern element %d", 
+	FcConfigMessage (parse, FcSevereWarning, "unknown pattern element %d",
 			 vstack->tag);
 	break;
     }
     FcVStackPopAndDestroy (parse);
-    
+
     return value;
 }
 
@@ -1996,7 +2116,7 @@ FcParsePatelt (FcConfigParse *parse)
 	FcPatternDestroy (pattern);
 	return;
     }
-    
+
     for (;;)
     {
 	value = FcPopValue (parse);
@@ -2052,7 +2172,10 @@ FcEndElement(void *userData, const XML_Char *name)
 {
     FcConfigParse   *parse = userData;
     FcChar8	    *data;
-    
+#ifdef _WIN32
+    FcChar8         buffer[1000];
+#endif
+
     if (!parse->pstack)
 	return;
     switch (parse->pstack->element) {
@@ -2071,61 +2194,47 @@ FcEndElement(void *userData, const XML_Char *name)
 	if (strcmp (data, "CUSTOMFONTDIR") == 0)
 	{
 		char *p;
-		FcStrFree (data);
-		data = malloc (1000);
-		if (!data)
-		{
-			FcConfigMessage (parse, FcSevereError, "out of memory");
-			break;
-		}
-		FcMemAlloc (FC_MEM_STRING, 1000);
-		if(!GetModuleFileName(NULL, data, 1000))
+		data = buffer;
+		if (!GetModuleFileName (NULL, buffer, sizeof (buffer) - 20))
 		{
 			FcConfigMessage (parse, FcSevereError, "GetModuleFileName failed");
-			FcStrFree (data);
 			break;
 		}
-		p = strrchr (data, '\\');
+		/*
+		 * Must use the multi-byte aware function to search
+		 * for backslash because East Asian double-byte code
+		 * pages have characters with backslash as the second
+		 * byte.
+		 */
+		p = _mbsrchr (data, '\\');
 		if (p) *p = '\0';
 		strcat (data, "\\fonts");
 	}
 	else if (strcmp (data, "APPSHAREFONTDIR") == 0)
 	{
 		char *p;
-		FcStrFree (data);
-		data = malloc (1000);
-		if (!data)
-		{
-			FcConfigMessage (parse, FcSevereError, "out of memory");
-			break;
-		}
-		FcMemAlloc (FC_MEM_STRING, 1000);
-		if(!GetModuleFileName(NULL, data, 1000))
+		data = buffer;
+		if (!GetModuleFileName (NULL, buffer, sizeof (buffer) - 20))
 		{
 			FcConfigMessage (parse, FcSevereError, "GetModuleFileName failed");
-			FcStrFree (data);
 			break;
 		}
-		p = strrchr (data, '\\');
+		p = _mbsrchr (data, '\\');
 		if (p) *p = '\0';
 		strcat (data, "\\..\\share\\fonts");
 	}
 	else if (strcmp (data, "WINDOWSFONTDIR") == 0)
 	{
 	    int rc;
-	    FcStrFree (data);
-	    data = malloc (1000);
-	    if (!data)
-	    {
-		FcConfigMessage (parse, FcSevereError, "out of memory");
-		break;
-	    }
-	    FcMemAlloc (FC_MEM_STRING, 1000);
-	    rc = GetWindowsDirectory (data, 800);
-	    if (rc == 0 || rc > 800)
+	    data = buffer;
+#if _WIN32_WINNT >= 0x0500
+	    rc = GetSystemWindowsDirectory (buffer, sizeof (buffer) - 20);
+#else
+	    rc = GetWindowsDirectory (buffer, sizeof (buffer) - 20);
+#endif
+	    if (rc == 0 || rc > sizeof (buffer) - 20)
 	    {
-		FcConfigMessage (parse, FcSevereError, "GetWindowsDirectory failed");
-		FcStrFree (data);
+		FcConfigMessage (parse, FcSevereError, "GetSystemWindowsDirectory failed");
 		break;
 	    }
 	    if (data [strlen (data) - 1] != '\\')
@@ -2164,7 +2273,7 @@ FcEndElement(void *userData, const XML_Char *name)
 	    rc = GetTempPath (800, data);
 	    if (rc == 0 || rc > 800)
 	    {
-		FcConfigMessage (parse, FcSevereError, "GetWindowsDirectory failed");
+		FcConfigMessage (parse, FcSevereError, "GetTempPath failed");
 		FcStrFree (data);
 		break;
 	    }
@@ -2242,11 +2351,14 @@ FcEndElement(void *userData, const XML_Char *name)
     case FcElementMatrix:
 	FcParseMatrix (parse);
 	break;
+    case FcElementRange:
+	FcParseRange (parse);
+	break;
     case FcElementBool:
 	FcParseBool (parse);
 	break;
-    case FcElementCharset:
-/*	FcParseCharset (parse); */
+    case FcElementCharSet:
+	FcParseCharSet (parse);
 	break;
     case FcElementSelectfont:
 	break;
@@ -2339,7 +2451,7 @@ static void
 FcCharacterData (void *userData, const XML_Char *s, int len)
 {
     FcConfigParse   *parse = userData;
-    
+
     if (!parse->pstack)
 	return;
     if (!FcStrBufData (&parse->pstack->str, (FcChar8 *) s, len))
@@ -2425,18 +2537,18 @@ FcConfigParseAndLoadDir (FcConfig	*config,
 	ret = FcFalse;
 	goto bail1;
     }
-    
+
     strcpy ((char *) file, (char *) dir);
     strcat ((char *) file, "/");
     base = file + strlen ((char *) file);
-    
+
     files = FcStrSetCreate ();
     if (!files)
     {
 	ret = FcFalse;
 	goto bail2;
     }
-    
+
     if (FcDebug () & FC_DBG_CONFIG)
 	printf ("\tScanning config dir %s\n", dir);
 	
@@ -2464,7 +2576,7 @@ FcConfigParseAndLoadDir (FcConfig	*config,
     if (ret)
     {
 	int i;
-	qsort (files->strs, files->num, sizeof (FcChar8 *), 
+	qsort (files->strs, files->num, sizeof (FcChar8 *),
 	       (int (*)(const void *, const void *)) FcSortCmpStr);
 	for (i = 0; ret && i < files->num; i++)
 	    ret = FcConfigParseAndLoad (config, files->strs[i], complain);
@@ -2491,18 +2603,18 @@ FcConfigParseAndLoad (FcConfig	    *config,
     int		    len;
     FcConfigParse   parse;
     FcBool	    error = FcTrue;
-    
+
 #ifdef ENABLE_LIBXML2
     xmlSAXHandler   sax;
     char            buf[BUFSIZ];
 #else
     void	    *buf;
 #endif
-    
+
     filename = FcConfigFilename (name);
     if (!filename)
 	goto bail0;
-    
+
     if (FcStrSetMember (config->configFiles, filename))
     {
         FcStrFree (filename);
@@ -2526,11 +2638,11 @@ FcConfigParseAndLoad (FcConfig	    *config,
 	printf ("\tLoading config file %s\n", filename);
 
     fd = open ((char *) filename, O_RDONLY);
-    if (fd == -1) { 
+    if (fd == -1) {
 	FcStrFree (filename);
 	goto bail0;
     }
-    
+
 #ifdef ENABLE_LIBXML2
     memset(&sax, 0, sizeof(sax));
 
@@ -2555,7 +2667,7 @@ FcConfigParseAndLoad (FcConfig	    *config,
 #ifndef ENABLE_LIBXML2
 
     XML_SetUserData (p, &parse);
-    
+
     XML_SetDoctypeDeclHandler (p, FcStartDoctypeDecl, FcEndDoctypeDecl);
     XML_SetElementHandler (p, FcStartElement, FcEndElement);
     XML_SetCharacterDataHandler (p, FcCharacterData);
@@ -2584,7 +2696,7 @@ FcConfigParseAndLoad (FcConfig	    *config,
 	if (!XML_ParseBuffer (p, len, len == 0))
 #endif
 	{
-	    FcConfigMessage (&parse, FcSevereError, "%s", 
+	    FcConfigMessage (&parse, FcSevereError, "%s",
 			   XML_ErrorString (XML_GetErrorCode (p)));
 	    goto bail3;
 	}