ferret 0.9.1 → 0.9.2

data/ext/termdocs.c

@@ -1,4 +1,4 @@
-#include <index.h>
+#include "index.h"
 #include <string.h>
 
 static char * const TPE_VS_TDE_ERROR_MSG = "TermPosEnum does not handle processing multiple documents in one call. Use TermDocEnum instead.";
@@ -59,22 +59,24 @@ bool stde_next(TermDocEnum *tde)
   SegmentTermDocEnum *stde = (SegmentTermDocEnum *)tde->data;
   while (true) { 
 
-    if (stde->count >= stde->doc_freq)
+    if (stde->count >= stde->doc_freq) {
       return false;
+    }
 
-    doc_code = is_read_vint(stde->freq_in);
-    stde->doc_num += doc_code >> 1;    // shift off low bit
-    if ((doc_code & 1) != 0) {         // if low bit is set
-      stde->freq = 1;                  // freq is one
+    doc_code = (int)is_read_vint(stde->freq_in);
+    stde->doc_num += doc_code >> 1;    /* shift off low bit */
+    if ((doc_code & 1) != 0) {         /* if low bit is set */
+      stde->freq = 1;                  /* freq is one */
     } else {
-      stde->freq = is_read_vint(stde->freq_in); // else read freq
+      stde->freq = (int)is_read_vint(stde->freq_in); /* read freq */
     }
 
     stde->count++;
 
     if (stde->deleted_docs == NULL ||
-        bv_get(stde->deleted_docs, stde->doc_num) == 0)
-      break; // We found an undeleted doc so return
+        bv_get(stde->deleted_docs, stde->doc_num) == 0) {
+      break; /* We found an undeleted doc so return */
+    }
       
     stde->skip_prox(stde);
   }
