ferret 0.3.2 → 0.9.0

data/ext/ram_store.c

@@ -0,0 +1,447 @@
+#include <string.h>
+#include <store.h>
+
+typedef struct RamFile {
+  char *name;
+  uchar **buffers;
+  int bufcnt;
+  int len;
+  int refcnt;
+  bool alive;
+} RamFile;
+
+RamFile *rf_create(const char *name)
+{
+  RamFile *rf = ALLOC(RamFile);
+  rf->buffers = ALLOC(uchar *);
+  rf->buffers[0] = ALLOC_N(uchar, BUFFER_SIZE);
+  rf->name = estrdup(name);
+  rf->len = 0;
+  rf->bufcnt = 1;
+  rf->refcnt = 0;
+  rf->alive = true;
+  return rf;
+}
+
+void rf_extend_if_necessary(RamFile *rf, int buf_num)
+{
+  while (rf->bufcnt <= buf_num) {
+    REALLOC_N(rf->buffers, uchar *, (rf->bufcnt + 1));
+    rf->buffers[rf->bufcnt++] = ALLOC_N(uchar, BUFFER_SIZE);
+  }
+}
+
+void rf_close(void *p)
+{
+  int i;
+  RamFile *rf = (RamFile *)p;
+  if (rf->refcnt > 0 || rf->alive) return;
+  free(rf->name);
+  for (i = 0; i < rf->bufcnt; i++) {
+    free(rf->buffers[i]);
+  }
+  free(rf->buffers);
+  free(rf);
+}
+
+void ram_touch(Store *store, char *filename)
+{
+  if (h_get(store->dir.ht, filename) == NULL)
+    h_set(store->dir.ht, filename, rf_create(filename));
+}
+
+int ram_exists(Store *store, char *filename)
+{
+  if (h_get(store->dir.ht, filename) != NULL)
+    return true;
+  else
+    return false;
+}
+
+int ram_remove(Store *store, char *filename)
+{
+  RamFile *rf = h_rem(store->dir.ht, filename, false);
+  if (rf != NULL) {
+    rf->alive = false;
+    rf_close(rf);
+    return true;
+  } else {
+    return false;
+  }
+}
+
+int ram_rename(Store *store, char *from, char *to)
+{
+  RamFile *rf = (RamFile *)h_rem(store->dir.ht, from, false);
+  if (rf == NULL)
+    eprintf(IO_ERROR, "tried to rename a file that doesn't exist");
+
+  free(rf->name);
+
+  rf->name = estrdup(to);
+
+  // clean up the file we are overwriting
+  RamFile *tmp = (RamFile *)h_get(store->dir.ht, to);
+  if (tmp != NULL)
+    tmp->alive = false;
+
+  h_set(store->dir.ht, rf->name, rf);
+  return true;
+}
+
+int ram_count(Store *store)
+{
+  return store->dir.ht->used;
+}
+
+void ram_each(Store *store, void (*func)(char *fname, void *arg), void *arg)
+{
+  HshTable *ht = store->dir.ht;
+  RamFile *rf;
+  int i;
+  for (i = 0; i <= ht->mask; i++) {
+    rf = (RamFile *)ht->table[i].value;
+    if (rf) {
+      if (strncmp(rf->name, LOCK_PREFIX, strlen(LOCK_PREFIX)) == 0)
+        continue;
+      func(rf->name, arg);
+    }
+  }
+}
+
+void ram_close(Store *store)
+{
+  HshTable *ht = store->dir.ht;
+  RamFile *rf;
+  int i;
+  for (i = 0; i <= ht->mask; i++) {
+    rf = (RamFile *)ht->table[i].value;
+    if (rf) rf->alive = false;
+  }
+  h_destroy(store->dir.ht);
+  store_destroy(store);
+}
+
+/*
+ * Be sure to keep the locks
+ */
+void ram_clear(Store *store)
+{
+  int i;
+  HshTable *ht = store->dir.ht;
+  RamFile *rf;
+  for (i = 0; i <= ht->mask; i++) {
+    rf = (RamFile *)ht->table[i].value;
+    if (rf && !file_is_lock(rf->name)) {
+      rf->alive = false;
+      h_del(ht, rf->name);
+    }
+  }
+}
+
+void ram_clear_locks(Store *store)
+{
+  int i;
+  HshTable *ht = store->dir.ht;
+  RamFile *rf;
+  for (i = 0; i <= ht->mask; i++) {
+    rf = (RamFile *)ht->table[i].value;
+    if (rf && file_is_lock(rf->name)) {
+      rf->alive = false;
+      h_del(ht, rf->name);
+    }
+  }
+}
+void ram_clear_all(Store *store)
+{
+  int i;
+  HshTable *ht = store->dir.ht;
+  RamFile *rf;
+  for (i = 0; i <= ht->mask; i++) {
+    rf = (RamFile *)ht->table[i].value;
+    if (rf) {
+      rf->alive = false;
+      h_del(ht, rf->name);
+    }
+  }
+}
+
+int ram_length(Store *store, char *filename)
+{
+  RamFile *rf = (RamFile *)h_get(store->dir.ht, filename);
+  if (rf != NULL)
+    return rf->len;
+  else
+    return 0;
+}
+
+int ramo_length(OutStream *os)
+{
+  return ((RamFile *)os->file)->len;
+}
+
+void ramo_flush_internal(OutStream *os, uchar *src, int len)
+{
+  RamFile *rf = (RamFile *)os->file;
+  int buffer_number, buffer_offset, bytes_in_buffer, bytes_to_copy;
+  int src_offset;
+  int pointer = os->pointer;
+ 
+  buffer_number = (int)(pointer / BUFFER_SIZE);
+  buffer_offset = pointer % BUFFER_SIZE;
+  bytes_in_buffer = BUFFER_SIZE - buffer_offset;
+  bytes_to_copy = bytes_in_buffer < len ? bytes_in_buffer : len;
+
+  rf_extend_if_necessary(rf, buffer_number);
+
+  uchar *buffer = rf->buffers[buffer_number];
+  memcpy(buffer + buffer_offset, src, bytes_to_copy);
+  
+  if (bytes_to_copy < len) {
+    src_offset = bytes_to_copy;
+    bytes_to_copy = len - bytes_to_copy;
+    buffer_number += 1;
+    rf_extend_if_necessary(rf, buffer_number);
+    buffer = rf->buffers[buffer_number];
+
+    memcpy(buffer, src + src_offset, bytes_to_copy);
+  }
+  os->pointer += len;
+
+  if (os->pointer > rf->len)
+    rf->len = os->pointer;
+}
+
+void ramo_seek_internal(OutStream *os, int pos)
+{
+  os->pointer = pos;
+}
+
+void ramo_reset(OutStream *os)
+{
+  RamFile *rf = (RamFile *)os->file;
+  os_seek(os, 0);
+  rf->len = 0;
+}
+
+void ramo_close_internal(OutStream *os)
+{
+  RamFile *rf = (RamFile *)os->file;
+  rf->refcnt--;
+  rf_close(rf);
+}
+
+void ramo_write_to(OutStream *os, OutStream *other_o)
+{
+  int i, len;
+  RamFile *rf = (RamFile *)os->file;
+  os_flush(os);
+  int last_buffer_number = (int)(rf->len / BUFFER_SIZE);
+  int last_buffer_offset = rf->len % BUFFER_SIZE;
+  for (i = 0; i <= last_buffer_number; i++) {
+    len = (i == last_buffer_number ? last_buffer_offset : BUFFER_SIZE);
+    os_write_bytes(other_o, rf->buffers[i], len);
+  }
+}
+
+OutStream *ram_create_buffer()
+{
+  RamFile *rf = rf_create("");
+  rf->alive = false;
+  OutStream *os = os_create();
+  os->file = rf;
+  os->pointer = 0;
+  os->flush_internal = &ramo_flush_internal;
+  os->seek_internal  = &ramo_seek_internal;
+  os->close_internal = &ramo_close_internal;
+  return os;
+}
+
+void ram_destroy_buffer(OutStream *os)
+{
+  rf_close(os->file);
+  free(os);
+}
+
+OutStream *ram_create_output(Store *store, const char *filename)
+{
+  RamFile *rf = (RamFile *)h_get(store->dir.ht, filename);
+  if (rf == NULL) {
+    rf = rf_create(filename);
+    h_set(store->dir.ht, rf->name, rf);
+  }
+  rf->refcnt++;
+  OutStream *os = os_create();
+  os->pointer = 0;
+  os->file = rf;
+  os->flush_internal = &ramo_flush_internal;
+  os->seek_internal  = &ramo_seek_internal;
+  os->close_internal = &ramo_close_internal;
+  return os;
+}
+
+void rami_read_internal(InStream *is, uchar *b, int offset, int len)
+{
+  RamFile *rf = (RamFile *)is->file;
+
+  int buffer_number, buffer_offset, bytes_in_buffer, bytes_to_copy;
+  int remainder = len;
+  int start = is->d.pointer;
+  uchar *buffer;
+  
+  while (remainder > 0) {
+    buffer_number = (int)(start / BUFFER_SIZE);
+    buffer_offset = start % BUFFER_SIZE;
+    bytes_in_buffer = BUFFER_SIZE - buffer_offset;
+    
+    if (bytes_in_buffer >= remainder) {
+      bytes_to_copy = remainder;
+    } else {
+      bytes_to_copy = bytes_in_buffer;
+    }
+    buffer = rf->buffers[buffer_number];
+    memcpy(b + offset, buffer + buffer_offset, bytes_to_copy);
+    offset += bytes_to_copy;
+    start += bytes_to_copy;
+    remainder -= bytes_to_copy;
+  }
+  
+  is->d.pointer += len;
+}
+
+int rami_length(InStream *is)
+{
+  return ((RamFile *)is->file)->len;
+}
+
+void rami_seek_internal(InStream *is, int pos)
+{
+  is->d.pointer = pos;
+}
+
+void rami_close_internal(InStream *is)
+{
+  RamFile *rf = (RamFile *)is->file;
+  rf->refcnt--;
+  rf_close(rf);
+}
+
+void rami_clone_internal(InStream *is, InStream *new_index_i)
+{
+  ((RamFile *)is->file)->refcnt++;
+}
+
+InStream *ram_open_input(Store *store, const char *filename)
+{
+  RamFile *rf = (RamFile *)h_get(store->dir.ht, filename);
+  if (rf == NULL) {
+    eprintf(IO_ERROR, "Couldn't open the ram file %s to read", filename);
+  }
+  rf->refcnt++;
+  InStream *is = is_create();
+  is->file = rf;
+  is->d.pointer = 0;
+  is->is_clone = false;
+  is->read_internal   = &rami_read_internal;
+  is->seek_internal   = &rami_seek_internal;
+  is->close_internal  = &rami_close_internal;
+  is->clone_internal  = &rami_clone_internal;
+  is->length_internal = &rami_length;
+  return is;
+}
+
+#define LOCK_OBTAIN_TIMEOUT 5
+
+int ram_lock_obtain(Lock *lock)
+{
+  int ret = true;
+  if (ram_exists(lock->store, lock->name))
+    ret = false;
+  ram_touch(lock->store, lock->name);
+  return ret;
+}
+
+int ram_lock_is_locked(Lock *lock)
+{
+  return ram_exists(lock->store, lock->name);
+}
+
+void ram_lock_release(Lock *lock)
+{
+  ram_remove(lock->store, lock->name);
+}
+
+Lock *ram_open_lock(Store *store, char *lockname)
+{
+  Lock *lock = ALLOC(Lock);
+  char lname[100];
+  sprintf(lname, "%s%s.lck", LOCK_PREFIX, lockname);
+  lock->name = estrdup(lname);
+  lock->store = store;
+  lock->obtain = &ram_lock_obtain;
+  lock->release = &ram_lock_release;
+  lock->is_locked = &ram_lock_is_locked;
+  return lock;
+}
+
+void ram_close_lock(Lock *lock)
+{
+  free(lock->name);
+  free(lock);
+}
+
+
+Store *open_ram_store()
+{
+  Store *new_store = store_create();
+
+  new_store->dir.ht        = h_new_str(NULL, rf_close);
+  new_store->touch         = &ram_touch;
+  new_store->exists        = &ram_exists;
+  new_store->remove        = &ram_remove;
+  new_store->rename        = &ram_rename;
+  new_store->count         = &ram_count;
+  new_store->close         = &ram_close;
+  new_store->clear         = &ram_clear;
+  new_store->clear_all     = &ram_clear_all;
+  new_store->clear_locks   = &ram_clear_locks;
+  new_store->length        = &ram_length;
+  new_store->each          = &ram_each;
+  new_store->create_output = &ram_create_output;
+  new_store->open_input    = &ram_open_input;
+  new_store->open_lock     = &ram_open_lock;
+  new_store->close_lock    = &ram_close_lock;
+  return new_store;
+}
+
+struct CopyFileArg {
+  Store *to_store, *from_store;
+};
+
+static void copy_files(char *fname, void *arg)
+{
+  struct CopyFileArg *cfa = (struct CopyFileArg *)arg;
+  OutStream *os = cfa->to_store->create_output(cfa->to_store, fname);
+  InStream *is = cfa->from_store->open_input(cfa->from_store, fname);
+  int len = is_length(is);
+  uchar buffer[len+1];
+  is_read_bytes(is, buffer, 0, len);
+  os_write_bytes(os, buffer, len);
+  is_close(is);
+  os_close(os);
+}
+
+Store *open_ram_store_and_copy(Store *from_store, bool close_dir)
+{
+  Store *store = open_ram_store();
+  struct CopyFileArg cfa;
+  cfa.to_store = store;
+  cfa.from_store = from_store;
+
+  from_store->each(from_store, &copy_files, &cfa);
+
+  if (close_dir)
+    from_store->close(from_store);
+
+  return store;
+}

