Added new FcFini function for cleaning up all memory. Fixed a few memory

[fontconfig.git] / src / fccfg.c

diff --git a/src/fccfg.c b/src/fccfg.c
index 3684d790f6011378baafa0f99ebaa99f2b23429b..12cad846f057a9c008d74a22554109caecdec423 100644 (file)
--- a/src/fccfg.c
+++ b/src/fccfg.c
@@ -24,12 +24,16 @@
 
 #include "fcint.h"
 
-#if defined (_WIN32) && defined (PIC)
+#if defined (_WIN32) && (defined (PIC) || defined (DLL_EXPORT))
 #define STRICT
 #include <windows.h>
 #undef STRICT
 #endif
 
+#if defined (_WIN32) && !defined (R_OK)
+#define R_OK 4
+#endif
+
 FcConfig    *_fcConfig;
 
 FcConfig *
@@ -156,6 +160,8 @@ FcSubstDestroy (FcSubst *s)
            FcTestDestroy (s->test);
        if (s->edit)
            FcEditDestroy (s->edit);
+       free (s);
+       FcMemFree (FC_MEM_SUBST, sizeof (FcSubst));
        s = n;
     }
 }
@@ -174,13 +180,18 @@ FcConfigDestroy (FcConfig *config)
     FcStrSetDestroy (config->acceptGlobs);
     FcStrSetDestroy (config->rejectGlobs);
 
-    FcStrFree (config->cache);
+    if (config->blanks)
+       FcBlanksDestroy (config->blanks);
+
+    if (config->cache)
+       FcStrFree (config->cache);
 
     FcSubstDestroy (config->substPattern);
     FcSubstDestroy (config->substFont);
     for (set = FcSetSystem; set <= FcSetApplication; set++)
        if (config->fonts[set])
            FcFontSetDestroy (config->fonts[set]);
+
     free (config);
     FcMemFree (FC_MEM_CONFIG, sizeof (FcConfig));
 }
@@ -207,7 +218,8 @@ FcConfigBuildFonts (FcConfig *config)
     if (!cache)
        goto bail1;
 
-    FcGlobalCacheLoad (cache, config->cache);
+    if (config->cache)
+       FcGlobalCacheLoad (cache, config->cache);
 
     list = FcConfigGetFontDirs (config);
     if (!list)
@@ -226,7 +238,8 @@ FcConfigBuildFonts (FcConfig *config)
     if (FcDebug () & FC_DBG_FONTSET)
        FcFontSetPrint (fonts);
 
-    FcGlobalCacheSave (cache, config->cache);
+    if (config->cache)
+       FcGlobalCacheSave (cache, config->cache);
     FcGlobalCacheDestroy (cache);
 
     FcConfigSetFonts (config, fonts, FcSetSystem);
@@ -507,42 +520,43 @@ FcConfigPromote (FcValue v, FcValue u)
 }
 
 FcBool
