ferret 0.9.0 → 0.9.1

data/ext/index.h

@@ -11,6 +11,8 @@
 #include "store.h"
 #include "document.h"
 #include "analysis.h"
+#include "similarity.h"
+
 
 #define SEGMENT_NAME_MAX_LENGTH 100
 
@@ -112,26 +114,6 @@ FieldInfos *fis_add_doc(FieldInfos *fis, Document *doc);
 unsigned long long fis_get_number(FieldInfos *fis, char *name);
 FieldInfo *fis_get_fi(FieldInfos *fis, char *name);
 
-
-/****************************************************************************
- *
- * Term
- *
- ****************************************************************************/
-
-typedef struct Term {
-  char *field;
-  char *text;
-} Term;
-
-Term *term_clone(Term *term);
-Term *term_create(const char *field, char *text);
-void term_destroy(void *p);
-int term_cmp(void *t1, void *t2);
-int term_eq(const void *t1, const void *t2);
-unsigned int term_hash(const void *t);
-char *term_to_s(Term *term);
-
 /****************************************************************************
  *
  * TermBuffer
@@ -566,8 +548,6 @@ void p_add_occurance(Posting *p, int position, TVOffsetInfo *offset);
  *
  ****************************************************************************/
 
-#include "search.h"
-
 typedef struct DocumentWriter {
   Store *store;
   Analyzer *analyzer;

data/ext/index_io.c

@@ -1,6 +1,8 @@
 #include <store.h>
 #include <string.h>
 
+static char * const STORE_EOF_ERROR_MSG = "EOF Error when trying to refill";
+
 Buffer *buf_create()
 {
   Buffer *buf = ALLOC(Buffer);
@@ -102,7 +104,7 @@ void is_refill(InStream *is)
 
   is->buf.len = last - start;
   if (is->buf.len <= 0) {
-    eprintf(IO_ERROR, "EOF Error when trying to refill. flen was %d\n", flen);
+    RAISE(EOF_ERROR, STORE_EOF_ERROR_MSG);
   }
 
   is->read_internal(is, is->buf.buf, 0, is->buf.len);
@@ -166,16 +168,6 @@ InStream *is_clone(InStream *is)
 {
   InStream *new_index_i = ALLOC(InStream);
   memcpy(new_index_i, is, sizeof(InStream));
-  //new_index_i->buf.start = is->buf.start;
-  //new_index_i->buf.pos = is->buf.pos;
-  //new_index_i->buf.len = is->buf.len;
-  //new_index_i->file = is->file;
-  //new_index_i->d = is->d;
-  //new_index_i->read_internal = is->read_internal;
-  //new_index_i->seek_internal = is->seek_internal;
-  //new_index_i->length_internal = is->length_internal;
-  //new_index_i->clone_internal = is->clone_internal;
-  //new_index_i->close_internal = is->close_internal;
   new_index_i->is_clone = true;
   is->clone_internal(is, new_index_i);
   return new_index_i;

data/ext/index_rw.c

@@ -2,6 +2,13 @@
 #include <stdlib.h>
 #include <string.h>
 #include <array.h>
+static char * const FORMAT_VERSION_ERROR_MSG = "Unknown format version";
+static char * const WRITE_LOCK_ERROR_MSG = "Could not obtain write lock when trying to write index";
+static char * const COMMIT_LOCK_ERROR_MSG = "Could not obtain commit lock when trying to write index";
+static char * const DELETED_DOC_ERROR_MSG = "Tried to get doc that has already been deleted";
+static char * const INVALID_FIELD_TYPE_MSG = "Invalid field-type";
+static char * const DOC_ORDER_ERROR_MSG = "docs out of order curent";
+static char * const STALE_READER_ERROR_MSG = "IndexReader out of date and no longer valid for delete, undelete, or set_norm operations";
 
 const char *INDEX_EXTENSIONS[] = {
     "cfs", "fnm", "fdx", "fdt", "tii", "tis", "frq", "prx", "del",
@@ -260,81 +267,84 @@ Posting **dw_sort_posting_table(DocumentWriter *dw)
 
 void dw_write_postings(DocumentWriter *dw, Posting **postings, char *segment)
 {
-  OutStream *freq_out, *prox_out;
-  TermInfosWriter *tiw;
-  TermVectorsWriter *tvw = NULL;
-  FieldInfo *fi;
+  OutStream * volatile freq_out = NULL, * volatile prox_out = NULL;
+  TermInfosWriter * volatile tiw = NULL;
+  TermVectorsWriter * volatile tvw = NULL;
   Store *store = dw->store;
-  TermInfo *ti;
+  TermInfo * volatile ti = NULL;
   Posting *posting;
   int i, j, posting_freq, position, last_position;
   char fname[SEGMENT_NAME_MAX_LENGTH], *curr_field = NULL, *term_field;
   strcpy(fname, segment);
 
-  //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);
-  ti = ti_create(0, 0, 0, 0);
-
-  for (i = 0; i < dw->pcnt; i++) {
-    posting = postings[i];
-
-    // add an entry to the 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
-    posting_freq = posting->freq;
-    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
-    }
+  TRY
+    //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);
+    ti = ti_create(0, 0, 0, 0);
+
+    for (i = 0; i < dw->pcnt; i++) {
+      posting = postings[i];
+
+      // add an entry to the 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
+      posting_freq = posting->freq;
+      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
+      }
 
-    last_position = 0;               // write positions
+      last_position = 0;               // write positions
 
-    for (j = 0; j < posting_freq; j++) {
-      position = posting->positions[j];
-      os_write_vint(prox_out, position - last_position);
-      last_position = position;
-    }
+      for (j = 0; j < posting_freq; j++) {
+        position = posting->positions[j];
+        os_write_vint(prox_out, position - last_position);
+        last_position = position;
+      }
 
-    // check to see if we switched to a new field
-    term_field = posting->term->field;
-    if (curr_field != term_field)  {
-      // changing field - see if there is something to save
-      curr_field = term_field;
-      fi = (FieldInfo *)ht_get(dw->fis->by_name, curr_field);
-      if (fi->store_tv) {
-        if (tvw == NULL) {
-          tvw = tvw_open(store, segment, dw->fis);
-          tvw_open_doc(tvw);
-        }
-        tvw_open_field(tvw, curr_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
+        curr_field = term_field;
+        fi = (FieldInfo *)ht_get(dw->fis->by_name, curr_field);
+        if (fi->store_tv) {
+          if (tvw == NULL) {
+            tvw = tvw_open(store, segment, dw->fis);
+            tvw_open_doc(tvw);
+          }
+          tvw_open_field(tvw, curr_field);
 
-      } else if (tvw != NULL) {
-        tvw_close_field(tvw);
+        } else if (tvw != NULL) {
+          tvw_close_field(tvw);
+        }
+      }
+      // 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);
       }
     }
-    // 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);
+  XFINALLY
+    if (tvw) {
+      tvw_close_doc(tvw);
+      tvw_close(tvw);
     }
-  }
-  if (tvw != NULL) {
-    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
-  os_close(freq_out);
-  os_close(prox_out);
-  tiw_close(tiw);
-  ti_destroy(ti);
+    // 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);
+    if (ti) ti_destroy(ti);
+  XENDTRY
 }
 
 void dw_write_norms(DocumentWriter *dw, char *segment)
@@ -353,8 +363,11 @@ void dw_write_norms(DocumentWriter *dw, char *segment)
       norm = dw->field_boosts[i] * sim_length_norm(dw->similarity, fi->name, dw->field_lengths[i]);
       sprintf(fname, "%s.f%d", segment, i);
       norms_out = dw->store->create_output(dw->store, fname);
-      os_write_byte(norms_out, sim_encode_norm(dw->similarity, norm));
-      os_close(norms_out);
+      TRY
+        os_write_byte(norms_out, sim_encode_norm(dw->similarity, norm));
+      XFINALLY
+        os_close(norms_out);
+      XENDTRY
     }
   }
 }
@@ -369,8 +382,11 @@ void dw_add_doc(DocumentWriter *dw, char *segment, Document *doc)
 
   // write field values
   FieldsWriter *fw = fw_open(dw->store, segment, dw->fis);
-  fw_add_doc(fw, doc);
-  fw_close(fw);
+  TRY
+    fw_add_doc(fw, doc);
+  XFINALLY
+    fw_close(fw);
+  XENDTRY
 
   // invert doc into posting_table
   h_clear(dw->postingtable);        // clear posting_table
@@ -547,34 +563,38 @@ void sis_read(SegmentInfos *sis, Store *store)
   int doc_cnt;
   char *name;
   InStream *is = store->open_input(store, SEGMENT_FILENAME);
-  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 < FORMAT)
-      eprintf(ERROR, "Unknown format version: %ld", sis->format);
-    sis->version = is_read_long(is);
-    sis->counter = 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;
-  for (i = 0; i < seg_count; i++) {
-    name = is_read_string(is);
-    doc_cnt = is_read_int(is);
-    sis_add_si(sis, si_create(name, doc_cnt, 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
-  }
-  is_close(is);
+  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 < 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
+      sis->counter = sis->format;
+    }
+      
+    int seg_count = is_read_int(is);
+    int i;
+    for (i = 0; i < seg_count; i++) {
+      name = is_read_string(is);
+      doc_cnt = is_read_int(is);
+      sis_add_si(sis, si_create(name, doc_cnt, 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
+    }
+  XFINALLY
+    is_close(is);
+  XENDTRY
 }
 
 void sis_write(SegmentInfos *sis, Store *store)
@@ -582,17 +602,20 @@ void sis_write(SegmentInfos *sis, Store *store)
   int i;
   SegmentInfo *si;
   OutStream *os = store->create_output(store, TEMPORARY_SEGMENT_FILENAME);
-  os_write_int(os, FORMAT);
-  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++) {
-    si = sis->segs[i];
-    os_write_string(os, si->name);
-    os_write_int(os, si->doc_cnt);
-  }
+  TRY
+    os_write_int(os, FORMAT);
+    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++) {
+      si = sis->segs[i];
+      os_write_string(os, si->name);
+      os_write_int(os, si->doc_cnt);
+    }
   