data/ext/search.c

@@ -0,0 +1,524 @@
+#include <string.h>
+#include "search.h"
+
+/***************************************************************************
+ *
+ * Explanation
+ *
+ ***************************************************************************/
+
+Explanation *expl_create(float value, char *description)
+{
+  Explanation *self = ALLOC(Explanation);
+  self->value = value;
+  self->description = description;
+  self->dcnt = 0;
+  self->dcapa = EXPLANATION_DETAILS_START_SIZE;
+  self->details = ALLOC_N(Explanation *, EXPLANATION_DETAILS_START_SIZE);
+  return self;
+}
+
+void expl_destoy(void *p)
+{
+  Explanation *expl = (Explanation *)p;
+  int i;
+  for (i = 0; i < expl->dcnt; i++) {
+    expl_destoy(expl->details[i]);
+  }
+  free(expl->details);
+  free(expl->description);
+  free(expl);
+}
+
+Explanation *expl_add_detail(Explanation *self, Explanation *detail)
+{
+  if (self->dcnt >= self->dcapa) {
+    self->dcapa *= 2;
+    REALLOC_N(self->details, Explanation *, self->dcapa);
+  }
+  self->details[self->dcnt] = detail;
+  self->dcnt++;
+  return self;
+}
+
+char *expl_to_s(Explanation *self, int depth)
+{
+  int i;
+  char dbuf[32];
+  char *buffer = ALLOC_N(char, depth * 2 + 1);
+  memset(buffer, ' ', sizeof(char) * depth * 2);
+  buffer[depth*2] = 0;
+
+  dbl_to_s(dbuf, self->value);
+  buffer = estrcat(buffer, epstrdup("%s = %s\n",
+        strlen(dbuf) + strlen(self->description),
+        dbuf, self->description));
+  for (i = 0; i < self->dcnt; i++) {
+    buffer = estrcat(buffer, expl_to_s(self->details[i], depth + 1));
+  }
+
+  return buffer;
+}
+
+char *expl_to_html(Explanation *self)
+{
+  int i;
+  char dbuf[32];
+  char *buffer;
+  dbl_to_s(dbuf, self->value);
+  buffer = epstrdup("<ul>\n<li>%s = %s</li>\n",
+        strlen(dbuf) + strlen(self->description),
+        dbuf, self->description);
+
+  for (i = 0; i < self->dcnt; i++) {
+    estrcat(buffer, expl_to_html(self->details[i]));
+  }
+
+  REALLOC_N(buffer, char, strlen(buffer) + 10);
+  return strcat(buffer, "</ul>\n");
+}
+
+/***************************************************************************
+ *
+ * Hit
+ *
+ ***************************************************************************/
+
+bool hit_less_than(void *hit1, void *hit2)
+{
+  if (((Hit *)hit1)->score == ((Hit *)hit2)->score) {
+    return ((Hit *)hit1)->doc > ((Hit *)hit2)->doc;
+  } else {
+    return ((Hit *)hit1)->score < ((Hit *)hit2)->score;
+  }
+}
+
+inline bool hit_lt(Hit *hit1, Hit *hit2)
+{
+  if (hit1->score == hit2->score) {
+    return hit1->doc > hit2->doc;
+  } else {
+    return hit1->score < hit2->score;
+  }
+}
+
+void hit_pq_down(PriorityQueue *pq)
+{
+  register int i = 1;
+  register int j = 2; //i << 1;
+  register int k = 3; //j + 1;
+  Hit **heap = (Hit **)pq->heap;
+  Hit *node = heap[i]; // save top node
+
+  if ((k <= pq->count) && hit_lt(heap[k], heap[j]))
+    j = k;
+
+  while ((j <= pq->count) && hit_lt(heap[j], node)) {
+    heap[i] = heap[j];      // shift up child
+    i = j;
+    j = i << 1;
+    k = j + 1;
+    if ((k <= pq->count) && hit_lt(heap[k], heap[j]))
+      j = k;
+  }
+  heap[i] = node;
+}
+
+Hit *hit_pq_pop(PriorityQueue *pq)
+{
+  if (pq->count > 0) {
+    Hit *result = (Hit *)pq->heap[1];  // save first value
+    pq->heap[1] = pq->heap[pq->count]; // move last to first
+    pq->heap[pq->count] = NULL;
+    pq->count--;
+    hit_pq_down(pq);                   // adjust heap
+    return result;
+  } else {
+    return NULL;
+  }
+}
+
+inline void hit_pq_up(PriorityQueue *pq)
+{
+	int i,j;
+	i = pq->count;
+	j = i >> 1;
+  Hit **heap = (Hit **)pq->heap;
+  Hit *node = heap[i];
+
+	while ((j > 0) && hit_lt(node, heap[j])) {
+		heap[i] = heap[j];
+		i = j;
+		j = j >> 1;
+	}
+  heap[i] = node;
+}
+
+
+void hit_pq_push(PriorityQueue *pq, void *elem) 
+{
+  pq->count++;
+  pq->heap[pq->count] = elem;
+  hit_pq_up(pq);
+}
+
+
+
+/***************************************************************************
+ *
+ * TopDocs
+ *
+ ***************************************************************************/
+
+TopDocs *td_create(int total_hits, int size, Hit **hits)
+{
+  TopDocs *td = ALLOC(TopDocs);
+  td->total_hits = total_hits;
+  td->size = size;
+  td->hits = hits;
+  return td;
+}
+
+void td_destroy(void *p)
+{
+  TopDocs *td = (TopDocs *)p;
+  int i;
+  for (i = 0; i < td->size; i++) {
+    free(td->hits[i]);
+  }
+  free(td->hits);
+  free(td);
+}
+
+char *td_to_s(TopDocs *td)
+{
+  int i;
+  char dbuf[32];
+  Hit *hit;
+  char *buffer = epstrdup("%d hits sorted by <score, doc_num>\n", 20, td->total_hits);
+  for (i = 0; i < td->size; i++) {
+    hit = td->hits[i];
+    dbl_to_s(dbuf, hit->score);
+    estrcat(buffer, epstrdup("\t%d:%s\n", 52, hit->doc, dbuf));
+  }
+  return buffer;
+}
+
+/***************************************************************************
+ *
+ * Weight
+ *
+ ***************************************************************************/
+
+Query *w_get_query(Weight *self)
+{
+  return self->query;
+}
+
+float w_get_value(Weight *self)
+{
+  return self->value;
+}
+
+float w_sum_of_squared_weights(Weight *self)
+{
+  self->qweight = self->idf * self->query->boost;
+  return self->qweight * self->qweight; // square it
+}
+
+void w_normalize(Weight *self, float normalization_factor)
+{
+  self->qnorm = normalization_factor;
+  self->qweight *= normalization_factor; // normalize query weight
+  self->value = self->qweight * self->idf; // idf for document
+}
+
+/***************************************************************************
+ *
+ * Query
+ *
+ ***************************************************************************/
+
+Similarity *q_get_similarity(Query *self, Searcher *searcher)
+{
+  return searcher->get_similarity(searcher);
+}
+
+Query *q_rewrite(Query *self, IndexReader *ir)
+{
+  return self;
+}
+
+Weight *q_weight(Query *self, Searcher *searcher)
+{
+  if (self->weight) {
+    self->weight->destroy(self->weight);
+  }
+  Query  *query   = searcher->rewrite(searcher, self);
+  Weight *weight  = query->create_weight(query, searcher);
+  float   sum     = weight->sum_of_squared_weights(weight);
+  Similarity *sim = query->get_similarity(query, searcher);
+  float   norm    = sim_query_norm(sim, sum);
+
+  weight->normalize(weight, norm);
+  return self->weight = weight;
+}
+
+void q_destroy(Query *self)
+{
+  if (self->rewritten) {
+    self->rewritten->destroy(self->rewritten);
+    self->rewritten = NULL;
+  }
+  if (self->weight) {
+    self->weight->destroy(self->weight);
+  }
+  free(self);
+}
+
+void q_extract_terms(Query *self, Array *terms)
+{
+  /* do nothing by default */
+}
+
+Query *q_create()
+{
+  Query *self = ALLOC(Query);
+  ZEROSET(self, Query, 1);
+  self->destroy_all = true;
+  self->boost = 1.0;
+  self->rewrite = &q_rewrite;
+  self->get_similarity = &q_get_similarity;
+  self->extract_terms = &q_extract_terms;
+  self->weight = NULL;
+  self->rewritten = NULL;
+  return self;
+}
+
+/***************************************************************************
+ *
+ * Scorer
+ *
+ ***************************************************************************/
+
+void scorer_destroy(void *p)
+{
+  Scorer *scorer = (Scorer *)p;
+  free(scorer->data);
+  free(scorer);
+}
+
+Scorer *scorer_create(Similarity *similarity)
+{
+  Scorer *self = ALLOC(Scorer);
+  self->destroy = &scorer_destroy;
+  self->data = NULL;
+  self->similarity = similarity;
+  return self;
+}
+
+bool scorer_less_than(void *p1, void *p2)
+{
+  Scorer *s1 = (Scorer *)p1;
+  Scorer *s2 = (Scorer *)p2;
+  return s1->score(s1) < s2->score(s2);
+}
+
+bool scorer_doc_less_than(void *p1, void *p2)
+{
+  return ((Scorer *)p1)->doc < ((Scorer *)p2)->doc;
+}
+
+int scorer_doc_cmp(const void *p1, const void *p2)
+{
+  return (*(Scorer **)p1)->doc - (*(Scorer **)p2)->doc;
+}
+/***************************************************************************
+ *
+ * Searcher
+ *
+ ***************************************************************************/
+
+int sea_doc_freq(Searcher *self, Term *term)
+{
+  return self->ir->doc_freq(self->ir, term);
+}
+
+int *sea_doc_freqs(Searcher *self, Term **terms, int tcnt)
+{
+  int *freqs = ALLOC_N(int, tcnt);
+  int i;
+  for (i = 0; i < tcnt; i++) {
+    freqs[i] = self->ir->doc_freq(self->ir, terms[i]);
+  }
+  return freqs;
+}
+
+Document *sea_get_doc(Searcher *self, int doc_num)
+{
+  return self->ir->get_doc(self->ir, doc_num);
+}
+
+int sea_max_doc(Searcher *self)
+{
+  return self->ir->max_doc(self->ir);
+}
+
+Weight *sea_create_weight(Searcher *self, Query *query)
+{
+  return q_weight(query, self);
+}
+
+TopDocs *sea_search(Searcher *self, Query *query, int first_doc,
+    int num_docs, Filter *filter, Sort *sort)
+{
+  int max_size = first_doc + num_docs;
+  int i;
+  Weight *weight;
+  Scorer *scorer;
+  Hit **score_docs = NULL;
+  Hit *hit;
+  int total_hits = 0;
+  float min_score = 0.0, score;
+  BitVector *bits = (filter ? filter->get_bv(filter, self->ir) : NULL);
+  Hit *(*hq_pop)(PriorityQueue *pq);
+  void (*hq_down)(PriorityQueue *pq);
+  void (*hq_push)(PriorityQueue *pq, void *elem);
+  void (*hq_destroy)(void *p);
+  PriorityQueue *hq;
+
+
+  if (num_docs <= 0)
+    eprintf(ARG_ERROR, "num_docs must be > 0 to run a search");
+
+  if (first_doc < 0)
+    eprintf(ARG_ERROR, "first_doc must be >= 0 to run a search");
+
+  weight = q_weight(query, self);
+  scorer = weight->scorer(weight, self->ir);
+  if (!scorer) {
+    if (bits) bv_destroy(bits);
+    return td_create(0, 0, NULL);
+  }
+
+  if (sort) {
+    hq = fshq_pq_create(max_size, sort, self->ir);
+    hq_pop = &fshq_pq_pop;
+    hq_down = &fshq_pq_down;
+    hq_push = &fshq_pq_push;
+    hq_destroy = &fshq_pq_destroy;
+  } else {
+    hq = pq_create(max_size, &hit_less_than);
+    hq_pop = &hit_pq_pop;
+    hq_down = &hit_pq_down;
+    hq_push = &hit_pq_push;
+    hq_destroy = &pq_destroy;
+  }
+
+  while (scorer->next(scorer)) {
+    if (bits && !bv_get(bits, scorer->doc)) continue;
+    total_hits++;
+    score = scorer->score(scorer);
+    if (hq->count < max_size) {
+      hit = ALLOC(Hit);
+      hit->doc = scorer->doc; hit->score = score;
+      hq_push(hq, hit);
+      min_score = ((Hit *)pq_top(hq))->score; // maintain min_score
+    } else if (score > min_score) {
+      hit = pq_top(hq);
+      hit->doc = scorer->doc; hit->score = score;
+      hq_down(hq);
+      min_score = ((Hit *)pq_top(hq))->score; // maintain min_score
+    }
+  }
+  scorer->destroy(scorer);
+
+  if (hq->count > first_doc) {
+    if ((hq->count - first_doc) < num_docs) {
+      num_docs = hq->count - first_doc;
+    }
+    score_docs = ALLOC_N(Hit *, num_docs);
+    for (i = num_docs - 1; i >= 0; i--) {
+      score_docs[i] = hq_pop(hq);
+      //hit = score_docs[i] = pq_pop(hq);
+      //printf("hit = %d-->%f\n", hit->doc, hit->score);
+    }
+  } else {
+    num_docs = 0;
+  }
+  pq_clear(hq);
+  hq_destroy(hq);
+
+  if (bits) bv_destroy(bits);
+  return td_create(total_hits, num_docs, score_docs);
+}
+
+void sea_search_each(Searcher *self, Query *query, Filter *filter,
+    void (*fn)(Searcher *self, int doc_num, void *arg), void *arg)
+{
+  Weight *weight;
+  Scorer *scorer;
+  BitVector *bits = (filter ? filter->get_bv(filter, self->ir) : NULL);
+
+  weight = q_weight(query, self);
+  scorer = weight->scorer(weight, self->ir);
+  if (!scorer) {
+    if (bits) bv_destroy(bits);
+    return;
+  }
+
+  while (scorer->next(scorer)) {
+    if (bits && !bv_get(bits, scorer->doc)) continue;
+    fn(self, scorer->doc, arg);
+  }
+  scorer->destroy(scorer);
+}
+
+Query *sea_rewrite(Searcher *self, Query *original)
+{
+  Query *query = original;
+  Query *rewritten_query = query->rewrite(query, self->ir);
+  while (query != rewritten_query) {
+    query = rewritten_query;
+    rewritten_query = query->rewrite(query, self->ir);
+  }
+  return query;
+}
+
+Explanation *sea_explain(Searcher *self, Query *query, int doc_num)
+{
+  Weight *weight = q_weight(query, self);
+  return weight->explain(weight, self->ir, doc_num);
+}
+
+Similarity *sea_get_similarity(Searcher *self)
+{
+  return self->similarity;
+}
+
+void sea_close(Searcher *self)
+{
+  if (self->ir)
+    ir_close(self->ir);
+  free(self);
+}
+
+Searcher *sea_create(IndexReader *ir)
+{
+  Searcher *self = ALLOC(Searcher);
+  self->ir = ir;
+  self->similarity = sim_create_default();
+  self->doc_freq = &sea_doc_freq;
+  self->doc_freqs = &sea_doc_freqs;
+  self->get_doc = &sea_get_doc;
+  self->max_doc = &sea_max_doc;
+  self->create_weight = &sea_create_weight;
+  self->search = &sea_search;
+  self->rewrite = &sea_rewrite;
+  self->explain = &sea_explain;
+  self->get_similarity = &sea_get_similarity;
+  self->close = &sea_close;
+  return self;
+}
+
+