ferret 0.9.1 → 0.9.2

data/ext/term.c

@@ -1,7 +1,7 @@
-#include <index.h>
+#include "index.h"
+#include "helper.h"
+#include "hash.h"
 #include <string.h>
-#include <helper.h>
-#include <hash.h>
 
 static char * const FORMAT_VERSION_ERROR_MSG = "Unknown format version";
 static char * const TERM_ORDER_ERROR_MSG = "term out of order";
@@ -32,11 +32,10 @@ Term *term_create(const char *field, char *text)
   return t;
 }
 
-void term_destroy(void *p)
+void term_destroy(Term *self)
 {
-  Term *t = (Term *)p;
-  free(t->text);
-  free(t);
+  free(self->text);
+  free(self);
 }
 
 int term_cmp(void *t1, void *t2)
@@ -87,9 +86,9 @@ TermBuffer *tb_create()
   return tb;
 }
 
-void tb_destroy(void *p)
+void tb_destroy(TermBuffer *tb)
 {
-  free(p);
+  free(tb);
 }
 
 TermBuffer *tb_set_term(TermBuffer *tb, Term *t)
@@ -106,8 +105,9 @@ Term *tb_get_term(TermBuffer *tb)
 
 int tb_cmp(TermBuffer *tb1, TermBuffer *tb2)
 {
-  int res = strcmp(tb1->field, tb2->field);
-  if (res != 0) {
+  int res;
+  if ((tb1->field != tb2->field) &&
+      (0 != (res = strcmp(tb1->field, tb2->field)))) {
     return res;
   } else {
     return strcmp(tb1->text, tb2->text);
@@ -133,12 +133,13 @@ TermBuffer *tb_cpy(TermBuffer *tb1, TermBuffer *tb2)
 
 TermBuffer *tb_read(TermBuffer *tb, InStream *is, FieldInfos *fis)
 {
-  int start = is_read_vint(is);
-  int length = is_read_vint(is);
+  signed int fnum;
+  int start = (int)is_read_vint(is);
+  int length = (int)is_read_vint(is);
   int total_length = start + length;
   is_read_bytes(is, (uchar *)tb->text, start, length);
   tb->text[total_length] = '\0';
-  int fnum = is_read_vint(is);
+  fnum = (signed int)is_read_vint(is);
   if (fnum < 0)
     tb->field = (char *)EMPTY_STRING;
   else
@@ -171,9 +172,9 @@ TermInfo *ti_set(TermInfo *ti, int doc_freq, int freq_pointer, int prox_pointer,
   return ti;
 }
 
-void ti_destroy(void *p)
+void ti_destroy(TermInfo *ti)
 {
-  free(p);
+  free(ti);
 }
 
 TermInfo *ti_cpy(TermInfo *ti, TermInfo *other)
@@ -208,13 +209,12 @@ TermEnum *te_create()
   return te;
 }
 
-void te_destroy(void *p)
+void te_destroy(TermEnum *te)
 {
-  TermEnum *te = (TermEnum *)p;
   tb_destroy(te->tb_curr);
   tb_destroy(te->tb_prev);
   ti_destroy(te->ti_curr);
-  free(p);
+  free(te);
 }
 
 Term *te_get_term(TermEnum *te)
@@ -246,11 +246,12 @@ TermBuffer *te_skip_to(TermEnum *te, Term *t)
  *
  ****************************************************************************/
 
-#define GET_STE SegmentTermEnum *ste = (SegmentTermEnum *)te->data;
+#define GET_STE SegmentTermEnum *ste = (SegmentTermEnum *)te->data
 
 TermBuffer *ste_next(TermEnum *te)
 {
   GET_STE;
+  TermInfo *ti;
   InStream *is = ste->is;
   ste->pos++;
   if (ste->pos > ste->size - 1) {
@@ -261,38 +262,43 @@ TermBuffer *ste_next(TermEnum *te)
   tb_cpy(te->tb_prev, te->tb_curr);
   tb_read(te->tb_curr, is, ste->fis);
   
-  TermInfo *ti = te->ti_curr;
-  ti->doc_freq = is_read_vint(is);         // read doc freq
-  ti->freq_pointer += is_read_vint(is);    // read freq pointer
-  ti->prox_pointer += is_read_vint(is);    // read prox pointer
+  ti = te->ti_curr;
+  ti->doc_freq = (int)is_read_vint(is);     /* read doc freq */
+  ti->freq_pointer += (int)is_read_vint(is);/* read freq pointer */
+  ti->prox_pointer += (int)is_read_vint(is);/* read prox pointer */
   
   if (ste->format == -1) {
-    // just read skip_offset in order to increment  file pointer
-    // value is never used since skip_to is switched off
+    /* just read skip_offset in order to increment  file pointer
+     * value is never used since skip_to is switched off */
     if (!ste->is_index) {
-      if (ti->doc_freq > ste->format_m1skip_interval)
-        ti->skip_offset = is_read_vint(is);
+      if (ti->doc_freq > ste->format_m1skip_interval) {
+        ti->skip_offset = (int)is_read_vint(is);
+      }
     }
   } else {
-    if (ti->doc_freq >= ste->skip_interval)
-      ti->skip_offset = is_read_vint(is);
+    if (ti->doc_freq >= ste->skip_interval) {
+      ti->skip_offset = (int)is_read_vint(is);
+    }
   }
   
-  if (ste->is_index)
-    ste->index_pointer += is_read_vint(is); // read index pointer
+  if (ste->is_index) {
+    ste->index_pointer += (int)is_read_vint(is); /* read index pointer */
+  }
 
   return te->tb_curr;
 }
 
 TermEnum *ste_clone(TermEnum *other_te);
+
 TermEnum *ste_allocate()
 {
   TermEnum *te = te_create();
+  SegmentTermEnum *ste;
+
   te->next = &ste_next;
   te->close = &ste_close;
   te->clone = &ste_clone;
-  SegmentTermEnum *ste =
-    ALLOC(SegmentTermEnum);
+  ste = ALLOC(SegmentTermEnum);
   te->data = ste;
   return te;
 }
@@ -302,6 +308,7 @@ TermEnum *ste_clone(TermEnum *other_te)
   SegmentTermEnum *other_ste = (SegmentTermEnum *)other_te->data;
   TermEnum *te = ste_allocate();
   SegmentTermEnum *ste = (SegmentTermEnum *)te->data;
+
   memcpy(ste, other_ste, sizeof(SegmentTermEnum));
   ste->is = is_clone(other_ste->is);
   tb_cpy(te->tb_curr, other_te->tb_curr);
@@ -323,6 +330,8 @@ TermEnum *ste_create(InStream *is, FieldInfos *fis, int is_index)
 {
   TermEnum *te = ste_allocate();
   GET_STE;
+  int first_int;
+  
   ste->fis = fis;
   ste->is_index = is_index;
   ste->is = is;
@@ -330,36 +339,36 @@ TermEnum *ste_create(InStream *is, FieldInfos *fis, int is_index)
   ste->index_pointer = 0;
   ste->format_m1skip_interval = -1;
 
-  int first_int = is_read_int(is);
+  first_int = (int)is_read_int(is);
 
   if (first_int >= 0) {
-    // original-format file, without explicit format version number
+    /* original-format file, without explicit format version number */
     ste->format = 0;
     ste->size = first_int;
 
-    // back-compatible settings
+    /* back-compatible settings */
     ste->index_interval = 128;
-    ste->skip_interval = INT_MAX; // switch off skip_to optimization
+    ste->skip_interval = INT_MAX; /* switch off skip_to optimization */
 
   } else {
-    // check that it is a format we can understand
+    /* check that it is a format we can understand */
     if (first_int < TERM_INFO_FORMAT)
-      RAISE(ERROR, FORMAT_VERSION_ERROR_MSG);
+      RAISE(EXCEPTION, FORMAT_VERSION_ERROR_MSG);
 
-    // we have a format version number
+    /* we have a format version number */
     ste->format = first_int;
 
 
-    ste->size = is_read_long(is); // read the size
+    ste->size = (int)is_read_long(is); /* read the size */
     
     if (ste->format == -1) {
       if (!ste->is_index) {
         ste->index_interval = is_read_int(is);
         ste->format_m1skip_interval = is_read_int(is);
       }
-      // switch off skip_to optimization for file format prior to
-      // 1.4rc2 in order to avoid a bug in skip_to implementation
-      // of these versions
+      /* switch off skip_to optimization for file format prior to
+       * 1.4rc2 in order to avoid a bug in skip_to implementation
+       * of these versions */
       ste->skip_interval = INT_MAX;
     } else {
       ste->index_interval = is_read_int(is);
@@ -407,7 +416,7 @@ Term *ste_scan_for_term(TermEnum *te, int pos)
  *
  ****************************************************************************/
 
-#define GET_MTE MultiTermEnum *mte = (MultiTermEnum *)te->data;
+#define GET_MTE MultiTermEnum *mte = (MultiTermEnum *)te->data
 
 TermBuffer *mte_next(TermEnum *te)
 {
@@ -426,11 +435,11 @@ TermBuffer *mte_next(TermEnum *te)
 
   while ((top != NULL) && (tb_cmp(te->tb_curr, top->tb) == 0)) {
     pq_pop(mte->smi_queue);
-    te->ti_curr->doc_freq += top->te->ti_curr->doc_freq;    // increment freq
+    te->ti_curr->doc_freq += top->te->ti_curr->doc_freq;/* increment freq */
     if (smi_next(top)) {
-      pq_push(mte->smi_queue, top);          // restore queue
+      pq_push(mte->smi_queue, top); /* restore queue */
     } else {
-      smi_destroy(top);          // done with a segment
+      smi_destroy(top);             /* done with a segment */
     }
     top = (SegmentMergeInfo *)pq_top(mte->smi_queue);
   }
@@ -455,21 +464,21 @@ TermEnum *mte_clone(TermEnum *te)
 TermEnum *mte_create(IndexReader **readers, int *starts, int rcnt, Term *t)
 {
   int i;
+  IndexReader *reader;
+  TermEnum *sub_te;
+  MultiTermEnum *mte = ALLOC(MultiTermEnum);
   TermEnum *te = te_create();
   te->next = &mte_next;
   te->clone = &mte_clone;
   te->close = &mte_close;
 
-  MultiTermEnum *mte = ALLOC(MultiTermEnum);
   te->data = mte;
 
-  IndexReader *reader;
-  TermEnum *sub_te;
-
-  mte->smi_queue = pq_create(rcnt, &smi_lt);
-  mte->smi_queue->free_elem = &smi_destroy;
+  mte->smi_queue = pq_create(rcnt, (lt_ft)&smi_lt);
+  mte->smi_queue->free_elem = (free_ft)&smi_destroy;
 
   for (i = 0; i < rcnt; i++) {
+    SegmentMergeInfo *smi;
     reader = readers[i];
 
     if (t != NULL) {
@@ -478,10 +487,10 @@ TermEnum *mte_create(IndexReader **readers, int *starts, int rcnt, Term *t)
       sub_te = reader->terms(reader);
     }
 
-    SegmentMergeInfo *smi = smi_create(starts[i], sub_te, reader);
+    smi = smi_create(starts[i], sub_te, reader);
     if (((t == NULL) && smi_next(smi)) ||
         (sub_te->tb_curr->field != (char *)EMPTY_STRING)) {
-      pq_push(mte->smi_queue, smi);          // initialize queue
+      pq_push(mte->smi_queue, smi);          /* initialize queue */
     } else {
       smi_destroy(smi);
     }
@@ -508,7 +517,10 @@ TermInfosWriter *tiw_open_internal(Store *store,
     int interval,
     int is_index)
 {
+  char fname[SEGMENT_NAME_MAX_LENGTH];
   TermInfosWriter *tiw = ALLOC(TermInfosWriter);
+  OutStream *os;
+
   tiw->index_interval = interval;
   tiw->skip_interval = 16;
   tiw->last_index_pointer = 0;
@@ -520,14 +532,13 @@ TermInfosWriter *tiw_open_internal(Store *store,
   tiw->curr_field = NULL;
   tiw->curr_field_num = -1;
 
-  char fname[SEGMENT_NAME_MAX_LENGTH];
   strcpy(fname, segment);
   strcat(fname, (is_index ? ".tii" : ".tis"));
-  OutStream *os = tiw->os = store->create_output(store, fname);
-  os_write_int(os, TERM_INFO_FORMAT);                     // write format
-  os_write_long(os, 0);                         // leave space for size
-  os_write_int(os, tiw->index_interval);        // write index_interval
-  os_write_int(os, tiw->skip_interval);         // write skip_interval
+  os = tiw->os = store->create_output(store, fname);
+  os_write_int(os, TERM_INFO_FORMAT);           /* write format */
+  os_write_long(os, 0);                         /* leave space for size */
+  os_write_int(os, tiw->index_interval);        /* write index_interval */
+  os_write_int(os, tiw->skip_interval);         /* write skip_interval */
   if (!is_index) {
     tiw->other = tiw_open_internal(store, segment, fis, interval, true);
     tiw->other->other = tiw;
@@ -544,11 +555,11 @@ void tiw_write_term(TermInfosWriter *tiw, OutStream *os, Term *t)
 {
   //printf("%s, %s\n", tiw->last_term->text, t->text);
   int start = hlp_string_diff(tiw->last_term->text, t->text);
-  int length = strlen(t->text) - start;
+  int length = (int)strlen(t->text) - start;
 
-  os_write_vint(os, start);                   // write shared prefix length
-  os_write_vint(os, length);                  // write delta length
-  os_write_chars(os, t->text, start, length); // write delta chars
+  os_write_vint(os, start);                   /* write shared prefix length */
+  os_write_vint(os, length);                  /* write delta length */
+  os_write_chars(os, t->text, start, length); /* write delta chars */
   if (tiw->curr_field != t->field) {
     tiw->curr_field = t->field;
     tiw->curr_field_num = fis_get_number(tiw->fis, t->field);
@@ -559,6 +570,7 @@ void tiw_write_term(TermInfosWriter *tiw, OutStream *os, Term *t)
 
 void tiw_add(TermInfosWriter *tiw, Term *t, TermInfo *ti)
 {
+#ifdef DEBUG
   if (tiw->is_index && term_cmp(tiw->last_term, t) > 0) {
     RAISE(STATE_ERROR, TERM_ORDER_ERROR_MSG);
   }
@@ -568,22 +580,27 @@ void tiw_add(TermInfosWriter *tiw, Term *t, TermInfo *ti)
   if (ti->prox_pointer < tiw->last_term_info->prox_pointer) {
     RAISE(STATE_ERROR, PP_ORDER_ERROR_MSG);
   }
+#endif
 
-  if (!tiw->is_index && (tiw->size % tiw->index_interval) == 0)
-    tiw_add(tiw->other, tiw->last_term, tiw->last_term_info); // add an index term
+  if (!tiw->is_index && (tiw->size % tiw->index_interval) == 0) {
+    /* add an index term */
+    tiw_add(tiw->other, tiw->last_term, tiw->last_term_info);
+  }
 
-  tiw_write_term(tiw, tiw->os, t);                          // write term
-  os_write_vint(tiw->os, ti->doc_freq);                   // write doc freq
+  tiw_write_term(tiw, tiw->os, t);                            /* write term */
+  os_write_vint(tiw->os, ti->doc_freq);                       /* write doc freq */
   os_write_vint(tiw->os, ti->freq_pointer - tiw->last_term_info->freq_pointer);
   os_write_vint(tiw->os, ti->prox_pointer - tiw->last_term_info->prox_pointer);
-  if (ti->doc_freq >= tiw->skip_interval) 
+
+  if (ti->doc_freq >= tiw->skip_interval) {
     os_write_vint(tiw->os, ti->skip_offset);
+  }
 
   if (tiw->is_index) {
     OutStream *other_os = tiw->other->os;
     int other_pos = os_pos(other_os);
     os_write_vint(tiw->os, other_pos - tiw->last_index_pointer);
-    tiw->last_index_pointer = other_pos; // write pointer
+    tiw->last_index_pointer = other_pos; /* write pointer */
   }
 
   ti_cpy(tiw->last_term_info, ti);
@@ -593,7 +610,7 @@ void tiw_add(TermInfosWriter *tiw, Term *t, TermInfo *ti)
 void tiw_close(TermInfosWriter *tiw)
 {
   OutStream *os = tiw->os;
-  os_seek(os, 4); // write @size after format
+  os_seek(os, 4); /* write @size after format */
   os_write_long(os, tiw->size);
   os_close(os);
 
@@ -632,17 +649,20 @@ void tir_close(TermInfosReader *tir)
 
 TermInfosReader *tir_open(Store *store, char *segment, FieldInfos *fis)
 {
+  SegmentTermEnum *ste;
   TermInfosReader *tir = ALLOC(TermInfosReader);
   char fname[SEGMENT_NAME_MAX_LENGTH];
+  InStream *is;
+  
   mutex_init(&tir->mutex, NULL);
   strcpy(fname, segment);
   strcpy(fname + strlen(segment), ".tis");
-  InStream *is = store->open_input(store, fname);
+  is = store->open_input(store, fname);
   tir->orig_te = ste_create(is, fis, false);
   thread_key_create(&tir->thread_te, NULL);
-  tir->te_bucket = ary_create(1, (destroy_func_t)tir->orig_te->close);
+  tir->te_bucket = ary_create(1, (free_ft)tir->orig_te->close);
 
-  SegmentTermEnum *ste = tir->orig_te->data;
+  ste = tir->orig_te->data;
   tir->size = ste->size;
   tir->skip_interval = ste->skip_interval;
 
@@ -659,6 +679,9 @@ void tir_ensure_index_is_read(TermInfosReader *tir)
 {
   mutex_lock(&tir->mutex);
   if (tir->index_terms == NULL) {
+    TermEnum *index_te;
+    SegmentTermEnum *ste;
+    int i = 0;
     int index_size = ((SegmentTermEnum *)tir->index_te->data)->size;
     tir->index_size = index_size;
 
@@ -666,9 +689,8 @@ void tir_ensure_index_is_read(TermInfosReader *tir)
     tir->index_term_infos = ALLOC_N(TermInfo *, index_size);
     tir->index_pointers = ALLOC_N(int, index_size);
 
-    int i = 0;
-    TermEnum *index_te = tir->index_te;
-    SegmentTermEnum *ste = index_te->data;
+    index_te = tir->index_te;
+    ste = index_te->data;
 
     TRY
       while (ste_next(index_te) != NULL) {
@@ -708,7 +730,7 @@ void tir_seek_enum(TermInfosReader *tir, int ind_offset)
 
 int tir_get_index_offset(TermInfosReader *tir, Term *t)
 {
-  int lo = 0;            // binary search tir->index_terms[]
+  int lo = 0;            /* binary search tir->index_terms[] */
   int hi = tir->index_size - 1;
   int mid, delta;
   Term **index_terms = tir->index_terms;
@@ -729,61 +751,70 @@ int tir_get_index_offset(TermInfosReader *tir, Term *t)
 
 TermInfo *tir_get_ti(TermInfosReader *tir, Term *t)
 {
-  if (tir->size == 0)
+  TermEnum *te;
+  SegmentTermEnum *ste;
+  if (tir->size == 0) {
     return NULL;
+  }
 
   tir_ensure_index_is_read(tir);
 
-  // optimize sequential access: first try scanning cached enum w/o seeking
-  TermEnum *te = tir_enum(tir);
-  SegmentTermEnum *ste = (SegmentTermEnum *)te->data;
+  /* optimize sequential access: first try scanning cached enum w/o seeking */
+  te = tir_enum(tir);
+  ste = (SegmentTermEnum *)te->data;
   if (ste->pos < ste->size && tb_term_cmp(te->tb_curr, t) <= 0) {
     SegmentTermEnum *ste = (SegmentTermEnum *)te->data;
     int enum_offset = (int)(ste->pos / ste->index_interval) + 1;
     if (tir->index_size == enum_offset ||
-        term_cmp(t, tir->index_terms[enum_offset]) < 0) { // but before end of block
-      return ste_scan_for_term_info(te, t);       // no need to seek
+        term_cmp(t, tir->index_terms[enum_offset]) < 0) { /* but before end of block */
+      return ste_scan_for_term_info(te, t);               /* no need to seek */
     }
   }
 
-  // random-access: must seek
+  /* random-access: must seek */
   tir_seek_enum(tir, tir_get_index_offset(tir, t));
   return ste_scan_for_term_info(te, t);
 }
 
 Term *tir_get_term(TermInfosReader *tir, int pos)
 { 
-  if (tir->size == 0)
+  if (tir->size == 0) {
     return NULL;
+  } else {
+    TermEnum *te = tir_enum(tir);
+    SegmentTermEnum *ste = (SegmentTermEnum *)te->data;
+    if (pos >= ste->pos &&
+        pos < (ste->pos + ste->index_interval)) {
+      return ste_scan_for_term(te, pos);      /* can avoid seek */
+    }
 
-  TermEnum *te = tir_enum(tir);
-  SegmentTermEnum *ste = (SegmentTermEnum *)te->data;
-  if (pos >= ste->pos &&
-      pos < (ste->pos + ste->index_interval)) {
-    return ste_scan_for_term(te, pos);      // can avoid seek
+    tir_seek_enum(tir, (int)(pos / ste->index_interval)); /* must seek */
+    return ste_scan_for_term(te, pos);
   }
-
-  tir_seek_enum(tir, (int)(pos / ste->index_interval)); // must seek
-  return ste_scan_for_term(te, pos);
 }
 
 int tir_get_term_pos(TermInfosReader *tir, Term *t)
 {
-  if (tir->size == 0)
+  if (tir->size == 0) {
     return -1;
+  } else {
+    TermEnum *te;
+    int ind_offset;
+    
+    tir_ensure_index_is_read(tir);
 
-  tir_ensure_index_is_read(tir);
-
-  int ind_offset = tir_get_index_offset(tir, t);
-  tir_seek_enum(tir, ind_offset);
+    ind_offset = tir_get_index_offset(tir, t);
+    tir_seek_enum(tir, ind_offset);
 
-  TermEnum *te = tir_enum(tir);
-  while ((tb_term_cmp(te->tb_curr, t) < 0) && (ste_next(te) != NULL))
-    ;
+    te = tir_enum(tir);
+    while ((tb_term_cmp(te->tb_curr, t) < 0) && (ste_next(te) != NULL)) {
+    }
 
-  if (tb_term_cmp(te->tb_curr, t) == 0)
-    return ((SegmentTermEnum *)te->data)->pos;
-  else
-    return -1;
+    if (tb_term_cmp(te->tb_curr, t) == 0) {
+      return ((SegmentTermEnum *)te->data)->pos;
+    } else {
+      return -1;
+    }
+  }
 }