Handle pattern elements moving during multiple edits

[fontconfig.git] / src / fccfg.c

diff --git a/src/fccfg.c b/src/fccfg.c
index d8bbe8ddb595ec78c1bd124327ef12903f2fdebd..36a76a416c5619f54987872232dfe2c805ebb357 100644 (file)
--- a/src/fccfg.c
+++ b/src/fccfg.c
@@ -24,6 +24,12 @@
 
 #include "fcint.h"
 
+#if defined (_WIN32) && defined (PIC)
+#define STRICT
+#include <windows.h>
+#undef STRICT
+#endif
+
 FcConfig    *_fcConfig;
 
 FcConfig *
@@ -134,8 +140,10 @@ FcSubstDestroy (FcSubst *s)
     while (s)
     {
        n = s->next;
-       FcTestDestroy (s->test);
-       FcEditDestroy (s->edit);
+       if (s->test)
+           FcTestDestroy (s->test);
+       if (s->edit)
+           FcEditDestroy (s->edit);
        s = n;
     }
 }
@@ -640,6 +648,13 @@ FcConfigCompareValue (const FcValue        m_o,
 }
 
 
+#define _FcDoubleFloor(d)      ((int) (d))
+#define _FcDoubleCeil(d)       ((double) (int) (d) == (d) ? (int) (d) : (int) ((d) + 1))
+#define FcDoubleFloor(d)       ((d) >= 0 ? _FcDoubleFloor(d) : -_FcDoubleCeil(-(d)))
+#define FcDoubleCeil(d)                ((d) >= 0 ? _FcDoubleCeil(d) : -_FcDoubleFloor(-(d)))
+#define FcDoubleRound(d)       FcDoubleFloor ((d) + 0.5)
+#define FcDoubleTrunc(d)       ((d) >= 0 ? _FcDoubleFloor (d) : -_FcDoubleFloor (-(d)))
+
 static FcValue
 FcConfigEvaluate (FcPattern *p, FcExpr *e)
 {
@@ -828,6 +843,70 @@ FcConfigEvaluate (FcPattern *p, FcExpr *e)
        }
        FcValueDestroy (vl);
        break;
+    case FcOpFloor:
+       vl = FcConfigEvaluate (p, e->u.tree.left);
+       switch (vl.type) {
+       case FcTypeInteger:
+           v = vl;
+           break;
+       case FcTypeDouble:
+           v.type = FcTypeInteger;
+           v.u.i = FcDoubleFloor (vl.u.d);
+           break;
+       default:
+           v.type = FcTypeVoid;
+           break;
+       }
+       FcValueDestroy (vl);
+       break;
+    case FcOpCeil:
+       vl = FcConfigEvaluate (p, e->u.tree.left);
+       switch (vl.type) {
+       case FcTypeInteger:
+           v = vl;
+           break;
+       case FcTypeDouble:
+           v.type = FcTypeInteger;
+           v.u.i = FcDoubleCeil (vl.u.d);
+           break;
+       default:
+           v.type = FcTypeVoid;
+           break;
+       }
+       FcValueDestroy (vl);
+       break;
+    case FcOpRound:
+       vl = FcConfigEvaluate (p, e->u.tree.left);
+       switch (vl.type) {
+       case FcTypeInteger:
+           v = vl;
+           break;
+       case FcTypeDouble:
+           v.type = FcTypeInteger;
+           v.u.i = FcDoubleRound (vl.u.d);
+           break;
+       default:
+           v.type = FcTypeVoid;
+           break;
+       }
+       FcValueDestroy (vl);
+       break;
+    case FcOpTrunc:
+       vl = FcConfigEvaluate (p, e->u.tree.left);
+       switch (vl.type) {
+       case FcTypeInteger:
+           v = vl;
+           break;
+       case FcTypeDouble:
+           v.type = FcTypeInteger;
+           v.u.i = FcDoubleTrunc (vl.u.d);
+           break;
+       default:
+           v.type = FcTypeVoid;
+           break;
+       }
+       FcValueDestroy (vl);
+       break;
     default:
        v.type = FcTypeVoid;
        break;
