* 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
#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)
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)
-{
- FcExpr *e = (FcExpr *) malloc (sizeof (FcExpr));
-
- if (e)
- {
- FcMemAlloc (FC_MEM_EXPR, sizeof (FcExpr));
- e->op = FcOpNil;
- }
- 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;
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);
case FcOpField:
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
free (e);
}
-char *
-FcConfigSaveField (const char *field)
-{
- return (char *) FcStrCopy ((FcChar8 *) field);
-}
-
typedef enum _FcElement {
FcElementNone,
FcElementFontconfig,
{ "config", FcElementConfig },
{ "match", FcElementMatch },
{ "alias", FcElementAlias },
-
+
{ "blank", FcElementBlank },
{ "rescan", FcElementRescan },
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,
FcVStackBool,
-
+
FcVStackTest,
FcVStackExpr,
FcVStackEdit
{
const FcObjectType *o;
const FcConstant *c;
-
+
/* If parsing the expression failed, some nodes may be NULL */
if (!expr)
return;
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,
FcVStackPopAndDestroy (FcConfigParse *parse)
{
FcVStack *vstack = parse->vstack;
-
+
if (!vstack || vstack->pstack != parse->pstack)
return;
switch (vstack->tag) {
case FcVStackNone:
break;
- case FcVStackString:
case FcVStackFamily:
+ break;
+ case FcVStackString:
case FcVStackField:
case FcVStackConstant:
case FcVStackGlob:
}
static FcChar8 **
-FcConfigSaveAttr (const XML_Char **attr)
+FcConfigSaveAttr (const XML_Char **attr, FcChar8 **buf, int size_bytes)
{
int slen;
int i;
slen += strlen ((char *) attr[i]) + 1;
if (i == 0)
return 0;
- new = malloc ((i + 1) * sizeof (FcChar8 *) + slen);
- if (!new)
+ slen += (i + 1) * sizeof (FcChar8 *);
+ if (slen <= size_bytes)
+ new = buf;
+ else
{
- FcConfigMessage (0, FcSevereError, "out of memory");
- return 0;
+ new = malloc (slen);
+ if (!new)
+ {
+ FcConfigMessage (0, FcSevereError, "out of memory");
+ return 0;
+ }
+ FcMemAlloc (FC_MEM_ATTR, 1); /* size is too expensive */
}
- FcMemAlloc (FC_MEM_ATTR, 1); /* size is too expensive */
s = (FcChar8 *) (new + (i + 1));
for (i = 0; attr[i]; i++)
{
new->prev = parse->pstack;
new->element = element;
- new->attr = FcConfigSaveAttr (attr);
+ 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);
{
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");
{
FcChar8 *s, *end;
int l;
-
+
if (!parse->pstack)
return;
s = FcStrBufDoneStatic (&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 = FcStrBufDoneStatic (&parse->pstack->str);
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 = FcVStackPeek (parse)))
{
double v;
FcValueBinding *binding_ret)
{
FcValueBinding binding;
-
+
if (!binding_string)
binding = FcValueBindingWeak;
else
FcVStackPopAndDestroy (parse);
if (expr)
{
- new = FcExprCreateOp (left, FcOpComma, expr);
+ new = FcExprCreateOp (parse->config, left, FcOpComma, expr);
if (!new)
{
FcConfigMessage (parse, FcSevereError, "out of memory");
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);
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
}
if (prefer)
{
- edit = FcEditCreate (parse,
+ edit = FcEditCreate (parse,
FC_FAMILY_OBJECT,
FcOpPrepend,
prefer,
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 FcVStackBool:
- expr = FcExprCreateBool (vstack->u.bool_);
+ expr = FcExprCreateBool (parse->config, vstack->u.bool_);
break;
case FcVStackTest:
break;
{
if (expr)
{
- new = FcExprCreateOp (left, op, expr);
+ new = FcExprCreateOp (parse->config, left, op, expr);
if (!new)
{
FcConfigMessage (parse, FcSevereError, "out of memory");
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 = FcStrBufDoneStatic (&parse->pstack->str);
if (!s)
{
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;
}
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));
}
{
switch (vstack->tag) {
case FcVStackGlob:
- if (!FcConfigGlobAdd (parse->config,
+ if (!FcConfigGlobAdd (parse->config,
vstack->u.string,
element == FcElementAcceptfont))
{
{
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 = FcTypeBool;
break;
default:
- FcConfigMessage (parse, FcSevereWarning, "unknown pattern element %d",
+ FcConfigMessage (parse, FcSevereWarning, "unknown pattern element %d",
vstack->tag);
break;
}
FcVStackPopAndDestroy (parse);
-
+
return value;
}
FcPatternDestroy (pattern);
return;
}
-
+
for (;;)
{
value = FcPopValue (parse);
{
FcConfigParse *parse = userData;
FcChar8 *data;
-
+#ifdef _WIN32
+ FcChar8 buffer[1000];
+#endif
+
if (!parse->pstack)
return;
switch (parse->pstack->element) {
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] != '\\')
rc = GetTempPath (800, data);
if (rc == 0 || rc > 800)
{
- FcConfigMessage (parse, FcSevereError, "GetWindowsDirectory failed");
+ FcConfigMessage (parse, FcSevereError, "GetTempPath failed");
FcStrFree (data);
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))
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 *),
+ 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);
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);
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));
#ifndef ENABLE_LIBXML2
XML_SetUserData (p, &parse);
-
+
XML_SetDoctypeDeclHandler (p, FcStartDoctypeDecl, FcEndDoctypeDecl);
XML_SetElementHandler (p, FcStartElement, FcEndElement);
XML_SetCharacterDataHandler (p, FcCharacterData);
if (!XML_ParseBuffer (p, len, len == 0))
#endif
{
- FcConfigMessage (&parse, FcSevereError, "%s",
+ FcConfigMessage (&parse, FcSevereError, "%s",
XML_ErrorString (XML_GetErrorCode (p)));
goto bail3;
}