#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
{ "config", FcElementConfig },
{ "match", FcElementMatch },
{ "alias", FcElementAlias },
-
+
{ "blank", FcElementBlank },
{ "rescan", FcElementRescan },
switch (vstack->tag) {
case FcVStackNone:
break;
- case FcVStackString:
case FcVStackFamily:
+ break;
+ case FcVStackString:
case FcVStackField:
case FcVStackConstant:
case FcVStackGlob:
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
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);
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;
{
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;
}
git.wh0rd.org / fontconfig.git / blobdiff