-  os_close(os);
+  XFINALLY
+    os_close(os);
+  XENDTRY
 
   //install new segment info
   store->rename(store, TEMPORARY_SEGMENT_FILENAME, SEGMENT_FILENAME);
@@ -605,13 +628,17 @@ int sis_read_current_version(Store *store)
   InStream *is = store->open_input(store, SEGMENT_FILENAME);
   int format = 0;
   int version = 0;
-  format = is_read_int(is);
-  if (format < 0) {
-    if (format < FORMAT) 
-      eprintf(ERROR, "Unknown format version: %ld", format);
-    version = is_read_long(is);
-  }
-  is_close(is);
+
+  TRY
+    format = is_read_int(is);
+    if (format < 0) {
+      if (format < FORMAT) 
+        RAISE(ERROR, FORMAT_VERSION_ERROR_MSG);
+      version = is_read_long(is);
+    }
+  XFINALLY
+    is_close(is);
+  XENDTRY
    
   if (format < 0)
     return version;
@@ -658,22 +685,23 @@ IndexWriter *iw_open(Store *store, Analyzer *analyzer,
   // 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)) {
-    eprintf(STATE_ERROR,
-        "Could not obtain write lock when trying to write index");
+    RAISE(STATE_ERROR, WRITE_LOCK_ERROR_MSG);
   }
 
   if (create) {
     Lock *commit_lock = store->open_lock(store, COMMIT_LOCK_NAME);
     if (!commit_lock->obtain(commit_lock)) {
-      eprintf(STATE_ERROR,
-          "Could not obtain commit lock when trying to commit index");
+      store->close_lock(commit_lock);
+      RAISE(STATE_ERROR, COMMIT_LOCK_ERROR_MSG);
     }
-    // commit the index
-    store->clear(store);
-    sis_write(iw->sis, store);
-    //
-    commit_lock->release(commit_lock);
-    store->close_lock(commit_lock);
+    TRY
+      // commit the index
+      store->clear(store);
+      sis_write(iw->sis, store);
+    XFINALLY
+      commit_lock->release(commit_lock);
+      store->close_lock(commit_lock);
+    XENDTRY
   } else {
     sis_read(iw->sis, store);
   }
