]> git.wh0rd.org - fontconfig.git/blobdiff - src/fcpat.c
git.wh0rd.org / fontconfig.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fix problem dating back at least to 2.3.2 where globs weren't being applied
[fontconfig.git] / src / fcpat.c
diff --git a/src/fcpat.c b/src/fcpat.c
index b1bb5952e6e2d3d9f8696c40d65ba98c3c57f8e6..cba99911d99e7222f2cd61e60f1cfc454981b903 100644 (file)
--- a/src/fcpat.c
+++ b/src/fcpat.c
@@ -27,15 +27,13 @@
 #include <assert.h>
 #include "fcint.h"
 
-static FcPattern ** fcpatterns = 0;
+static FcPattern ** _fcPatterns = 0;
 static int fcpattern_bank_count = 0, fcpattern_ptr, fcpattern_count;
-FcPatternElt ** fcpatternelts = 0;
+FcPatternElt ** _fcPatternElts = 0;
 static int fcpatternelt_ptr, fcpatternelt_count;
-FcValueList ** fcvaluelists = 0;
+FcValueList ** _fcValueLists = 0;
 static int fcvaluelist_bank_count = 0, fcvaluelist_ptr, fcvaluelist_count;
 
-static const char *
-FcPatternFindFullFname (const FcPattern *p);
 static FcPatternEltPtr
 FcPatternEltPtrCreateDynamic (FcPatternElt * e);
 
@@ -1447,7 +1445,7 @@ FcStrDistributeBytes (FcCache * metadata, void * block_ptr);
 static const FcChar8 *
 FcStrSerialize (int bank, const FcChar8 * s);
 static void *
-FcStrUnserialize (FcCache metadata, void *block_ptr);
+FcStrUnserialize (FcCache * metadata, void *block_ptr);
 
 static void
 FcValueListNewBank (void);
@@ -1460,7 +1458,7 @@ FcValueListDistributeBytes (FcCache * metadata, void *block_ptr);
 static FcValueListPtr
 FcValueListSerialize(int bank, FcValueList *pi);
 static void *
-FcValueListUnserialize (FcCache metadata, void *block_ptr);
+FcValueListUnserialize (FcCache * metadata, void *block_ptr);
 
 
 void
@@ -1507,27 +1505,27 @@ FcPatternEnsureBank (int bi)
     FcPatternElt **ep;
     int i;
 
-    if (!fcpatterns || fcpattern_bank_count <= bi)
+    if (!_fcPatterns || fcpattern_bank_count <= bi)
     {
        int new_count = bi + 4;
-       pp = realloc (fcpatterns, sizeof (FcPattern *) * new_count);
+       pp = realloc (_fcPatterns, sizeof (FcPattern *) * new_count);
        if (!pp)
            return 0;
 
        FcMemAlloc (FC_MEM_PATTERN, sizeof (FcPattern *) * new_count);
-       fcpatterns = pp;
+       _fcPatterns = pp;
 
-       ep = realloc (fcpatternelts, sizeof (FcPatternElt *) * new_count);
+       ep = realloc (_fcPatternElts, sizeof (FcPatternElt *) * new_count);
        if (!ep)
            return 0;
 
        FcMemAlloc (FC_MEM_PATELT, sizeof (FcPatternElt *) * new_count);
-       fcpatternelts = ep;
+       _fcPatternElts = ep;
 
        for (i = fcpattern_bank_count; i < new_count; i++)
        {
-           fcpatterns[i] = 0;
-           fcpatternelts[i] = 0;
+           _fcPatterns[i] = 0;
+           _fcPatternElts[i] = 0;
        }
 
        fcpattern_bank_count = new_count;
@@ -1547,14 +1545,14 @@ FcPatternDistributeBytes (FcCache * metadata, void * block_ptr)
 
     fcpattern_ptr = 0;
     block_ptr = ALIGN(block_ptr, FcPattern);
-    fcpatterns[bi] = (FcPattern *)block_ptr;
+    _fcPatterns[bi] = (FcPattern *)block_ptr;
     block_ptr = (void *)((char *)block_ptr + 
                         (sizeof (FcPattern) * fcpattern_count));
     
     FcMemAlloc (FC_MEM_PATELT, sizeof (FcPatternElt) * fcpatternelt_count);
     fcpatternelt_ptr = 0;
     block_ptr = ALIGN(block_ptr, FcPatternElt);
-    fcpatternelts[bi] = (FcPatternElt *)block_ptr;
+    _fcPatternElts[bi] = (FcPatternElt *)block_ptr;
     block_ptr = (void *)((char *)block_ptr + 
                         (sizeof (FcPatternElt) * fcpatternelt_count));
 
@@ -1575,10 +1573,10 @@ FcPatternSerialize (int bank, FcPattern *old)
     FcValueListPtr v, nv_head, nvp;
     int i, elts, bi = FcCacheBankToIndex(bank);
 
-    p = &fcpatterns[bi][fcpattern_ptr++];
+    p = &_fcPatterns[bi][fcpattern_ptr++];
     p->bank = bank;
     elts = fcpatternelt_ptr;
-    nep = &fcpatternelts[bi][elts];
+    nep = &_fcPatternElts[bi][elts];
     if (!nep)
        return FcFalse;
 
@@ -1619,24 +1617,24 @@ FcPatternSerialize (int bank, FcPattern *old)
 }
 
 void *
