ferret 0.9.6 → 0.10.0

data/ext/bitvector.h

@@ -1,29 +1,271 @@
 #ifndef FRT_BIT_VECTOR_H
 #define FRT_BIT_VECTOR_H
 
-#include <global.h>
-#include <store.h>
-
-#define BV_INIT_CAPA 256 
-typedef struct BitVector {
-  uchar *bits;
-  int size;
-  int capa;
-  int count;
-  int curr_bit;
+#include "global.h"
+
+#define BV_INIT_CAPA 256
+typedef struct BitVector
+{
+    /** The bits are held in an array of 32-bit integers */
+    f_u32 *bits;
+
+    /** size is equal to 1 + the highest order bit set */
+    int size;
+
+    /** capa is the number of words (U32) allocated for the bits */
+    int capa;
+
+    /** count is the running count of bits set. This is kept up to date by
+     *bv_set and bv_unset. You can reset this value by calling bv_recount */
+    int count;
+
+    /** curr_bit is used by scan_next to record the previously  scanned bit */
+    int curr_bit;
+
+    bool extends_as_ones : 1;
 } BitVector;
 
-BitVector *bv_create();;
-BitVector *bv_create_size(int size);
-void bv_destroy(BitVector *bv);
-void bv_set(BitVector *bv, int bit);
-int bv_get(BitVector *bv, int bit);
-void bv_clear(BitVector *bv);
-void bv_unset(BitVector *bv, int bit);
-void bv_write(BitVector *bv, Store *store, char *name);
-BitVector *bv_read(Store *store, char *name);
-void bv_scan_reset(BitVector *bv);
-int bv_scan_next(BitVector *bv);
-int bv_scan_next_from(BitVector *bv, register const int from);
+/**
+ * Create a new BitVector with a capacity of +BV_INIT_CAPA+. Note that the
+ * BitVector is growable and will adjust it's capacity when you use bv_set.
+ *
+ * @return BitVector with a capacity of +BV_INIT_CAPA+.
+ */
+extern BitVector *bv_new();
+
+/**
+ * Create a new BitVector with a capacity of +capa+. Note that the BitVector
+ * is growable and will adjust it's capacity when you use bv_set.
+ *
+ * @param capa the initial capacity of the BitVector
+ * @return BitVector with a capacity of +capa+.
+ */
+extern BitVector *bv_new_capa(int capa);
+
+/**
+ * Destroy a BitVector, freeing all memory allocated to that BitVector
+ *
+ * @param bv BitVector to destroy
+ */
+extern void bv_destroy(BitVector *bv);
+
+/**
+ * Set the bit at position +index+. If +index+ is outside of the range of the
+ * BitVector, that is >= BitVector.size, BitVector.size will be set to +index+
+ * + 1. If it is greater than the capacity of the BitVector, the capacity will
+ * be expanded to accomodate.
+ *
+ * @param bv the BitVector to set the bit in
+ * @param index the index of the bit to set
+ */
+extern void bv_set(BitVector *bv, int index);
+
+/**
+ * Unsafely set the bit at position +index+. If you choose to use this
+ * function you must create the BitVector with a large enough capacity to
+ * accomodate all of the bv_set_fast operations. You must also set bits in
+ * order and only one time per bit. Otherwise, use the safe bv_set function.
+ *
+ * So this is ok;
+ * <pre>
+ *   BitVector *bv = bv_new_capa(1000);
+ *   bv_set_fast(bv, 900);
+ *   bv_set_fast(bv, 920);
+ *   bv_set_fast(bv, 999);
+ * </pre>
+ *
+ * While these are not ok;
+ * <pre>
+ *   BitVector *bv = bv_new_capa(90);
+ *   bv_set_fast(bv, 80);
+ *   bv_set_fast(bv, 79); // <= Bad: Out of Order
+ *   bv_set_fast(bv, 80); // <= Bad: Already set
+ *   bv_set_fast(bv, 90); // <= Bad: Out of Range. index must be < capa
+ * </pre>
+ *
+ * @param bv the BitVector to set the bit in
+ * @param index the index of the bit to set
+ */
+extern void bv_set_fast(BitVector *bv, int bit);
+
+/**
+ * Return 1 if the bit at +index+ was set or 0 otherwise. If +index+ is out of
+ * range, that is greater then the BitVectors capacity, it will also return 0.
+ *
+ * @param bv the BitVector to check in
+ * @param index the index of the bit to check
+ * @return 1 if the bit was set, 0 otherwise
+ */
+extern int bv_get(BitVector *bv, int index);
+
+/**
+ * Unset the bit at position +index+. If the +index+ was out of range, that is
+ * greater than the BitVectors capacity then do nothing. (bv_get will return 0
+ * in this case anyway).
+ *
+ * @param bv the BitVector to unset the bit in
+ * @param index the index of the bit to unset
+ */
+extern void bv_unset(BitVector *bv, int bit);
+
+/**
+ * Clear all set bits. This function will set all set bits to 0.
+ *
+ * @param bv the BitVector to clear
+ */
+extern void bv_clear(BitVector *bv);
+
+/**
+ * Resets the set bit count by running through the whole BitVector and
+ * counting all set bits. A running count of the bits is kept by bv_set,
+ *bv_get and bv_set_fast so this function is only necessary if the count could
+ * have been corrupted somehow or if the BitVector has been constructed in a
+ * different way (for example being read from the file_system).
+ *
+ * @param bv the BitVector to count the bits in
+ * @return the number of set bits in the BitVector. BitVector.count is also
+ *   set
+ */
+extern int bv_recount(BitVector *bv);
+
+/**
+ * Reset the BitVector for scanning. This function should be called before
+ * using bv_scan_next to scan through all set bits in the BitVector. This is
+ * not necessary when using bv_scan_next_from.
+ *
+ * @param bv the BitVector to reset for scanning
+ */
+extern void bv_scan_reset(BitVector *bv);
+
+/**
+ * Scan the BitVector for the next set bit. Before using this function you
+ * should reset the BitVector for scanning using +bv_scan_reset+. You can the
+ * repeated call bv_scan_next to get each set bit until it finally returns
+ * -1.
+ *
+ * @param bv the BitVector to scan
+ * @return the next set bits index or -1 if no more bits are set
+ */
+extern int bv_scan_next(BitVector *bv);
+
+/**
+ * Scan the BitVector for the next set bit after +from+. If no more bits are
+ * set then return -1, otherwise return the index of teh next set bit.
+ *
+ * @param bv the BitVector to scan
+ * @return the next set bit's index or -1 if no more bits are set
+ */
+
+extern int bv_scan_next_from(BitVector *bv, register const int from);
+/**
+ * Scan the BitVector for the next unset bit. Before using this function you
+ * should reset the BitVector for scanning using +bv_scan_reset+. You can the
+ * repeated call bv_scan_next to get each unset bit until it finally returns
+ * -1.
+ *
+ * @param bv the BitVector to scan
+ * @return the next unset bits index or -1 if no more bits are unset
+ */
+extern int bv_scan_next_unset(BitVector *bv);
+
+/**
+ * Scan the BitVector for the next unset bit after +from+. If no more bits are
+ * unset then return -1, otherwise return the index of teh next unset bit.
+ *
+ * @param bv the BitVector to scan
+ * @return the next unset bit's index or -1 if no more bits are unset
+ */
+extern int bv_scan_next_unset_from(BitVector *bv, register const int from);
+
+/**
+ * Check whether the two BitVectors have the same bits set.
+ *
+ * @param bv1 first BitVector to compare
+ * @param bv2 second BitVectors to compare
+ * @return true if bv1 == bv2
+ */
+extern int bv_eq(BitVector *bv1, BitVector *bv2);
+
+/**
+ * Determines a hash value for the BitVector
+ *
+ * @param bv the BitVector to hash
+ * @return A hash value for the BitVector
+ */
+extern ulong bv_hash(BitVector *bv);
+
+/**
+ * ANDs two BitVectors (+bv1+ and +bv2+) together and return the resultant
+ * BitVector
+ *
+ * @param bv1 first BitVector to AND
+ * @param bv2 second BitVector to AND
+ * @return A BitVector with all bits set that are set in both bv1 and bv2
+ */
+extern BitVector *bv_and(BitVector *bv1, BitVector *bv2);
+
+/**
+ * ORs two BitVectors (+bv1+ and +bv2+) together and return the resultant
+ * BitVector
+ *
+ * @param bv1 first BitVector to OR
+ * @param bv2 second BitVector to OR
+ * @return A BitVector with all bits set that are set in both bv1 and bv2
+ */
+extern BitVector *bv_or(BitVector *bv1, BitVector *bv2);
+
+/**
+ * XORs two BitVectors (+bv1+ and +bv2+) together and return the resultant
+ * BitVector
+ *
+ * @param bv1 first BitVector to XOR
+ * @param bv2 second BitVector to XOR
+ * @return A BitVector with all bits set that are equal in bv1 and bv2
+ */
+extern BitVector *bv_xor(BitVector *bv1, BitVector *bv2);
+
+/**
+ * Returns BitVector with all of +bv+'s bits flipped
+ *
+ * @param bv BitVector to flip
+ * @return A BitVector with all bits set that are set in both bv1 and bv2
+ */
+extern BitVector *bv_not(BitVector *bv);
+
+/**
+ * ANDs two BitVectors together +bv1+ and +bv2+ in place of +bv1+
+ *
+ * @param bv1 first BitVector to AND
+ * @param bv2 second BitVector to AND
+ * @return A BitVector
+ * @return bv1 with all bits set that where set in both bv1 and bv2
+ */
+extern BitVector *bv_and_x(BitVector *bv1, BitVector *bv2);
+
+/**
+ * ORs two BitVectors together
+ *
+ * @param bv1 first BitVector to OR
+ * @param bv2 second BitVector to OR
+ * @return bv1
+ */
+extern BitVector *bv_or_x(BitVector *bv1, BitVector *bv2);
+
+/**
+ * XORs two BitVectors together +bv1+ and +bv2+ in place of +bv1+
+ *
+ * @param bv1 first BitVector to XOR
+ * @param bv2 second BitVector to XOR
+ * @return bv1
+ */
+extern BitVector *bv_xor_x(BitVector *bv1, BitVector *bv2);
+
+/**
+ * Flips all bits in the BitVector +bv+
+ *
+ * @param bv BitVector to flip
+ * @return A +bv+ with all it's bits flipped
+ */
+extern BitVector *bv_not_x(BitVector *bv);
 
 #endif

data/ext/compound_io.c

@@ -1,15 +1,9 @@
 #include "index.h" 
-
-static char * const ALREADY_CLOSED_MSG = "Already closed";
-static char * const STREAM_CLOSED_MSG = "Stream closed";
-static char * const MISSING_FILE_MSG = "No sub-file found";
-static char * const ALREADY_MERGED_MSG = "Already merged";
-static char * const REMAINDER_ERROR_MSG = "Non-zero remainder length after copying";
-static char * const FILE_OFFSET_MSG =  "Difference in the output file offsets"
-        " does not match the original file length";
-static char * const NO_FILES_TO_MERGE_MSG = "No Files to merge into the compound file";
+#include "array.h" 
 
 extern void store_destroy(Store *store);
+extern InStream *is_new();
+extern Store *store_new();
 
 /****************************************************************************
  *
@@ -18,232 +12,244 @@ extern void store_destroy(Store *store);
  ****************************************************************************/
 
 typedef struct FileEntry {
-  int offset;
-  int length;
+    off_t offset;
+    off_t length;
 } FileEntry;
 
-void cmpd_touch(Store *store, char *filename)
+static void cmpd_touch(Store *store, char *file_name)
 {
-  store->dir.cmpd->store->touch(store->dir.cmpd->store, filename);
+    store->dir.cmpd->store->touch(store->dir.cmpd->store, file_name);
 }
 
-int cmpd_exists(Store *store, char *filename)
+static int cmpd_exists(Store *store, char *file_name)
 {
-  if (h_get(store->dir.cmpd->entries, filename) != NULL) {
-    return true;
-  } else {
-    return false;
-  }
+    if (h_get(store->dir.cmpd->entries, file_name) != NULL) {
+        return true;
+    }
+    else {
+        return false;
+    }
 }
 
 /**
  * @throws UNSUPPORTED_ERROR
  */
-int cmpd_remove(Store *store, char *filename)
+static int cmpd_remove(Store *store, char *file_name)
 {
-  RAISE(UNSUPPORTED_ERROR, UNSUPPORTED_ERROR_MSG);
-  return 0;
+    (void)store;
+    (void)file_name;
+    RAISE(UNSUPPORTED_ERROR, UNSUPPORTED_ERROR_MSG);
+    return 0;
 }
 
 /**
  * @throws UNSUPPORTED_ERROR
  */
-int cmpd_rename(Store *store, char *from, char *to)
+static void cmpd_rename(Store *store, char *from, char *to)
 {
-  RAISE(UNSUPPORTED_ERROR, UNSUPPORTED_ERROR_MSG);
-  return 0;
+    (void)store;
+    (void)from;
+    (void)to;
+    RAISE(UNSUPPORTED_ERROR, UNSUPPORTED_ERROR_MSG);
 }
 
-int cmpd_count(Store *store)
+static int cmpd_count(Store *store)
 {
-  return store->dir.cmpd->entries->used;
+    return store->dir.cmpd->entries->size;
 }
 
 /**
  * @throws UNSUPPORTED_ERROR
  */
-void cmpd_clear(Store *store)
+static void cmpd_clear(Store *store)
 {
-  RAISE(UNSUPPORTED_ERROR, UNSUPPORTED_ERROR_MSG);
+    (void)store;
+    RAISE(UNSUPPORTED_ERROR, UNSUPPORTED_ERROR_MSG);
 }
 
-void cmpd_close_i(Store *store)
+static void cmpd_close_i(Store *store)
 {
-  CompoundStore *cmpd = store->dir.cmpd;
-  if (cmpd->stream == NULL)
-    RAISE(IO_ERROR, ALREADY_CLOSED_MSG);
+    CompoundStore *cmpd = store->dir.cmpd;
+    if (cmpd->stream == NULL) {
+        RAISE(IO_ERROR, "Tried to close already closed compound store");
+    }
 
-  h_destroy(cmpd->entries);
+    h_destroy(cmpd->entries);
 
-  is_close(cmpd->stream);
-  cmpd->stream = NULL;
-  free(store->dir.cmpd);
-  store_destroy(store);
+    is_close(cmpd->stream);
+    cmpd->stream = NULL;
+    free(store->dir.cmpd);
+    store_destroy(store);
 }
 
-int cmpd_length(Store *store, char *filename)
+static off_t cmpd_length(Store *store, char *file_name)
 {
-  FileEntry *fe = (FileEntry *)h_get(store->dir.cmpd->entries, filename);
-  if (fe != NULL)
-    return fe->length;
-  else
-    return 0;
+    FileEntry *fe = h_get(store->dir.cmpd->entries, file_name);
+    if (fe != NULL) {
+        return fe->length;
+    }
+    else {
+        return 0;
+    }
 }
 
-void cmpdi_seek_internal(InStream *is, int pos) {}
-void cmpdi_close_internal(InStream *is)
+static void cmpdi_seek_i(InStream *is, off_t pos)
 {
-  //is_close(is->d.cis->sub);
-  free(is->d.cis);
+    (void)is;
+    (void)pos;
 }
 
-void cmpdi_clone_internal(InStream *is, InStream *new_is)
+static void cmpdi_close_i(InStream *is)
 {
-  CompoundInStream *cis = ALLOC(CompoundInStream);
-  //cis->sub = is_clone(is->d.cis->sub);
-  cis->sub = is->d.cis->sub;
-  cis->offset = is->d.cis->offset;
-  cis->length = is->d.cis->length;
-  new_is->d.cis = cis;
+    free(is->d.cis);
 }
 
-int cmpdi_length_internal(InStream *is)
+static off_t cmpdi_length_i(InStream *is)
 {
-  return (is->d.cis->length);
+    return (is->d.cis->length);
 }
 
 /*
  * raises: EOF_ERROR
  */
-void cmpdi_read_internal(InStream *is, uchar *b, int offset, int len)
+static void cmpdi_read_i(InStream *is, uchar *b, int len)
 {
-  CompoundInStream *cis = is->d.cis;
-  int start = is_pos(is);
-  if ((start + len) > cis->length)
-    RAISE(EOF_ERROR, EOF_ERROR_MSG);
-  is_seek(cis->sub, cis->offset + start);
-  is_read_bytes(cis->sub, b, offset, len);
+    CompoundInStream *cis = is->d.cis;
+    off_t start = is_pos(is);
+
+    if ((start + len) > cis->length) {
+        RAISE(EOF_ERROR, "Tried to read past end of file. File length is "
+              "<%"F_OFF_T_PFX"d> and tried to read to <%"F_OFF_T_PFX"d>",
+              cis->length, start + len);
+    }
+
+    is_seek(cis->sub, cis->offset + start);
+    is_read_bytes(cis->sub, b, len);
 }
 
-InStream *cmpd_create_input(InStream *sub_is, int offset, int length)
+static const struct InStreamMethods CMPD_IN_STREAM_METHODS = {
+    cmpdi_read_i,
+    cmpdi_seek_i,
+    cmpdi_length_i,
+    cmpdi_close_i
+};
+
+static InStream *cmpd_create_input(InStream *sub_is, off_t offset, off_t length)
 {
-  InStream *is = is_create();
-  CompoundInStream *cis = ALLOC(CompoundInStream);
-  //cis->sub = is_clone(sub_is);
-  cis->sub = sub_is;
-  cis->offset = offset;
-  cis->length = length;
-  is->d.cis = cis;
-  is->file = NULL;
-
-  is->read_internal = &cmpdi_read_internal;
-  is->seek_internal = &cmpdi_seek_internal;
-  is->close_internal = &cmpdi_close_internal;
-  is->clone_internal = &cmpdi_clone_internal;
-  is->length_internal = &cmpdi_length_internal;
-  return is;
+    InStream *is = is_new();
+    CompoundInStream *cis = ALLOC(CompoundInStream);
+
+    cis->sub = sub_is;
+    cis->offset = offset;
+    cis->length = length;
+    is->d.cis = cis;
+    is->m = &CMPD_IN_STREAM_METHODS;
+
+    return is;
 }
 
-InStream *cmpd_open_input(Store *store, const char *filename)
+static InStream *cmpd_open_input(Store *store, const char *file_name)
 {
-  FileEntry *entry;
-  CompoundStore *cmpd = store->dir.cmpd;
-  InStream *is;
+    FileEntry *entry;
+    CompoundStore *cmpd = store->dir.cmpd;
+    InStream *is;
+
+    mutex_lock(&store->mutex);
+    if (cmpd->stream == NULL) {
+        mutex_unlock(&store->mutex);
+        RAISE(IO_ERROR, "Can't open compound file input stream. Parent "
+              "stream is closed.");
+    }
 
-  mutex_lock(&store->mutex);
-  if (cmpd->stream == NULL) {
-    mutex_unlock(&store->mutex);
-    RAISE(IO_ERROR, STREAM_CLOSED_MSG);
-  }
+    entry = h_get(cmpd->entries, file_name);
+    if (entry == NULL) {
+        mutex_unlock(&store->mutex);
+        RAISE(IO_ERROR, "File %s does not exist: ", file_name);
+    }
 
-  entry = (FileEntry *)h_get(cmpd->entries, filename);
-  if (entry == NULL) {
+    is = cmpd_create_input(cmpd->stream, entry->offset, entry->length);
     mutex_unlock(&store->mutex);
-    RAISE(IO_ERROR, MISSING_FILE_MSG);
-  }
-
-  is = cmpd_create_input(cmpd->stream, entry->offset, entry->length);
-  mutex_unlock(&store->mutex);
 
-  return is;
+    return is;
 }
 
-OutStream *cmpd_create_output(Store *store, const char *filename)
+static OutStream *cmpd_new_output(Store *store, const char *file_name)
 {
-  RAISE(UNSUPPORTED_ERROR, UNSUPPORTED_ERROR_MSG);
-  return NULL;
+    (void)store;
+    (void)file_name;
+    RAISE(UNSUPPORTED_ERROR, UNSUPPORTED_ERROR_MSG);
+    return NULL;
 }
 
-Lock *cmpd_open_lock(Store *store, char *lockname)
+static Lock *cmpd_open_lock(Store *store, char *lock_name)
 {
-  RAISE(UNSUPPORTED_ERROR, UNSUPPORTED_ERROR_MSG);
-  return NULL;
+    (void)store;
+    (void)lock_name;
+    RAISE(UNSUPPORTED_ERROR, UNSUPPORTED_ERROR_MSG);
+    return NULL;
 }
 
-void cmpd_close_lock(Lock *lock)
+static void cmpd_close_lock(Lock *lock)
 {
-  RAISE(UNSUPPORTED_ERROR, UNSUPPORTED_ERROR_MSG);
+    (void)lock;
+    RAISE(UNSUPPORTED_ERROR, UNSUPPORTED_ERROR_MSG);
 }
 
 Store *open_cmpd_store(Store *store, const char *name)
 {
-  int count, i, offset;
-  char *fname;
-  FileEntry *entry;
-  Store * volatile new_store = NULL;
-  CompoundStore * volatile cmpd = NULL;
-  InStream * volatile is = NULL;
-
-  TRY
-    new_store = store_create();
+    int count, i;
+    off_t offset;
+    char *fname;
+    FileEntry *entry;
+    Store *new_store = NULL;
+    CompoundStore *cmpd = NULL;
+    InStream *is = NULL;
+
+    new_store = store_new();
     cmpd = ALLOC(CompoundStore);
 
-    cmpd->store   = store;
-    cmpd->name    = name;
-    cmpd->entries = h_new_str(&free, &free);
+    cmpd->store       = store;
+    cmpd->name        = name;
+    cmpd->entries     = h_new_str(&free, &free);
     is = cmpd->stream = store->open_input(store, cmpd->name);
 
-    // read the directory and init files
-    count = (int)is_read_vint(is);
+    /* read the directory and init files */
+    count = is_read_vint(is);
     entry = NULL;
     for (i = 0; i < count; i++) {
-      offset = (int)is_read_long(is);
-      fname = is_read_string(is);
+        offset = (off_t)is_read_i64(is);
+        fname = is_read_string(is);
 
-      if (entry != NULL) {
-        // set length of the previous entry
-        entry->length = offset - entry->offset;
-      }
+        if (entry != NULL) {
+            /* set length of the previous entry */
+            entry->length = offset - entry->offset;
+        }
 
-      entry = ALLOC(FileEntry);
-      entry->offset = offset;
-      h_set(cmpd->entries, fname, entry);
+        entry = ALLOC(FileEntry);
+        entry->offset = offset;
+        h_set(cmpd->entries, fname, entry);
     }
 
-    // set the length of the final entry
-    if (entry != NULL)
-      entry->length = is_length(is) - entry->offset;
-  XCATCHALL
-    free(new_store);
-    free(cmpd);
-    if (is) is_close(is);
-  XENDTRY
-
-
-  new_store->dir.cmpd = cmpd;
-  new_store->touch    = &cmpd_touch;
-  new_store->exists   = &cmpd_exists;
-  new_store->remove   = &cmpd_remove;
-  new_store->rename   = &cmpd_rename;
-  new_store->count    = &cmpd_count;
-  new_store->clear    = &cmpd_clear;
-  new_store->length   = &cmpd_length;
-  new_store->close_i  = &cmpd_close_i;
-  new_store->create_output = &cmpd_create_output;
-  new_store->open_input    = &cmpd_open_input;
-  new_store->open_lock     = &cmpd_open_lock;
-  new_store->close_lock    = &cmpd_close_lock;
-  return new_store;
+    /* set the length of the final entry */
+    if (entry != NULL) {
+        entry->length = is_length(is) - entry->offset;
+    }
+
+    new_store->dir.cmpd     = cmpd;
+    new_store->touch        = &cmpd_touch;
+    new_store->exists       = &cmpd_exists;
+    new_store->remove       = &cmpd_remove;
+    new_store->rename       = &cmpd_rename;
+    new_store->count        = &cmpd_count;
+    new_store->clear        = &cmpd_clear;
+    new_store->length       = &cmpd_length;
+    new_store->close_i      = &cmpd_close_i;
+    new_store->new_output   = &cmpd_new_output;
+    new_store->open_input   = &cmpd_open_input;
+    new_store->open_lock    = &cmpd_open_lock;
+    new_store->close_lock   = &cmpd_close_lock;
+
+    return new_store;
 }
 
 /****************************************************************************
@@ -252,123 +258,105 @@ Store *open_cmpd_store(Store *store, const char *name)
  *
  ****************************************************************************/
 
-typedef struct WFileEntry {
-  char *name;
-  int dir_offset;
-  int data_offset;
-} WFileEntry;
-
-WFileEntry *wfe_create(char *name)
-{
-  WFileEntry *wfe = ALLOC(WFileEntry);
-  wfe->name = name;
-  return wfe;
-}
-
 CompoundWriter *open_cw(Store *store, char *name)
 {
-  CompoundWriter *cw = ALLOC(CompoundWriter);
-  cw->store = store;
-  cw->name = name;
-  cw->ids = hs_str_create(NULL);
-  cw->file_entries = ary_create(1, &free);
-  cw->merged = false;
-  return cw;
+    CompoundWriter *cw = ALLOC(CompoundWriter);
+    cw->store = store;
+    cw->name = name;
+    cw->ids = hs_new_str(&free);
+    cw->file_entries = ary_new_type_capa(CWFileEntry, CW_INIT_CAPA);
+    return cw;
 }
 
 void cw_add_file(CompoundWriter *cw, char *id)
 {
-  if (cw->merged) RAISE(STATE_ERROR, ALREADY_MERGED_MSG);
-  if (hs_add(cw->ids, id) != HASH_KEY_DOES_NOT_EXIST)
-    RAISE(STATE_ERROR, ALREADY_MERGED_MSG);
+    id = estrdup(id);
+    if (hs_add(cw->ids, id) != HASH_KEY_DOES_NOT_EXIST) {
+        RAISE(IO_ERROR, "Tried to add file \"%s\" which has already been "
+              "added to the compound store", id);
+    }
 
-  hs_add(cw->ids, id);
-  ary_append(cw->file_entries, wfe_create(id));
+    ary_grow(cw->file_entries);
+    ary_last(cw->file_entries).name = id;
 }
 
-void cw_copy_file(CompoundWriter *cw, WFileEntry *src, OutStream *os)
+static void cw_copy_file(CompoundWriter *cw, CWFileEntry *src, OutStream *os)
 {
-  int start_ptr = os_pos(os);
-  int end_ptr;
-  int remainder, length, len;
-  uchar buffer[BUFFER_SIZE];
-  
-  InStream *is = cw->store->open_input(cw->store, src->name);
-  
-  TRY
-    remainder = length = is_length(is);
+    off_t start_ptr = os_pos(os);
+    off_t end_ptr;
+    off_t remainder, length, len;
+    uchar buffer[BUFFER_SIZE];
 
+    InStream *is = cw->store->open_input(cw->store, src->name);
+
+    remainder = length = is_length(is);
 
     while (remainder > 0) {
-      len = MIN(remainder, BUFFER_SIZE);
-      is_read_bytes(is, buffer, 0, len);
-      os_write_bytes(os, buffer, len);
-      remainder -= len;
+        len = MIN(remainder, BUFFER_SIZE);
+        is_read_bytes(is, buffer, len);
+        os_write_bytes(os, buffer, len);
+        remainder -= len;
     }
 
-    // Verify that remainder is 0
-    if (remainder != 0)
-      RAISE(IO_ERROR, REMAINDER_ERROR_MSG);
+    /* Verify that remainder is 0 */
+    if (remainder != 0) {
+        RAISE(IO_ERROR, "There seems to be an error in the compound file "
+              "should have read to the end but there are <%"F_OFF_T_PFX"d> "
+              "bytes left", remainder);
+    }
 
-    // Verify that the output length diff is equal to original file
+    /* Verify that the output length diff is equal to original file */
     end_ptr = os_pos(os);
     len = end_ptr - start_ptr;
-    if (len != length)
-      RAISE(IO_ERROR, FILE_OFFSET_MSG);
+    if (len != length) {
+        RAISE(IO_ERROR, "Difference in compound file output file offsets "
+              "<%"F_OFF_T_PFX"d> does not match the original file lenght "
+              "<%"F_OFF_T_PFX"d>", len, length);
+    }
 
-  XFINALLY
     is_close(is);
-  XENDTRY
 }
 
 void cw_close(CompoundWriter *cw)
 {
-  OutStream * volatile os = NULL;
-  int i;
-  WFileEntry *wfe;
+    OutStream *os = NULL;
+    int i;
 
-  if (cw->merged) RAISE(STATE_ERROR, ALREADY_MERGED_MSG);
-  if (cw->ids->size <= 0)
-    RAISE(STATE_ERROR, NO_FILES_TO_MERGE_MSG);
+    if (cw->ids->size <= 0) {
+        RAISE(STATE_ERROR, "Tried to merge compound file with no entries");
+    }
 
-  cw->merged = true;
+    os = cw->store->new_output(cw->store, cw->name);
 
-  TRY
-    os = cw->store->create_output(cw->store, cw->name);
-    os_write_vint(os, cw->file_entries->size);
+    os_write_vint(os, ary_size(cw->file_entries));
 
     /* Write the directory with all offsets at 0.
      * Remember the positions of directory entries so that we can adjust the
      * offsets later */
-
-    for (i = 0; i < cw->file_entries->size; i++) {
-      wfe = (WFileEntry *)cw->file_entries->elems[i];
-      wfe->dir_offset = os_pos(os);
-      os_write_long(os, 0);  // for now
-      os_write_string(os, wfe->name);
+    for (i = 0; i < ary_size(cw->file_entries); i++) {
+        cw->file_entries[i].dir_offset = os_pos(os);
+        os_write_u64(os, 0);  /* for now */
+        os_write_string(os, cw->file_entries[i].name);
     }
 
     /* Open the files and copy their data into the stream.  Remember the
      * locations of each file's data section. */
-    for (i = 0; i < cw->file_entries->size; i++) {
-      wfe = (WFileEntry *)cw->file_entries->elems[i];
-      wfe->data_offset = os_pos(os);
-      cw_copy_file(cw, wfe, os);
+    for (i = 0; i < ary_size(cw->file_entries); i++) {
+        cw->file_entries[i].data_offset = os_pos(os);
+        cw_copy_file(cw, &cw->file_entries[i], os);
     }
 
     /* Write the data offsets into the directory of the compound stream */
-    for (i = 0; i < cw->file_entries->size; i++) {
-      wfe = (WFileEntry *)cw->file_entries->elems[i];
-      os_seek(os, wfe->dir_offset);
-      os_write_long(os, wfe->data_offset);
+    for (i = 0; i < ary_size(cw->file_entries); i++) {
+        os_seek(os, cw->file_entries[i].dir_offset);
+        os_write_u64(os, cw->file_entries[i].data_offset);
+    }
+
+    if (os) {
+        os_close(os);
     }
 
-  XFINALLY
-    if (os) os_close(os);
     hs_destroy(cw->ids);
-    ary_destroy(cw->file_entries);
+    ary_free(cw->file_entries);
     free(cw);
-    break;
-  XENDTRY
 }
-