/*
- * $RCSId: xc/lib/fontconfig/src/fcxml.c,v 1.21 2002/08/22 18:53:22 keithp Exp $
+ * fontconfig/src/fcxml.c
*
* Copyright © 2002 Keith Packard
*
* 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
* PERFORMANCE OF THIS SOFTWARE.
*/
-#include <stdarg.h>
#include "fcint.h"
+#include <fcntl.h>
+#include <stdarg.h>
#include <dirent.h>
-#if ENABLE_LIBXML2
+#ifdef ENABLE_LIBXML2
#include <libxml/parser.h>
#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)
if (test->next)
FcTestDestroy (test->next);
FcExprDestroy (test->expr);
- FcStrFree ((FcChar8 *) test->field);
FcMemFree (FC_MEM_TEST, sizeof (FcTest));
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 *
+FcExprCreateLangSet (FcConfig *config, FcLangSet *langset)
{
- FcExpr *e = (FcExpr *) malloc (sizeof (FcExpr));
+ FcExpr *e = FcConfigAllocExpr (config);
+ if (e)
+ {
+ e->op = FcOpLangSet;
+ e->u.lval = FcLangSetCopy (langset);
+ }
+ return e;
+}
+static FcExpr *
+FcExprCreateField (FcConfig *config, const char *field)
+{
+ FcExpr *e = FcConfigAllocExpr (config);
if (e)
{
- FcMemAlloc (FC_MEM_EXPR, sizeof (FcExpr));
e->op = FcOpField;
- e->u.field = (char *) FcStrCopy ((FcChar8 *) field);
+ 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;
return e;
}
-void
+static void
FcExprDestroy (FcExpr *e)
{
if (!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;
+ case FcOpLangSet:
+ FcLangSetDestroy (e->u.lval);
+ break;
case FcOpBool:
break;
case FcOpField:
- FcStrFree ((FcChar8 *) e->u.field);
break;
case FcOpConst:
- FcStrFree (e->u.constant);
break;
case FcOpAssign:
case FcOpAssignReplace:
case FcOpInvalid:
break;
}
- FcMemFree (FC_MEM_EXPR, sizeof (FcExpr));
- free (e);
+
+ e->op = FcOpNil;
}
void
{
if (e->next)
FcEditDestroy (e->next);
- FcStrFree ((FcChar8 *) e->field);
if (e->expr)
FcExprDestroy (e->expr);
free (e);
}
-char *
-FcConfigSaveField (const char *field)
-{
- return (char *) FcStrCopy ((FcChar8 *) field);
-}
-
typedef enum _FcElement {
FcElementNone,
FcElementFontconfig,
FcElementDir,
+ FcElementCacheDir,
FcElementCache,
FcElementInclude,
FcElementConfig,
FcElementDouble,
FcElementString,
FcElementMatrix,
+ FcElementRange,
FcElementBool,
- FcElementCharset,
+ FcElementCharSet,
+ FcElementLangSet,
FcElementName,
FcElementConst,
FcElementOr,
FcElementUnknown
} FcElement;
-static struct {
+static const struct {
const char name[16];
FcElement element;
} fcElementMap[] = {
{ "fontconfig", FcElementFontconfig },
{ "dir", FcElementDir },
+ { "cachedir", FcElementCacheDir },
{ "cache", FcElementCache },
{ "include", FcElementInclude },
{ "config", FcElementConfig },
{ "match", FcElementMatch },
{ "alias", FcElementAlias },
-
+
{ "blank", FcElementBlank },
{ "rescan", FcElementRescan },
{ "double", FcElementDouble },
{ "string", FcElementString },
{ "matrix", FcElementMatrix },
+ { "range", FcElementRange },
{ "bool", FcElementBool },
- { "charset", FcElementCharset },
+ { "charset", FcElementCharSet },
+ { "langset", FcElementLangSet },
{ "name", FcElementName },
{ "const", FcElementConst },
{ "or", FcElementOr },
FcElement element;
FcChar8 **attr;
FcStrBuf str;
+ FcChar8 *attr_buf_static[16];
} FcPStack;
-
+
typedef enum _FcVStackTag {
FcVStackNone,
FcVStackConstant,
FcVStackGlob,
FcVStackPattern,
-
+
FcVStackPrefer,
FcVStackAccept,
FcVStackDefault,
-
+
FcVStackInteger,
FcVStackDouble,
FcVStackMatrix,
+ FcVStackRange,
FcVStackBool,
-
+ FcVStackCharSet,
+ FcVStackLangSet,
+
FcVStackTest,
FcVStackExpr,
FcVStackEdit
int integer;
double _double;
FcMatrix *matrix;
- FcBool bool;
+ FcRange range;
+ FcBool bool_;
+ FcCharSet *charset;
+ FcLangSet *langset;
FcTest *test;
FcQual qual;
const FcChar8 *name;
FcConfig *config;
XML_Parser parser;
+ int pstack_static_used;
+ FcPStack pstack_static[8];
+ int vstack_static_used;
+ FcVStack vstack_static[64];
} FcConfigParse;
typedef enum _FcConfigSeverity {
{
if (parse->name)
fprintf (stderr, "Fontconfig %s: \"%s\", line %d: ", s,
- parse->name, XML_GetCurrentLineNumber (parse->parser));
+ parse->name, (int)XML_GetCurrentLineNumber (parse->parser));
else
fprintf (stderr, "Fontconfig %s: line %d: ", s,
- XML_GetCurrentLineNumber (parse->parser));
+ (int)XML_GetCurrentLineNumber (parse->parser));
if (severe >= FcSevereError)
parse->error = FcTrue;
}
if ((value == FcTypeLangSet && type == FcTypeString) ||
(value == FcTypeString && type == FcTypeLangSet))
return;
+ if (type == (FcType) -1)
+ return;
FcConfigMessage (parse, FcSevereWarning, "saw %s, expected %s",
FcTypeName (value), FcTypeName (type));
}
{
const FcObjectType *o;
const FcConstant *c;
-
+
+ /* If parsing the expression failed, some nodes may be NULL */
+ if (!expr)
+ return;
+
switch (expr->op) {
case FcOpInteger:
case FcOpDouble:
case FcOpCharSet:
FcTypecheckValue (parse, FcTypeCharSet, type);
break;
+ case FcOpLangSet:
+ FcTypecheckValue (parse, FcTypeLangSet, type);
+ break;
case FcOpNil:
break;
case FcOpField:
- o = FcNameGetObjectType (expr->u.field);
+ o = FcNameGetObjectType (FcObjectName (expr->u.object));
if (o)
FcTypecheckValue (parse, o->type, type);
break;
if (o)
FcTypecheckValue (parse, o->type, type);
}
- else
- FcConfigMessage (parse, FcSevereWarning,
+ else
+ FcConfigMessage (parse, FcSevereWarning,
"invalid constant used : %s",
expr->u.constant);
break;
static FcTest *
FcTestCreate (FcConfigParse *parse,
- FcMatchKind kind,
+ FcMatchKind kind,
FcQual qual,
const FcChar8 *field,
FcOp compare,
test->next = 0;
test->kind = kind;
test->qual = qual;
- test->field = (char *) FcStrCopy (field);
+ test->object = FcObjectFromName ((const char *) field);
test->op = compare;
test->expr = expr;
- o = FcNameGetObjectType (test->field);
+ o = FcNameGetObjectType (FcObjectName (test->object));
if (o)
FcTypecheckExpr (parse, expr, o->type);
}
static FcEdit *
FcEditCreate (FcConfigParse *parse,
- const char *field,
+ FcObject object,
FcOp op,
FcExpr *expr,
FcValueBinding binding)
const FcObjectType *o;
e->next = 0;
- e->field = field; /* already saved in grammar */
+ e->object = object;
e->op = op;
e->expr = expr;
e->binding = binding;
- o = FcNameGetObjectType (e->field);
+ o = FcNameGetObjectType (FcObjectName (e->object));
if (o)
FcTypecheckExpr (parse, expr, o->type);
}
return e;
}
-static void
-FcVStackPush (FcConfigParse *parse, FcVStack *vstack)
-{
- vstack->prev = parse->vstack;
- vstack->pstack = parse->pstack ? parse->pstack->prev : 0;
- parse->vstack = vstack;
-}
-
static FcVStack *
-FcVStackCreate (void)
+FcVStackCreateAndPush (FcConfigParse *parse)
{
FcVStack *new;
- new = malloc (sizeof (FcVStack));
- if (!new)
- return 0;
- FcMemAlloc (FC_MEM_VSTACK, sizeof (FcVStack));
+ if (parse->vstack_static_used < sizeof (parse->vstack_static) / sizeof (parse->vstack_static[0]))
+ new = &parse->vstack_static[parse->vstack_static_used++];
+ else
+ {
+ new = malloc (sizeof (FcVStack));
+ if (!new)
+ return 0;
+ FcMemAlloc (FC_MEM_VSTACK, sizeof (FcVStack));
+ }
new->tag = FcVStackNone;
new->prev = 0;
- return new;
-}
-static void
-FcVStackDestroy (FcVStack *vstack)
-{
- FcVStack *prev;
+ new->prev = parse->vstack;
+ new->pstack = parse->pstack ? parse->pstack->prev : 0;
+ parse->vstack = new;
- for (; vstack; vstack = prev)
- {
- prev = vstack->prev;
- switch (vstack->tag) {
- case FcVStackNone:
- break;
- case FcVStackString:
- case FcVStackFamily:
- case FcVStackField:
- case FcVStackConstant:
- case FcVStackGlob:
- FcStrFree (vstack->u.string);
- break;
- case FcVStackPattern:
- FcPatternDestroy (vstack->u.pattern);
- break;
- case FcVStackInteger:
- case FcVStackDouble:
- break;
- case FcVStackMatrix:
- FcMatrixFree (vstack->u.matrix);
- break;
- case FcVStackBool:
- break;
- case FcVStackTest:
- FcTestDestroy (vstack->u.test);
- break;
- case FcVStackExpr:
- case FcVStackPrefer:
- case FcVStackAccept:
- case FcVStackDefault:
- FcExprDestroy (vstack->u.expr);
- break;
- case FcVStackEdit:
- FcEditDestroy (vstack->u.edit);
- break;
- }
- FcMemFree (FC_MEM_VSTACK, sizeof (FcVStack));
- free (vstack);
- }
+ return new;
}
static FcBool
FcVStackPushString (FcConfigParse *parse, FcVStackTag tag, FcChar8 *string)
{
- FcVStack *vstack = FcVStackCreate ();
+ FcVStack *vstack = FcVStackCreateAndPush (parse);
if (!vstack)
return FcFalse;
vstack->u.string = string;
vstack->tag = tag;
- FcVStackPush (parse, vstack);
return FcTrue;
}
static FcBool
FcVStackPushInteger (FcConfigParse *parse, int integer)
{
- FcVStack *vstack = FcVStackCreate ();
+ FcVStack *vstack = FcVStackCreateAndPush (parse);
if (!vstack)
return FcFalse;
vstack->u.integer = integer;
vstack->tag = FcVStackInteger;
- FcVStackPush (parse, vstack);
return FcTrue;
}
static FcBool
FcVStackPushDouble (FcConfigParse *parse, double _double)
{
- FcVStack *vstack = FcVStackCreate ();
+ FcVStack *vstack = FcVStackCreateAndPush (parse);
if (!vstack)
return FcFalse;
vstack->u._double = _double;
vstack->tag = FcVStackDouble;
- FcVStackPush (parse, vstack);
return FcTrue;
}
static FcBool
FcVStackPushMatrix (FcConfigParse *parse, FcMatrix *matrix)
{
- FcVStack *vstack = FcVStackCreate ();
- if (!vstack)
- return FcFalse;
+ FcVStack *vstack;
matrix = FcMatrixCopy (matrix);
if (!matrix)
- {
- FcVStackDestroy (vstack);
return FcFalse;
- }
+ vstack = FcVStackCreateAndPush (parse);
+ if (!vstack)
+ return FcFalse;
vstack->u.matrix = matrix;
vstack->tag = FcVStackMatrix;
- FcVStackPush (parse, vstack);
return FcTrue;
}
static FcBool
-FcVStackPushBool (FcConfigParse *parse, FcBool bool)
+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_)
{
- FcVStack *vstack = FcVStackCreate ();
+ FcVStack *vstack = FcVStackCreateAndPush (parse);
if (!vstack)
return FcFalse;
- vstack->u.bool = bool;
+ vstack->u.bool_ = bool_;
vstack->tag = FcVStackBool;
- FcVStackPush (parse, vstack);
+ 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
+FcVStackPushLangSet (FcConfigParse *parse, FcLangSet *langset)
+{
+ FcVStack *vstack;
+ if (!langset)
+ return FcFalse;
+ vstack = FcVStackCreateAndPush (parse);
+ if (!vstack)
+ return FcFalse;
+ vstack->u.langset = langset;
+ vstack->tag = FcVStackLangSet;
return FcTrue;
}
static FcBool
FcVStackPushTest (FcConfigParse *parse, FcTest *test)
{
- FcVStack *vstack = FcVStackCreate ();
+ FcVStack *vstack = FcVStackCreateAndPush (parse);
if (!vstack)
return FcFalse;
vstack->u.test = test;
vstack->tag = FcVStackTest;
- FcVStackPush (parse, vstack);
return FcTrue;
}
static FcBool
FcVStackPushExpr (FcConfigParse *parse, FcVStackTag tag, FcExpr *expr)
{
- FcVStack *vstack = FcVStackCreate ();
+ FcVStack *vstack = FcVStackCreateAndPush (parse);
if (!vstack)
return FcFalse;
vstack->u.expr = expr;
vstack->tag = tag;
- FcVStackPush (parse, vstack);
return FcTrue;
}
static FcBool
FcVStackPushEdit (FcConfigParse *parse, FcEdit *edit)
{
- FcVStack *vstack = FcVStackCreate ();
+ FcVStack *vstack = FcVStackCreateAndPush (parse);
if (!vstack)
return FcFalse;
vstack->u.edit = edit;
vstack->tag = FcVStackEdit;
- FcVStackPush (parse, vstack);
return FcTrue;
}
static FcBool
FcVStackPushPattern (FcConfigParse *parse, FcPattern *pattern)
{
- FcVStack *vstack = FcVStackCreate ();
+ FcVStack *vstack = FcVStackCreateAndPush (parse);
if (!vstack)
return FcFalse;
vstack->u.pattern = pattern;
vstack->tag = FcVStackPattern;
- FcVStackPush (parse, vstack);
return FcTrue;
}
return vstack;
}
-static void
-FcVStackClear (FcConfigParse *parse)
+static FcVStack *
+FcVStackPeek (FcConfigParse *parse)
{
- while (parse->vstack && parse->vstack->pstack == parse->pstack)
- {
- FcVStack *vstack = parse->vstack;
- parse->vstack = vstack->prev;
- vstack->prev = 0;
- FcVStackDestroy (vstack);
- }
+ FcVStack *vstack = parse->vstack;
+
+ return vstack && vstack->pstack == parse->pstack ? vstack : 0;
}
-static FcVStack *
-FcVStackPop (FcConfigParse *parse)
+static void
+FcVStackPopAndDestroy (FcConfigParse *parse)
{
FcVStack *vstack = parse->vstack;
-
+
if (!vstack || vstack->pstack != parse->pstack)
- return 0;
+ return;
+
parse->vstack = vstack->prev;
- vstack->prev = 0;
- return vstack;
+
+ switch (vstack->tag) {
+ case FcVStackNone:
+ break;
+ case FcVStackFamily:
+ break;
+ case FcVStackString:
+ case FcVStackField:
+ case FcVStackConstant:
+ case FcVStackGlob:
+ FcStrFree (vstack->u.string);
+ break;
+ case FcVStackPattern:
+ FcPatternDestroy (vstack->u.pattern);
+ break;
+ case FcVStackInteger:
+ case FcVStackDouble:
+ break;
+ case FcVStackMatrix:
+ FcMatrixFree (vstack->u.matrix);
+ break;
+ case FcVStackRange:
+ case FcVStackBool:
+ break;
+ case FcVStackCharSet:
+ FcCharSetDestroy (vstack->u.charset);
+ break;
+ case FcVStackLangSet:
+ FcLangSetDestroy (vstack->u.langset);
+ break;
+ case FcVStackTest:
+ FcTestDestroy (vstack->u.test);
+ break;
+ case FcVStackExpr:
+ case FcVStackPrefer:
+ case FcVStackAccept:
+ case FcVStackDefault:
+ FcExprDestroy (vstack->u.expr);
+ break;
+ case FcVStackEdit:
+ FcEditDestroy (vstack->u.edit);
+ break;
+ }
+
+ if (vstack == &parse->vstack_static[parse->vstack_static_used - 1])
+ parse->vstack_static_used--;
+ else
+ {
+ FcMemFree (FC_MEM_VSTACK, sizeof (FcVStack));
+ free (vstack);
+ }
+}
+
+static void
+FcVStackClear (FcConfigParse *parse)
+{
+ while (FcVStackPeek (parse))
+ FcVStackPopAndDestroy (parse);
}
static int
}
static FcChar8 **
-FcConfigSaveAttr (const XML_Char **attr)
+FcConfigSaveAttr (const XML_Char **attr, FcChar8 **buf, int size_bytes)
{
- int n;
int slen;
int i;
FcChar8 **new;
slen = 0;
for (i = 0; attr[i]; i++)
slen += strlen ((char *) attr[i]) + 1;
- n = i;
- new = malloc ((i + 1) * sizeof (FcChar8 *) + slen);
- if (!new)
+ if (i == 0)
return 0;
- FcMemAlloc (FC_MEM_ATTR, 1); /* size is too expensive */
+ slen += (i + 1) * sizeof (FcChar8 *);
+ if (slen <= size_bytes)
+ new = buf;
+ else
+ {
+ new = malloc (slen);
+ if (!new)
+ {
+ FcConfigMessage (0, FcSevereError, "out of memory");
+ return 0;
+ }
+ FcMemAlloc (FC_MEM_ATTR, 1); /* size is too expensive */
+ }
s = (FcChar8 *) (new + (i + 1));
for (i = 0; attr[i]; i++)
{
static FcBool
FcPStackPush (FcConfigParse *parse, FcElement element, const XML_Char **attr)
{
- FcPStack *new = malloc (sizeof (FcPStack));
+ FcPStack *new;
- if (!new)
- return FcFalse;
- FcMemAlloc (FC_MEM_PSTACK, sizeof (FcPStack));
- new->prev = parse->pstack;
- new->element = element;
- if (attr)
+ if (parse->pstack_static_used < sizeof (parse->pstack_static) / sizeof (parse->pstack_static[0]))
+ new = &parse->pstack_static[parse->pstack_static_used++];
+ else
{
- new->attr = FcConfigSaveAttr (attr);
- if (!new->attr)
- FcConfigMessage (parse, FcSevereError, "out of memory");
+ new = malloc (sizeof (FcPStack));
+ if (!new)
+ return FcFalse;
+ FcMemAlloc (FC_MEM_PSTACK, sizeof (FcPStack));
}
- else
- new->attr = 0;
+
+ new->prev = parse->pstack;
+ new->element = element;
+ new->attr = FcConfigSaveAttr (attr, new->attr_buf_static, sizeof (new->attr_buf_static));
FcStrBufInit (&new->str, 0, 0);
parse->pstack = new;
return FcTrue;
FcPStackPop (FcConfigParse *parse)
{
FcPStack *old;
-
- if (!parse->pstack)
+
+ if (!parse->pstack)
{
FcConfigMessage (parse, FcSevereError, "mismatching element");
return FcFalse;
old = parse->pstack;
parse->pstack = old->prev;
FcStrBufDestroy (&old->str);
- if (old->attr)
+ if (old->attr && old->attr != old->attr_buf_static)
{
FcMemFree (FC_MEM_ATTR, 1); /* size is to expensive */
free (old->attr);
}
- FcMemFree (FC_MEM_PSTACK, sizeof (FcPStack));
- free (old);
+
+ if (old == &parse->pstack_static[parse->pstack_static_used - 1])
+ parse->pstack_static_used--;
+ else
+ {
+ FcMemFree (FC_MEM_PSTACK, sizeof (FcPStack));
+ free (old);
+ }
return FcTrue;
}
FcConfigInit (FcConfigParse *parse, const FcChar8 *name, FcConfig *config, XML_Parser parser)
{
parse->pstack = 0;
+ parse->pstack_static_used = 0;
parse->vstack = 0;
+ parse->vstack_static_used = 0;
parse->error = FcFalse;
parse->name = name;
parse->config = config;
return 0;
attrs = parse->pstack->attr;
+ if (!attrs)
+ return 0;
+
while (*attrs)
{
if (!strcmp ((char *) *attrs, 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");
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:
+ if (v->u.range.begin <= v->u.range.end)
{
- FcConfigMessage (parse, FcSevereError, "out of memory");
- break;
+ for (i = v->u.range.begin; i <= v->u.range.end; i++)
+ {
+ 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
{
FcChar8 *s, *end;
int l;
-
+
if (!parse->pstack)
return;
- s = FcStrBufDone (&parse->pstack->str);
+ s = FcStrBufDoneStatic (&parse->pstack->str);
if (!s)
{
FcConfigMessage (parse, FcSevereError, "out of memory");
FcConfigMessage (parse, FcSevereError, "\"%s\": not a valid integer", s);
else
FcVStackPushInteger (parse, l);
- FcStrFree (s);
+ FcStrBufDestroy (&parse->pstack->str);
}
/*
- * 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;
{
FcChar8 *s, *end;
double d;
-
+
if (!parse->pstack)
return;
- s = FcStrBufDone (&parse->pstack->str);
+ s = FcStrBufDoneStatic (&parse->pstack->str);
if (!s)
{
FcConfigMessage (parse, FcSevereError, "out of memory");
FcConfigMessage (parse, FcSevereError, "\"%s\": not a valid double", s);
else
FcVStackPushDouble (parse, d);
- FcStrFree (s);
+ FcStrBufDestroy (&parse->pstack->str);
}
static void
FcParseString (FcConfigParse *parse, FcVStackTag tag)
{
FcChar8 *s;
-
+
if (!parse->pstack)
return;
s = FcStrBufDone (&parse->pstack->str);
FcVStack *vstack;
enum { m_done, m_xx, m_xy, m_yx, m_yy } matrix_state = m_yy;
FcMatrix m;
-
- while ((vstack = FcVStackPop (parse)))
+
+ while ((vstack = FcVStackPeek (parse)))
{
double v;
switch (vstack->tag) {
case m_yy: m.yy = v; break;
default: break;
}
- FcVStackDestroy (vstack);
+ FcVStackPopAndDestroy (parse);
matrix_state--;
}
if (matrix_state != m_done)
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)
+FcConfigLexBool (FcConfigParse *parse, const FcChar8 *bool_)
{
FcBool result = FcFalse;
- if (!FcNameBool (bool, &result))
+ if (!FcNameBool (bool_, &result))
FcConfigMessage (parse, FcSevereWarning, "\"%s\" is not known boolean",
- bool);
+ bool_);
return result;
}
if (!parse->pstack)
return;
- s = FcStrBufDone (&parse->pstack->str);
+ s = FcStrBufDoneStatic (&parse->pstack->str);
if (!s)
{
FcConfigMessage (parse, FcSevereError, "out of memory");
return;
}
FcVStackPushBool (parse, FcConfigLexBool (parse, s));
- FcStrFree (s);
+ 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:
+ if (vstack->u.range.begin <= vstack->u.range.end)
+ {
+ 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 void
+FcParseLangSet (FcConfigParse *parse)
+{
+ FcVStack *vstack;
+ FcLangSet *langset = FcLangSetCreate ();
+ int n = 0;
+
+ while ((vstack = FcVStackPeek (parse)))
+ {
+ switch (vstack->tag) {
+ case FcVStackString:
+ if (!FcLangSetAdd (langset, vstack->u.string))
+ {
+ FcConfigMessage (parse, FcSevereWarning, "invalid langset: %s", vstack->u.string);
+ }
+ else
+ n++;
+ break;
+ default:
+ FcConfigMessage (parse, FcSevereError, "invalid element in langset");
+ break;
+ }
+ FcVStackPopAndDestroy (parse);
+ }
+ if (n > 0)
+ FcVStackPushLangSet (parse, langset);
+ else
+ FcLangSetDestroy (langset);
+}
+
+static FcBool
+FcConfigLexBinding (FcConfigParse *parse,
+ const FcChar8 *binding_string,
+ FcValueBinding *binding_ret)
+{
+ FcValueBinding binding;
+
+ if (!binding_string)
+ binding = FcValueBindingWeak;
+ else
+ {
+ if (!strcmp ((char *) binding_string, "weak"))
+ binding = FcValueBindingWeak;
+ else if (!strcmp ((char *) binding_string, "strong"))
+ binding = FcValueBindingStrong;
+ else if (!strcmp ((char *) binding_string, "same"))
+ binding = FcValueBindingSame;
+ else
+ {
+ FcConfigMessage (parse, FcSevereWarning, "invalid binding \"%s\"", binding_string);
+ return FcFalse;
+ }
+ }
+ *binding_ret = binding;
+ return FcTrue;
}
static void
FcVStack *vstack;
FcExpr *left, *expr = 0, *new;
- while ((vstack = FcVStackPop (parse)))
+ while ((vstack = FcVStackPeek (parse)))
{
if (vstack->tag != FcVStackFamily)
{
FcConfigMessage (parse, FcSevereWarning, "non-family");
- FcVStackDestroy (vstack);
+ FcVStackPopAndDestroy (parse);
continue;
}
left = vstack->u.expr;
vstack->tag = FcVStackNone;
- FcVStackDestroy (vstack);
+ FcVStackPopAndDestroy (parse);
if (expr)
{
- new = FcExprCreateOp (left, FcOpComma, expr);
+ new = FcExprCreateOp (parse->config, left, FcOpComma, expr);
if (!new)
{
FcConfigMessage (parse, FcSevereError, "out of memory");
if (!FcVStackPushExpr (parse, tag, expr))
{
FcConfigMessage (parse, FcSevereError, "out of memory");
- if (expr)
- FcExprDestroy (expr);
+ FcExprDestroy (expr);
}
}
}
if (!parse->pstack)
return;
- s = FcStrBufDone (&parse->pstack->str);
+ s = FcStrBufDoneStatic (&parse->pstack->str);
if (!s)
{
FcConfigMessage (parse, FcSevereError, "out of memory");
return;
}
- expr = FcExprCreateString (s);
- FcStrFree (s);
+ expr = FcExprCreateString (parse->config, s);
+ FcStrBufDestroy (&parse->pstack->str);
if (expr)
FcVStackPushExpr (parse, FcVStackFamily, expr);
}
FcEdit *edit = 0, *next;
FcVStack *vstack;
FcTest *test;
+ FcValueBinding binding;
- while ((vstack = FcVStackPop (parse)))
+ if (!FcConfigLexBinding (parse, FcConfigGetAttribute (parse, "binding"), &binding))
+ return;
+ while ((vstack = FcVStackPeek (parse)))
{
switch (vstack->tag) {
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
FcConfigMessage (parse, FcSevereWarning, "bad alias");
break;
}
- FcVStackDestroy (vstack);
+ FcVStackPopAndDestroy (parse);
}
if (!family)
{
}
if (prefer)
{
- edit = FcEditCreate (parse,
- FcConfigSaveField ("family"),
+ edit = FcEditCreate (parse,
+ FC_FAMILY_OBJECT,
FcOpPrepend,
prefer,
- FcValueBindingWeak);
+ binding);
if (edit)
edit->next = 0;
else
{
next = edit;
edit = FcEditCreate (parse,
- FcConfigSaveField ("family"),
+ FC_FAMILY_OBJECT,
FcOpAppend,
accept,
- FcValueBindingWeak);
+ binding);
if (edit)
edit->next = next;
else
{
next = edit;
edit = FcEditCreate (parse,
- FcConfigSaveField ("family"),
+ FC_FAMILY_OBJECT,
FcOpAppendLast,
def,
- FcValueBindingWeak);
+ binding);
if (edit)
edit->next = next;
else
static FcExpr *
FcPopExpr (FcConfigParse *parse)
{
- FcVStack *vstack = FcVStackPop (parse);
+ FcVStack *vstack = FcVStackPeek (parse);
FcExpr *expr = 0;
if (!vstack)
return 0;
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) */
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 FcVStackLangSet:
+ expr = FcExprCreateLangSet (parse->config, vstack->u.langset);
break;
case FcVStackTest:
break;
default:
break;
}
- FcVStackDestroy (vstack);
+ FcVStackPopAndDestroy (parse);
return expr;
}
{
if (expr)
{
- new = FcExprCreateOp (left, op, expr);
+ new = FcExprCreateOp (parse->config, left, op, expr);
if (!new)
{
FcConfigMessage (parse, FcSevereError, "out of memory");
FcExprDestroy (left);
FcExprDestroy (expr);
- break;
+ return 0;
}
expr = new;
}
if ((operand = FcPopExpr (parse)))
{
- new = FcExprCreateOp (operand, op, 0);
+ new = FcExprCreateOp (parse->config, operand, op, 0);
if (!new)
{
FcExprDestroy (operand);
FcChar8 *s;
const FcChar8 *i;
FcBool ignore_missing = FcFalse;
-
- s = FcStrBufDone (&parse->pstack->str);
+
+ s = FcStrBufDoneStatic (&parse->pstack->str);
if (!s)
{
FcConfigMessage (parse, FcSevereError, "out of memory");
ignore_missing = FcTrue;
if (!FcConfigParseAndLoad (parse->config, s, !ignore_missing))
parse->error = FcTrue;
- FcStrFree (s);
+ FcStrBufDestroy (&parse->pstack->str);
}
typedef struct _FcOpMap {
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;
}
return FcConfigLexOp (compare, fcCompareOps, NUM_COMPARE_OPS);
}
-
static void
FcParseTest (FcConfigParse *parse)
{
kind = FcMatchPattern;
else if (!strcmp ((char *) kind_string, "font"))
kind = FcMatchFont;
+ else if (!strcmp ((char *) kind_string, "scan"))
+ kind = FcMatchScan;
else if (!strcmp ((char *) kind_string, "default"))
kind = FcMatchDefault;
else
{
const FcChar8 *name;
const FcChar8 *mode_string;
- const FcChar8 *binding_string;
FcOp mode;
FcValueBinding binding;
FcExpr *expr;
return;
}
}
- binding_string = FcConfigGetAttribute (parse, "binding");
- if (!binding_string)
- binding = FcValueBindingWeak;
- else
- {
- if (!strcmp ((char *) binding_string, "weak"))
- binding = FcValueBindingWeak;
- else if (!strcmp ((char *) binding_string, "strong"))
- binding = FcValueBindingStrong;
- else if (!strcmp ((char *) binding_string, "same"))
- binding = FcValueBindingSame;
- else
- {
- FcConfigMessage (parse, FcSevereWarning, "invalid edit binding \"%s\"", binding_string);
- return;
- }
- }
+ if (!FcConfigLexBinding (parse, FcConfigGetAttribute (parse, "binding"), &binding))
+ return;
+
expr = FcPopBinary (parse, FcOpComma);
- edit = FcEditCreate (parse, (char *) FcStrCopy (name), mode, expr, binding);
+ edit = FcEditCreate (parse, FcObjectFromName ((char *) name),
+ mode, expr, binding);
if (!edit)
{
FcConfigMessage (parse, FcSevereError, "out of memory");
kind = FcMatchPattern;
else if (!strcmp ((char *) kind_name, "font"))
kind = FcMatchFont;
+ else if (!strcmp ((char *) kind_name, "scan"))
+ kind = FcMatchScan;
else
{
FcConfigMessage (parse, FcSevereWarning, "invalid match target \"%s\"", kind_name);
return;
}
}
- while ((vstack = FcVStackPop (parse)))
+ while ((vstack = FcVStackPeek (parse)))
{
switch (vstack->tag) {
case FcVStackTest:
vstack->u.edit->next = edit;
edit = vstack->u.edit;
vstack->tag = FcVStackNone;
+ if (kind == FcMatchScan && edit->object > FC_MAX_BASE_OBJECT)
+ {
+ FcConfigMessage (parse, FcSevereError,
+ "<match target=\"scan\"> cannot edit user-defined object \"%s\"",
+ FcObjectName(edit->object));
+ }
break;
default:
FcConfigMessage (parse, FcSevereWarning, "invalid match element");
break;
}
- FcVStackDestroy (vstack);
+ FcVStackPopAndDestroy (parse);
}
if (!FcConfigAddEdit (parse->config, test, edit, kind))
FcConfigMessage (parse, FcSevereError, "out of memory");
{
FcVStack *vstack;
- while ((vstack = FcVStackPop (parse)))
+ while ((vstack = FcVStackPeek (parse)))
{
switch (vstack->tag) {
case FcVStackGlob:
- if (!FcConfigGlobAdd (parse->config,
+ if (!FcConfigGlobAdd (parse->config,
vstack->u.string,
element == FcElementAcceptfont))
{
FcConfigMessage (parse, FcSevereWarning, "bad font selector");
break;
}
- FcVStackDestroy (vstack);
+ FcVStackPopAndDestroy (parse);
}
}
static FcValue
FcPopValue (FcConfigParse *parse)
{
- FcVStack *vstack = FcVStackPop (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;
value.type = FcTypeMatrix;
break;
case FcVStackBool:
- value.u.b = vstack->u.bool;
+ 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;
+ case FcVStackLangSet:
+ value.u.l = FcLangSetCopy (vstack->u.langset);
+ if (value.u.l)
+ value.type = FcTypeLangSet;
+ break;
default:
- FcConfigMessage (parse, FcSevereWarning, "unknown pattern element %d",
+ FcConfigMessage (parse, FcSevereWarning, "unknown pattern element %d",
vstack->tag);
break;
}
- FcVStackDestroy (vstack);
-
+ FcVStackPopAndDestroy (parse);
+
return value;
}
if (!name)
{
FcConfigMessage (parse, FcSevereWarning, "missing pattern element name");
+ FcPatternDestroy (pattern);
return;
}
-
+
for (;;)
{
value = FcPopValue (parse);
if (!FcPatternAdd (pattern, name, value, FcTrue))
{
FcConfigMessage (parse, FcSevereError, "out of memory");
+ FcValueDestroy(value);
break;
}
+ FcValueDestroy(value);
}
FcVStackPushPattern (parse, pattern);
return;
}
- while ((vstack = FcVStackPop (parse)))
+ while ((vstack = FcVStackPeek (parse)))
{
switch (vstack->tag) {
case FcVStackPattern:
if (!FcPatternAppend (pattern, vstack->u.pattern))
{
FcConfigMessage (parse, FcSevereError, "out of memory");
+ FcPatternDestroy (pattern);
return;
}
break;
FcConfigMessage (parse, FcSevereWarning, "unknown pattern element");
break;
}
- FcVStackDestroy (vstack);
+ FcVStackPopAndDestroy (parse);
}
FcVStackPushPattern (parse, pattern);
{
FcConfigParse *parse = userData;
FcChar8 *data;
-
+#ifdef _WIN32
+ FcChar8 buffer[1000];
+#endif
+
if (!parse->pstack)
return;
switch (parse->pstack->element) {
case FcElementFontconfig:
break;
case FcElementDir:
+ data = FcStrBufDoneStatic (&parse->pstack->str);
+ if (!data)
+ {
+ FcConfigMessage (parse, FcSevereError, "out of memory");
+ break;
+ }
+#ifdef _WIN32
+ if (strcmp (data, "CUSTOMFONTDIR") == 0)
+ {
+ char *p;
+ data = buffer;
+ if (!GetModuleFileName (NULL, buffer, sizeof (buffer) - 20))
+ {
+ FcConfigMessage (parse, FcSevereError, "GetModuleFileName failed");
+ break;
+ }
+ /*
+ * 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;
+ data = buffer;
+ if (!GetModuleFileName (NULL, buffer, sizeof (buffer) - 20))
+ {
+ FcConfigMessage (parse, FcSevereError, "GetModuleFileName failed");
+ break;
+ }
+ p = _mbsrchr (data, '\\');
+ if (p) *p = '\0';
+ strcat (data, "\\..\\share\\fonts");
+ }
+ else if (strcmp (data, "WINDOWSFONTDIR") == 0)
+ {
+ int rc;
+ 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, "GetSystemWindowsDirectory failed");
+ break;
+ }
+ if (data [strlen (data) - 1] != '\\')
+ strcat (data, "\\");
+ strcat (data, "fonts");
+ }
+#endif
+ if (strlen ((char *) data) == 0)
+ FcConfigMessage (parse, FcSevereWarning, "empty font directory name ignored");
+ else if (!FcStrUsesHome (data) || FcConfigHome ())
+ {
+ if (!FcConfigAddDir (parse->config, data))
+ FcConfigMessage (parse, FcSevereError, "out of memory; cannot add directory %s", data);
+ }
+ FcStrBufDestroy (&parse->pstack->str);
+ break;
+ case FcElementCacheDir:
data = FcStrBufDone (&parse->pstack->str);
if (!data)
{
break;
}
#ifdef _WIN32
- if (strcmp (data, "WINDOWSFONTDIR") == 0)
+ if (strcmp (data, "WINDOWSTEMPDIR_FONTCONFIG_CACHE") == 0)
{
int rc;
FcStrFree (data);
break;
}
FcMemAlloc (FC_MEM_STRING, 1000);
- rc = GetWindowsDirectory (data, 800);
+ rc = GetTempPath (800, data);
if (rc == 0 || rc > 800)
{
- FcConfigMessage (parse, FcSevereError, "GetWindowsDirectory failed");
+ FcConfigMessage (parse, FcSevereError, "GetTempPath failed");
FcStrFree (data);
break;
}
if (data [strlen (data) - 1] != '\\')
strcat (data, "\\");
- strcat (data, "fonts");
+ strcat (data, "fontconfig\\cache");
}
#endif
if (!FcStrUsesHome (data) || FcConfigHome ())
{
- if (!FcConfigAddDir (parse->config, data))
- FcConfigMessage (parse, FcSevereError, "out of memory");
+ if (!FcConfigAddCacheDir (parse->config, data))
+ FcConfigMessage (parse, FcSevereError, "out of memory; cannot add cache directory %s", data);
}
FcStrFree (data);
break;
+
case FcElementCache:
- data = FcStrBufDone (&parse->pstack->str);
+ data = FcStrBufDoneStatic (&parse->pstack->str);
if (!data)
{
FcConfigMessage (parse, FcSevereError, "out of memory");
break;
}
- if (!FcStrUsesHome (data) || FcConfigHome ())
- {
- if (!FcConfigSetCache (parse->config, data))
- FcConfigMessage (parse, FcSevereError, "out of memory");
- }
- FcStrFree (data);
+ /* discard this data; no longer used */
+ FcStrBufDestroy (&parse->pstack->str);
break;
case FcElementInclude:
FcParseInclude (parse);
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 FcElementLangSet:
+ FcParseLangSet (parse);
break;
case FcElementSelectfont:
break;
FcCharacterData (void *userData, const XML_Char *s, int len)
{
FcConfigParse *parse = userData;
-
+
if (!parse->pstack)
return;
if (!FcStrBufData (&parse->pstack->str, (FcChar8 *) s, len))
FcConfigMessage (parse, FcSevereError, "invalid doctype \"%s\"", doctypeName);
}
-#if ENABLE_LIBXML2
+#ifdef ENABLE_LIBXML2
static void
FcInternalSubsetDecl (void *userData,
#endif /* ENABLE_LIBXML2 */
+static int
+FcSortCmpStr (const void *a, const void *b)
+{
+ const FcChar8 *as = *((FcChar8 **) a);
+ const FcChar8 *bs = *((FcChar8 **) b);
+ return FcStrCmp (as, bs);
+}
+
static FcBool
FcConfigParseAndLoadDir (FcConfig *config,
const FcChar8 *name,
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);
if (ret)
{
int i;
- qsort (files->strs, files->num, sizeof (FcChar8 *),
- (int (*)(const void *, const void *)) FcStrCmp);
+ 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);
}
XML_Parser p;
FcChar8 *filename;
- FILE *f;
+ int fd;
int len;
FcConfigParse parse;
FcBool error = FcTrue;
-
-#if ENABLE_LIBXML2
+
+#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);
+ return FcTrue;
+ }
+
if (!FcStrSetAdd (config->configFiles, filename))
{
FcStrFree (filename);
if (FcDebug () & FC_DBG_CONFIG)
printf ("\tLoading config file %s\n", filename);
- f = fopen ((char *) filename, "r");
- if (!f) {
+ fd = open ((char *) filename, O_RDONLY);
+ if (fd == -1) {
FcStrFree (filename);
goto bail0;
}
-
-#if ENABLE_LIBXML2
+
+#ifdef ENABLE_LIBXML2
memset(&sax, 0, sizeof(sax));
sax.internalSubset = FcInternalSubsetDecl;
if (!FcConfigInit (&parse, name, config, p))
goto bail2;
-#if !ENABLE_LIBXML2
+#ifndef ENABLE_LIBXML2
XML_SetUserData (p, &parse);
-
+
XML_SetDoctypeDeclHandler (p, FcStartDoctypeDecl, FcEndDoctypeDecl);
XML_SetElementHandler (p, FcStartElement, FcEndElement);
XML_SetCharacterDataHandler (p, FcCharacterData);
#endif /* ENABLE_LIBXML2 */
do {
-#if !ENABLE_LIBXML2
+#ifndef ENABLE_LIBXML2
buf = XML_GetBuffer (p, BUFSIZ);
if (!buf)
{
goto bail3;
}
#endif
- len = fread (buf, 1, BUFSIZ, f);
+ len = read (fd, buf, BUFSIZ);
if (len < 0)
{
FcConfigMessage (&parse, FcSevereError, "failed reading config file");
goto bail3;
}
-#if ENABLE_LIBXML2
+#ifdef ENABLE_LIBXML2
if (xmlParseChunk (p, buf, len, len == 0))
#else
if (!XML_ParseBuffer (p, len, len == 0))
#endif
{
- FcConfigMessage (&parse, FcSevereError, "%s",
+ FcConfigMessage (&parse, FcSevereError, "%s",
XML_ErrorString (XML_GetErrorCode (p)));
goto bail3;
}
bail2:
XML_ParserFree (p);
bail1:
- fclose (f);
- f = NULL;
+ close (fd);
+ fd = -1;
bail0:
if (error && complain)
{
}
return FcTrue;
}
+#define __fcxml__
+#include "fcaliastail.h"
+#undef __fcxml__