ferret 0.9.6 → 0.10.0

data/ext/r_term.c

@@ -1,219 +0,0 @@
-#include "ferret.h"
-#include "index.h"
-
-VALUE cTerm;
-/****************************************************************************
- *
- * Term Methods
- *
- ****************************************************************************/
-
-typedef struct RTerm {
-  VALUE field;
-  VALUE text;
-} RTerm;
-
-void
-frt_term_mark(void *p)
-{
-  RTerm *term = (RTerm *)p;
-  rb_gc_mark(term->field);
-  rb_gc_mark(term->text);
-}
-
-static VALUE
-frt_term_alloc(VALUE klass)
-{
-  RTerm *term = ALLOC(RTerm);
-  term->field = Qnil;
-  term->text = Qnil;
-  return Data_Wrap_Struct(klass, &frt_term_mark, &free, term);
-}
-
-#define GET_TERM RTerm *term; Data_Get_Struct(self, RTerm, term)
-static VALUE 
-frt_term_init(VALUE self, VALUE rfield, VALUE rtext)
-{
-  GET_TERM;
-  term->field = rb_obj_as_string(rfield);
-  term->text = rb_obj_as_string(rtext);
-  return self;
-}
-
-VALUE
-frt_get_rterm(char *field, char *text)
-{
-  RTerm *rterm = ALLOC(RTerm);
-  rterm->field = rb_str_new2(field);
-  rterm->text = rb_str_new2(text);
-  return Data_Wrap_Struct(cTerm, &frt_term_mark, &free, rterm);
-}
-
-Term *
-frt_set_term(VALUE self, Term *t)
-{
-  GET_TERM;
-  t->field = RSTRING(term->field)->ptr;
-  t->text = RSTRING(term->text)->ptr;
-  return t;
-}
-
-Term *
-frt_get_term(VALUE self)
-{
-  Term *t = NULL;
-  if (self != Qnil) {
-    GET_TERM;
-    t = ALLOC(Term);
-    /* store text and field in text so that field will be freed with text */
-    t->text = ALLOC_N(char, RSTRING(term->text)->len +
-        RSTRING(term->field)->len + 2);
-    sprintf(t->text, "%s %s", RSTRING(term->text)->ptr,
-        RSTRING(term->field)->ptr);
-    t->text[RSTRING(term->text)->len] = '\0';
-    t->field = t->text + RSTRING(term->text)->len + 1;
-  }
-  return t;
-}
-
-static VALUE 
-frt_term_get_text(VALUE self)
-{
-  GET_TERM;
-  return term->text;
-}
-
-static VALUE 
-frt_term_set_text(VALUE self, VALUE rtext)
-{
-  GET_TERM;
-  term->text = rb_obj_as_string(rtext);
-  return Qnil;
-}
-
-static VALUE 
-frt_term_get_field(VALUE self)
-{
-  GET_TERM;
-  return term->field;
-}
-
-static VALUE 
-frt_term_set_field(VALUE self, VALUE rfield)
-{
-  GET_TERM;
-  term->field = rb_obj_as_string(rfield);
-  return Qnil;
-}
-
-VALUE 
-frt_term_to_s(VALUE self)
-{
-  int tlen, flen;
-  char *res;
-  GET_TERM;
-  tlen = RSTRING(term->text)->len;
-  flen = RSTRING(term->field)->len;
-  res = alloca(flen + tlen + 1);    
-  
-  MEMCPY(res, StringValuePtr(term->field), char, flen);
-  res[flen] = ':';
-  MEMCPY(res + flen + 1, StringValuePtr(term->text), char, tlen);
-  return rb_str_new(res, tlen + flen + 1 );
-}
-
-inline int
-frt_term_cmp(RTerm *t1, RTerm *t2)
-{
-  int comp = rb_str_cmp(t1->field, t2->field);
-  if (comp == 0) {
-    comp = rb_str_cmp(t1->text, t2->text);
-  }
-  return comp;
-}
-
-int
-frt_term_compare_to_int(VALUE self, VALUE rother)
-{
-  RTerm *other;
-  GET_TERM;
-  Data_Get_Struct(rother, RTerm, other);
-  return frt_term_cmp(term, other);
-}
-
-VALUE
-frt_term_lt(VALUE self, VALUE rother)
-{
-  return frt_term_compare_to_int(self, rother) < 0 ? Qtrue : Qfalse;
-}
-
-VALUE
-frt_term_gt(VALUE self, VALUE rother)
-{
-  return frt_term_compare_to_int(self, rother) > 0 ? Qtrue : Qfalse;
-}
-
-VALUE
-frt_term_le(VALUE self, VALUE rother)
-{
-  return frt_term_compare_to_int(self, rother) <= 0 ? Qtrue : Qfalse;
-}
-
-VALUE
-frt_term_ge(VALUE self, VALUE rother)
-{
-  return frt_term_compare_to_int(self, rother) >= 0 ? Qtrue : Qfalse;
-}
-
-VALUE
-frt_term_eq(VALUE self, VALUE rother)
-{
-  if (rother == Qnil)
-    return Qfalse;
-  return frt_term_compare_to_int(self, rother) == 0 ? Qtrue : Qfalse;
-}
-
-
-static VALUE
-frt_term_compare_to(VALUE self, VALUE other)
-{
-  return INT2FIX(frt_term_compare_to_int(self, other));
-}
-
-static VALUE
-frt_term_hash(VALUE self)
-{
-  GET_TERM;
-  return INT2FIX(rb_str_hash(term->field) + rb_str_hash(term->text));
-}
-
-/****************************************************************************
- *
- * Init Function
- *
- ****************************************************************************/
-
-void
-Init_term(void)
-{
-  /* Term */
-  cTerm = rb_define_class_under(mIndex, "Term", rb_cObject);
-  rb_define_alloc_func(cTerm, frt_term_alloc);
-  rb_include_module(cTerm, rb_mComparable);
-
-  rb_define_method(cTerm, "initialize", frt_term_init, 2);
-  rb_define_method(cTerm, "set!", frt_term_init, 2);
-  rb_define_method(cTerm, "to_s", frt_term_to_s, 0);
-  rb_define_method(cTerm, "<=>", frt_term_compare_to, 1);
-  rb_define_method(cTerm, "<", frt_term_lt, 1);
-  rb_define_method(cTerm, ">", frt_term_gt, 1);
-  rb_define_method(cTerm, "<=", frt_term_le, 1);
-  rb_define_method(cTerm, ">=", frt_term_ge, 1);
-  rb_define_method(cTerm, "eql?", frt_term_eq, 1);
-  rb_define_method(cTerm, "==", frt_term_eq, 1);
-  rb_define_method(cTerm, "text", frt_term_get_text, 0);
-  rb_define_method(cTerm, "text=", frt_term_set_text, 1);
-  rb_define_method(cTerm, "field", frt_term_get_field, 0);
-  rb_define_method(cTerm, "field=", frt_term_set_field, 1);
-  rb_define_method(cTerm, "hash", frt_term_hash, 0);
-}