@@ -1153,6 +1232,14 @@ FcConfigSubstituteWithPat (FcConfig    *config,
                    !FcStrCmpIgnoreCase ((FcChar8 *) t->field, 
                                         (FcChar8 *) e->field))
                {
+                   /* 
+                    * KLUDGE - the pattern may have been reallocated or
+                    * things may have been inserted or deleted above
+                    * this element by other edits.  Go back and find
+                    * the element again
+                    */
+                   if (e != s->edit && st[i].elt)
+                       st[i].elt = FcPatternFindElt (p, t->field);
                    if (!st[i].elt)
                        t = 0;
                    break;
@@ -1265,9 +1352,53 @@ FcConfigSubstitute (FcConfig     *config,
     return FcConfigSubstituteWithPat (config, p, 0, kind);
 }
 
-#ifndef FONTCONFIG_PATH
-#define FONTCONFIG_PATH        "/etc/fonts"
-#endif
+#if defined (_WIN32) && defined (PIC)
+
+static FcChar8 fontconfig_path[1000] = "";
+
+BOOL WINAPI
+DllMain (HINSTANCE hinstDLL,
+        DWORD     fdwReason,
+        LPVOID    lpvReserved)
+{
+  FcChar8 *p;
+
+  switch (fdwReason) {
+  case DLL_PROCESS_ATTACH:
+      if (!GetModuleFileName ((HMODULE) hinstDLL, fontconfig_path,
+                             sizeof (fontconfig_path)))
+         break;
+
+      /* If the fontconfig DLL is in a "bin" or "lib" subfolder,
+       * assume it's a Unix-style installation tree, and use
+       * "etc/fonts" in there as FONTCONFIG_PATH. Otherwise use the
+       * folder where the DLL is as FONTCONFIG_PATH.
+       */
+      p = strrchr (fontconfig_path, '\\');
+      if (p)
+      {
+         *p = '\0';
+         p = strrchr (fontconfig_path, '\\');
+         if (p && (FcStrCmpIgnoreCase (p + 1, "bin") == 0 ||
+                   FcStrCmpIgnoreCase (p + 1, "lib") == 0))
+             *p = '\0';
+         strcat (fontconfig_path, "\\etc\\fonts");
+      }
+      else
+          fontconfig_path[0] = '\0';
+      
+      break;
+  }
+
+  return TRUE;
+}
+
+#undef FONTCONFIG_PATH
+#define FONTCONFIG_PATH fontconfig_path
+
+#else /* !(_WIN32 && PIC) */
+
+#endif /* !(_WIN32 && PIC) */
 
 #ifndef FONTCONFIG_FILE
 #define FONTCONFIG_FILE        "fonts.conf"
@@ -1285,9 +1416,16 @@ FcConfigFileExists (const FcChar8 *dir, const FcChar8 *file)
        return 0;
 
     strcpy ((char *) path, (const char *) dir);
-    /* make sure there's a single separating / */
+    /* make sure there's a single separator */
+#ifdef _WIN32
+    if ((!path[0] || (path[strlen((char *) path)-1] != '/' &&
+                     path[strlen((char *) path)-1] != '\\')) &&
+        (file[0] != '/' && file[0] != '\\'))
+       strcat ((char *) path, "\\");
+#else
     if ((!path[0] || path[strlen((char *) path)-1] != '/') && file[0] != '/')
        strcat ((char *) path, "/");
+#endif
     strcat ((char *) path, (char *) file);
 
     FcMemAlloc (FC_MEM_STRING, strlen ((char *) path) + 1);
@@ -1314,7 +1452,7 @@ FcConfigGetPath (void)
        e = env;
        npath++;
        while (*e)
-           if (*e++ == ':')
+           if (*e++ == FC_SEARCH_PATH_SEPARATOR)
                npath++;
     }
     path = calloc (npath, sizeof (FcChar8 *));
@@ -1327,7 +1465,7 @@ FcConfigGetPath (void)
        e = env;
        while (*e) 
        {
-           colon = (FcChar8 *) strchr ((char *) e, ':');
+           colon = (FcChar8 *) strchr ((char *) e, FC_SEARCH_PATH_SEPARATOR);
            if (!colon)
                colon = e + strlen ((char *) e);
            path[i] = malloc (colon - e + 1);
@@ -1374,7 +1512,16 @@ FcChar8 *
 FcConfigHome (void)
 {
     if (_FcConfigHomeEnabled)
-       return getenv ("HOME");
+    {
+        char *home = getenv ("HOME");
+
+#ifdef _WIN32
+       if (home == NULL)
+           home = getenv ("USERPROFILE");
+#endif
+
+       return home;
+    }
     return 0;
 }
 
@@ -1398,6 +1545,14 @@ FcConfigFilename (const FcChar8 *url)
            url = (FcChar8 *) FONTCONFIG_FILE;
     }
     file = 0;
+
+#ifdef _WIN32
+    if (isalpha (*url) &&
+       url[1] == ':' &&
+       (url[2] == '/' || url[2] == '\\'))
+       goto absolute_path;
+#endif
+
     switch (*url) {
     case '~':
        dir = FcConfigHome ();
@@ -1406,6 +1561,10 @@ FcConfigFilename (const FcChar8 *url)
        else
            file = 0;
        break;
+#ifdef _WIN32
+    case '\\':
+    absolute_path:
+#endif
     case '/':
        file = FcConfigFileExists (0, url);
        break;