@@ -743,8 +771,7 @@ void make_compound_file(IndexWriter *iw, char *merged_name, SegmentMerger *merge
   Lock *commit_lock = iw->store->open_lock(iw->store, COMMIT_LOCK_NAME);
 
   if (!commit_lock->obtain(commit_lock)) {
-    eprintf(STATE_ERROR,
-        "Could not obtain commit lock when  trying to commit index");
+    RAISE(STATE_ERROR, COMMIT_LOCK_ERROR_MSG);
   }
 
   // make compound file visible for SegmentReaders
@@ -789,8 +816,7 @@ void iw_merge_segments_with_max(IndexWriter *iw, int min_segment, int max_segmen
   mutex_lock(&iw->store->mutex);
   Lock *commit_lock = iw->store->open_lock(iw->store, COMMIT_LOCK_NAME);
   if (!commit_lock->obtain(commit_lock)) {
-    eprintf(STATE_ERROR,
-        "Could not obtain commit lock when trying to commit index");
+    RAISE(STATE_ERROR, COMMIT_LOCK_ERROR_MSG);
   }
   // commit the index
   sis_write(iw->sis, iw->store);
@@ -998,7 +1024,7 @@ void iw_add_readers(IndexWriter *iw, IndexReader **irs, int cnt)
 
   Lock *commit_lock = iw->store->open_lock(iw->store, COMMIT_LOCK_NAME);
   if (!commit_lock->obtain(commit_lock)) // obtain write lock
-    eprintf(STATE_ERROR, "Index locked for commit: %s", COMMIT_LOCK_NAME);
+    RAISE(STATE_ERROR, COMMIT_LOCK_ERROR_MSG);
 
   sis_write(iw->sis, iw->store); // commit changes
   iw_delete_segments(iw, &ir, del_cnt);
@@ -1051,8 +1077,11 @@ void norm_rewrite(Norm *norm, Store *store, char *segment,
   char norm_fname[SEGMENT_NAME_MAX_LENGTH];
   sprintf(tmp_fname, "%s.tmp", segment);
   OutStream *os = store->create_output(store, tmp_fname);
-  os_write_bytes(os, norm->bytes, doc_count);
-  os_close(os);
+  TRY
+    os_write_bytes(os, norm->bytes, doc_count);
+  XFINALLY
+    os_close(os);
+  XENDTRY
   if (cfs_store) {
     sprintf(norm_fname, "%s.s%d", segment, norm->field_num);
   } else {
@@ -1190,8 +1219,7 @@ Document *sr_get_doc(IndexReader *ir, int doc_num)
   mutex_lock(&ir->mutex);
   if (sr_is_deleted_internal(ir, doc_num)) {
     mutex_unlock(&ir->mutex);
-    eprintf(STATE_ERROR,
-        "Tried to get doc <%ld> that has already been deleted", doc_num);
+    RAISE(STATE_ERROR, DELETED_DOC_ERROR_MSG);
   }
   GET_SR;
   doc = fr_get_doc(sr->fr, doc_num);
@@ -1359,7 +1387,7 @@ HashSet *sr_get_field_names(IndexReader *ir, int field_type)
         if (fi->store_pos && fi->store_offset) hs_add(field_set, fi->name);
         break;
       default:
-        eprintf(ARG_ERROR, "Invalid field_type <%ld>.", field_type);
+        RAISE(ARG_ERROR, INVALID_FIELD_TYPE_MSG);
     }
   }
   return field_set;
@@ -1500,6 +1528,7 @@ IndexReader *sr_open_internal(IndexReader *ir, SegmentInfo *si)
   }
 
   sprintf(fname, "%s.fnm", sr->segment);
+  
   sr->fis = fis_open(store, fname);
   sr->fr = fr_open(store, sr->segment, sr->fis);
 
@@ -2023,19 +2052,22 @@ int sm_merge_fields(SegmentMerger *sm)
   // merge field values
   FieldsWriter *fw = fw_open(sm->store, sm->name, fis);
 
-  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
-        doc = ir->get_doc(ir, j);
-        fw_add_doc(fw, doc);
-        doc_destroy(doc);
-        doc_count++;
+  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
+          doc = ir->get_doc(ir, j);
+          fw_add_doc(fw, doc);
+          doc_destroy(doc);
+          doc_count++;
+        }
       }
     }