-FcPatternUnserialize (FcCache metadata, void *block_ptr)
+FcPatternUnserialize (FcCache * metadata, void *block_ptr)
 {
-    int bi = FcCacheBankToIndex(metadata.bank);
+    int bi = FcCacheBankToIndex(metadata->bank);
     if (!FcPatternEnsureBank(bi))
        return FcFalse;
 
-    FcMemAlloc (FC_MEM_PATTERN, sizeof (FcPattern) * metadata.pattern_count);
+    FcMemAlloc (FC_MEM_PATTERN, sizeof (FcPattern) * metadata->pattern_count);
     block_ptr = ALIGN(block_ptr, FcPattern);
-    fcpatterns[bi] = (FcPattern *)block_ptr;
+    _fcPatterns[bi] = (FcPattern *)block_ptr;
     block_ptr = (void *)((char *)block_ptr + 
-                        (sizeof (FcPattern) * metadata.pattern_count));
+                        (sizeof (FcPattern) * metadata->pattern_count));
     
     FcMemAlloc (FC_MEM_PATELT, 
-               sizeof (FcPatternElt) * metadata.patternelt_count);
+               sizeof (FcPatternElt) * metadata->patternelt_count);
     block_ptr = ALIGN(block_ptr, FcPatternElt);
-    fcpatternelts[bi] = (FcPatternElt *)block_ptr;
+    _fcPatternElts[bi] = (FcPatternElt *)block_ptr;
     block_ptr = (void *)((char *)block_ptr + 
-                        (sizeof (FcPatternElt) * metadata.patternelt_count));
+                        (sizeof (FcPatternElt) * metadata->patternelt_count));
        
     block_ptr = FcStrUnserialize (metadata, block_ptr);
     block_ptr = FcValueListUnserialize (metadata, block_ptr);
@@ -1697,19 +1695,19 @@ FcValueListEnsureBank (int bi)
 {
     FcValueList **pvl;
 
-    if (!fcvaluelists || fcvaluelist_bank_count <= bi)
+    if (!_fcValueLists || fcvaluelist_bank_count <= bi)
     {
        int new_count = bi + 2, i;
 
-       pvl = realloc (fcvaluelists, sizeof (FcValueList *) * new_count);
+       pvl = realloc (_fcValueLists, sizeof (FcValueList *) * new_count);
        if (!pvl)
            return FcFalse;
 
        FcMemAlloc (FC_MEM_VALLIST, sizeof (FcValueList *) * new_count);
 
-       fcvaluelists = pvl;
+       _fcValueLists = pvl;
        for (i = fcvaluelist_bank_count; i < new_count; i++)
-           fcvaluelists[i] = 0;
+           _fcValueLists[i] = 0;
 
        fcvaluelist_bank_count = new_count;
     }
@@ -1727,7 +1725,7 @@ FcValueListDistributeBytes (FcCache * metadata, void *block_ptr)
     FcMemAlloc (FC_MEM_VALLIST, sizeof (FcValueList) * fcvaluelist_count);
     fcvaluelist_ptr = 0;
     block_ptr = ALIGN(block_ptr, FcValueList);
-    fcvaluelists[bi] = (FcValueList *)block_ptr;
+    _fcValueLists[bi] = (FcValueList *)block_ptr;
     block_ptr = (void *)((char *)block_ptr + 
                         (sizeof (FcValueList) * fcvaluelist_count));
     metadata->valuelist_count = fcvaluelist_count;
@@ -1752,11 +1750,11 @@ FcValueListSerialize(int bank, FcValueList *pi)
        return new;
     }
 