-FcConfigCompareValue (const FcValue    m_o,
+FcConfigCompareValue (const FcValue    left_o,
                      FcOp              op,
-                     const FcValue     v_o)
+                     const FcValue     right_o)
 {
-    FcValue    m = m_o;
-    FcValue    v = v_o;
+    FcValue    left = left_o;
+    FcValue    right = right_o;
     FcBool     ret = FcFalse;
     
-    m = FcConfigPromote (m, v);
-    v = FcConfigPromote (v, m);
-    if (m.type == v.type) 
+    left = FcConfigPromote (left, right);
+    right = FcConfigPromote (right, left);
+    if (left.type == right.type) 
     {
-       switch (m.type) {
+       switch (left.type) {
        case FcTypeInteger:
            break;      /* FcConfigPromote prevents this from happening */
        case FcTypeDouble:
            switch (op) {
            case FcOpEqual:
            case FcOpContains:
-               ret = m.u.d == v.u.d;
+           case FcOpListing:
+               ret = left.u.d == right.u.d;
                break;
            case FcOpNotEqual:
            case FcOpNotContains:
-               ret = m.u.d != v.u.d;
+               ret = left.u.d != right.u.d;
                break;
            case FcOpLess:    
-               ret = m.u.d < v.u.d;
+               ret = left.u.d < right.u.d;
                break;
            case FcOpLessEqual:    
-               ret = m.u.d <= v.u.d;
+               ret = left.u.d <= right.u.d;
                break;
            case FcOpMore:    
-               ret = m.u.d > v.u.d;
+               ret = left.u.d > right.u.d;
                break;
            case FcOpMoreEqual:    
-               ret = m.u.d >= v.u.d;
+               ret = left.u.d >= right.u.d;
                break;
            default:
                break;
@@ -552,11 +566,12 @@ FcConfigCompareValue (const FcValue       m_o,
            switch (op) {
            case FcOpEqual:    
            case FcOpContains:
-               ret = m.u.b == v.u.b;
+           case FcOpListing:
+               ret = left.u.b == right.u.b;
                break;
            case FcOpNotEqual:
            case FcOpNotContains:
-               ret = m.u.b != v.u.b;
+               ret = left.u.b != right.u.b;
                break;
            default:
                break;
@@ -565,12 +580,15 @@ FcConfigCompareValue (const FcValue       m_o,
        case FcTypeString:
            switch (op) {
            case FcOpEqual:    
+           case FcOpListing:
+               ret = FcStrCmpIgnoreCase (left.u.s, right.u.s) == 0;
+               break;
            case FcOpContains:
-               ret = FcStrCmpIgnoreCase (m.u.s, v.u.s) == 0;
+               ret = FcStrStrIgnoreCase (left.u.s, right.u.s) != 0;
                break;
            case FcOpNotEqual:
            case FcOpNotContains:
-               ret = FcStrCmpIgnoreCase (m.u.s, v.u.s) != 0;
+               ret = FcStrCmpIgnoreCase (left.u.s, right.u.s) != 0;
                break;
            default:
                break;
@@ -580,11 +598,12 @@ FcConfigCompareValue (const FcValue       m_o,
            switch (op) {
            case FcOpEqual:
            case FcOpContains:
-               ret = FcMatrixEqual (m.u.m, v.u.m);
+           case FcOpListing:
+               ret = FcMatrixEqual (left.u.m, right.u.m);
                break;
            case FcOpNotEqual:
            case FcOpNotContains:
-               ret = !FcMatrixEqual (m.u.m, v.u.m);
+               ret = !FcMatrixEqual (left.u.m, right.u.m);
                break;
            default:
                break;
@@ -593,18 +612,19 @@ FcConfigCompareValue (const FcValue       m_o,
        case FcTypeCharSet:
            switch (op) {
            case FcOpContains:
-               /* v contains m if m is a subset of v */
-               ret = FcCharSetIsSubset (m.u.c, v.u.c);
+           case FcOpListing:
+               /* left contains right if right is a subset of left */
+               ret = FcCharSetIsSubset (right.u.c, left.u.c);
                break;
            case FcOpNotContains:
-               /* v contains m if m is a subset of v */
-               ret = !FcCharSetIsSubset (m.u.c, v.u.c);
+               /* left contains right if right is a subset of left */
+               ret = !FcCharSetIsSubset (right.u.c, left.u.c);
                break;
            case FcOpEqual:
-               ret = FcCharSetEqual (m.u.c, v.u.c);
+               ret = FcCharSetEqual (left.u.c, right.u.c);
                break;
            case FcOpNotEqual:
-               ret = !FcCharSetEqual (m.u.c, v.u.c);
+               ret = !FcCharSetEqual (left.u.c, right.u.c);
                break;
            default:
                break;
@@ -613,16 +633,17 @@ FcConfigCompareValue (const FcValue       m_o,
        case FcTypeLangSet:
            switch (op) {
            case FcOpContains:
-               ret = FcLangSetContains (v.u.l, m.u.l);
+           case FcOpListing:
+               ret = FcLangSetContains (left.u.l, right.u.l);
                break;
            case FcOpNotContains:
-               ret = FcLangSetContains (v.u.l, m.u.l);
+               ret = FcLangSetContains (left.u.l, right.u.l);
                break;
            case FcOpEqual:
-               ret = FcLangSetEqual (v.u.l, m.u.l);
+               ret = FcLangSetEqual (left.u.l, right.u.l);
                break;
            case FcOpNotEqual:
-               ret = !FcLangSetEqual (v.u.l, m.u.l);
+               ret = !FcLangSetEqual (left.u.l, right.u.l);
                break;
            default:
                break;
@@ -632,6 +653,7 @@ FcConfigCompareValue (const FcValue m_o,
            switch (op) {
            case FcOpEqual:
            case FcOpContains:
+           case FcOpListing:
                ret = FcTrue;
                break;
            default:
@@ -642,11 +664,12 @@ FcConfigCompareValue (const FcValue       m_o,
            switch (op) {
            case FcOpEqual:
            case FcOpContains:
-               ret = m.u.f == v.u.f;
+           case FcOpListing:
+               ret = left.u.f == right.u.f;
                break;
            case FcOpNotEqual:
            case FcOpNotContains:
-               ret = m.u.f != v.u.f;
+               ret = left.u.f != right.u.f;
                break;
            default:
                break;
@@ -737,6 +760,7 @@ FcConfigEvaluate (FcPattern *p, FcExpr *e)
     case FcOpMoreEqual:
     case FcOpContains:
     case FcOpNotContains:
+    case FcOpListing:
        vl = FcConfigEvaluate (p, e->u.tree.left);
        vr = FcConfigEvaluate (p, e->u.tree.right);
        v.type = FcTypeBool;
@@ -941,6 +965,7 @@ FcConfigMatchValueList (FcPattern   *p,
     
     while (e)
     {
+       /* Compute the value of the match expression */
        if (e->op == FcOpComma)
        {
            value = FcConfigEvaluate (p, e->u.tree.left);
@@ -954,6 +979,7 @@ FcConfigMatchValueList (FcPattern   *p,
 
        for (v = values; v; v = v->next)
        {
+           /* Compare the pattern value to the match expression value */
            if (FcConfigCompareValue (v->value, t->op, value))
            {
                if (!ret)
@@ -1367,7 +1393,7 @@ FcConfigSubstitute (FcConfig      *config,
     return FcConfigSubstituteWithPat (config, p, 0, kind);
 }
 
-#if defined (_WIN32) && defined (PIC)
+#if defined (_WIN32) && (defined (PIC) || defined (DLL_EXPORT))
 
 static FcChar8 fontconfig_path[1000] = "";