data/ext/term.c

@@ -1,820 +0,0 @@
-#include "index.h"
-#include "helper.h"
-#include "hash.h"
-#include <string.h>
-
-static char * const FORMAT_VERSION_ERROR_MSG = "Unknown format version";
-static char * const TERM_ORDER_ERROR_MSG = "term out of order";
-static char * const FP_ORDER_ERROR_MSG = "freq pointer out of order";
-static char * const PP_ORDER_ERROR_MSG = "prox pointer out of order";
-
-/****************************************************************************
- *
- * Term
- *
- ****************************************************************************/
-
-Term *term_clone(Term *term)
-{
-  Term *t = ALLOC(Term);
-
-  t->field = term->field;
-  t->text = estrdup(term->text);
-  return t;
-}
-
-Term *term_create(const char *field, char *text)
-{
-  Term *t = ALLOC(Term);
-
-  t->field = (char *)field;
-  t->text = estrdup(text);
-  return t;
-}
-
-void term_destroy(Term *self)
-{
-  free(self->text);
-  free(self);
-}
-
-int term_cmp(void *t1, void *t2)
-{
-  int res = strcmp(((Term *)t1)->field, ((Term *)t2)->field);
-  if (res != 0) {
-    return res;
-  } else {
-    return strcmp(((Term *)t1)->text, ((Term *)t2)->text);
-  }
-}
-
-int term_eq(const void *t1, const void *t2)
-{
-  return (strcmp(((Term *)t1)->text, ((Term *)t2)->text)) == 0 &&
-    (strcmp(((Term *)t1)->field, ((Term *)t2)->field) == 0);
-}
-
-unsigned int term_hash(const void *t)
-{
-  return str_hash(((Term *)t)->text) * str_hash(((Term *)t)->field);
-}
-
-char *term_to_s(Term *term)
-{
-  char *string = ALLOC_N(char, strlen(term->field) + strlen(term->text) + 2);
-  sprintf(string, "%s:%s", term->field, term->text);
-  return string;
-}
-
-/****************************************************************************
- *
- * TermBuffer
- *
- ****************************************************************************/
-
-void tb_reset(TermBuffer *tb)
-{
-  tb->field = (char *)EMPTY_STRING;
-  tb->text[0] = '\0';
-}
-
-TermBuffer *tb_create()
-{
-  TermBuffer *tb = ALLOC(TermBuffer);
-  tb->field = (char *)EMPTY_STRING;
-  tb->text[0] = '\0';
-  return tb;
-}
-
-void tb_destroy(TermBuffer *tb)
-{
-  free(tb);
-}
-
-TermBuffer *tb_set_term(TermBuffer *tb, Term *t)
-{
-  tb->field = t->field;
-  strcpy(tb->text, t->text);
-  return tb;
-}
-
-Term *tb_get_term(TermBuffer *tb)
-{
-  return term_create(tb->field, tb->text);
-}
-
-int tb_cmp(TermBuffer *tb1, TermBuffer *tb2)
-{
-  int res;
-  if ((tb1->field != tb2->field) &&
-      (0 != (res = strcmp(tb1->field, tb2->field)))) {
-    return res;
-  } else {
-    return strcmp(tb1->text, tb2->text);
-  }
-}
-
-int tb_term_cmp(TermBuffer *tb, Term *t)
-{
-  int res = strcmp(tb->field, t->field);
-  if (res != 0) {
-    return res;
-  } else {
-    return strcmp(tb->text, t->text);
-  }
-}
-
-TermBuffer *tb_cpy(TermBuffer *tb1, TermBuffer *tb2)
-{
-  tb1->field = tb2->field;
-  strcpy(tb1->text, tb2->text);
-  return tb1;
-}
-
-TermBuffer *tb_read(TermBuffer *tb, InStream *is, FieldInfos *fis)
-{
-  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';
-  fnum = (signed int)is_read_vint(is);
-  if (fnum < 0)
-    tb->field = (char *)EMPTY_STRING;
-  else
-    tb->field = fis->by_number[fnum]->name;
-  return tb;
-}
-
-/****************************************************************************
- *
- * TermInfo
- *
- ****************************************************************************/
-
-TermInfo *ti_create(int doc_freq, int freq_pointer, int prox_pointer, int skip_offset)
-{
-  TermInfo *ti = ALLOC(TermInfo);
-  ti->doc_freq = doc_freq;
-  ti->freq_pointer = freq_pointer;
-  ti->prox_pointer = prox_pointer;
-  ti->skip_offset = skip_offset;
-  return ti;
-}
-
-TermInfo *ti_set(TermInfo *ti, int doc_freq, int freq_pointer, int prox_pointer, int skip_offset)
-{
-  ti->doc_freq = doc_freq;
-  ti->freq_pointer = freq_pointer;
-  ti->prox_pointer = prox_pointer;
-  ti->skip_offset = skip_offset;
-  return ti;
-}
-
-void ti_destroy(TermInfo *ti)
-{
-  free(ti);
-}
-
-TermInfo *ti_cpy(TermInfo *ti, TermInfo *other)
-{
-  memcpy(ti, other, sizeof(TermInfo));
-  return ti;
-}
-
-TermInfo *ti_clone(TermInfo *other)
-{
-  return ti_create(other->doc_freq,
-      other->freq_pointer, other->prox_pointer, other->skip_offset);
-}
-
-int ti_eq(TermInfo *ti, TermInfo *other)
-{
-  return (memcmp(ti, other, sizeof(TermInfo)) == 0);
-}
-
-/****************************************************************************
- *
- * TermEnum
- *
- ****************************************************************************/
-
-TermEnum *te_create()
-{
-  TermEnum *te = ALLOC(TermEnum);
-  te->tb_curr = tb_create();
-  te->tb_prev = tb_create();
-  te->ti_curr = ti_create(0, 0, 0, 0);
-  return te;
-}
-
-void te_destroy(TermEnum *te)
-{
-  tb_destroy(te->tb_curr);
-  tb_destroy(te->tb_prev);
-  ti_destroy(te->ti_curr);
-  free(te);
-}
-
-Term *te_get_term(TermEnum *te)
-{
-  return tb_get_term(te->tb_curr);
-}
-
-TermInfo *te_get_ti(TermEnum *te)
-{
-  TermInfo *ti = te->ti_curr;
-  return ti_create(ti->doc_freq, ti->freq_pointer, ti->prox_pointer, ti->skip_offset);
-}
-
-TermBuffer *te_skip_to(TermEnum *te, Term *t)
-{
-  TermBuffer *tb_curr;
-  if (tb_term_cmp(te->tb_curr, t) == 0)
-    return te->tb_curr;
-
-  while (((tb_curr = te->next(te)) != NULL) &&
-      (tb_term_cmp(tb_curr, t) < 0)) {
-  }
-  return tb_curr;
-}
-
-/****************************************************************************
- *
- * SegmentTermEnum
- *
- ****************************************************************************/
-
-#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) {
-    tb_reset(te->tb_curr);
-    return NULL;
-  }
-
-  tb_cpy(te->tb_prev, te->tb_curr);
-  tb_read(te->tb_curr, is, ste->fis);
-  
-  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 */
-    if (!ste->is_index) {
-      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 = (int)is_read_vint(is);
-    }
-  }
-  
-  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;
-  ste = ALLOC(SegmentTermEnum);
-  te->data = ste;
-  return te;
-}
-
-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);
-  tb_cpy(te->tb_prev, other_te->tb_prev);
-  ti_cpy(te->ti_curr, other_te->ti_curr);
-  return te;
-}
-
-void ste_close(TermEnum *te)
-{
-  GET_STE;
-  is_close(ste->is);
-  free(ste);
-  te->data = NULL;
-  te_destroy(te);
-}
-
-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;
-  ste->pos = -1;
-  ste->index_pointer = 0;
-  ste->format_m1skip_interval = -1;
-
-  first_int = (int)is_read_int(is);
-
-  if (first_int >= 0) {
-    /* original-format file, without explicit format version number */
-    ste->format = 0;
-    ste->size = first_int;
-
-    /* back-compatible settings */
-    ste->index_interval = 128;
-    ste->skip_interval = INT_MAX; /* switch off skip_to optimization */
-
-  } else {
-    /* check that it is a format we can understand */
-    if (first_int < TERM_INFO_FORMAT)
-      RAISE(EXCEPTION, FORMAT_VERSION_ERROR_MSG);
-
-    /* we have a format version number */
-    ste->format = first_int;
-
-
-    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 */
-      ste->skip_interval = INT_MAX;
-    } else {
-      ste->index_interval = is_read_int(is);
-      ste->skip_interval = is_read_int(is);
-    }
-  }
-  return te;
-}
-
-void ste_seek(TermEnum *te, int pointer, int pos, Term *t, TermInfo *ti)
-{
-  GET_STE;
-  is_seek(ste->is, pointer);
-  ste->pos = pos;
-  tb_set_term(te->tb_curr, t);
-  tb_reset(te->tb_prev);
-  ti_cpy(te->ti_curr, ti);
-}
-
-TermInfo *ste_scan_for_term_info(TermEnum *te, Term *t)
-{
-  te_skip_to(te, t);
-
-  if (tb_term_cmp(te->tb_curr, t) == 0) {
-    return te_get_ti(te);
-  } else {
-    return NULL;
-  }
-}
-
-Term *ste_scan_for_term(TermEnum *te, int pos)
-{
-  GET_STE;
-  while (ste->pos < pos) {
-    if (ste_next(te) == NULL)
-      return NULL;
-  }
-
-  return te_get_term(te);
-}
-
-/****************************************************************************
- *
- * MultiTermEnum
- *
- ****************************************************************************/
-
-#define GET_MTE MultiTermEnum *mte = (MultiTermEnum *)te->data
-
-TermBuffer *mte_next(TermEnum *te)
-{
-  GET_MTE;
-  SegmentMergeInfo *top = (SegmentMergeInfo *)pq_top(mte->smi_queue);
-
-  if (top == NULL) {
-    tb_reset(te->tb_curr);
-    return false;
-  }
-
-  tb_cpy(te->tb_prev, te->tb_curr);
-  tb_cpy(te->tb_curr, top->tb);
-
-  te->ti_curr->doc_freq = 0;
-
-  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 */
-    if (smi_next(top)) {
-      pq_push(mte->smi_queue, top); /* restore queue */
-    } else {
-      smi_destroy(top);             /* done with a segment */
-    }
-    top = (SegmentMergeInfo *)pq_top(mte->smi_queue);
-  }
-  return te->tb_curr;
-}
-
-void mte_close(TermEnum *te)
-{
-  GET_MTE;
-  pq_clear(mte->smi_queue);
-  pq_destroy(mte->smi_queue);
-  free(mte);
-  te_destroy(te);
-}
-
-TermEnum *mte_clone(TermEnum *te)
-{
-  RAISE(UNSUPPORTED_ERROR, UNSUPPORTED_ERROR_MSG);
-  return NULL;
-}
-
-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;
-
-  te->data = mte;
-
-  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) {
-      sub_te = reader->terms_from(reader, t);
-    } else {
-      sub_te = reader->terms(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 */
-    } else {
-      smi_destroy(smi);
-    }
-  }
-
-  if ((t != NULL) && (mte->smi_queue->count > 0)) {
-    mte_next(te);
-  }
-
-  return te;
-}
-
-/****************************************************************************
- *
- * TermInfosWriter
- *
- ****************************************************************************/
-
-const Term EmptyTerm = {"", ""};
-
-TermInfosWriter *tiw_open_internal(Store *store,
-    char *segment,
-    FieldInfos *fis,
-    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;
-  tiw->last_term = (Term *)&EmptyTerm;
-  tiw->last_term_info = ti_create(0,0,0,0);
-  tiw->size = 0;
-  tiw->is_index = is_index;
-  tiw->fis = fis;
-  tiw->curr_field = NULL;
-  tiw->curr_field_num = -1;
-
-  strcpy(fname, segment);
-  strcat(fname, (is_index ? ".tii" : ".tis"));
-  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;
-  }
-  return tiw;
-}
-
-TermInfosWriter *tiw_open(Store *store, char *segment, FieldInfos *fis, int interval)
-{
-  return tiw_open_internal(store, segment, fis, interval, false);
-}
-
-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 = (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 */
-  if (tiw->curr_field != t->field) {
-    tiw->curr_field = t->field;
-    tiw->curr_field_num = fis_get_number(tiw->fis, t->field);
-  }
-  os_write_vint(os, tiw->curr_field_num);
-  tiw->last_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);
-  }
-  if (ti->freq_pointer < tiw->last_term_info->freq_pointer) {
-    RAISE(STATE_ERROR, FP_ORDER_ERROR_MSG); 
-  }
-  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) {
-    /* 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 */
-  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) {
-    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 */
-  }
-
-  ti_cpy(tiw->last_term_info, ti);
-  tiw->size++;
-}
-
-void tiw_close(TermInfosWriter *tiw)
-{
-  OutStream *os = tiw->os;
-  os_seek(os, 4); /* write @size after format */
-  os_write_long(os, tiw->size);
-  os_close(os);
-
-  if (!tiw->is_index)
-    tiw_close(tiw->other);
-
-  ti_destroy(tiw->last_term_info);
-  free(tiw);
-}
-
-/****************************************************************************
- *
- * TermInfosReader
- *
- ****************************************************************************/
-
-void tir_close(TermInfosReader *tir)
-{
-  int i;
-  if (tir->index_terms != NULL) {
-    for (i = 0; i < tir->index_size; i++) {
-      term_destroy(tir->index_terms[i]);
-      ti_destroy(tir->index_term_infos[i]);
-    }
-    free(tir->index_terms);
-    free(tir->index_term_infos);
-    free(tir->index_pointers);
-  }
-  if (tir->orig_te) tir->orig_te->close(tir->orig_te);
-  thread_key_delete(tir->thread_te);
-  ary_destroy(tir->te_bucket);
-  if (tir->index_te) tir->index_te->close(tir->index_te);
-  mutex_destroy(&tir->mutex);
-  free(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");
-  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, (free_ft)tir->orig_te->close);
-
-  ste = tir->orig_te->data;
-  tir->size = ste->size;
-  tir->skip_interval = ste->skip_interval;
-
-  strcpy(fname + strlen(segment), ".tii");
-  is = store->open_input(store, fname);
-  tir->index_te = ste_create(is, fis, true);
-  tir->index_terms = NULL;
-  tir->index_term_infos = NULL;
-  tir->index_pointers = NULL;
-  return tir;
-}
-
-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;
-
-    tir->index_terms = ALLOC_N(Term *, index_size);
-    tir->index_term_infos = ALLOC_N(TermInfo *, index_size);
-    tir->index_pointers = ALLOC_N(int, index_size);
-
-    index_te = tir->index_te;
-    ste = index_te->data;
-
-    TRY
-      while (ste_next(index_te) != NULL) {
-        tir->index_terms[i] = te_get_term(index_te);
-        tir->index_term_infos[i] = te_get_ti(index_te);
-        tir->index_pointers[i] = ste->index_pointer;
-        i++;
-      }
-    XFINALLY
-      index_te->close(index_te);
-      tir->index_te = NULL;
-    XENDTRY
-  }
-  mutex_unlock(&tir->mutex);
-}
-
-static inline TermEnum *tir_enum(TermInfosReader *tir)
-{
-  TermEnum *te;
-  if ((te = thread_getspecific(tir->thread_te)) == NULL) {
-    te = tir->orig_te->clone(tir->orig_te);
-    ary_append(tir->te_bucket, te);
-    thread_setspecific(tir->thread_te, te);
-  }
-  return te;
-}
-
-void tir_seek_enum(TermInfosReader *tir, int ind_offset)
-{
-  TermEnum *te = tir_enum(tir);
-  SegmentTermEnum *ste = (SegmentTermEnum *)te->data;
-  ste_seek(te, tir->index_pointers[ind_offset],
-      (ind_offset * ste->index_interval) - 1,
-      tir->index_terms[ind_offset],
-      tir->index_term_infos[ind_offset]);
-}
-
-int tir_get_index_offset(TermInfosReader *tir, Term *t)
-{
-  int lo = 0;            /* binary search tir->index_terms[] */
-  int hi = tir->index_size - 1;
-  int mid, delta;
-  Term **index_terms = tir->index_terms;
-
-  while (hi >= lo) {
-    mid = (lo + hi) >> 1;
-    delta = term_cmp(t, index_terms[mid]);
-    if (delta < 0) {
-      hi = mid - 1;
-    } else if (delta > 0) {
-      lo = mid + 1;
-    } else {
-      return mid;
-    }
-  }
-  return hi;
-}
-
-TermInfo *tir_get_ti(TermInfosReader *tir, Term *t)
-{
-  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 */
-  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 */
-    }
-  }
-
-  /* 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) {
-    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 */
-    }
-
-    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) {
-    return -1;
-  } else {
-    TermEnum *te;
-    int ind_offset;
-    
-    tir_ensure_index_is_read(tir);
-
-    ind_offset = tir_get_index_offset(tir, t);
-    tir_seek_enum(tir, ind_offset);
-
-    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;
-    }
-  }
-}
-