ferret 0.9.1 → 0.9.2

data/ext/index_rw.c

@@ -1,4 +1,4 @@
-#include <index.h>
+#include "index.h"
 #include <stdlib.h>
 #include <string.h>
 #include <array.h>
@@ -24,11 +24,11 @@ const char *VECTOR_EXTENSIONS[] = {
 };
       
 FerretConfig config = {
-  10,       // default merge_factor
-  10,       // default min_merge_docs
-  INT_MAX,  // default max_merge_docs
-  10000,    // default max_field_length
-  128       // default term_index_interval
+  10,       /* default merge_factor */
+  10,       /* default min_merge_docs */
+  INT_MAX,  /* default max_merge_docs */
+  10000,    /* default max_field_length */
+  128       /* default term_index_interval */
 };
 
 /***************************************************************************
@@ -47,33 +47,32 @@ int co_eq(const void *key1, const void *key2)
   return (key1 == key2);
 }
 
-void co_destroy(void *p)
+void co_destroy(CacheObject *self)
 {
-  CacheObject *co = (CacheObject *)p;
-  h_rem(co->ref_tab1, co->ref2, false);
-  h_rem(co->ref_tab2, co->ref1, false);
-  co->destroy(co->obj);
-  free(co);
+  h_rem(self->ref_tab1, self->ref2, false);
+  h_rem(self->ref_tab2, self->ref1, false);
+  self->destroy(self->obj);
+  free(self);
 }
 
 CacheObject *co_create(HshTable *ref_tab1, HshTable *ref_tab2,
-    void *ref1, void *ref2, void (*destroy)(void *p), void *obj)
+    void *ref1, void *ref2, free_ft destroy, void *obj)
 {
-  CacheObject *co = ALLOC(CacheObject);
-  h_set(ref_tab1, ref2, co);
-  h_set(ref_tab2, ref1, co);
-  co->ref_tab1 = ref_tab1;
-  co->ref_tab2 = ref_tab2;
-  co->ref1 = ref1;
-  co->ref2 = ref2;
-  co->destroy = destroy;
-  co->obj = obj;
-  return co;
+  CacheObject *self = ALLOC(CacheObject);
+  h_set(ref_tab1, ref2, self);
+  h_set(ref_tab2, ref1, self);
+  self->ref_tab1 = ref_tab1;
+  self->ref_tab2 = ref_tab2;
+  self->ref1 = ref1;
+  self->ref2 = ref2;
+  self->destroy = destroy;
+  self->obj = obj;
+  return self;
 }
 
 HshTable *co_hsh_create()
 {
-  return h_new(&co_hash, &co_eq, NULL, &co_destroy);
+  return h_new(&co_hash, &co_eq, (free_ft)NULL, (free_ft)&co_destroy);
 }
 
 /***************************************************************************
@@ -84,39 +83,38 @@ HshTable *co_hsh_create()
 
 Posting *p_create(Term *term, int position, TVOffsetInfo *offset)
 {
-  Posting *p = ALLOC(Posting);
-  p->freq = 1;
-  p->size = 1;
-  p->term = term;
-  p->positions = ALLOC(int);
-  p->positions[0] = position;
-  p->offsets = ALLOC(TVOffsetInfo *);
-  p->offsets[0] = offset;
-  return p;
+  Posting *self = ALLOC(Posting);
+  self->freq = 1;
+  self->size = 1;
+  self->term = term;
+  self->positions = ALLOC(int);
+  self->positions[0] = position;
+  self->offsets = ALLOC(TVOffsetInfo *);
+  self->offsets[0] = offset;
+  return self;
 }
 
-void p_destroy(void *p)
+void p_destroy(Posting *self)
 {
-  // the positions and offsets will be put in a TVTerm so no need to free
+  /* the positions and offsets will be put in a TVTerm so no need to free */
   int i;
-  Posting *post = (Posting *)p;
-  free(post->positions);
-  for (i = 0; i < post->freq; i++)
-    tvoi_destroy(post->offsets[i]);
-  free(post->offsets);
-  free(p);
+  free(self->positions);
+  for (i = 0; i < self->freq; i++)
+    tvoi_destroy(self->offsets[i]);
+  free(self->offsets);
+  free(self);
 }
 