-  }
-  fw_close(fw);
+  XFINALLY
+    fw_close(fw);
+  XENDTRY
   return doc_count;
 }
 
@@ -2084,9 +2116,7 @@ int sm_append_postings(SegmentMerger *sm, SegmentMergeInfo **smis, int cnt)
       doc += base;          // convert to merged space
 
       if (doc < last_doc)
-        eprintf(STATE_ERROR,
-            "docs out of order curent doc = %ld and previous doc = %ld",
-            doc, last_doc);
+        RAISE(STATE_ERROR, DOC_ORDER_ERROR_MSG);
 
       df++;
 
@@ -2205,28 +2235,32 @@ void sm_merge_terms(SegmentMerger *sm)
 {
   int i;
   char fname[SEGMENT_NAME_MAX_LENGTH];
-  sprintf(fname, "%s.frq", sm->name);
-  sm->freq_out = sm->store->create_output(sm->store, fname);
-  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.
-  sm->terms_buf_pointer = 0;
-  sm->terms_buf_size = sm->tiw->index_interval + 2;
-  sm->terms_buf = ALLOC_N(Term, sm->terms_buf_size);
-  for (i = 0; i < sm->terms_buf_size; i++) {
-    sm->terms_buf[i].field = NULL;
-    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_merge_term_infos(sm);
 
-  sm_close(sm);
+  TRY
+    sprintf(fname, "%s.frq", sm->name);
+    sm->freq_out = sm->store->create_output(sm->store, fname);
+    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.
+    sm->terms_buf_pointer = 0;
+    sm->terms_buf_size = sm->tiw->index_interval + 2;
+    sm->terms_buf = ALLOC_N(Term, sm->terms_buf_size);
+    for (i = 0; i < sm->terms_buf_size; i++) {
+      sm->terms_buf[i].field = NULL;
+      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_merge_term_infos(sm);
+
+  XFINALLY
+    sm_close(sm);
+  XENDTRY
 }
 
 void sm_merge_norms(SegmentMerger *sm)
@@ -2242,20 +2276,23 @@ void sm_merge_norms(SegmentMerger *sm)
     if (fi->is_indexed && !fi->omit_norms)  {
       sprintf(fname, "%s.f%d", sm->name, i);
       os = sm->store->create_output(sm->store, fname);
-      for (j = 0; j < sm->readers->size; j++) {
-        ir = sm->readers->elems[j];
-        max_doc = ir->max_doc(ir);
-        norm_buf = ALLOC_N(uchar, max_doc);
-        memset(norm_buf, 0, sizeof(uchar) * max_doc);
-        ir->get_norms_into(ir, fi->name, norm_buf, 0);
-        for (k = 0; k < max_doc; k++) {
-          if (!ir->is_deleted(ir, k)) {
-            os_write_byte(os, norm_buf[k]);
+      TRY
+        for (j = 0; j < sm->readers->size; j++) {
+          ir = sm->readers->elems[j];
+          max_doc = ir->max_doc(ir);
+          norm_buf = ALLOC_N(uchar, max_doc);
+          memset(norm_buf, 0, sizeof(uchar) * max_doc);
+          ir->get_norms_into(ir, fi->name, norm_buf, 0);
+          for (k = 0; k < max_doc; k++) {
+            if (!ir->is_deleted(ir, k)) {
+              os_write_byte(os, norm_buf[k]);
+            }
           }
+          free(norm_buf);
         }
-        free(norm_buf);
-      }
-      os_close(os);
+      XFINALLY
+        os_close(os);
+      XENDTRY
     }
   }
 }
@@ -2266,19 +2303,22 @@ void sm_merge_vectors(SegmentMerger *sm)
   TermVectorsWriter *tvw = tvw_open(sm->store, sm->name, sm->fis);
   IndexReader *ir;
   Array *tvs;
-  for (i = 0; i < sm->readers->size; i++) {
-    ir = sm->readers->elems[i];
-    max_doc = ir->max_doc(ir);
-    for (j = 0; j < max_doc; j++) {
-      // 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);
+  TRY
+    for (i = 0; i < sm->readers->size; i++) {
+      ir = sm->readers->elems[i];
+      max_doc = ir->max_doc(ir);
+      for (j = 0; j < max_doc; j++) {
+        // 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);
+        }
       }
     }
-  }
-  tvw_close(tvw);
+  XFINALLY
+    tvw_close(tvw);
+  XENDTRY
 }
 
 int sm_merge(SegmentMerger *sm)
@@ -2342,12 +2382,12 @@ void ir_acquire_not_necessary(IndexReader *ir) {}
 void ir_acquire_write_lock(IndexReader *ir)
 {
   if (ir->is_stale)
-    eprintf(STATE_ERROR, "IndexReader out of date and no longer valid for delete, undelete, or set_norm operations");
+    RAISE(STATE_ERROR, STALE_READER_ERROR_MSG);
 
   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
-      eprintf(STATE_ERROR, "Index locked for write: %s", WRITE_LOCK_NAME);
+      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
@@ -2356,7 +2396,7 @@ void ir_acquire_write_lock(IndexReader *ir)
       ir->write_lock->release(ir->write_lock);
       ir->store->close_lock(ir->write_lock);
       ir->write_lock = NULL;
-      eprintf(STATE_ERROR, "IndexReader out of date and no longer valid for delete, undelete, or set_norm operations");
+      RAISE(STATE_ERROR, STALE_READER_ERROR_MSG);
     }
   }
 }
@@ -2472,7 +2512,7 @@ void ir_commit_internal(IndexReader *ir)
       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
-        eprintf(STATE_ERROR, "Index locked for commit: %s", COMMIT_LOCK_NAME);
+        RAISE(STATE_ERROR, COMMIT_LOCK_ERROR_MSG);
 
       ir->do_commit(ir);
       sis_write(ir->sis, ir->store);
@@ -2538,6 +2578,18 @@ void ir_add_cache(IndexReader *ir)
 
 bool ir_is_latest(IndexReader *ir)
 {
-  return sis_read_current_version(ir->store) == ir->sis->version;
+  bool is_latest = false;
+  Lock *commit_lock = ir->store->open_lock(ir->store, COMMIT_LOCK_NAME);
+  if (!commit_lock->obtain(commit_lock)) {
+    ir->store->close_lock(commit_lock);
+    RAISE(STATE_ERROR, COMMIT_LOCK_ERROR_MSG);
+  }
+  TRY
+    is_latest = (sis_read_current_version(ir->store) == ir->sis->version);
+  XFINALLY
+    commit_lock->release(commit_lock);
+    ir->store->close_lock(commit_lock);
+  XENDTRY
+  return is_latest;
 }