@@ -90,41 +92,49 @@ int stde_freq(TermDocEnum *tde)
 bool stde_skip_to(TermDocEnum *tde, int target_doc_num)
 {
   SegmentTermDocEnum *stde = (SegmentTermDocEnum *)tde->data;
-  if (stde->doc_freq >= stde->skip_interval) { // optimized case
 
-    if (stde->skip_in == NULL)
-      stde->skip_in = is_clone(stde->freq_in); // lazily clone
+  if (stde->doc_freq >= stde->skip_interval) { /* optimized case */
+    int last_skip_doc;
+    int last_freq_pointer;
+    int last_prox_pointer;
+    int num_skipped;
+
+    if (stde->skip_in == NULL) {
+      stde->skip_in = is_clone(stde->freq_in); /* lazily clone */
+    }
 
-    if (!stde->have_skipped) {                 // lazily seek skip stream
+    if (!stde->have_skipped) {                 /* lazily seek skip stream */
       is_seek(stde->skip_in, stde->skip_pointer);
       stde->have_skipped = true;
     }
 
-    // scan skip data
-    int last_skip_doc = stde->skip_doc;
-    int last_freq_pointer = is_pos(stde->freq_in);
-    int last_prox_pointer = -1;
-    int num_skipped = -1 - (stde->count % stde->skip_interval);
+    /* scan skip data */
+    last_skip_doc = stde->skip_doc;
+    last_freq_pointer = is_pos(stde->freq_in);
+    last_prox_pointer = -1;
+    num_skipped = -1 - (stde->count % stde->skip_interval);
 
     while (target_doc_num > stde->skip_doc) {
       last_skip_doc = stde->skip_doc;
       last_freq_pointer = stde->freq_pointer;
       last_prox_pointer = stde->prox_pointer;
 
-      if (stde->skip_doc != 0 && stde->skip_doc >= stde->doc_num)
+      if (stde->skip_doc != 0 && stde->skip_doc >= stde->doc_num) {
         num_skipped += stde->skip_interval;
+      }
       
-      if(stde->skip_count >= stde->num_skips)
+      if(stde->skip_count >= stde->num_skips) {
         break;
+      }
 
-      stde->skip_doc += is_read_vint(stde->skip_in);
-      stde->freq_pointer += is_read_vint(stde->skip_in);
-      stde->prox_pointer += is_read_vint(stde->skip_in);
+      stde->skip_doc += (int)is_read_vint(stde->skip_in);
+      stde->freq_pointer += (int)is_read_vint(stde->skip_in);
+      stde->prox_pointer += (int)is_read_vint(stde->skip_in);
 
       stde->skip_count++;
     }
 
-    // if we found something to skip, so skip it
+    /* if we found something to skip, so skip it */
     if (last_freq_pointer > is_pos(stde->freq_in)) {
       is_seek(stde->freq_in, last_freq_pointer);
       stde->seek_prox(stde, last_prox_pointer);
@@ -134,7 +144,7 @@ bool stde_skip_to(TermDocEnum *tde, int target_doc_num)
     }
   }
 
-  // done skipping, now just scan
+  /* done skipping, now just scan */
   do { 
     if (! tde->next(tde)) {
       return false;
@@ -148,13 +158,14 @@ int stde_read(TermDocEnum *tde, int *docs, int *freqs, int req_num)
   SegmentTermDocEnum *stde = (SegmentTermDocEnum *)tde->data;
   int i = 0, doc_code;
   while (i < req_num && stde->count < stde->doc_freq) {
-    // manually inlined call to next() for speed
-    doc_code = is_read_vint(stde->freq_in);
-    stde->doc_num += doc_code >> 1;                 // shift off low bit
-    if ((doc_code & 1) != 0)                        // if low bit is set
-      stde->freq = 1;                               // freq is one
-    else
-      stde->freq = is_read_vint(stde->freq_in);   // else read freq
+    /* manually inlined call to next() for speed */
+    doc_code = (int)is_read_vint(stde->freq_in);
+    stde->doc_num += (doc_code >> 1);            /* shift off low bit */
+    if ((doc_code & 1) != 0) {                   /* if low bit is set */
+      stde->freq = 1;                            /* freq is one */
+    } else {
+      stde->freq = (int)is_read_vint(stde->freq_in);  /* else read freq */
+    }
 
     stde->count++;
 
@@ -170,6 +181,7 @@ int stde_read(TermDocEnum *tde, int *docs, int *freqs, int req_num)
 
 TermDocEnum *stde_create(IndexReader *ir)
 {
+  SegmentTermDocEnum *stde = ALLOC_AND_ZERO(SegmentTermDocEnum);
   SegmentReader *sr = (SegmentReader *)ir->data;
   TermDocEnum *tde = ALLOC(TermDocEnum);
   tde->seek = &stde_seek;
@@ -181,8 +193,6 @@ TermDocEnum *stde_create(IndexReader *ir)
   tde->next_position = NULL;
   tde->close = &stde_close;
 
-  SegmentTermDocEnum *stde = ALLOC(SegmentTermDocEnum);
-  ZEROSET(stde, SegmentTermDocEnum, 1); // set all values to 0
   tde->data = stde;
   stde->parent = sr;
   stde->freq_in = is_clone(sr->freq_in);
@@ -260,11 +270,12 @@ int stpe_next_position(TermDocEnum *tde)
 {
   SegmentTermDocEnum *stde = (SegmentTermDocEnum *)tde->data;
   stde->prox_cnt--;
-  return stde->position += is_read_vint(stde->prox_in);
+  return stde->position += (int)is_read_vint(stde->prox_in);
 }
 
 TermDocEnum *stpe_create(IndexReader *ir)
 {
+  SegmentTermDocEnum *stde;
   SegmentReader *sr = (SegmentReader *)ir->data;
   TermDocEnum *tde = stde_create(ir);
   tde->close = &stpe_close;
@@ -273,7 +284,7 @@ TermDocEnum *stpe_create(IndexReader *ir)
   tde->read = &stpe_read;
   tde->next_position = &stpe_next_position;
 
-  SegmentTermDocEnum *stde = (SegmentTermDocEnum *)tde->data;
+  stde = (SegmentTermDocEnum *)tde->data;
   stde->prox_in = is_clone(sr->prox_in);
   stde->prox_cnt = 0;
   stde->position = 0;
@@ -321,16 +332,18 @@ TermDocEnum *mtde_term_docs_from_reader(IndexReader *ir)
 
 TermDocEnum *mtde_term_docs(MultiTermDocEnum *mtde, int i)
 {
-  if (mtde->term == NULL)
+  if (mtde->term == NULL) {
     return NULL;
+  } else {
 
-  TermDocEnum *tde = mtde->irs_tde[i];
-  if (tde == NULL) {
-    tde = mtde->irs_tde[i] = mtde->term_docs_from_reader(mtde->irs[i]);
-  }
+    TermDocEnum *tde = mtde->irs_tde[i];
+    if (tde == NULL) {
+      tde = mtde->irs_tde[i] = mtde->term_docs_from_reader(mtde->irs[i]);
+    }
 
-  tde->seek(tde, mtde->term);
-  return tde;
+    tde->seek(tde, mtde->term);
+    return tde;
+  }
 }
 
 bool mtde_next(TermDocEnum *tde)
@@ -411,6 +424,7 @@ int mtde_read(TermDocEnum *tde, int *docs, int *freqs, int req_num)
 
 TermDocEnum *mtde_create(IndexReader **irs, int *starts, int ir_cnt)
 {
+  MultiTermDocEnum *mtde = ALLOC_AND_ZERO(MultiTermDocEnum);
   TermDocEnum *tde = ALLOC(TermDocEnum);
   tde->close = &mtde_close;
   tde->seek = &mtde_seek;
@@ -421,8 +435,6 @@ TermDocEnum *mtde_create(IndexReader **irs, int *starts, int ir_cnt)
   tde->read = &mtde_read;
   tde->next_position = NULL;
 
-  MultiTermDocEnum *mtde = ALLOC(MultiTermDocEnum);
-  ZEROSET(mtde, MultiTermDocEnum, 1); // set all values to 0
   tde->data = mtde;
   mtde->irs = irs;
   mtde->starts = starts;
@@ -467,8 +479,7 @@ TermDocEnum *mtpe_create(IndexReader **irs, int *starts, int ir_cnt)
  ****************************************************************************/
 
 #define GET_MTDPE MultipleTermDocPosEnum *mtdpe = (MultipleTermDocPosEnum *)self->data
-void tde_destroy(void *p) {
-  TermDocEnum *self = (TermDocEnum *)p;
+void tde_destroy(TermDocEnum *self) {
   self->close(self);
 }
 
@@ -570,12 +581,26 @@ int mtdpe_next_position(TermDocEnum *self)
 
 TermDocEnum *mtdpe_create(IndexReader *ir, Term **terms, int t_cnt)
 {
+  int i;
   TermDocEnum *self = ALLOC(TermDocEnum);
-  MultipleTermDocPosEnum *mtdpe = ALLOC(MultipleTermDocPosEnum);
+  MultipleTermDocPosEnum *mtdpe = ALLOC_AND_ZERO_N(MultipleTermDocPosEnum, 1);
   PriorityQueue *pq;
   TermDocEnum *tpe;
-  int i;
 
+  pq = mtdpe->pq = pq_create(t_cnt, &tdpe_less_than);
+  mtdpe->pos_queue_capa = MTDPE_POS_QUEUE_INIT_CAPA;
+  mtdpe->pos_queue = ALLOC_N(int, MTDPE_POS_QUEUE_INIT_CAPA);
+  for (i = 0; i < t_cnt; i++) {
+    tpe = ir_term_positions_for(ir, terms[i]);
+    if (tpe->next(tpe)) {
+      pq_push(pq, tpe);
+    } else {
+      tpe->close(tpe);
+    }
+  }
+  pq->free_elem = (free_ft)&tde_destroy;
+
+  self->data = mtdpe;
   self->close = &mtdpe_close;
   self->seek = &mtdpe_seek;
   self->next = &mtdpe_next;
@@ -585,17 +610,6 @@ TermDocEnum *mtdpe_create(IndexReader *ir, Term **terms, int t_cnt)
   self->read = &mtdpe_read;
   self->next_position = &mtdpe_next_position;
 
-  ZEROSET(mtdpe, MultipleTermDocPosEnum, 1); // set all values to 0
-  self->data = mtdpe;
-  pq = mtdpe->pq = pq_create(t_cnt, &tdpe_less_than);
-  mtdpe->pos_queue_capa = MTDPE_POS_QUEUE_INIT_CAPA;
-  mtdpe->pos_queue = ALLOC_N(int, MTDPE_POS_QUEUE_INIT_CAPA);
-  for (i = 0; i < t_cnt; i++) {
-    tpe = ir_term_positions_for(ir, terms[i]);
-    if (tpe->next(tpe)) pq_push(pq, tpe);
-  }
-  pq->free_elem = &tde_destroy;
-
   return self;
 }
 

data/ext/vector.c

@@ -1,6 +1,6 @@
-#include <index.h>
+#include "index.h"
+#include "helper.h"
 #include <string.h>
-#include <helper.h>
 
 static char * const NULL_POS_ERROR_MSG = "Trying to write positions that are null!";
 static char * const NULL_OFFSETS_ERROR_MSG = "Trying to write offsets that are null!";
@@ -50,33 +50,25 @@ TVTerm *tvt_create(char *text, int freq, int *positions, TVOffsetInfo **offsets)
 
 void tvt_destroy(void *p)
 {
-  //int i;
-  //TVTerm *tvt = (TVTerm *)p;
-  //free(tvt->text);
-  //free(tvt->positions);
-  //if (tvt->offsets != NULL) {
-  //  for (i = 0; i < tvt->freq; i++) {
-  //    tvoi_destroy(tvt->offsets[i]);
-  //  }
-  //  free(tvt->offsets);
-  //}
   free(p);
 }
 
 
 TermVectorsWriter *tvw_open(Store *store, char *segment, FieldInfos *fis)
 {
+  char fname[SEGMENT_NAME_MAX_LENGTH];
+  size_t segment_len = strlen(segment);
   TermVectorsWriter *tvw = ALLOC(TermVectorsWriter);
+  OutStream *os;
+
   tvw->curr_field = NULL;
   tvw->curr_doc_pointer = -1;
  
-  // Open files for TermVector storage
-  char fname[SEGMENT_NAME_MAX_LENGTH];
-  int segment_len = strlen(segment);
+  /* Open files for TermVector storage */
   strcpy(fname, segment);
 
   strcpy(fname + segment_len, TVX_EXTENSION);
-  OutStream *os = tvw->tvx = store->create_output(store, fname);
+  os = tvw->tvx = store->create_output(store, fname);
   os_write_int(os, FORMAT_VERSION);
 
   strcpy(fname + segment_len, TVD_EXTENSION);
@@ -104,43 +96,48 @@ void tvw_write_field(TermVectorsWriter *tvw)
   int i, j, start, length;
   char *last_term_text;
   TVOffsetInfo *tmp_offset;
-  // remember where this field is written
+  TVTerm **terms = tvw->terms;
+  TVTerm *term;
+  /* remember where this field is written */
   OutStream *tvf = tvw->tvf;
+  int store_positions = tvw->curr_field->store_positions;
+  int store_offsets = tvw->curr_field->store_offsets;
+  uchar bits = 0x0;
+
   tvw->curr_field->tvf_pointer = os_pos(tvf);
   
-  // write the number of terms
+  /* write the number of terms */
   os_write_vint(tvf, tvw->tcnt);
   
-  int store_positions = tvw->curr_field->store_positions;
-  int store_offsets = tvw->curr_field->store_offsets;
-  int bits = 0x0;
-  if (store_positions) 
+  if (store_positions) {
     bits |= STORE_POSITIONS_WITH_TERMVECTOR;
+  }
 
-  if (store_offsets) 
+  if (store_offsets) {
     bits |= STORE_OFFSET_WITH_TERMVECTOR;
+  }
 
-  os_write_byte(tvf, bits);
+  os_write_byte(tvf, (uchar)bits);
   
   last_term_text = (char *)EMPTY_STRING;
-  TVTerm **terms = tvw->terms;
-  TVTerm *term;
   for (i = 0; i < tvw->tcnt; i++) {
     term = terms[i];
     start = hlp_string_diff(last_term_text, term->text);
-    length = strlen(term->text) - start;
-    os_write_vint(tvf, start);       // write shared prefix length
-    os_write_vint(tvf, length);      // write delta length
-    os_write_chars(tvf, term->text, start, length);  // write delta chars
+    length = (int)strlen(term->text) - start;
+    os_write_vint(tvf, start);       /* write shared prefix length */
+    os_write_vint(tvf, length);      /* write delta length */
+    os_write_chars(tvf, term->text, start, length);  /* write delta chars */
     os_write_vint(tvf, term->freq);
     last_term_text = term->text;
     
     if (store_positions) {
-      if (term->positions == NULL)
-        RAISE(IO_ERROR, NULL_POS_ERROR_MSG);
-      
-      // use delta encoding for positions
       int last_pos = 0;
+      
+      if (term->positions == NULL) {
+        RAISE(IO_ERROR, NULL_POS_ERROR_MSG);
+      }
+
+      /* use delta encoding for positions */
       for (j = 0; j < term->freq; j++) {
         os_write_vint(tvf, term->positions[j] - last_pos);
         last_pos = term->positions[j];
@@ -148,16 +145,18 @@ void tvw_write_field(TermVectorsWriter *tvw)
     }
     
     if (store_offsets) {
-      if (term->offsets == NULL)
-        RAISE(IO_ERROR, NULL_OFFSETS_ERROR_MSG);
-      
-      // use delta encoding for offsets
       int last_end = 0;
+
+      if (term->offsets == NULL) {
+        RAISE(IO_ERROR, NULL_OFFSETS_ERROR_MSG);
+      }
+
+      /* use delta encoding for offsets */
       for (j = 0; j < term->freq; j++) {
         tmp_offset = term->offsets[j];
         os_write_vint(tvf, tmp_offset->start - last_end);
 
-        // save the diff between the two.
+        /* save the diff between the two */
         os_write_vint(tvf, tmp_offset->end - tmp_offset->start);
         last_end = tmp_offset->end;
       }
@@ -169,13 +168,14 @@ void tvw_close_field(TermVectorsWriter *tvw)
 {
   int i;
   if (tvw->curr_field != NULL) {
-    // save field and terms
+    /* save field and terms */
     tvw_write_field(tvw);
 
     if (tvw->fcnt >= tvw->fsize) {
       tvw->fsize *=2;
-      if (tvw->fsize < FIELD_ARR_START_SIZE)
+      if (tvw->fsize < FIELD_ARR_START_SIZE) {
         tvw->fsize = FIELD_ARR_START_SIZE;
+      }
       REALLOC_N(tvw->fields, TVField *, tvw->fsize);
     }
     tvw->fields[tvw->fcnt] = tvw->curr_field;
@@ -205,30 +205,34 @@ void tvw_open_field(TermVectorsWriter *tvw, char *field)
 
 void tvw_write_doc(TermVectorsWriter *tvw)
 {
-  if (tvw->curr_field != NULL)
+  OutStream *tvd = tvw->tvd;
+  int i;
+  TVField **fields = tvw->fields;
+  int last_field_pointer = 0;
+
+  if (tvw->curr_field != NULL) {
     RAISE(STATE_ERROR, FIELD_OPEN_ERROR_MSG);
+  }
 
-  // puts("Writing doc pointer: " + @curr_doc_pointer)
-  //  write document index record
+  //printf("Writing doc pointer: %d\n", tvw->curr_doc_pointer);
+  /*  write document index record */
   os_write_long(tvw->tvx, tvw->curr_doc_pointer);
 
-  OutStream *tvd = tvw->tvd;
-  // write the number of @fields
+  //printf("Writing field count: %ld, %d, %d -> ", (long long)tvw, tvw->fcnt, os_pos(tvd));
+  /* write the number of @fields */
   os_write_vint(tvd, tvw->fcnt);
-
-  // write field numbers
-  int i;
-  TVField **fields = tvw->fields;
+  
+  /* write field numbers */
   for (i = 0; i < tvw->fcnt; i++) {
     os_write_vint(tvd, fields[i]->number);
   }
 
-  // write field pointers
-  int last_field_pointer = 0;
+  /* write field pointers */
   for (i = 0; i < tvw->fcnt; i++) {
     os_write_vint(tvd, fields[i]->tvf_pointer - last_field_pointer);
     last_field_pointer = fields[i]->tvf_pointer;
   }
+  //printf("%d\n", os_pos(tvw->tvd));
 }
 
 void tvw_close_doc(TermVectorsWriter *tvw)
@@ -257,8 +261,10 @@ void tvw_add_term(TermVectorsWriter *tvw,
 {
   if (tvw->tcnt >= tvw->tsize) {
     tvw->tsize *= 2;
-    if (tvw->tsize < TERM_ARR_START_SIZE) 
+    if (tvw->tsize < TERM_ARR_START_SIZE) {
       tvw->tsize = TERM_ARR_START_SIZE;
+    }
+
     REALLOC_N(tvw->terms, TVTerm *, tvw->tsize);
   }
   tvw->terms[tvw->tcnt] = tvt_create(text, freq, positions, offsets);
@@ -267,31 +273,36 @@ void tvw_add_term(TermVectorsWriter *tvw,
 
 void tvw_add_all_doc_vectors(TermVectorsWriter *tvw, Array *vectors)
 {
-  tvw_open_doc(tvw);
-
   int i, j, store_positions, store_offsets;
   TermVector *tv;
+
+  tvw_open_doc(tvw);
+
   for (i = 0; i < vectors->size; i++) {
     tv = vectors->elems[i];
 
     store_positions = (tv->tcnt > 0 && tv->positions != NULL);
     store_offsets = (tv->tcnt > 0 && tv->offsets != NULL);
 
-    tvw_create_field(tvw, fis_get_number(tvw->fis, tv->field),
+    tvw_create_field(tvw, (int)fis_get_number(tvw->fis, tv->field),
                  store_positions, store_offsets);
 
     if (store_positions && store_offsets) {
-      for (j = 0; j < tv->tcnt; j++)
+      for (j = 0; j < tv->tcnt; j++) {
         tvw_add_term(tvw, tv->terms[j], tv->freqs[j], tv->positions[j], tv->offsets[j]);
+      }
     } else if (store_positions) {
-      for (j = 0; j < tv->tcnt; j++)
+      for (j = 0; j < tv->tcnt; j++) {
         tvw_add_term(tvw, tv->terms[j], tv->freqs[j], tv->positions[j], NULL);
+      }
     } else if (store_offsets) {
-      for (j = 0; j < tv->tcnt; j++)
+      for (j = 0; j < tv->tcnt; j++) {
         tvw_add_term(tvw, tv->terms[j], tv->freqs[j], NULL, tv->offsets[j]);
+      }
     } else {
-      for (j = 0; j < tv->tcnt; j++)
+      for (j = 0; j < tv->tcnt; j++) {
         tvw_add_term(tvw, tv->terms[j], tv->freqs[j], NULL, NULL);
+      }
     }
     tvw_close_field(tvw);
   }
@@ -333,10 +344,9 @@ TermVector *tv_create(
   return tv;
 }
 
-void tv_destroy(void *p)
+void tv_destroy(TermVector *tv)
 {
   int i, j;
-  TermVector *tv = (TermVector *)p;
   for (i = 0; i < tv->tcnt; i++) {
     free(tv->terms[i]);
   }
@@ -357,12 +367,11 @@ void tv_destroy(void *p)
     free(tv->offsets);
   }
   free(tv->freqs);
-  free(p);
+  free(tv);
 }
 
-void tv_destroy_except_data(void *p)
+void tv_destroy_except_data(TermVector *tv)
 {
-  TermVector *tv = (TermVector *)p;
   free(tv->terms);
   if (tv->positions != NULL) {
     free(tv->positions);
@@ -371,23 +380,23 @@ void tv_destroy_except_data(void *p)
     free(tv->offsets);
   }
   free(tv->freqs);
-  free(p);
+  free(tv);
 }
 
 int tvr_check_valid_format(InStream *is)
 {
   int format = is_read_int(is);
   if (format > FORMAT_VERSION)
-    RAISE(ERROR, FORMAT_VERSION_ERROR_MSG);
+    RAISE(EXCEPTION, FORMAT_VERSION_ERROR_MSG);
   return format;
 }
 
 TermVectorsReader *tvr_clone(TermVectorsReader *orig)
 {
   TermVectorsReader *clone = NULL;
+  clone = ALLOC(TermVectorsReader);
+  memcpy(clone, orig, sizeof(TermVectorsReader));
   if (orig->tvx && orig->tvd && orig->tvf) { 
-    clone = ALLOC(TermVectorsReader);
-    memcpy(clone, orig, sizeof(TermVectorsReader));
     clone->tvx = is_clone(orig->tvx);
     clone->tvd = is_clone(orig->tvd);
     clone->tvf = is_clone(orig->tvf);
@@ -400,23 +409,30 @@ TermVectorsReader *tvr_open(Store *store, char *segment, FieldInfos *fis)
   TermVectorsReader *tvr = ALLOC(TermVectorsReader);
   // Open files for TermVector storage
   char fname[SEGMENT_NAME_MAX_LENGTH];
-  int segment_len = strlen(segment);
+  size_t segment_len = strlen(segment);
+  InStream *is;
+
   strcpy(fname, segment);
 
   strcpy(fname + segment_len, TVX_EXTENSION);
-  InStream *is = tvr->tvx = store->open_input(store, fname);
-  tvr_check_valid_format(is);
-  tvr->size = is_length(is)/8;
+  if (!store->exists(store, fname)) {
+    tvr->tvx = tvr->tvd = tvr->tvf = NULL;
+    tvr->size = 0;
+  } else {
+    is = tvr->tvx = store->open_input(store, fname);
+    tvr_check_valid_format(is);
+    tvr->size = is_length(is)/8;
 
-  strcpy(fname + segment_len, TVD_EXTENSION);
-  is = tvr->tvd = store->open_input(store, fname);
-  tvr->tvd_format = tvr_check_valid_format(is);
+    strcpy(fname + segment_len, TVD_EXTENSION);
+    is = tvr->tvd = store->open_input(store, fname);
+    tvr->tvd_format = tvr_check_valid_format(is);
 
-  strcpy(fname + segment_len, TVF_EXTENSION);
-  is = tvr->tvf = store->open_input(store, fname);
-  tvr->tvf_format = tvr_check_valid_format(is);
+    strcpy(fname + segment_len, TVF_EXTENSION);
+    is = tvr->tvf = store->open_input(store, fname);
+    tvr->tvf_format = tvr_check_valid_format(is);
 
-  tvr->fis = fis;
+    tvr->fis = fis;
+  }
   return tvr;
 }
 
@@ -426,9 +442,15 @@ void tvr_close(TermVectorsReader *tvr)
    * exception, everything else will also be closed.  */
   TRY
   XFINALLY
-    is_close(tvr->tvx);
-    is_close(tvr->tvd);
-    is_close(tvr->tvf);
+    if (tvr->tvx) {
+      is_close(tvr->tvx);
+    }
+    if (tvr->tvd) {
+      is_close(tvr->tvd);
+    }
+    if (tvr->tvf) {
+      is_close(tvr->tvf);
+    }
     free(tvr);
   XENDTRY
 }
@@ -436,17 +458,29 @@ void tvr_close(TermVectorsReader *tvr)
 TermVector *tvr_read_term_vector(TermVectorsReader *tvr,
     char *field, int tvf_pointer)
 {
-  int i, j, store_positions, store_offsets, bits;
-  // Now read the data from specified position
-  // We don't need to offset by the FORMAT here since the pointer
-  // already includes the offset
+  int i, j, store_positions, store_offsets, bits, num_terms;
+  char **terms;
+  int *term_freqs;
+  
+  /*  we may not need these, but declare them */
+  int **positions = NULL; 
+  TVOffsetInfo ***offsets = NULL;
+  int start, delta_length, total_length, freq, prev_pos;
+  int start_offset, end_offset, prev_offset;
+  int *pos;
+  TVOffsetInfo **offs;
+  char buffer[MAX_WORD_SIZE] = "";
+  
+  /* Now read the data from specified position. We don't need to offset
+   * offset by the FORMAT here since the pointer already includes the offset */
   is_seek(tvr->tvf, tvf_pointer);
-
-  int num_terms = is_read_vint(tvr->tvf);
-  // If no terms - return a constant empty termvector. However, this should
-  // never occur!
-  if (num_terms == 0)
+  num_terms = (int)is_read_vint(tvr->tvf);
+  
+  /* If no terms - return a constant empty termvector. However, this should
+   * never occur! */
+  if (num_terms == 0) {
     return tv_create(field, NULL, 0, NULL, NULL, NULL);
+  }
   
   if(tvr->tvf_format == FORMAT_VERSION) {
     bits = is_read_byte(tvr->tvf);
@@ -458,41 +492,34 @@ TermVector *tvr_read_term_vector(TermVectorsReader *tvr,
     store_offsets = false;
   }
 
-  char **terms = ALLOC_N(char *, num_terms);
-  int *term_freqs = ALLOC_N(int, num_terms);
-  
-  //  we may not need these, but declare them
-  int **positions = NULL; 
-  TVOffsetInfo ***offsets = NULL;
+  terms = ALLOC_N(char *, num_terms);
+  term_freqs = ALLOC_N(int, num_terms);
 
-  if(store_positions)
+  if (store_positions) {
     positions = ALLOC_N(int *, num_terms);
+  }
 
-  if(store_offsets)
+  if (store_offsets) {
     offsets = ALLOC_N(TVOffsetInfo **, num_terms);
+  }
   
-  int start, delta_length, total_length, freq, prev_pos;
-  int start_offset, end_offset, prev_offset;
-  int *pos;
-  TVOffsetInfo **offs;
-  char buffer[MAX_WORD_SIZE] = "";
   
   for (i = 0; i < num_terms; i++) {
-    start = is_read_vint(tvr->tvf);
-    delta_length = is_read_vint(tvr->tvf);
+    start = (int)is_read_vint(tvr->tvf);
+    delta_length = (int)is_read_vint(tvr->tvf);
     total_length = start + delta_length;
     is_read_chars(tvr->tvf, buffer, start, delta_length);
     buffer[total_length] = '\0';
     terms[i] = estrdup(buffer);
-    freq = is_read_vint(tvr->tvf);
+    freq = (int)is_read_vint(tvr->tvf);
     term_freqs[i] = freq;
     
-    if (store_positions) {//read in the positions
+    if (store_positions) {/* read in the positions */
       pos = ALLOC_N(int, freq);
       positions[i] = pos;
       prev_pos = 0;
       for (j = 0; j < freq; j++) {
-        pos[j] = prev_pos + is_read_vint(tvr->tvf);
+        pos[j] = prev_pos + (int)is_read_vint(tvr->tvf);
         prev_pos = pos[j];
       }
     }
@@ -502,8 +529,8 @@ TermVector *tvr_read_term_vector(TermVectorsReader *tvr,
       offsets[i] = offs;
       prev_offset = 0;
       for (j = 0; j < freq; j++) {
-        start_offset = prev_offset + is_read_vint(tvr->tvf);
-        end_offset = start_offset + is_read_vint(tvr->tvf);
+        start_offset = prev_offset + (int)is_read_vint(tvr->tvf);
+        end_offset = start_offset + (int)is_read_vint(tvr->tvf);
         offs[j] = tvoi_create(start_offset, end_offset);
         prev_offset = end_offset;
       }
@@ -516,39 +543,41 @@ Array *tvr_get_tv(TermVectorsReader *tvr, int doc_num)
 {
   int i;
   Array *tvs = NULL;
-  // Check if no term vectors are available for this segment at all
+  /* Check if no term vectors are available for this segment at all */
   if (tvr->tvx != NULL) {
-    // We need to offset by
+    int position, field_count;
+    /* We need to offset by */
     is_seek(tvr->tvx, (doc_num * 8) + FORMAT_SIZE);
 
-    int position = is_read_long(tvr->tvx);
+    position = (int)is_read_long(tvr->tvx);
 
     is_seek(tvr->tvd, position);
-    int field_count = is_read_vint(tvr->tvd);
+    field_count = (int)is_read_vint(tvr->tvd);
 
-    // No fields are vectorized for this document
+    /* No fields are vectorized for this document */
     if (field_count > 0) {
       int number = 0;
+      int position = 0;
+      int *tvf_pointers = ALLOC_N(int, field_count);
       char **fields = ALLOC_N(char *, field_count);
       
       for (i = 0; i < field_count; i++) {
-        if (tvr->tvd_format == FORMAT_VERSION)
-          number = is_read_vint(tvr->tvd);
-        else
-          number += is_read_vint(tvr->tvd);
+        if (tvr->tvd_format == FORMAT_VERSION) {
+          number = (int)is_read_vint(tvr->tvd);
+        } else {
+          number += (int)is_read_vint(tvr->tvd);
+        }
 
         fields[i] = tvr->fis->by_number[number]->name;
       }
 
-      // Compute position in the tvf file
-      int position = 0;
-      int *tvf_pointers = ALLOC_N(int, field_count);
+      /* Compute position in the tvf file */
       for (i = 0; i < field_count; i++) {
-        position += is_read_vint(tvr->tvd);
+        position += (int)is_read_vint(tvr->tvd);
         tvf_pointers[i] = position;
       }
 
-      tvs = ary_create(field_count, &tv_destroy);
+      tvs = ary_create(field_count, (free_ft)&tv_destroy);
       for (i = 0; i < field_count; i++) {
         ary_append(tvs, tvr_read_term_vector(tvr, fields[i], tvf_pointers[i]));
       }
@@ -562,45 +591,45 @@ Array *tvr_get_tv(TermVectorsReader *tvr, int doc_num)
 TermVector *tvr_get_field_tv(TermVectorsReader *tvr, int doc_num, char *field)
 {
   int i;
-  // Check if no term vectors are available for this segment at all
-  int field_number = fis_get_number(tvr->fis, field);
+  /* Check if no term vectors are available for this segment at all */
+  int field_number = (int)fis_get_number(tvr->fis, field);
   TermVector *tv = NULL;
 
   if (tvr->tvx != NULL) {
-    // We need to account for the FORMAT_SIZE at when seeking in the @tvx
-    // We don't need to do this in other seeks because we already have the
-    // file pointer that was written in another file
+    int pos, field_count, number = 0, found = -1;
+    /* We need to account for the FORMAT_SIZE at when seeking in the @tvx
+     * We don't need to do this in other seeks because we already have the
+     * file pointer that was written in another file */
     is_seek(tvr->tvx, (doc_num * 8) + FORMAT_SIZE);
-    // puts("TVX Pointer: " + @tvx.pos())
-    int pos = is_read_long(tvr->tvx);
+    //printf("TVX Pointer: %d\n", is_pos(tvr->tvx));
+    pos = (int)is_read_long(tvr->tvx);
 
     is_seek(tvr->tvd, pos);
-    int field_count = is_read_vint(tvr->tvd);
-    //puts("Num Fields: " + field_count)
-    // There are only a few fields per document. We opt for a full scan
-    // rather then requiring that they be ordered. We need to read through
-    // all of the fields anyway to get to the tvf pointers.
-    int number = 0;
-    int found = -1;
-
+    field_count = (int)is_read_vint(tvr->tvd);
+    //printf("Num Fields: %d\n", field_count);
+    /* There are only a few fields per document. We opt for a full scan
+     * rather then requiring that they be ordered. We need to read through
+     * all of the fields anyway to get to the tvf pointers. */
     for (i = 0; i < field_count; i++) {
-      if (tvr->tvd_format == FORMAT_VERSION)
-        number = is_read_vint(tvr->tvd);
-      else
-        number += is_read_vint(tvr->tvd);
+      if (tvr->tvd_format == FORMAT_VERSION) {
+        number = (int)is_read_vint(tvr->tvd);
+      } else {
+        number += (int)is_read_vint(tvr->tvd);
+      }
 
-      if (number == field_number)
+      if (number == field_number) {
         found = i;
+      }
     }
 
-    // This field, although valid in the segment, was not found in this
-    // document
+    /* This field, although valid in the segment, was not found in this
+     * document */
     if (found != -1) {
-      // Compute pos in the @tvf file
+      /* Compute pos in the tvf file */
       pos = 0;
-      for (i = 0; i <= found; i++)
-        pos += is_read_vint(tvr->tvd);
-
+      for (i = 0; i <= found; i++) {
+        pos += (int)is_read_vint(tvr->tvd);
+      }
       tv = tvr_read_term_vector(tvr, field, pos);
     }
   }