Don't add current_arch_start more than once.

Fix ordering of ALIGN with respect to saving block_ptr; add another ALIGN
    to fcfs.c.
reviewed by: plam

diff --git a/ChangeLog b/ChangeLog
index f803d66a6404821dd8faa8efb1324fe320c8920d..c02da827edb6cd7d99f93fcafb35ef7556642923 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,19 @@
+2005-11-17  Andreas Schwab  <schwab@suse.de>
+       reviewed by: plam
+       
+       * src/fccache.c (FcGlobalCacheSave): 
+
+       Don't add current_arch_start more than once.
+
+2005-11-16  Patrick Lam  <plam@mit.edu>
+       * src/fccharset.c (FcCharSetDistributeBytes, FcCharSetUnserialize):
+       * src/fcfs.c (FcFontSetUnserialize):
+       * src/fcname.c (FcObjectDistributeBytes, FcObjectUnserialize):
+       * src/fcpat.c (FcStrUnserialize):
+
+       Fix ordering of ALIGN with respect to saving block_ptr; add
+       another ALIGN to fcfs.c.
+
 2005-11-16  Patrick Lam  <plam@mit.edu>
        * src/fccache.c (FcDirCacheProduce)
        

diff --git a/src/fccache.c b/src/fccache.c
index 84a366e662469daa9d56c575e314c595c9ecaa3c..fb3f0bb5b02577bff585535ecec71ff42e6099ab 100644 (file)
--- a/src/fccache.c
+++ b/src/fccache.c
@@ -367,7 +367,7 @@ FcGlobalCacheSave (FcGlobalCache    *cache,
     {
        truncate_to += strlen(dir->name) + 1;
        truncate_to += sizeof (FcCache);
-       truncate_to = FcCacheNextOffset (current_arch_start + truncate_to);
+       truncate_to = FcCacheNextOffset (truncate_to);
        truncate_to += dir->metadata.count;
     }
     truncate_to -= current_arch_start;

diff --git a/src/fccharset.c b/src/fccharset.c
index 790d78f3c619d1fab28096594f839a21413a5f9f..e152a5a00684b48cdc8fcadadd31b8012b64b35a 100644 (file)
--- a/src/fccharset.c
+++ b/src/fccharset.c
@@ -1379,20 +1379,20 @@ FcCharSetDistributeBytes (FcCache * metadata, void * block_ptr)
     if (!FcCharSetEnsureBank(bi))
        return 0;
 
-    charsets[bi] = (FcCharSet *)block_ptr;
     block_ptr = ALIGN (block_ptr, FcCharSet);
+    charsets[bi] = (FcCharSet *)block_ptr;
     block_ptr = (void *)((char *)block_ptr + 
                     (sizeof (FcCharSet) * charset_count));
-    numbers[bi] = (FcChar16 *)block_ptr;
     block_ptr = ALIGN (block_ptr, FcChar16);
+    numbers[bi] = (FcChar16 *)block_ptr;
     block_ptr = (void *)((char *)block_ptr + 
                     (sizeof(FcChar16) * charset_numbers_count));
-    leaves[bi] = (FcCharLeaf *)block_ptr;
     block_ptr = ALIGN (block_ptr, FcCharLeaf);
+    leaves[bi] = (FcCharLeaf *)block_ptr;
     block_ptr = (void *)((char *)block_ptr +
                     (sizeof(FcCharLeaf) * charset_leaf_count));
-    leaf_idx[bi] = (int *)block_ptr;
     block_ptr = ALIGN (block_ptr, int);
+    leaf_idx[bi] = (int *)block_ptr;
     block_ptr = (void *)((char *)block_ptr +
                     (sizeof(int) * charset_leaf_idx_count));
 
@@ -1438,15 +1438,19 @@ FcCharSetUnserialize (FcCache metadata, void *block_ptr)
     if (!FcCharSetEnsureBank(bi))
        return 0;
 
+    block_ptr = ALIGN (block_ptr, FcCharSet);
     charsets[bi] = (FcCharSet *)block_ptr;
     block_ptr = (void *)((char *)block_ptr + 
                     (sizeof (FcCharSet) * metadata.charset_count));
+    block_ptr = ALIGN (block_ptr, FcChar16);
     numbers[bi] = (FcChar16 *)block_ptr;
     block_ptr = (void *)((char *)block_ptr + 
                     (sizeof(FcChar16) * metadata.charset_numbers_count));
+    block_ptr = ALIGN (block_ptr, FcCharLeaf);
     leaves[bi] = (FcCharLeaf *)block_ptr;
     block_ptr = (void *)((char *)block_ptr +
                     (sizeof(FcCharLeaf) * metadata.charset_leaf_count));
+    block_ptr = ALIGN (block_ptr, int);
     leaf_idx[bi] = (int *)block_ptr;
     block_ptr = (void *)((char *)block_ptr +
                     (sizeof(int) * metadata.charset_leaf_idx_count));

diff --git a/src/fcfs.c b/src/fcfs.c
index 0788a6f628769e7eea06aaf5e6a577457b2b929e..83b3e965f75bc42af13adb1a96b5a9502eb16347 100644 (file)
--- a/src/fcfs.c
+++ b/src/fcfs.c
@@ -155,6 +155,7 @@ FcFontSetUnserialize(FcCache metadata, FcFontSet * s, void * block_ptr)
     int nfont;
     int i, n;
 
+    block_ptr = ALIGN (block_ptr, int);
     nfont = *(int *)block_ptr;
     block_ptr = (int *)block_ptr + 1;
 
@@ -174,10 +175,17 @@ FcFontSetUnserialize(FcCache metadata, FcFontSet * s, void * block_ptr)
     if (nfont > 0)
     {
        FcPattern * p = (FcPattern *)block_ptr;
-       block_ptr = FcPatternUnserialize (metadata, block_ptr);
+
+        /* The following line is a bit counterintuitive.  The usual
+         * convention is that FcPatternUnserialize is responsible for
+         * aligning the FcPattern.  However, the FontSet also stores
+         * the FcPatterns in its own array, so we need to align here
+         * too. */
+        p = ALIGN(p, FcPattern);
        for (i = 0; i < nfont; i++)
            s->fonts[n + i] = p+i;
 
+       block_ptr = FcPatternUnserialize (metadata, block_ptr);
        block_ptr = FcObjectUnserialize (metadata, block_ptr);
     }
 

diff --git a/src/fcname.c b/src/fcname.c
index 6ca4f1ad30b3e497ba188189043cf2ad9d2145ac..bf265bd26f63ddc9a4b631b9fd31bbd041cd301e 100644 (file)
--- a/src/fcname.c
+++ b/src/fcname.c
@@ -341,11 +341,11 @@ FcObjectNeededBytesAlign (void)
 void *
 FcObjectDistributeBytes (FcCache * metadata, void * block_ptr)
 {
-    *(int *)block_ptr = biggest_known_ntypes;
     block_ptr = ALIGN (block_ptr, int);
+    *(int *)block_ptr = biggest_known_ntypes;
     block_ptr = (int *) block_ptr + 1;
-    biggest_ptr = block_ptr;
     block_ptr = ALIGN (block_ptr, char);
+    biggest_ptr = block_ptr;
     block_ptr = (char *) block_ptr + biggest_known_count;
     return block_ptr;
 }
@@ -367,6 +367,7 @@ FcObjectUnserialize (FcCache metadata, void *block_ptr)
 {
     int new_biggest;
     new_biggest = *(int *)block_ptr;
+    block_ptr = ALIGN (block_ptr, int);
     block_ptr = (int *) block_ptr + 1;
     if (biggest_known_ntypes < new_biggest)
     {
@@ -409,6 +410,7 @@ FcObjectUnserialize (FcCache metadata, void *block_ptr)
        biggest_known_ntypes = new_biggest;
        biggest_known_types = (const FcObjectType *)bn;
     }
+    block_ptr = ALIGN (block_ptr, char);
     block_ptr = (char *) block_ptr + biggest_known_count;
     return block_ptr;
 }

diff --git a/src/fcpat.c b/src/fcpat.c
index bb922fef3914059dc53698ccd851a305b83a426e..a82fb6fb03a7223ee08286cab1f66f2de9714354 100644 (file)
--- a/src/fcpat.c
+++ b/src/fcpat.c
@@ -1963,6 +1963,7 @@ FcStrUnserialize (FcCache metadata, void *block_ptr)
        return 0;
 
     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));