-void p_add_occurance(Posting *p, int position, TVOffsetInfo *offset)
+void p_add_occurance(Posting *self, int position, TVOffsetInfo *offset)
 {
-  if (p->freq >= p->size) {
-    p->size *= 2;
-    REALLOC_N(p->positions, int, p->size);
-    REALLOC_N(p->offsets, TVOffsetInfo *, p->size);
+  if (self->freq >= self->size) {
+    self->size *= 2;
+    REALLOC_N(self->positions, int, self->size);
+    REALLOC_N(self->offsets, TVOffsetInfo *, self->size);
   }
-  p->positions[p->freq] = position;
-  p->offsets[p->freq] = offset;
-  p->freq++;
+  self->positions[self->freq] = position;
+  self->offsets[self->freq] = offset;
+  self->freq++;
 }
 
 inline int p_cmp(const void *const p1, const void *const p2)
@@ -137,47 +135,49 @@ DocumentWriter *dw_open(Store *store,
                         int max_field_length,
                         int term_index_interval)
 {
-  DocumentWriter *dw = ALLOC(DocumentWriter);
-  dw->store = store;
-  dw->analyzer = analyzer;
-  dw->similarity = similarity;
-  dw->fis = NULL;
-  dw->postingtable = h_new(&term_hash, &term_eq, &term_destroy, &p_destroy);
-  dw->max_field_length = max_field_length;
-  dw->term_index_interval = term_index_interval;
-  return dw;
+  DocumentWriter *self = ALLOC(DocumentWriter);
+  self->store = store;
+  self->analyzer = analyzer;
+  self->similarity = similarity;
+  self->fis = NULL;
+  self->postingtable = h_new(&term_hash, &term_eq,
+                             (free_ft)&term_destroy,
+                             (free_ft)&p_destroy);
+  self->max_field_length = max_field_length;
+  self->term_index_interval = term_index_interval;
+  return self;
 }
 
-void dw_close(DocumentWriter *dw)
+void dw_close(DocumentWriter *self)
 {
-  if (dw->fis) fis_destroy(dw->fis);
-  h_destroy(dw->postingtable);
-  free(dw);
+  if (self->fis) fis_destroy(self->fis);
+  h_destroy(self->postingtable);
+  free(self);
 }
 
-void dw_add_position(DocumentWriter *dw, char *field, char *text,
+void dw_add_position(DocumentWriter *self, char *field, char *text,
     int position, TVOffsetInfo *offset) 
 {
   Term termbuf = {field, text}, *term;
-  Posting *p = (Posting *)h_get(dw->postingtable, &termbuf);
+  Posting *p = (Posting *)h_get(self->postingtable, &termbuf);
 
-  if (p) { // word seen before
-    // double the size of posting to make room for more posts.
+  if (p) { /* word seen before */
     if (p->freq >= p->size) {
+      /* double size of posting to make room for more posts. */
       p->size <<= 1;
       REALLOC_N(p->positions, int, p->size);
       p->offsets = REALLOC_N(p->offsets, TVOffsetInfo *, p->size);
     }
-    p->positions[p->freq] = position;    // add new position
-    p->offsets[p->freq] = offset;        // add new position
-    p->freq++;                        // update frequency
-  } else { // word not seen before
+    p->positions[p->freq] = position;    /* add new position */
+    p->offsets[p->freq] = offset;        /* add new offset */
+    p->freq++;                           /* update frequency */
+  } else { /* word not seen before */
     term = term_create(field, text);
-    h_set(dw->postingtable, term, p_create(term, position, offset));
+    h_set(self->postingtable, term, p_create(term, position, offset));
   }
 }
 
-void dw_invert_doc(DocumentWriter *dw, Document *doc)
+void dw_invert_doc(DocumentWriter *self, Document *doc)
 {
   int i;
   int dfcnt = doc->dfcnt;
@@ -191,69 +191,74 @@ void dw_invert_doc(DocumentWriter *dw, Document *doc)
   for (i = 0; i < dfcnt; i++) {
     field = fields[i];
     field_name = field->name;
-    fi = ((FieldInfo *)ht_get(dw->fis->by_name, field_name));
+    fi = ((FieldInfo *)ht_get(self->fis->by_name, field_name));
     field_number = fi->number;
 
-    length = dw->field_lengths[field_number];
-    offset = dw->field_offsets[field_number];
-    position = dw->field_positions[field_number];
+    length = self->field_lengths[field_number];
+    offset = self->field_offsets[field_number];
+    position = self->field_positions[field_number];
 
     if (fi->is_indexed) {
-      if (!field->is_tokenized) {// un-tokenized field
+      if (!field->is_tokenized) { /* un-tokenized field */
         text = field->data;
-        slen = strlen(text);
+        slen = (int)strlen(text);
         if (fi->store_offset) {
-          dw_add_position(dw, field_name, text, position,
+          dw_add_position(self, field_name, text, position,
               tvoi_create(offset, offset+slen));
         } else {
-          dw_add_position(dw, field_name, text, position, NULL);
+          dw_add_position(self, field_name, text, position, NULL);
         }
         offset += slen;
         length++;
       } else {
 
-        // Tokenize field and add to posting_table
-        stream = a_get_ts(dw->analyzer, field_name, field->data);
+        /* Tokenize field and add to posting_table */
+        stream = a_get_ts(self->analyzer, field_name, field->data);
 
         while ((token = ts_next(stream)) != NULL) {
           position += (token->pos_inc - 1);
 
           if (fi->store_offset) {
-            dw_add_position(dw, 
+            dw_add_position(self, 
                 field_name,
                 token->text,
                 position,
                 tvoi_create(offset + token->start, offset + token->end));
             position++;
           } else {
-            dw_add_position(dw, field_name, token->text, position, NULL);
+            dw_add_position(self, field_name, token->text, position, NULL);
             position++;
           }
 
           length++;
-          // stop if we reach the max field length
-          if (length > dw->max_field_length)
+          /* stop if we reach the max field length */
+          if (length > self->max_field_length) {
             break;
+          }
         }
 
-        if (token)
+        if (token) {
           offset += token->end + 1;
+        }
       }
-      dw->field_lengths[field_number] = length;
-      dw->field_offsets[field_number] = offset;
-      dw->field_positions[field_number] = position;
-      dw->field_boosts[field_number] *= field->boost;
+      self->field_lengths[field_number] = length;
+      self->field_offsets[field_number] = offset;
+      self->field_positions[field_number] = position;
+      self->field_boosts[field_number] *= field->boost;
     }
   }
 }
 
-Posting **dw_sort_posting_table(DocumentWriter *dw)
+Posting **dw_sort_posting_table(DocumentWriter *self)
 {
-  HshTable *ht = dw->postingtable;
-  int i;
-  dw->pcnt = i = ht->used;
-  Posting **postings = ALLOC_N(Posting *, i);
+  HshTable *ht = self->postingtable;
   HshEntry *he = ht->table;
+  Posting **postings;
+  int i;
+
+  self->pcnt = i = ht->used;
+  postings = ALLOC_N(Posting *, i);
+
   while (i > 0) {
     if (he->value != NULL) {
       i--;
@@ -261,16 +266,16 @@ Posting **dw_sort_posting_table(DocumentWriter *dw)
     }
     he++;
   }
-  qsort(postings, dw->pcnt, sizeof(Posting *), &p_cmp);
+  qsort(postings, self->pcnt, sizeof(Posting *), &p_cmp);
   return postings;
 }
 
-void dw_write_postings(DocumentWriter *dw, Posting **postings, char *segment)
+void dw_write_postings(DocumentWriter *self, Posting **postings, char *segment)
 {
   OutStream * volatile freq_out = NULL, * volatile prox_out = NULL;
   TermInfosWriter * volatile tiw = NULL;
   TermVectorsWriter * volatile tvw = NULL;
-  Store *store = dw->store;
+  Store *store = self->store;
   TermInfo * volatile ti = NULL;
   Posting *posting;
   int i, j, posting_freq, position, last_position;
@@ -278,31 +283,31 @@ void dw_write_postings(DocumentWriter *dw, Posting **postings, char *segment)
   strcpy(fname, segment);
 
   TRY
-    //open files for inverse index storage
+    /* open files for inverse index storage */
     sprintf(fname, "%s.frq", segment);
     freq_out = store->create_output(store, fname);
     sprintf(fname, "%s.prx", segment);
     prox_out = store->create_output(store, fname);
-    tiw = tiw_open(store, segment, dw->fis, dw->term_index_interval);
+    tiw = tiw_open(store, segment, self->fis, self->term_index_interval);
     ti = ti_create(0, 0, 0, 0);
 
-    for (i = 0; i < dw->pcnt; i++) {
+    for (i = 0; i < self->pcnt; i++) {
       posting = postings[i];
 
-      // add an entry to the dictionary with pointers to prox and freq_out files
+      /* add an entry to dictionary with pointers to prox and freq_out files */
       ti_set(ti, 1, os_pos(freq_out), os_pos(prox_out), -1);
       tiw_add(tiw, posting->term, ti);
 
-      // add an entry to the freq_out file
+      /* add an entry to the freq_out file */
       posting_freq = posting->freq;
-      if (posting_freq == 1) {         // optimize freq=1
-        os_write_vint(freq_out, 1);            // set low bit of doc num.
+      if (posting_freq == 1) {                 /* optimize freq=1 */
+        os_write_vint(freq_out, 1);            /* set low bit of doc num */
       } else {
-        os_write_vint(freq_out, 0);            // the doc number
-        os_write_vint(freq_out, posting_freq); // frequency in doc
+        os_write_vint(freq_out, 0);            /* the doc number */
+        os_write_vint(freq_out, posting_freq); /* frequency in doc */
       }
 
-      last_position = 0;               // write positions
+      last_position = 0;               /* write positions */
 
       for (j = 0; j < posting_freq; j++) {
         position = posting->positions[j];
@@ -310,16 +315,16 @@ void dw_write_postings(DocumentWriter *dw, Posting **postings, char *segment)
         last_position = position;
       }
 
-      // check to see if we switched to a new field
+      /* check to see if we switched to a new field */
       term_field = posting->term->field;
       if (curr_field != term_field)  {
         FieldInfo *fi;
-        // changing field - see if there is something to save
+        /* changing field - see if there is something to save */
         curr_field = term_field;
-        fi = (FieldInfo *)ht_get(dw->fis->by_name, curr_field);
+        fi = (FieldInfo *)ht_get(self->fis->by_name, curr_field);
         if (fi->store_tv) {
           if (tvw == NULL) {
-            tvw = tvw_open(store, segment, dw->fis);
+            tvw = tvw_open(store, segment, self->fis);
             tvw_open_doc(tvw);
           }
           tvw_open_field(tvw, curr_field);
@@ -328,7 +333,7 @@ void dw_write_postings(DocumentWriter *dw, Posting **postings, char *segment)
           tvw_close_field(tvw);
         }
       }
-      // tvw->curr_field != NULL implies field is still open
+      /* tvw->curr_field != NULL implies field is still open */
       if (tvw != NULL && tvw->curr_field != NULL) {
         tvw_add_term(tvw, posting->term->text, posting_freq, posting->positions, posting->offsets);
       }
@@ -338,8 +343,8 @@ void dw_write_postings(DocumentWriter *dw, Posting **postings, char *segment)
       tvw_close_doc(tvw);
       tvw_close(tvw);
     }
-    // make an effort to close all streams we can but remember and re-raise
-    // the last exception encountered in this process
+    /* make an effort to close all streams we can but remember and re-raise
+     * the last exception encountered in this process */
     if (freq_out) os_close(freq_out);
     if (prox_out) os_close(prox_out);
     if (tiw) tiw_close(tiw);
@@ -347,24 +352,25 @@ void dw_write_postings(DocumentWriter *dw, Posting **postings, char *segment)
   XENDTRY
 }
 
-void dw_write_norms(DocumentWriter *dw, char *segment)
+void dw_write_norms(DocumentWriter *self, char *segment)
 {
   int i;
   float norm;
   OutStream *norms_out;
   char fname[SEGMENT_NAME_MAX_LENGTH];
-  FieldInfos *fis = dw->fis;
+  FieldInfos *fis = self->fis;
   FieldInfo *fi;
 
   for (i = 0; i < fis->fcnt; i++) {
     fi = fis->by_number[i];
     
     if (fi->is_indexed && !fi->omit_norms) {
-      norm = dw->field_boosts[i] * sim_length_norm(dw->similarity, fi->name, dw->field_lengths[i]);
+      norm = self->field_boosts[i] *
+        sim_length_norm(self->similarity, fi->name, self->field_lengths[i]);
       sprintf(fname, "%s.f%d", segment, i);
-      norms_out = dw->store->create_output(dw->store, fname);
+      norms_out = self->store->create_output(self->store, fname);
       TRY
-        os_write_byte(norms_out, sim_encode_norm(dw->similarity, norm));
+        os_write_byte(norms_out, sim_encode_norm(self->similarity, norm));
       XFINALLY
         os_close(norms_out);
       XENDTRY
@@ -372,49 +378,54 @@ void dw_write_norms(DocumentWriter *dw, char *segment)
   }
 }
 
-void dw_add_doc(DocumentWriter *dw, char *segment, Document *doc)
+void dw_add_doc(DocumentWriter *self, char *segment, Document *doc)
 {
+  Posting **postings;
+  FieldsWriter *fw;
   int i;
-  // write field names
-  dw->fis = fis_create();
-  fis_add_doc(dw->fis, doc);
-  fis_write(dw->fis, dw->store, segment, ".fnm");
 
-  // write field values
-  FieldsWriter *fw = fw_open(dw->store, segment, dw->fis);
+  /* write field names */
+  self->fis = fis_create();
+  fis_add_doc(self->fis, doc);
+  fis_write(self->fis, self->store, segment, ".fnm");
+
+  /* write field values */
+  fw = fw_open(self->store, segment, self->fis);
   TRY
     fw_add_doc(fw, doc);
   XFINALLY
     fw_close(fw);
   XENDTRY
 
-  // invert doc into posting_table
-  h_clear(dw->postingtable);        // clear posting_table
+  /* invert doc into posting_table */
 
-  dw->field_boosts = ALLOC_N(float, dw->fis->fcnt);
-  dw->field_lengths = ALLOC_AND_ZERO_N(int, dw->fis->fcnt);
-  dw->field_offsets = ALLOC_AND_ZERO_N(int, dw->fis->fcnt);
-  dw->field_positions = ALLOC_AND_ZERO_N(int, dw->fis->fcnt);
+  h_clear(self->postingtable); /* clear posting_table */
 
-  for (i = 0; i < dw->fis->fcnt; i++)
-    dw->field_boosts[i] = doc->boost;
+  self->field_boosts = ALLOC_N(float, self->fis->fcnt);
+  self->field_lengths = ALLOC_AND_ZERO_N(int, self->fis->fcnt);
+  self->field_offsets = ALLOC_AND_ZERO_N(int, self->fis->fcnt);
+  self->field_positions = ALLOC_AND_ZERO_N(int, self->fis->fcnt);
 
-  dw_invert_doc(dw, doc);
+  for (i = 0; i < self->fis->fcnt; i++) {
+    self->field_boosts[i] = doc->boost;
+  }
+
+  dw_invert_doc(self, doc);
 
-  // sort posting_table into an array
-  Posting **postings = dw_sort_posting_table(dw);
+  /* sort posting_table into an array */
+  postings = dw_sort_posting_table(self);
 
-  // write postings
-  dw_write_postings(dw, postings, segment);
+  /* write postings */
+  dw_write_postings(self, postings, segment);
   free(postings);
 
-  // write norms of indexed fields
-  dw_write_norms(dw, segment);
+  /* write norms of indexed fields */
+  dw_write_norms(self, segment);
 
-  free(dw->field_boosts);
-  free(dw->field_lengths);
-  free(dw->field_offsets);
-  free(dw->field_positions);
+  free(self->field_boosts);
+  free(self->field_lengths);
+  free(self->field_offsets);
+  free(self->field_positions);
 }
 
 /****************************************************************************
@@ -432,9 +443,8 @@ SegmentInfo *si_create(char *name, int doc_cnt, Store *store)
   return si;
 }
 
-void si_destroy(void *p)
+void si_destroy(SegmentInfo *si)
 {
-  SegmentInfo *si = (SegmentInfo *)p;
   free(si->name);
   free(si);
 }
@@ -501,21 +511,19 @@ SegmentInfos *sis_create()
   return sis;
 }
 
-void sis_destroy_not_infos(void *p)
+void sis_destroy_not_infos(SegmentInfos *sis)
 {
-  SegmentInfos *sis = (SegmentInfos *)p;
   free(sis->segs);
-  free(p);
+  free(sis);
 }
 
-void sis_destroy(void *p)
+void sis_destroy(SegmentInfos *sis)
 {
   int i;
-  SegmentInfos *sis = (SegmentInfos *)p;
   for (i = 0; i < sis->scnt; i++)
     si_destroy(sis->segs[i]);
   free(sis->segs);
-  free(p);
+  free(sis);
 }
 
 void sis_add_si(SegmentInfos *sis, SegmentInfo *si)
@@ -533,8 +541,9 @@ void sis_del_at(SegmentInfos *sis, int at)
   int i;
   si_destroy(sis->segs[at]);
   sis->scnt--;
-  for (i = at; i < sis->scnt; i++)
+  for (i = at; i < sis->scnt; i++) {
     sis->segs[i] = sis->segs[i+1];
+  }
 }
 
 void sis_del_from_to(SegmentInfos *sis, int from, int to)
@@ -561,24 +570,25 @@ void sis_clear(SegmentInfos *sis)
 void sis_read(SegmentInfos *sis, Store *store)
 {
   int doc_cnt;
+  int seg_count;
+  int i;
   char *name;
   InStream *is = store->open_input(store, SEGMENT_FILENAME);
 
   TRY
 
     sis->format = is_read_int(is);
-    if (sis->format < 0) { // file contains explicit format info
-      // check that it is a format we can understand
+    if (sis->format < 0) { /* file contains explicit format info */
+      /* check that it is a format we can understand */
       if (sis->format < FORMAT)
-        RAISE(ERROR, FORMAT_VERSION_ERROR_MSG);
-      sis->version = is_read_long(is);
-      sis->counter = is_read_int(is);
-    } else { // file is in old format without explicit format info
+        RAISE(EXCEPTION, FORMAT_VERSION_ERROR_MSG);
+      sis->version = (uint)is_read_long(is);
+      sis->counter = (int)is_read_int(is);
+    } else { /* file is in old format without explicit format info */
       sis->counter = sis->format;
     }
       
-    int seg_count = is_read_int(is);
-    int i;
+    seg_count = is_read_int(is);
     for (i = 0; i < seg_count; i++) {
       name = is_read_string(is);
       doc_cnt = is_read_int(is);
@@ -586,11 +596,12 @@ void sis_read(SegmentInfos *sis, Store *store)
     }
    
     if (sis->format >= 0) {
-      // in old format the version number may be at the end of the file
-      if (is_pos(is) >= is_length(is))
-        sis->version = 0; // old file format without version number
-      else
-        sis->version = is_read_long(is); // read version
+      /* in old format the version number may be at the end of the file */
+      if (is_pos(is) >= is_length(is)) {
+        sis->version = 0; /* old file format without version number */
+      } else {
+        sis->version = (int)is_read_long(is); /* read version */
+      }
     }
   XFINALLY
     is_close(is);
@@ -604,7 +615,7 @@ void sis_write(SegmentInfos *sis, Store *store)
   OutStream *os = store->create_output(store, TEMPORARY_SEGMENT_FILENAME);
   TRY
     os_write_int(os, FORMAT);
-    os_write_long(os, ++(sis->version)); // every write changes the index
+    os_write_long(os, ++(sis->version)); /* every write changes the index */
     os_write_int(os, sis->counter);
     os_write_int(os, sis->scnt); 
     for (i = 0; i < sis->scnt; i++) {
@@ -617,24 +628,27 @@ void sis_write(SegmentInfos *sis, Store *store)
     os_close(os);
   XENDTRY
 
-  //install new segment info
+  /* install new segment info */
   store->rename(store, TEMPORARY_SEGMENT_FILENAME, SEGMENT_FILENAME);
 }
 
 int sis_read_current_version(Store *store)
 {
-  if (!store->exists(store, SEGMENT_FILENAME))
-    return 0;
-  InStream *is = store->open_input(store, SEGMENT_FILENAME);
+  InStream *is;
+  SegmentInfos *sis;
   int format = 0;
   int version = 0;
 
+  if (!store->exists(store, SEGMENT_FILENAME))
+    return 0;
+  is = store->open_input(store, SEGMENT_FILENAME);
+
   TRY
     format = is_read_int(is);
     if (format < 0) {
       if (format < FORMAT) 
-        RAISE(ERROR, FORMAT_VERSION_ERROR_MSG);
-      version = is_read_long(is);
+        RAISE(EXCEPTION, FORMAT_VERSION_ERROR_MSG);
+      version = (int)is_read_long(is);
     }
   XFINALLY
     is_close(is);
@@ -643,11 +657,11 @@ int sis_read_current_version(Store *store)
   if (format < 0)
     return version;
 
-  // We cannot be sure about the format of the file.
-  // Therefore we have to read the whole file and cannot simply
-  // seek to the version entry.
+  /* We cannot be sure about the format of the file.
+   * Therefore we have to read the whole file and cannot simply
+   * seek to the version entry. */
 
-  SegmentInfos *sis = sis_create();
+  sis = sis_create();
   sis_read(sis, store);
   version = sis->version;
   sis_destroy(sis);
@@ -660,8 +674,10 @@ int sis_read_current_version(Store *store)
  *
  ****************************************************************************/
 
-IndexWriter *iw_open(Store *store, Analyzer *analyzer,
-    bool create, bool close_store, bool close_analyzer)
+/**
+ * Deletes the analyzer by default but leaves the store by default
+ */
+IndexWriter *iw_open(Store *store, Analyzer *analyzer, bool create)
 {
   IndexWriter *iw = ALLOC(IndexWriter);
   if (create)
@@ -674,15 +690,14 @@ IndexWriter *iw_open(Store *store, Analyzer *analyzer,
   iw->term_index_interval = config.term_index_interval;
   iw->use_compound_file = true;
   iw->store = store;
-  iw->close_store = close_store;
-  iw->close_analyzer = close_analyzer;
+  ref(store);
   iw->analyzer = analyzer;
   iw->sis = sis_create();
   iw->similarity = sim_create_default();
   iw->ram_store = open_ram_store();
 
   mutex_lock(&store->mutex);
-  // keep the write_lock obtained until the IndexWriter is closed.
+  /* keep the write_lock obtained until the IndexWriter is closed. */
   iw->write_lock = store->open_lock(store, WRITE_LOCK_NAME);
   if (!iw->write_lock->obtain(iw->write_lock)) {
     RAISE(STATE_ERROR, WRITE_LOCK_ERROR_MSG);
@@ -695,7 +710,7 @@ IndexWriter *iw_open(Store *store, Analyzer *analyzer,
       RAISE(STATE_ERROR, COMMIT_LOCK_ERROR_MSG);
     }
     TRY
-      // commit the index
+      /* commit the index */
       store->clear(store);
       sis_write(iw->sis, store);
     XFINALLY
@@ -714,8 +729,9 @@ const char base36_digitmap[] = "0123456789abcdefghijklmnopqrstuvwxyz";
 char *new_segment_name(int counter) 
 {
   char buf[SEGMENT_NAME_MAX_LENGTH];
-  buf[SEGMENT_NAME_MAX_LENGTH - 1] = '\0';
   int i;
+
+  buf[SEGMENT_NAME_MAX_LENGTH - 1] = '\0';
   for (i = SEGMENT_NAME_MAX_LENGTH - 2; ; i--) {
     buf[i] = base36_digitmap[counter%36];
     counter /= 36;
@@ -749,8 +765,8 @@ void delete_files(Array *file_names, Store *store)
 Array *sr_file_names(IndexReader *ir);
 void iw_delete_segments(IndexWriter *iw, IndexReader **segment_readers, int del_cnt)
 {
-  // The java version keeps a record of files that it couldn't delete. This
-  // shouldn't be a problem on linux I hope.
+  /* The java version keeps a record of files that it couldn't delete. This
+   * shouldn't be a problem on linux I hope. */
   IndexReader *ir;
   int i;
   for (i = 0; i < del_cnt; i++) {
@@ -761,22 +777,25 @@ void iw_delete_segments(IndexWriter *iw, IndexReader **segment_readers, int del_
 
 void make_compound_file(IndexWriter *iw, char *merged_name, SegmentMerger *merger)
 {
+  Array *files_to_delete;
+  Lock *commit_lock;
   char merged_tmp[SEGMENT_NAME_MAX_LENGTH], merged_cfs[SEGMENT_NAME_MAX_LENGTH];
 
   mutex_lock(&iw->store->mutex);
   sprintf(merged_tmp, "%s.tmp", merged_name);
   sprintf(merged_cfs, "%s.cfs", merged_name);
 
-  Array *files_to_delete = sm_create_compound_file(merger, merged_tmp);
-  Lock *commit_lock = iw->store->open_lock(iw->store, COMMIT_LOCK_NAME);
+  files_to_delete = sm_create_compound_file(merger, merged_tmp);
+  commit_lock = iw->store->open_lock(iw->store, COMMIT_LOCK_NAME);
 
   if (!commit_lock->obtain(commit_lock)) {
     RAISE(STATE_ERROR, COMMIT_LOCK_ERROR_MSG);
   }
 
-  // make compound file visible for SegmentReaders
+  /* make compound file visible for SegmentReaders */
   iw->store->rename(iw->store, merged_tmp, merged_cfs);
-  // delete now unused files of segment
+
+  /* delete now unused files of segment */
   delete_files(files_to_delete, iw->store);
 
   commit_lock->release(commit_lock);
@@ -787,7 +806,9 @@ void make_compound_file(IndexWriter *iw, char *merged_name, SegmentMerger *merge
 void iw_merge_segments_with_max(IndexWriter *iw, int min_segment, int max_segment)
 {
   int i;
-  IndexReader *segments_to_delete[max_segment - min_segment];
+  int merged_doc_count;
+  Lock *commit_lock;
+  IndexReader **segments_to_delete = ALLOC_N(IndexReader *, max_segment - min_segment);
   int del_cnt = 0;
 
   char *merged_name = new_segment_name(iw->sis->counter++);
@@ -797,31 +818,31 @@ void iw_merge_segments_with_max(IndexWriter *iw, int min_segment, int max_segmen
 
 
   for (i = min_segment; i < max_segment; i++) {
-    reader = sr_open(iw->sis, i, false, false);
+    reader = sr_open(iw->sis, i, false);
     sm_add(merger, reader);
-    if ((reader->store == iw->store) || // if we own the directory
+    if ((reader->store == iw->store) ||         /* if we own the directory */
         (reader->store == iw->ram_store)) {
-      segments_to_delete[del_cnt++] = reader;   // queue segment for deletion
+      segments_to_delete[del_cnt++] = reader;   /* queue segment for deletion */
     }
   }
   
-  int merged_doc_count = sm_merge(merger);
+  merged_doc_count = sm_merge(merger);
 
   sis_del_from_to(iw->sis, min_segment, max_segment);
 
   sis_add_si(iw->sis, si_create(merged_name, merged_doc_count, iw->store));
 
-  // close readers before we attempt to delete now-obsolete segments
+  /* close readers before we attempt to delete now-obsolete segments */
 
   mutex_lock(&iw->store->mutex);
-  Lock *commit_lock = iw->store->open_lock(iw->store, COMMIT_LOCK_NAME);
+  commit_lock = iw->store->open_lock(iw->store, COMMIT_LOCK_NAME);
   if (!commit_lock->obtain(commit_lock)) {
     RAISE(STATE_ERROR, COMMIT_LOCK_ERROR_MSG);
   }
-  // commit the index
+  /* commit the index */
   sis_write(iw->sis, iw->store);
   iw_delete_segments(iw, segments_to_delete, del_cnt);
-  //
+
   commit_lock->release(commit_lock);
   iw->store->close_lock(commit_lock);
   mutex_unlock(&iw->store->mutex);
@@ -830,6 +851,7 @@ void iw_merge_segments_with_max(IndexWriter *iw, int min_segment, int max_segmen
     make_compound_file(iw, merged_name, merger);
   }
 
+  free(segments_to_delete);
   sm_destroy(merger);
 }
 
@@ -845,23 +867,25 @@ void iw_maybe_merge_segments(IndexWriter *iw)
   SegmentInfo *si;
 
   while (target_merge_docs <= iw->max_merge_docs) {
-    // find segments smaller than current target size
+    /* find segments smaller than current target size */
     min_segment = iw->sis->scnt - 1;
     merge_docs = 0;
     while (min_segment >= 0) {
       si = iw->sis->segs[min_segment];
-      if (si->doc_cnt >= target_merge_docs)
+      if (si->doc_cnt >= target_merge_docs) {
         break;
+      }
       merge_docs += si->doc_cnt;
       min_segment -= 1;
     }
 
-    if (merge_docs >= target_merge_docs)      // found a merge to do
+    if (merge_docs >= target_merge_docs) { /* found a merge to do */
       iw_merge_segments(iw, min_segment + 1);
-    else
+    } else {
       break;
+    }
 
-    target_merge_docs *= iw->merge_factor; // increase target size
+    target_merge_docs *= iw->merge_factor; /* increase target size */
   }
 }
 
@@ -883,12 +907,14 @@ void iw_flush_ram_segments(IndexWriter *iw)
    * that wasn't the ram segment. But if it fit's in with the merge
    * factor, why not merge it. Otherwise we leave it and increment min_seg
    */
-  if (min_segment < 0 ||                          // add one FS segment?
-      (doc_count + segs[min_segment]->doc_cnt) > iw->merge_factor ||
-      (segs[iw->sis->scnt-1]->store != iw->ram_store))
+  if ((min_segment < 0) ||                       /* add one FS segment? */
+      ((doc_count + segs[min_segment]->doc_cnt) > iw->merge_factor) ||
+      (segs[iw->sis->scnt - 1]->store != iw->ram_store)) {
     min_segment++;
-  if (min_segment >= iw->sis->scnt)
+  }
+  if (min_segment >= iw->sis->scnt) {
     return;
+  }
   iw_merge_segments(iw, min_segment);
 }
 
@@ -937,17 +963,16 @@ void iw_close(IndexWriter *iw)
 {
   mutex_lock(&iw->mutex);
   iw_flush_ram_segments(iw);
-  ram_close(iw->ram_store);
+  store_deref(iw->ram_store);
   sis_destroy(iw->sis);
 
   sim_destroy(iw->similarity);
-  if (iw->close_analyzer) a_destroy(iw->analyzer);
+  a_deref(iw->analyzer);
 
   iw->write_lock->release(iw->write_lock);
   iw->store->close_lock(iw->write_lock);
 
-  if (iw->close_store)
-    store_close(iw->store);
+  store_deref(iw->store);
   mutex_destroy(&iw->mutex);
   free(iw);
 }
@@ -957,13 +982,13 @@ void iw_add_indexes(IndexWriter *iw, Store **stores, int cnt)
   int i, j, end, start;
 
   mutex_lock(&iw->mutex);
-  iw_optimize_internal(iw); // start with zero or 1 seg
+  iw_optimize_internal(iw); /* start with zero or 1 seg */
 
   start = iw->sis->scnt;
 
   for (i = 0; i < cnt; i++) {
     Store *store = stores[i];
-    SegmentInfos *sis = sis_create(); // read infos from dir
+    SegmentInfos *sis = sis_create(); /* read infos from dir */
     sis_read(sis, store);
 
     for (j = 0; j < sis->scnt; j++) {
@@ -973,7 +998,7 @@ void iw_add_indexes(IndexWriter *iw, Store **stores, int cnt)
     sis_destroy_not_infos(sis);
   }
 
-  // merge newly added segments in log(n) passes
+  /* merge newly added segments in log(n) passes */
   while (iw->sis->scnt > start + iw->merge_factor) {
     for (i = start + 1; i < iw->sis->scnt; i++) {
       end = MIN(iw->sis->scnt, i + iw->merge_factor);
@@ -983,7 +1008,7 @@ void iw_add_indexes(IndexWriter *iw, Store **stores, int cnt)
     }
   }
 
-  // final cleanup
+  /* final cleanup */
   iw_optimize_internal(iw);
   mutex_unlock(&iw->mutex);
 }
@@ -996,16 +1021,20 @@ void iw_add_readers(IndexWriter *iw, IndexReader **irs, int cnt)
 {
   IndexReader *ir = NULL;
   int i, del_cnt = 0;
-
+  int doc_count;
+  char *merged_name;
+  SegmentMerger *merger;
+  Lock *commit_lock;
+  
   mutex_lock(&iw->mutex);
-  iw_optimize_internal(iw); // start with zero or 1 seg
+  iw_optimize_internal(iw); /* start with zero or 1 seg */
 
-  char *merged_name = new_segment_name(iw->sis->counter++);
+  merged_name = new_segment_name(iw->sis->counter++);
 
-  SegmentMerger *merger = sm_create(iw->store, merged_name, iw->term_index_interval);
-  merger->readers->free_elem = NULL; // don't close readers
+  merger = sm_create(iw->store, merged_name, iw->term_index_interval);
+  merger->readers->free_elem = NULL; /* don't close readers */
 
-  if (iw->sis->scnt == 1) {// add existing index, if any
+  if (iw->sis->scnt == 1) { /* add existing index, if any */
     ir = sr_open_si(iw->sis->segs[0]);
     sm_add(merger, ir);
     del_cnt = 1;
@@ -1015,18 +1044,19 @@ void iw_add_readers(IndexWriter *iw, IndexReader **irs, int cnt)
     sm_add(merger, irs[i]);
   }
 
-  int doc_count = sm_merge(merger); // merge 'em
+  doc_count = sm_merge(merger); /* merge 'em */
 
-  // pop old infos and add new ones.
+  /* pop old infos and add new ones. */
   sis_clear(iw->sis);
   sis_add_si(iw->sis, si_create(merged_name, doc_count, iw->store));
 
 
-  Lock *commit_lock = iw->store->open_lock(iw->store, COMMIT_LOCK_NAME);
-  if (!commit_lock->obtain(commit_lock)) // obtain write lock
+  commit_lock = iw->store->open_lock(iw->store, COMMIT_LOCK_NAME);
+  if (!commit_lock->obtain(commit_lock)) { /* obtain write lock */
     RAISE(STATE_ERROR, COMMIT_LOCK_ERROR_MSG);
+  }
 
-  sis_write(iw->sis, iw->store); // commit changes
+  sis_write(iw->sis, iw->store); /* commit changes */
   iw_delete_segments(iw, &ir, del_cnt);
   if (ir) ir_close(ir);
 
@@ -1059,24 +1089,28 @@ Norm *norm_create(InStream *is, int field_num)
   return norm;
 }
 
-void norm_destroy(void *p)
+void norm_destroy(Norm *norm)
 {
-  Norm *norm = (Norm *)p;
   is_close(norm->is);
-  if (norm->bytes != NULL) free(norm->bytes);
+  if (norm->bytes != NULL) {
+    free(norm->bytes);
+  }
   free(norm);
 }
 
 void norm_rewrite(Norm *norm, Store *store, char *segment,
     int doc_count, Store *cfs_store)
 {
-  if (norm->bytes == NULL)
-    return; // These norms do not need to be rewritten
-
+  OutStream *os;
   char tmp_fname[SEGMENT_NAME_MAX_LENGTH];
   char norm_fname[SEGMENT_NAME_MAX_LENGTH];
+
+  if (norm->bytes == NULL) {
+    return; /* These norms do not need to be rewritten */
+  }
+
   sprintf(tmp_fname, "%s.tmp", segment);
-  OutStream *os = store->create_output(store, tmp_fname);
+  os = store->create_output(store, tmp_fname);
   TRY
     os_write_bytes(os, norm->bytes, doc_count);
   XFINALLY
@@ -1097,7 +1131,7 @@ void norm_rewrite(Norm *norm, Store *store, char *segment,
  *
  ****************************************************************************/
 
-#define GET_SR SegmentReader *sr = (SegmentReader *)ir->data;
+#define GET_SR SegmentReader *sr = (SegmentReader *)ir->data
 
 int sr_max_doc(IndexReader *ir)
 {
@@ -1129,8 +1163,8 @@ void sr_close(IndexReader *ir)
 
   if (sr->freq_in) is_close(sr->freq_in);
   if (sr->prox_in) is_close(sr->prox_in);
+  
   fis_destroy(sr->fis);
-
   sr_close_norms(sr);
   
   if (sr->orig_tvr) {
@@ -1139,7 +1173,7 @@ void sr_close(IndexReader *ir)
     ary_destroy(sr->tvr_bucket);
   }
   if (sr->deleted_docs) bv_destroy(sr->deleted_docs);
-  if (sr->cfs_store) sr->cfs_store->close(sr->cfs_store);
+  if (sr->cfs_store) store_deref(sr->cfs_store);
   if (sr->fake_norms) free(sr->fake_norms);
   free(sr->segment);
   free(sr);
@@ -1175,8 +1209,8 @@ bool sr_is_deleted(IndexReader *ir, int doc_num)
 
 bool sr_has_norms(IndexReader *ir, char *field)
 {
-  bool has_norms;
   GET_SR;
+  bool has_norms;
   mutex_lock(&ir->mutex);
   has_norms = h_has_key(sr->norms, field);
   mutex_unlock(&ir->mutex);
@@ -1215,13 +1249,13 @@ TermEnum *sr_terms_from(IndexReader *ir, Term *term)
 
 Document *sr_get_doc(IndexReader *ir, int doc_num)
 {
+  GET_SR;
   Document *doc;
   mutex_lock(&ir->mutex);
   if (sr_is_deleted_internal(ir, doc_num)) {
     mutex_unlock(&ir->mutex);
     RAISE(STATE_ERROR, DELETED_DOC_ERROR_MSG);
   }
-  GET_SR;
   doc = fr_get_doc(sr->fr, doc_num);
   mutex_unlock(&ir->mutex);
   return doc;
@@ -1234,11 +1268,11 @@ sr_get_norms_into_internal(IndexReader *ir, char *field, uchar *buf, int offset)
   Norm *norm = h_get(sr->norms, field);
   if (norm == NULL) {
     memset(buf + offset*sizeof(uchar), 0, sr_max_doc(ir)*sizeof(uchar));
-  } else if (norm->bytes != NULL) { // can copy from cache
+  } else if (norm->bytes != NULL) { /* can copy from cache */
     memcpy(buf + offset*sizeof(uchar), norm->bytes, sr_max_doc(ir)*sizeof(uchar));
   } else {
     InStream *norm_in = is_clone(norm->is);
-    // read from disk
+    /* read from disk */
     is_seek(norm_in, 0);
     is_read_bytes(norm_in, buf, offset, sr_max_doc(ir));
     is_close(norm_in);
@@ -1256,13 +1290,14 @@ static inline uchar *sr_get_norms_internal(IndexReader *ir, char *field)
 {
   GET_SR;
   Norm *norm = h_get(sr->norms, field);
-  if (norm == NULL)                             // not an indexed field
+  if (norm == NULL) {                           /* not an indexed field */
     return NULL;
+  }
 
-  if (norm->bytes == NULL) {                    // value not yet read
+  if (norm->bytes == NULL) {                    /* value not yet read */
     uchar *bytes = ALLOC_N(uchar, ir->max_doc(ir));
     sr_get_norms_into_internal(ir, field, bytes, 0);
-    norm->bytes = bytes;                        // cache it
+    norm->bytes = bytes;                        /* cache it */
   }
   return norm->bytes;
 }
@@ -1278,8 +1313,8 @@ uchar *sr_get_norms(IndexReader *ir, char *field)
 
 static inline uchar *sr_get_norms_always(IndexReader *ir, char *field)
 {
-  uchar *bytes;
   GET_SR;
+  uchar *bytes;
   mutex_lock(&ir->mutex);
 
   bytes = sr_get_norms_internal(ir, field);
@@ -1303,7 +1338,7 @@ void sr_set_norm(IndexReader *ir, int doc_num, char *field, uchar val)
   
   norm = h_get(sr->norms, field);
   if (norm != NULL) { /* an indexed field */
-    norm->is_dirty = true;                           // mark it dirty
+    norm->is_dirty = true;                           /* mark it dirty */
     sr->norms_dirty = true;
 
     sr_get_norms_internal(ir, field)[doc_num] = val;
@@ -1318,13 +1353,15 @@ int sr_doc_freq(IndexReader *ir, Term *t)
     int df = ti->doc_freq;
     ti_destroy(ti);
     return df;
-  } else return 0;
+  } else {
+    return 0;
+  }
 }
 
 Array *sr_file_names(IndexReader *ir)
 {
   GET_SR;
-  Array *file_names = ary_create(0, &efree);
+  Array *file_names = ary_create(0, &free);
   FieldInfo *fi;
   int i;
   char fname[SEGMENT_NAME_MAX_LENGTH];
@@ -1352,8 +1389,8 @@ Array *sr_file_names(IndexReader *ir)
 
 HashSet *sr_get_field_names(IndexReader *ir, int field_type)
 {
-  int i;
   GET_SR;
+  int i;
   HashSet *field_set = hs_str_create(NULL);
   FieldInfo *fi;
   for (i = 0; i < sr->fis->fcnt; i++) {
@@ -1396,9 +1433,10 @@ HashSet *sr_get_field_names(IndexReader *ir, int field_type)
 int sr_num_docs(IndexReader *ir)
 {
   GET_SR;
-
+  int num_docs;
+  
   mutex_lock(&ir->mutex);
-  int num_docs = sr_max_doc(ir);
+  num_docs = sr_max_doc(ir);
   if (sr->deleted_docs != NULL)
     num_docs -= sr->deleted_docs->count;
   mutex_unlock(&ir->mutex);
@@ -1444,8 +1482,9 @@ TermVector *sr_get_term_vector(IndexReader *ir, int doc_num, char *field)
   FieldInfo *fi = (FieldInfo *)ht_get(sr->fis->by_name, field);
   TermVectorsReader *tvr;
 
-  if (fi == NULL || !fi->store_tv || !sr->orig_tvr || !(tvr = sr_tvr(sr)))
+  if (fi == NULL || !fi->store_tv || !sr->orig_tvr || !(tvr = sr_tvr(sr))) {
     return NULL;
+  }
 
   return tvr_get_field_tv(tvr, doc_num, field);
 }
@@ -1454,8 +1493,9 @@ Array *sr_get_term_vectors(IndexReader *ir, int doc_num)
 {
   GET_SR;
   TermVectorsReader *tvr;
-  if (sr->orig_tvr == NULL || (tvr = sr_tvr(sr)) == NULL)
+  if (sr->orig_tvr == NULL || (tvr = sr_tvr(sr)) == NULL) {
     return NULL;
+  }
 
   return tvr_get_tv(tvr, doc_num);
 }
@@ -1465,16 +1505,17 @@ void sr_commit(IndexReader *ir)
   GET_SR;
   char tmp_fname[SEGMENT_NAME_MAX_LENGTH];
   char del_fname[SEGMENT_NAME_MAX_LENGTH];
+
   sprintf(del_fname, "%s.del", sr->segment);
 
-  if (sr->deleted_docs_dirty) { // re-write deleted 
+  if (sr->deleted_docs_dirty) { /* re-write deleted */
     sprintf(tmp_fname, "%s.tmp", sr->segment);
     bv_write(sr->deleted_docs, ir->store, tmp_fname);
     ir->store->rename(ir->store, tmp_fname, del_fname);
   }
   if (sr->undelete_all && ir->store->exists(ir->store, del_fname))
     ir->store->remove(ir->store, del_fname);
-  if (sr->norms_dirty) {// re-write norms 
+  if (sr->norms_dirty) {/* re-write norms */
     int i;
     FieldInfo *fi;
     for (i = 0; i < sr->fis->fcnt; i++) {
@@ -1494,6 +1535,8 @@ IndexReader *sr_open_internal(IndexReader *ir, SegmentInfo *si)
 {
   Store *store = si->store;
   SegmentReader *sr = ALLOC(SegmentReader);
+  char fname[SEGMENT_NAME_MAX_LENGTH];
+  
   ir->get_term_vector = &sr_get_term_vector;
   ir->get_term_vectors = &sr_get_term_vectors;
   ir->num_docs = &sr_num_docs;
@@ -1518,7 +1561,6 @@ IndexReader *sr_open_internal(IndexReader *ir, SegmentInfo *si)
   ir->do_close = &sr_close;
   ir->data = sr;
   sr->segment = estrdup(si->name);
-  char fname[SEGMENT_NAME_MAX_LENGTH];
   sr->cfs_store = NULL;
   sr->fake_norms = NULL;
   sprintf(fname, "%s.cfs", sr->segment);
@@ -1545,13 +1587,13 @@ IndexReader *sr_open_internal(IndexReader *ir, SegmentInfo *si)
   sr->freq_in = store->open_input(store, fname);
   sprintf(fname, "%s.prx", sr->segment);
   sr->prox_in = store->open_input(store, fname);
-  sr->norms = h_new_str(NULL, &norm_destroy);
+  sr->norms = h_new_str((free_ft)NULL, (free_ft)&norm_destroy);
   sr_open_norms(ir, store);
 
   if (fis_has_vectors(sr->fis)) {
     sr->orig_tvr = tvr_open(store, sr->segment, sr->fis);
     thread_key_create(&sr->thread_tvr, NULL);
-    sr->tvr_bucket = ary_create(1, (destroy_func_t)&tvr_close);
+    sr->tvr_bucket = ary_create(1, (free_ft)&tvr_close);
   } else {
     sr->orig_tvr = NULL;
   }
@@ -1560,16 +1602,19 @@ IndexReader *sr_open_internal(IndexReader *ir, SegmentInfo *si)
 
 IndexReader *sr_open_si(SegmentInfo *si)
 {
-  IndexReader *ir = ir_create(si->store, NULL, false, false);
+  IndexReader *ir = ir_create(si->store, NULL, false);
+  ref(si->store);
   return sr_open_internal(ir, si);
 }
 
-IndexReader *sr_open(SegmentInfos *sis, int si_num, int is_owner, int close_store)
+IndexReader *sr_open(SegmentInfos *sis, int si_num, bool is_owner)
 {
   SegmentInfo *si = sis->segs[si_num];
-  IndexReader *ir = ir_create(si->store, sis, is_owner, close_store);
+  IndexReader *ir = ir_create(si->store, sis, is_owner);
+  ref(si->store);
   return sr_open_internal(ir, si);
 }
+
 /****************************************************************************
  *
  * MultiReader
@@ -1579,14 +1624,14 @@ IndexReader *sr_open(SegmentInfos *sis, int si_num, int is_owner, int close_stor
 #define GET_MR MultiReader *mr = (MultiReader *)ir->data
 #define GET_READER(doc_num) MultiReader *mr = (MultiReader *)ir->data;\
   int i = mr_reader_index(mr, doc_num);\
-  IndexReader *reader = mr->sub_readers[i];
+  IndexReader *reader = mr->sub_readers[i]
 
 
 
 int mr_reader_index(MultiReader *mr, int doc_num)
 {
-  int lo = 0;                       // search @starts array
-  int hi = mr->rcnt - 1;            // for first element less
+  int lo = 0;                       /* search @starts array */
+  int hi = mr->rcnt - 1;            /* for first element less */
   int mid;
   int mid_value;
 
@@ -1597,9 +1642,9 @@ int mr_reader_index(MultiReader *mr, int doc_num)
       hi = mid - 1;
     } else if (doc_num > mid_value) {
       lo = mid + 1;
-    } else { // found a match
+    } else { /* found a match */
       while ((mid+1 < mr->rcnt) && (mr->starts[mid+1] == mid_value))
-        mid += 1; // scan to last match in case we have empty segments
+        mid += 1; /* scan to last match in case we have empty segments */
       return mid;
     }
   }
@@ -1652,10 +1697,11 @@ Document *mr_get_doc(IndexReader *ir, int doc_num)
 void mr_get_norms_into(IndexReader *ir, char *field, uchar *buf, int offset)
 {
   int i;
+  uchar *bytes;
   GET_MR;
 
   mutex_lock(&ir->mutex);
-  uchar *bytes = h_get(mr->norms_cache, field);
+  bytes = h_get(mr->norms_cache, field);
   if (bytes != NULL) {
     memcpy(buf + offset, bytes, mr->max_doc);
   } else {
@@ -1684,7 +1730,7 @@ uchar *mr_get_norms(IndexReader *ir, char *field)
       reader = mr->sub_readers[i];
       reader->get_norms_into(reader, field, bytes, mr->starts[i]);
     }
-    h_set(mr->norms_cache, field, bytes); // update cache
+    h_set(mr->norms_cache, field, bytes); /* update cache */
   }
   mutex_unlock(&ir->mutex);
 
@@ -1694,7 +1740,7 @@ uchar *mr_get_norms(IndexReader *ir, char *field)
 void mr_set_norm(IndexReader *ir, int doc_num, char *field, uchar val)
 {
   GET_READER(doc_num);
-  h_del(mr->norms_cache, field);               // clear cache
+  h_del(mr->norms_cache, field);               /* clear cache */
   ir_set_norm(reader, doc_num - mr->starts[i], field, val);
 }
 
@@ -1712,7 +1758,7 @@ TermEnum *mr_terms_from(IndexReader *ir, Term *term)
 
 int mr_doc_freq(IndexReader *ir, Term *t)
 {
-  int total = 0, i;          // sum freqs in segments
+  int total = 0, i;          /* sum freqs in segments */
   GET_MR;
 
   IndexReader *reader;
@@ -1738,9 +1784,10 @@ TermDocEnum *mr_term_positions(IndexReader *ir)
 void mr_delete_doc(IndexReader *ir, int doc_num)
 {
   GET_READER(doc_num);
-  mr->num_docs_cache = -1;                     // invalidate cache
+  mr->num_docs_cache = -1; /* invalidate cache */
 
-  reader->do_delete_doc(reader, doc_num - mr->starts[i]); // dispatch to segment reader
+  /* dispatch to segment reader */
+  reader->do_delete_doc(reader, doc_num - mr->starts[i]);
   mr->has_deletions = true;
 }
 
@@ -1778,8 +1825,9 @@ void mr_undelete_all(IndexReader *ir)
 {
   int i;
   GET_MR;
-  mr->num_docs_cache = -1;                     // invalidate cache
   IndexReader *reader;
+
+  mr->num_docs_cache = -1;                     /* invalidate cache */
   for (i = 0; i < mr->rcnt; i++) {
     reader = mr->sub_readers[i];
     reader->do_undelete_all(reader);
@@ -1829,12 +1877,12 @@ void mr_close(IndexReader *ir)
 IndexReader *mr_open(Store *store,
     SegmentInfos *sis,
     IndexReader **sub_readers,
-    int rcnt,
-    int close_store)
+    int rcnt)
 {
   int i;
   MultiReader *mr = ALLOC(MultiReader);
   IndexReader *sub_reader;
+  IndexReader *ir;
   mr->sub_readers = sub_readers;
   mr->rcnt = rcnt;
 
@@ -1846,15 +1894,16 @@ IndexReader *mr_open(Store *store,
   for (i = 0; i < rcnt; i++) {
     sub_reader = sub_readers[i];
     mr->starts[i] = mr->max_doc;
-    mr->max_doc += sub_reader->max_doc(sub_reader); // compute max_docs
+    mr->max_doc += sub_reader->max_doc(sub_reader); /* compute max_docs */
 
-    if (sub_reader->has_deletions(sub_reader))
+    if (sub_reader->has_deletions(sub_reader)) {
       mr->has_deletions = true;
+    }
   }
   mr->starts[rcnt] = mr->max_doc;
-  mr->norms_cache = h_new_str(NULL, &efree);
+  mr->norms_cache = h_new_str(NULL, &free);
 
-  IndexReader *ir = ir_create(store, sis, true, close_store);
+  ir = ir_create(store, sis, true);
   ir->get_term_vector = &mr_get_term_vector;
   ir->get_term_vectors = &mr_get_term_vectors;
   ir->num_docs = &mr_num_docs;
@@ -1888,11 +1937,8 @@ IndexReader *mr_open(Store *store,
  *
  ****************************************************************************/
 
-bool smi_lt(void *p1, void *p2)
+bool smi_lt(SegmentMergeInfo *smi1, SegmentMergeInfo *smi2)
 {
-  SegmentMergeInfo *smi1 = (SegmentMergeInfo *)p1;
-  SegmentMergeInfo *smi2 = (SegmentMergeInfo *)p2;
-
   int cmpres = tb_cmp(smi1->tb, smi2->tb);
   if (cmpres == 0) {
     return smi1->base < smi2->base;
@@ -1906,8 +1952,9 @@ int *smi_load_doc_map(SegmentMergeInfo *smi)
   IndexReader *ir = smi->ir;
   if (ir->has_deletions(ir) && (smi->doc_map == NULL)) {
     int max_doc = ir->max_doc(ir);
-    smi->doc_map = ALLOC_N(int, max_doc);
     int j = 0, i;
+
+    smi->doc_map = ALLOC_N(int, max_doc);
     for (i = 0; i < max_doc; i++) {
       if (ir->is_deleted(ir, i)) {
         smi->doc_map[i] = -1;
@@ -1931,9 +1978,8 @@ SegmentMergeInfo *smi_create(int base, TermEnum *te, IndexReader *ir)
   return smi;
 }
 
-void smi_destroy(void *p)
+void smi_destroy(SegmentMergeInfo *smi)
 {
-  SegmentMergeInfo *smi = (SegmentMergeInfo *)p;
   smi->postings->close(smi->postings);
   smi->te->close(smi->te);
   if (smi->doc_map != NULL)
@@ -1957,7 +2003,7 @@ SegmentMerger *sm_create(Store *store, char *name, int term_index_interval)
   SegmentMerger *sm = ALLOC(SegmentMerger);
   sm->store = store;
   sm->name = estrdup(name);
-  sm->readers = ary_create(config.merge_factor, &ir_destroy);
+  sm->readers = ary_create(config.merge_factor, (free_ft)&ir_close);
   sm->fis = NULL;
   sm->freq_out = NULL;
   sm->prox_out = NULL;
@@ -1976,8 +2022,9 @@ void sm_close(SegmentMerger *sm)
   if (sm->freq_out != NULL) os_close(sm->freq_out);
   if (sm->prox_out != NULL) os_close(sm->prox_out);
   if (sm->tiw != NULL) {
-    for (i = 0; i < sm->terms_buf_size; i++)
+    for (i = 0; i < sm->terms_buf_size; i++) {
       free(sm->terms_buf[i].text);
+    }
     free(sm->terms_buf);
     tiw_close(sm->tiw);
   }
@@ -1988,9 +2035,8 @@ void sm_close(SegmentMerger *sm)
   sm->queue = NULL;
 }
 
-void sm_destroy(void *p)
+void sm_destroy(SegmentMerger *sm)
 {
-  SegmentMerger *sm = (SegmentMerger *)p;
   if (sm->fis != NULL) fis_destroy(sm->fis);
   ary_destroy(sm->readers);
   sm_close(sm);
@@ -2028,6 +2074,8 @@ int sm_merge_fields(SegmentMerger *sm)
   FieldInfos *fis = sm->fis = fis_create();
   int doc_count = 0;
   Document *doc;
+  FieldsWriter *fw;
+  
   for (i = 0; i < sm->readers->size; i++) {
     IndexReader *ir = sm->readers->elems[i];
     
@@ -2049,15 +2097,15 @@ int sm_merge_fields(SegmentMerger *sm)
   }
   fis_write(fis, sm->store, sm->name, ".fnm");
 
-  // merge field values
-  FieldsWriter *fw = fw_open(sm->store, sm->name, fis);
+  /* merge field values */
+  fw = fw_open(sm->store, sm->name, fis);
 
   TRY
     for (i = 0; i < sm->readers->size; i++) {
       IndexReader *ir = sm->readers->elems[i];
       maxdoc = ir->max_doc(ir);
       for (j = 0; j < maxdoc; j++) {
-        if (!ir->is_deleted(ir, j)) { // skip deleted docs
+        if (!ir->is_deleted(ir, j)) { /* skip deleted docs */
           doc = ir->get_doc(ir, j);
           fw_add_doc(fw, doc);
           doc_destroy(doc);
@@ -2098,7 +2146,7 @@ int sm_append_postings(SegmentMerger *sm, SegmentMergeInfo **smis, int cnt)
   int i, j;
   int last_doc = 0, base, doc, doc_code, freq, last_position, position;
   int *doc_map = NULL;
-  int df = 0;            // number of docs w/ term
+  int df = 0;            /* number of docs w/ term */
   TermDocEnum *postings;
   SegmentMergeInfo *smi;
   sm_reset_skip(sm);
@@ -2111,31 +2159,34 @@ int sm_append_postings(SegmentMerger *sm, SegmentMergeInfo **smis, int cnt)
     stde_seek_ti(postings, smi->te->ti_curr);
     while (postings->next(postings)) {
       doc = postings->doc_num(postings);
-      if (doc_map != NULL) 
-        doc = doc_map[doc]; // work around deletions
-      doc += base;          // convert to merged space
+      if (doc_map != NULL) {
+        doc = doc_map[doc]; /* work around deletions */
+      }
+      doc += base;          /* convert to merged space */
 
-      if (doc < last_doc)
+      if (doc < last_doc) {
         RAISE(STATE_ERROR, DOC_ORDER_ERROR_MSG);
+      }
 
       df++;
 
-      if ((df % sm->skip_interval) == 0) 
+      if ((df % sm->skip_interval) == 0) {
         sm_buffer_skip(sm, last_doc);
+      }
 
-      doc_code = (doc - last_doc) << 1;    // use low bit to flag freq=1
+      doc_code = (doc - last_doc) << 1;    /* use low bit to flag freq=1 */
       last_doc = doc;
 
       freq = postings->freq(postings);
       if (freq == 1) {
-        os_write_vint(sm->freq_out, doc_code | 1); // write doc & freq=1
+        os_write_vint(sm->freq_out, doc_code | 1); /* write doc & freq=1 */
       } else {
-        os_write_vint(sm->freq_out, doc_code); // write doc
-        os_write_vint(sm->freq_out, freq);     // write freqency in doc
+        os_write_vint(sm->freq_out, doc_code); /* write doc */
+        os_write_vint(sm->freq_out, freq);     /* write freqency in doc */
       }
         
 
-      last_position = 0;        // write position deltas
+      last_position = 0;        /* write position deltas */
       for (j = 0; j < freq; j++) {
         position = postings->next_position(postings);
         os_write_vint(sm->prox_out, position - last_position);
@@ -2167,12 +2218,12 @@ void sm_merge_term_info(SegmentMerger *sm, SegmentMergeInfo **smis, int cnt)
   int freq_pointer = os_pos(sm->freq_out);
   int prox_pointer = os_pos(sm->prox_out);
 
-  int df = sm_append_postings(sm, smis, cnt);      // append posting data
+  int df = sm_append_postings(sm, smis, cnt);      /* append posting data */
 
   int skip_pointer = sm_write_skip(sm);
 
   if (df > 0) {
-    // add an entry to the dictionary with pointers to prox and freq files
+    /* add an entry to the dictionary with pointers to prox and freq files */
     ti_set(sm->ti, df, freq_pointer, prox_pointer, (skip_pointer - freq_pointer));
     tiw_add(sm->tiw, sm_tb_to_term(sm, smis[0]->tb), sm->ti);
   }
@@ -2184,7 +2235,7 @@ void sm_merge_term_infos(SegmentMerger *sm)
   int i, match_size;
   IndexReader *ir;
   TermEnum *te;
-  SegmentMergeInfo *smi, *top;
+  SegmentMergeInfo *smi, *top, **match;
   TermBuffer *tb;
 
   for (i = 0; i < sm->readers->size; i++) {
@@ -2192,20 +2243,23 @@ void sm_merge_term_infos(SegmentMerger *sm)
     te = ir->terms(ir);
     smi = smi_create(base, te, ir);
     base += ir->num_docs(ir);
-    if (smi_next(smi) != NULL)
-      pq_push(sm->queue, smi); // initialize @queue
-    else
+    if (smi_next(smi) != NULL) {
+      pq_push(sm->queue, smi); /* initialize @queue */
+    } else {
       smi_destroy(smi);
+    }
   }
 
-  SegmentMergeInfo **match = ALLOC_N(SegmentMergeInfo *, sm->readers->size);
+  match = ALLOC_N(SegmentMergeInfo *, sm->readers->size);
 
   while (sm->queue->count > 0) {
-    //  for (i = 1; i <= sm->queue->count; i++) {
-    //    printf("<{%s:%s}>", ((SegmentMergeInfo *)sm->queue->heap[i])->tb->field,
-    //                        ((SegmentMergeInfo *)sm->queue->heap[i])->tb->text);
-    //  }printf("\n\n");
-    match_size = 0;     // pop matching terms
+    /*
+    for (i = 1; i <= sm->queue->count; i++) {
+      printf("<{%s:%s}>", ((SegmentMergeInfo *)sm->queue->heap[i])->tb->field,
+                          ((SegmentMergeInfo *)sm->queue->heap[i])->tb->text);
+    }printf("\n\n");
+    */
+    match_size = 0;     /* pop matching terms */
     match[match_size] = pq_pop(sm->queue);
     match_size++;
     tb = match[0]->tb;
@@ -2216,16 +2270,17 @@ void sm_merge_term_infos(SegmentMerger *sm)
       top = pq_top(sm->queue);
     }
 
-    //printf(">%s:%s<\n", match[0]->tb->field, match[0]->tb->text);
-    sm_merge_term_info(sm, match, match_size);      // add new TermInfo
+    /* printf(">%s:%s<\n", match[0]->tb->field, match[0]->tb->text); */
+    sm_merge_term_info(sm, match, match_size);      /* add new TermInfo */
 
     while (match_size > 0) {
       match_size--;
       smi = match[match_size];
-      if (smi_next(smi) != NULL)
-        pq_push(sm->queue, smi); // restore queue
-      else
-        smi_destroy(smi);      // done with a segment
+      if (smi_next(smi) != NULL) {
+        pq_push(sm->queue, smi); /* restore queue */
+      } else {
+        smi_destroy(smi);        /* done with a segment */
+      }
     }
   }
   free(match);
@@ -2242,10 +2297,10 @@ void sm_merge_terms(SegmentMerger *sm)
     sprintf(fname, "%s.prx", sm->name);
     sm->prox_out = sm->store->create_output(sm->store, fname);
     sm->tiw = tiw_open(sm->store, sm->name, sm->fis, sm->term_index_interval);
-    // terms_buf_pointer holds a buffer of terms since the TermInfosWriter needs
-    // to keep the last index_interval terms so that it can compare the last term
-    // put in the index with the next one. So the size of the buffer must by 
-    // index_interval + 2.
+    /* terms_buf_pointer holds a buffer of terms since the TermInfosWriter needs
+     * to keep the last index_interval terms so that it can compare the last term
+     * put in the index with the next one. So the size of the buffer must by 
+     * index_interval + 2. */
     sm->terms_buf_pointer = 0;
     sm->terms_buf_size = sm->tiw->index_interval + 2;
     sm->terms_buf = ALLOC_N(Term, sm->terms_buf_size);
@@ -2254,7 +2309,7 @@ void sm_merge_terms(SegmentMerger *sm)
       sm->terms_buf[i].text = ALLOC_N(char, MAX_WORD_SIZE);
     }
     sm->skip_interval = sm->tiw->skip_interval;
-    sm->queue = pq_create(sm->readers->size, &smi_lt);
+    sm->queue = pq_create(sm->readers->size, (lt_ft)&smi_lt);
 
     sm_merge_term_infos(sm);
 
@@ -2308,11 +2363,13 @@ void sm_merge_vectors(SegmentMerger *sm)
       ir = sm->readers->elems[i];
       max_doc = ir->max_doc(ir);
       for (j = 0; j < max_doc; j++) {
-        // skip deleted docs
+        /* skip deleted docs */
         if (! ir->is_deleted(ir, j)) {
           tvs = ir->get_term_vectors(ir, j);
-          tvw_add_all_doc_vectors(tvw, tvs);
-          ary_destroy(tvs);
+          if (tvs) {
+            tvw_add_all_doc_vectors(tvw, tvs);
+            ary_destroy(tvs);
+          }
         }
       }
     }
@@ -2333,7 +2390,7 @@ int sm_merge(SegmentMerger *sm)
 
 Array *sm_create_compound_file(SegmentMerger *sm, char *file_name)
 {
-  Array *files = ary_create(0, &efree);
+  Array *files = ary_create(0, &free);
   CompoundWriter *cw = open_cw(sm->store, file_name);
   FieldInfo *fi;
   char fname[SEGMENT_NAME_MAX_LENGTH];
@@ -2344,7 +2401,7 @@ Array *sm_create_compound_file(SegmentMerger *sm, char *file_name)
     ary_append(files, estrdup(fname));
   }
 
-  // Field norm files
+  /* Field norm files */
   for (i = 0; i < sm->fis->fcnt; i++) {
     fi = sm->fis->by_number[i];
     if (fi->is_indexed && !fi->omit_norms) {
@@ -2353,7 +2410,7 @@ Array *sm_create_compound_file(SegmentMerger *sm, char *file_name)
     }
   }
 
-  // Vector files
+  /* Vector files */
   if (fis_has_vectors(sm->fis)) {
     for (i = 0; i < NELEMS(VECTOR_EXTENSIONS); i++) {
       sprintf(fname, "%s.%s", sm->name, VECTOR_EXTENSIONS[i]);
@@ -2361,12 +2418,12 @@ Array *sm_create_compound_file(SegmentMerger *sm, char *file_name)
     }
   }
 
-  // Now merge all added files
+  /* Now merge all added files */
   for (i = 0; i < files->size; i++) {
     cw_add_file(cw, (char *)files->elems[i]);
   }
   
-  // Perform the merge
+  /* Perform the merge */
   cw_close(cw);
  
   return files;
@@ -2386,11 +2443,11 @@ void ir_acquire_write_lock(IndexReader *ir)
 
   if (ir->write_lock == NULL) {
     ir->write_lock = ir->store->open_lock(ir->store, WRITE_LOCK_NAME);
-    if (!ir->write_lock->obtain(ir->write_lock)) // obtain write lock
+    if (!ir->write_lock->obtain(ir->write_lock)) /* obtain write lock */
       RAISE(STATE_ERROR, WRITE_LOCK_ERROR_MSG);
 
-    // we have to check whether index has changed since this reader was opened.
-    // if so, this reader is no longer valid for deletion
+    /* we have to check whether index has changed since this reader was opened.
+     * if so, this reader is no longer valid for deletion */
     if (sis_read_current_version(ir->store) > ir->sis->version) {
       ir->is_stale = true;
       ir->write_lock->release(ir->write_lock);
@@ -2401,7 +2458,7 @@ void ir_acquire_write_lock(IndexReader *ir)
   }
 }
 
-IndexReader *ir_create(Store *store, SegmentInfos *sis, int is_owner, int close_store)
+IndexReader *ir_create(Store *store, SegmentInfos *sis, int is_owner)
 {
   IndexReader *ir = ALLOC(IndexReader);
 
@@ -2414,7 +2471,6 @@ IndexReader *ir_create(Store *store, SegmentInfos *sis, int is_owner, int close_
   }
 
   ir->store = store;
-  ir->close_store = close_store;
   ir->sis = sis;
   ir->has_changes = false;
   ir->is_stale = false;
@@ -2424,7 +2480,11 @@ IndexReader *ir_create(Store *store, SegmentInfos *sis, int is_owner, int close_
   return ir;
 }
 
-IndexReader *ir_open(Store *store, int close_store)
+/**
+ * Will keep a reference to the store. To let this method delete the store
+ * make sure you deref the store that you pass to it
+ */
+IndexReader *ir_open(Store *store)
 {
   int i;
   IndexReader *ir;
@@ -2434,13 +2494,14 @@ IndexReader *ir_open(Store *store, int close_store)
   sis = sis_create();
   sis_read(sis, store);
   if (sis->scnt == 1) {
-    ir = sr_open(sis, 0, true, close_store);
+    ir = sr_open(sis, 0, true);
   } else {
     IndexReader **readers = ALLOC_N(IndexReader *, sis->scnt);
     for (i = 0; i < sis->scnt; i++) {
-      readers[i] = sr_open(sis, i, false, false);
+      readers[i] = sr_open(sis, i, false);
     }
-    ir = mr_open(store, sis, readers, sis->scnt, close_store);
+    ref(store);
+    ir = mr_open(store, sis, readers, sis->scnt);
   }
   mutex_unlock(&store->mutex);
   return ir;
@@ -2481,11 +2542,13 @@ void ir_delete_doc(IndexReader *ir, int doc_num)
 Document *ir_get_doc_with_term(IndexReader *ir, Term *term)
 {
   TermDocEnum *tde = ir_term_docs_for(ir, term);
+  Document *doc = NULL;
+
   if (!tde) return NULL;
 
-  Document *doc = NULL;
-  if (tde->next(tde))
+  if (tde->next(tde)) {
     doc = ir->get_doc(ir, tde->doc_num(tde));
+  }
   tde->close(tde);
   return doc;
 }
@@ -2508,11 +2571,13 @@ void ir_commit_internal(IndexReader *ir)
 {
   if (ir->has_changes) {
     if (ir->is_owner) {
+      Lock *commit_lock;
 
       mutex_lock(&ir->store->mutex);
-      Lock *commit_lock = ir->store->open_lock(ir->store, COMMIT_LOCK_NAME);
-      if (!commit_lock->obtain(commit_lock)) // obtain write lock
+      commit_lock = ir->store->open_lock(ir->store, COMMIT_LOCK_NAME);
+      if (!commit_lock->obtain(commit_lock)) { /* obtain write lock */
         RAISE(STATE_ERROR, COMMIT_LOCK_ERROR_MSG);
+      }
 
       ir->do_commit(ir);
       sis_write(ir->sis, ir->store);
@@ -2522,7 +2587,7 @@ void ir_commit_internal(IndexReader *ir)
       mutex_unlock(&ir->store->mutex);
 
       if (ir->write_lock != NULL) {
-        ir->write_lock->release(ir->write_lock);  // release write lock
+        ir->write_lock->release(ir->write_lock);  /* release write lock */
         ir->store->close_lock(ir->write_lock);
         ir->write_lock = NULL;
       }
@@ -2545,9 +2610,7 @@ void ir_close(IndexReader *ir)
   mutex_lock(&ir->mutex);
   ir_commit_internal(ir);
   ir->do_close(ir);
-  if (ir->close_store) {
-    ir->store->close(ir->store);
-  }
+  store_deref(ir->store);
   if (ir->is_owner) {
     sis_destroy(ir->sis);
   }
@@ -2562,12 +2625,6 @@ void ir_close(IndexReader *ir)
   free(ir);
 }
 
-void ir_destroy(void *p)
-{
-  IndexReader *ir = (IndexReader *)p;
-  ir_close(ir);
-}
-
 /**
  * Don't call this method if the cache already exists
  **/