-    fcvaluelists[bi][fcvaluelist_ptr] = *pi;
+    _fcValueLists[bi][fcvaluelist_ptr] = *pi;
     new.bank = bank;
     new.u.stat = fcvaluelist_ptr++;
-    fcvaluelists[bi][new.u.stat].value = FcValueCanonicalize (&pi->value);
-    v = &fcvaluelists[bi][new.u.stat].value;
+    _fcValueLists[bi][new.u.stat].value = FcValueCanonicalize (&pi->value);
+    v = &_fcValueLists[bi][new.u.stat].value;
     switch (v->type)
     {
     case FcTypeString:
@@ -1798,19 +1796,19 @@ FcValueListSerialize(int bank, FcValueList *pi)
 }
 
 static void *
-FcValueListUnserialize (FcCache metadata, void *block_ptr)
+FcValueListUnserialize (FcCache * metadata, void *block_ptr)
 {
-    int bi = FcCacheBankToIndex(metadata.bank);
+    int bi = FcCacheBankToIndex(metadata->bank);
 
     if (!FcValueListEnsureBank(bi))
        return 0;
 
     FcMemAlloc (FC_MEM_VALLIST, 
-               sizeof (FcValueList) * metadata.valuelist_count);
+               sizeof (FcValueList) * metadata->valuelist_count);
     block_ptr = ALIGN(block_ptr, FcValueList);
-    fcvaluelists[bi] = (FcValueList *)block_ptr;
+    _fcValueLists[bi] = (FcValueList *)block_ptr;
     block_ptr = (void *)((char *)block_ptr + 
-                        (sizeof (FcValueList) * metadata.valuelist_count));
+                        (sizeof (FcValueList) * metadata->valuelist_count));
 
     block_ptr = FcCharSetUnserialize(metadata, block_ptr);
     block_ptr = FcLangSetUnserialize(metadata, block_ptr);
@@ -1957,17 +1955,17 @@ FcStrSerialize (int bank, const FcChar8 * s)
 }
 
 static void *
-FcStrUnserialize (FcCache metadata, void *block_ptr)
+FcStrUnserialize (FcCache * metadata, void *block_ptr)
 {
-    int bi = FcCacheBankToIndex(metadata.bank);
+    int bi = FcCacheBankToIndex(metadata->bank);
     if (!FcStrEnsureBank(bi))
        return 0;
 
-    FcMemAlloc (FC_MEM_STRING, sizeof (char) * metadata.str_count);
+    FcMemAlloc (FC_MEM_STRING, sizeof (char) * metadata->str_count);
     block_ptr = ALIGN (block_ptr, FcChar8);
     static_strs[bi] = (FcChar8 *)block_ptr;
     block_ptr = (void *)((char *)block_ptr + 
-                        (sizeof (char) * metadata.str_count));
+                        (sizeof (char) * metadata->str_count));
 
     return block_ptr;
 }
@@ -2016,7 +2014,7 @@ FcPatternAddFullFname (const FcPattern *p, const char *fname)
     pb->next->m.fname = fname;
 }
 
-static const char *
+const char *
 FcPatternFindFullFname (const FcPattern *p)
 {
     struct patternDirBucket    *pb;
http://fontconfig.org/