ferret 0.3.2 → 0.9.0

data/ext/lang.c

@@ -0,0 +1,31 @@
+#include <stdarg.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+#include "global.h"
+
+void ft_raise(char *file, int line_num, VALUE etype, const char *fmt, ...)
+{
+  va_list args;
+  char buf[MAX_ERROR_LEN];
+  char *buf_ptr = buf;
+
+  if (progname() != NULL) {
+    sprintf(buf_ptr, "%s: ", progname());
+    buf_ptr += strlen(buf_ptr);
+  }
+
+  sprintf(buf_ptr, "Error occured at <%s>:%d\n", file, line_num);
+  buf_ptr += strlen(buf_ptr);
+  va_start(args, fmt);
+  vsprintf(buf_ptr, fmt, args);
+  buf_ptr += strlen(buf_ptr);
+  va_end(args);
+
+  if (fmt[0] != '\0' && fmt[strlen(fmt)-1] == ':') {
+    sprintf(buf_ptr, " %s", strerror(errno));
+    buf_ptr += strlen(buf_ptr);
+  }
+  sprintf(buf_ptr, "\n");
+  rb_raise(etype, buf); /* conventional value for failed execution */
+}

data/ext/lang.h

@@ -0,0 +1,41 @@
+#ifndef FRT_LANG_H
+#define FRT_LANG_H
+
+#include <ruby.h>
+
+#define FERRET_EXT
+
+#define MAX_ERROR_LEN 2048
+#define eprintf(...) ft_raise(__FILE__, __LINE__, __VA_ARGS__)
+extern void ft_raise(char *file, int line_num, VALUE etype, const char *fmt, ...);
+extern void weprintf(const char *fmt, ...);
+extern char *progname(void);
+extern void setprogname(const char *str);
+
+extern VALUE cQueryParseException;
+
+#define ERROR rb_eException
+#define IO_ERROR rb_eIOError
+#define ARG_ERROR rb_eArgError
+#define EOF_ERROR rb_eEOFError
+#define UNSUPPORTED_ERROR rb_eNotImpError
+#define STATE_ERROR rb_eException
+#define PARSE_ERROR cQueryParseException
+#define MEM_ERROR rb_eNoMemError
+
+typedef void * mutex_t;
+typedef void * thread_key_t;
+#define MUTEX_INITIALIZER NULL
+#define MUTEX_RECURSIVE_INITIALIZER NULL
+#define mutex_init(a, b)
+#define mutex_lock(a)
+#define mutex_trylock(a)
+#define mutex_unlock(a)
+#define mutex_destroy(a)
+#define thread_key_create(a, b)
+#define thread_key_delete(a)
+#define thread_setspecific(a, b)
+#define thread_getspecific(a) NULL
+#define thread_exit(a)
+
+#endif

data/ext/priorityqueue.c

@@ -0,0 +1,228 @@
+#include <priorityqueue.h>
+  
+PriorityQueue *pq_create(int max_size, bool (*less_than)(void *p1, void *p2))
+{
+  PriorityQueue *pq = ALLOC(PriorityQueue);
+  pq->count = 0;
+  pq->size = max_size;
+  pq->heap = ALLOC_N(void *, (max_size + 1));
+  pq->lt = less_than;
+  pq->free_elem = &free;
+  return pq;
+}
+
+void pq_destroy(void *p)
+{
+  PriorityQueue *pq = (PriorityQueue *)p;
+  free(pq->heap);
+  free(p);
+}
+
+void pq_up(PriorityQueue *pq)
+{
+	int i,j;
+	i = pq->count;
+	j = i >> 1;
+  void **heap = pq->heap;
+  void *node = heap[i];
+
+	while ((j > 0) && pq->lt(node, heap[j])) {
+		heap[i] = heap[j];
+		i = j;
+		j = j >> 1;
+	}
+  heap[i] = node;
+}
+
+void pq_down(PriorityQueue *pq)
+{
+  register int i = 1;
+  register int j = 2; //i << 1;
+  register int k = 3; //j + 1;
+  register int count = pq->count;
+  void **heap = pq->heap;
+  void *node = heap[i]; // save top node
+
+  if ((k <= count) && (pq->lt(heap[k], heap[j])))
+    j = k;
+
+  while ((j <= count) && pq->lt(heap[j], node)) {
+    heap[i] = heap[j];      // shift up child
+    i = j;
+    j = i << 1;
+    k = j + 1;
+    if ((k <= count) && pq->lt(heap[k], heap[j]))
+      j = k;
+  }
+  heap[i] = node;
+}
+
+void pq_push(PriorityQueue *pq, void *elem) 
+{
+  pq->count++;
+  pq->heap[pq->count] = elem;
+  pq_up(pq);
+}
+
+void *pq_top(PriorityQueue *pq)
+{
+  return pq->heap[1];
+}
+
+void *pq_pop(PriorityQueue *pq)
+{
+  if (pq->count > 0) {
+    void *result = pq->heap[1];        // save first value
+    pq->heap[1] = pq->heap[pq->count]; // move last to first
+    pq->heap[pq->count] = NULL;
+    pq->count--;
+    pq_down(pq);                       // adjust heap
+    return result;
+  } else {
+    return NULL;
+  }
+}
+
+void pq_clear(PriorityQueue *pq)
+{
+  int i;
+  for (i = 1; i <= pq->count; i++) {
+    pq->free_elem(pq->heap[i]);
+    pq->heap[i] = NULL;
+  }
+  pq->count = 0;
+}
+
+int pq_insert(PriorityQueue *pq, void *elem) 
+{
+  if (pq->count < pq->size) {
+    pq_push(pq, elem);
+    return true;
+  } else if (pq->count > 0 && pq->lt(pq_top(pq), elem)) {
+    pq->free_elem(pq->heap[1]);
+    pq->heap[1] = elem;
+    pq_down(pq);
+    return true;
+  } else {
+    pq->free_elem(elem);
+    return false;
+  }
+}
+
+/*****************************************************************************
+ *
+ * PriorityQueue2
+ *
+ *****************************************************************************/
+
+PriorityQueue2 *pq2_create(int max_size,
+    bool (*less_than)(PriorityQueue2 *pq, void *p1, void *p2),
+    void (*destroy)(void *p))
+{
+  PriorityQueue2 *pq = ALLOC(PriorityQueue2);
+  pq->count = 0;
+  pq->size = max_size;
+  pq->heap = ALLOC_N(void *, (max_size + 1));
+  pq->lt = less_than;
+  pq->free_elem = &free;
+  pq->destroy = destroy;
+  return pq;
+}
+
+void pq2_destroy(void *p)
+{
+  PriorityQueue2 *pq = (PriorityQueue2 *)p;
+  free(pq->heap);
+  free(p);
+}
+
+void pq2_up(PriorityQueue2 *pq)
+{
+	int i,j;
+	i = pq->count;
+	j = i >> 1;
+  void **heap = pq->heap;
+  void *node = heap[i];
+
+	while ((j > 0) && pq->lt(pq, node, heap[j])) {
+		heap[i] = heap[j];
+		i = j;
+		j = j >> 1;
+	}
+  heap[i] = node;
+}
+
+void pq2_down(PriorityQueue2 *pq)
+{
+  register int i = 1;
+  register int j = 2; //i << 1;
+  register int k = 3; //j + 1;
+  register int count = pq->count;
+  void **heap = pq->heap;
+  void *node = heap[i]; // save top node
+
+  if ((k <= count) && (pq->lt(pq, heap[k], heap[j])))
+    j = k;
+
+  while ((j <= count) && pq->lt(pq, heap[j], node)) {
+    heap[i] = heap[j];      // shift up child
+    i = j;
+    j = i << 1;
+    k = j + 1;
+    if ((k <= count) && pq->lt(pq, heap[k], heap[j]))
+      j = k;
+  }
+  heap[i] = node;
+}
+
+void pq2_push(PriorityQueue2 *pq, void *elem) 
+{
+  pq->count++;
+  pq->heap[pq->count] = elem;
+  pq2_up(pq);
+}
+
+void *pq2_top(PriorityQueue2 *pq)
+{
+  return pq->heap[1];
+}
+
+void *pq2_pop(PriorityQueue2 *pq)
+{
+  if (pq->count > 0) {
+    void *result = pq->heap[1];        // save first value
+    pq->heap[1] = pq->heap[pq->count]; // move last to first
+    pq->heap[pq->count] = NULL;
+    pq->count--;
+    pq2_down(pq);                       // adjust heap
+    return result;
+  } else {
+    return NULL;
+  }
+}
+
+void pq2_clear(PriorityQueue2 *pq)
+{
+  int i;
+  for (i = 1; i <= pq->count; i++) {
+    pq->free_elem(pq->heap[i]);
+    pq->heap[i] = NULL;
+  }
+  pq->count = 0;
+}
+
+int pq2_insert(PriorityQueue2 *pq, void *elem) 
+{
+  if (pq->count < pq->size) {
+    pq2_push(pq, elem);
+    return true;
+  } else if (pq->count > 0 && pq->lt(pq, pq2_top(pq), elem)) {
+    pq->free_elem(pq->heap[1]);
+    pq->heap[1] = elem;
+    pq2_down(pq);
+    return true;
+  } else {
+    pq->free_elem(elem);
+    return false;
+  }
+}

data/ext/priorityqueue.h

@@ -0,0 +1,44 @@
+#ifndef FRT_PRIORITYQUEUE_H
+#define FRT_PRIORITYQUEUE_H
+
+#include "global.h"
+
+typedef struct PriorityQueue {
+  int count;
+  int size;
+  void **heap;
+  bool (*lt)(void *p1, void *p2);
+  void (*free_elem)(void *p1);
+} PriorityQueue;
+
+PriorityQueue *pq_create(int max_size, bool (*less_than)(void *p1, void *p2));
+void pq_destroy(void *p);
+void pq_push(PriorityQueue *pq, void *elem);
+void *pq_top(PriorityQueue *pq);
+void *pq_pop(PriorityQueue *pq);
+void pq_down(PriorityQueue *pq);
+void pq_clear(PriorityQueue *pq);
+int pq_insert(PriorityQueue *pq, void *elem);
+#define pq_full(pq) ((pq)->count == (pq)->size)
+
+typedef struct PriorityQueue2 {
+  int count;
+  int size;
+  void **heap;
+  void *data;
+  bool (*lt)(struct PriorityQueue2 *pq, void *p1, void *p2);
+  void (*free_elem)(void *p);
+  void (*destroy)(void *p);
+} PriorityQueue2;
+
+PriorityQueue2 *pq2_create(int max_size,
+    bool (*less_than)(PriorityQueue2 *pq, void *p1, void *p2),
+    void (*destroy)(void *p));
+void pq2_destroy(void *p);
+void pq2_push(PriorityQueue2 *pq, void *elem);
+void *pq2_top(PriorityQueue2 *pq);
+void *pq2_pop(PriorityQueue2 *pq);
+void pq2_down(PriorityQueue2 *pq);
+void pq2_clear(PriorityQueue2 *pq);
+int pq2_insert(PriorityQueue2 *pq, void *elem);
+#endif

data/ext/q_boolean.c

@@ -0,0 +1,1331 @@
+#include <string.h>
+#include "search.h"
+
+/***************************************************************************
+ *
+ * BooleanWeight
+ *
+ ***************************************************************************/
+
+float bw_sum_of_squared_weights(Weight *self)
+{
+  BooleanWeight *bw = (BooleanWeight *)self->data;
+  BooleanQuery *bq = (BooleanQuery *)self->query->data;
+  Weight *weight;
+
+  float sum = 0.0;
+  int i;
+
+  for (i = 0; i < bw->w_cnt; i++) {
+    if (! bq->clauses[i]->is_prohibited) {
+      weight = bw->weights[i];
+      sum += weight->sum_of_squared_weights(weight); // sum sub-weights
+    }
+  }
+
+  sum *= self->value * self->value;        // boost each sub-weight
+
+  return sum;
+}
+
+void bw_normalize(Weight *self, float normalization_factor)
+{
+  BooleanWeight *bw = (BooleanWeight *)self->data;
+  BooleanQuery *bq = (BooleanQuery *)self->query->data;
+  normalization_factor *= self->value; // multiply by query boost
+  Weight *weight;
+  int i;
+
+  for (i = 0; i < bw->w_cnt; i++) {
+    if (! bq->clauses[i]->is_prohibited) {
+      weight = bw->weights[i];
+      weight->normalize(weight, normalization_factor); // sum sub-weights
+    }
+  }
+}
+
+Scorer *bw_scorer(Weight *self, IndexReader *ir)
+{
+  Scorer *sub_scorer, *bsc = bsc_create(self->similarity);
+  BooleanWeight *bw = (BooleanWeight *)self->data;
+  BooleanQuery *bq = (BooleanQuery *)self->query->data;
+  BooleanClause *clause;
+  Weight *weight;
+  int i;
+
+  for (i = 0; i < bw->w_cnt; i++) {
+    clause = bq->clauses[i];
+    weight = bw->weights[i];
+    sub_scorer = weight->scorer(weight, ir);
+    if (sub_scorer) {
+      bsc_add_scorer(bsc, sub_scorer, clause->occur);
+    } else if (clause->is_required) {
+      bsc->destroy(bsc);
+      return NULL;
+    }
+  }
+
+  return bsc;
+}
+
+char *bw_to_s(Weight *self)
+{
+  char dbuf[32];
+  dbl_to_s(dbuf, self->value);
+  return epstrdup("BooleanWeight(%s)", strlen(dbuf), dbuf);
+}
+
+void bw_destroy(void *p)
+{
+  Weight *weight = (Weight *)p;
+  BooleanWeight *bw = (BooleanWeight *)weight->data;
+  free(bw->weights);
+  free(bw);
+  free(weight);
+}
+
+Explanation *bw_explain(Weight *self, IndexReader *ir, int doc_num)
+{
+  BooleanWeight *bw = (BooleanWeight *)self->data;
+  BooleanQuery *bq = (BooleanQuery *)self->query->data;
+  Explanation *sum_expl = expl_create(0.0, estrdup("sum of:"));
+  BooleanClause *clause;
+  Weight *weight;
+  Explanation *explanation;
+  int coord = 0;
+  int max_coord = 0;
+  float coord_factor = 0.0;
+  float sum = 0.0;
+  int i;
+
+  for (i = 0; i < bw->w_cnt; i++) {
+    weight = bw->weights[i];
+    clause = bq->clauses[i];
+    explanation = weight->explain(weight, ir, doc_num);
+    if (!clause->is_prohibited) max_coord++;
+    if (explanation->value > 0.0) {
+      if (!clause->is_prohibited) {
+        expl_add_detail(sum_expl, explanation);
+        sum += explanation->value;
+        coord++;
+      } else {
+        expl_destoy(explanation);
+        expl_destoy(sum_expl);
+        return expl_create(0.0, estrdup("match prohibited"));
+      }
+    } else if (clause->is_required) {
+      expl_destoy(explanation);
+      expl_destoy(sum_expl);
+      return expl_create(0.0, estrdup("match required"));
+    } else {
+      expl_destoy(explanation);
+    }
+  }
+  sum_expl->value = sum;
+
+  if (coord == 1) {                // only one clause matched
+    explanation = sum_expl;        // eliminate wrapper
+    sum_expl->dcnt = 0;
+    sum_expl = sum_expl->details[0];
+    expl_destoy(explanation);
+  }
+
+  coord_factor = sim_coord(self->similarity, coord, max_coord);
+
+  if (coord_factor == 1.0) {       // coord is no-op
+    return sum_expl;               // eliminate wrapper
+  } else {
+    explanation = expl_create(sum * coord_factor, estrdup("product of:"));
+    expl_add_detail(explanation, sum_expl);
+    expl_add_detail(explanation, expl_create(coord_factor, 
+          epstrdup("coord(%d/%d)", 40, coord, max_coord)));
+    return explanation;
+  }
+}
+
+Weight *bw_create(Query *query, Searcher *searcher)
+{
+  int i;
+  BooleanQuery *bq = (BooleanQuery *)query->data;
+  BooleanWeight *bw = ALLOC(BooleanWeight);
+  Weight *self = ALLOC(Weight);
+  ZEROSET(self, Weight, 1);
+  self->data = bw;
+  self->get_query = &w_get_query;
+  self->get_value = &w_get_value;
+  self->normalize = &bw_normalize;
+  self->scorer    = &bw_scorer;
+  self->explain   = &bw_explain;
+  self->to_s      = &bw_to_s;
+  self->destroy   = &bw_destroy;
+  self->sum_of_squared_weights = &bw_sum_of_squared_weights;
+
+  self->similarity = query->get_similarity(query, searcher);
+  self->query = query;
+  self->value = query->boost;
+
+  bw->w_cnt = bq->clause_cnt;
+  bw->weights = ALLOC_N(Weight *, bw->w_cnt);
+  for (i = 0; i < bw->w_cnt; i++) {
+    bw->weights[i] = q_weight(bq->clauses[i]->query, searcher);
+  }
+
+  return self;
+}
+
+/***************************************************************************
+ *
+ * BooleanClause
+ *
+ ***************************************************************************/
+
+void bc_set_occur(BooleanClause *self, unsigned int occur)
+{
+  self->occur = occur;
+  switch (occur) {
+    case BC_SHOULD:
+      self->is_prohibited = false;
+      self->is_required = false;
+      break;
+    case BC_MUST:
+      self->is_prohibited = false;
+      self->is_required = true;
+      break;
+    case BC_MUST_NOT:
+      self->is_prohibited = true;
+      self->is_required = false;
+      break;
+    default:
+      eprintf(ARG_ERROR, "Invalid value %d for BooleanClause Type", occur);
+  }
+}
+
+BooleanClause *bc_create(Query *query, unsigned int occur)
+{
+  BooleanClause *self = ALLOC(BooleanClause);
+  self->query = query;
+  bc_set_occur(self, occur);
+  return self;
+}
+
+/***************************************************************************
+ *
+ * BooleanQuery
+ *
+ ***************************************************************************/
+
+Query *bq_rewrite(Query *self, IndexReader *ir)
+{
+  BooleanQuery *bq = (BooleanQuery *)self->data;
+  BooleanClause *clause;
+  Query *query;
+  int i;
+
+  if (bq->clause_cnt == 1) { // optimize 1-clause queries
+    clause = bq->clauses[0];
+    if (! clause->is_prohibited) { // just return clause
+      query = clause->query->rewrite(clause->query, ir); // rewrite first
+
+      if (self->boost != 1.0) {// incorporate boost
+        // original_boost is initialized to 0.0. If it has been set to
+        // something else it means this query has already been boosted before
+        // so boost from the original value
+        if ((query == clause->query) && query->original_boost) { // rewrite was no-op
+          query->boost = query->original_boost * self->boost;
+        } else {
+          query->original_boost = query->boost; // save original boost
+          query->boost *= self->boost;
+        }
+      }
+
+      return query;
+    }
+  }
+
+  for (i = 0; i < bq->clause_cnt; i++) {
+    clause = bq->clauses[i];
+    clause->rewritten = clause->query->rewrite(clause->query, ir);
+  }
+  return self;  // no clauses rewritten
+}
+
+void bq_extract_terms(Query *self, Array *terms)
+{
+  BooleanQuery *bq = (BooleanQuery *)self->data;
+  BooleanClause *clause;
+  int i;
+  for (i = 0; i < bq->clause_cnt; i++) {
+    clause = bq->clauses[i];
+    clause->query->extract_terms(clause->query, terms);
+  }
+}
+
+char *bq_to_s(Query *self, char *field)
+{
+  BooleanQuery *bq = (BooleanQuery *)self->data;
+  BooleanClause *clause;
+  Query *sub_query;
+  char *buffer;
+  char *clause_str;
+  int bp = 0;
+  int size = QUERY_STRING_START_SIZE;
+  int needed;
+  int clause_len;
+
+  buffer = ALLOC_N(char, size);
+  if (self->boost != 1.0) {
+    buffer[0] = '(';
+    bp++;
+  }
+
+  int i;
+  for (i = 0; i < bq->clause_cnt; i++) {
+    clause = bq->clauses[i];
+    clause_str = clause->query->to_s(clause->query, field);
+    clause_len = strlen(clause_str);
+    needed = clause_len + 5;
+    while ((size - bp) < needed) {
+      size *= 2;
+      REALLOC_N(buffer, char, size);
+    }
+
+    if (i > 0) {
+      buffer[bp++] = ' ';
+    }
+    if (clause->is_prohibited) {
+      buffer[bp++] = '-';
+    } else if (clause->is_required) {
+      buffer[bp++] = '+';
+    }
+
+    sub_query = clause->query;
+    if (sub_query->type == BOOLEAN_QUERY) { // wrap sub-bools in parens
+      buffer[bp++] = '(';
+      memcpy(buffer + bp, clause_str, sizeof(char) * clause_len);
+      bp += clause_len;
+      buffer[bp++] = ')';
+    } else {
+      memcpy(buffer + bp, clause_str, sizeof(char) * clause_len);
+      bp += clause_len;
+    }
+    free(clause_str);
+  }
+
+  if (self->boost != 1.0) {
+    char dbuf[32];
+    dbl_to_s(dbuf, self->boost);
+    char *boost_str = epstrdup(")^%s", strlen(dbuf), dbuf);
+    int boost_len = strlen(boost_str);
+    REALLOC_N(buffer, char, bp + boost_len + 1);
+    memcpy(buffer + bp, boost_str, sizeof(char) * boost_len);
+    bp += boost_len;
+    free(boost_str);
+  }
+  buffer[bp] = 0;
+  return buffer;
+}
+
+void bq_destroy(void *p)
+{
+  Query *self = (Query *)p;
+  BooleanQuery *bq = (BooleanQuery *)self->data;
+  BooleanClause *clause;
+  int i;
+  for (i = 0; i < bq->clause_cnt; i++) {
+    clause = bq->clauses[i];
+    if (self->destroy_all) clause->query->destroy(clause->query);
+    free(clause);
+  }
+  free(bq->clauses);
+  if (bq->similarity) {
+    bq->similarity->destroy(bq->similarity);
+  }
+  free(bq);
+  q_destroy(self);
+}
+
+float bq_coord_disabled(Similarity *sim, int overlap, int max_overlap)
+{
+  return 1.0;
+}
+
+Similarity *bq_get_similarity(Query *self, Searcher *searcher)
+{
+  BooleanQuery *bq = (BooleanQuery *)self->data;
+  if (!bq->similarity) {
+    Similarity *sim = q_get_similarity(self, searcher); 
+    bq->similarity = ALLOC(Similarity);
+    memcpy(bq->similarity, sim, sizeof(Similarity));
+    bq->similarity->coord = &bq_coord_disabled;
+    bq->similarity->destroy = &free;
+  }
+
+  return bq->similarity;
+}
+
+Query *bq_create(bool coord_disabled)
+{
+  Query *self = q_create();
+  BooleanQuery *bq = ALLOC(BooleanQuery);
+  self->type = BOOLEAN_QUERY;
+  self->create_weight = &bw_create;
+  self->rewrite = &bq_rewrite;
+  self->extract_terms = &bq_extract_terms;
+  self->to_s = &bq_to_s;
+  self->destroy = &bq_destroy;
+  self->data = bq;
+  bq->coord_disabled = coord_disabled;
+  if (coord_disabled) {
+    self->get_similarity = &bq_get_similarity;
+  }
+  bq->max_clause_cnt = DEFAULT_MAX_CLAUSE_COUNT;
+  bq->clause_cnt = 0;
+  bq->clause_capa = BOOLEAN_CLAUSES_START_CAPA;
+  bq->clauses = ALLOC_N(BooleanClause *, BOOLEAN_CLAUSES_START_CAPA);
+  bq->similarity = NULL;
+
+  return self;
+}
+
+void bq_add_query(Query *self, Query *sub_query, unsigned int occur)
+{
+  BooleanQuery *bq = (BooleanQuery *)self->data;
+  BooleanClause *bc = bc_create(sub_query, occur);
+  if (bq->clause_cnt >= bq->clause_capa) {
+    bq->clause_capa *= 2;
+    REALLOC_N(bq->clauses, BooleanClause *, bq->clause_capa);
+  }
+  if (bq->clause_cnt > bq->max_clause_cnt) {
+    eprintf(STATE_ERROR, "Too many clauses.");
+  }
+  bq->clauses[bq->clause_cnt] = bc;
+  bq->clause_cnt++;
+}
+
+/***************************************************************************
+ *
+ * BooleanScorer
+ *
+ ***************************************************************************/
+
+/***************************************************************************
+ * Coordinator
+ ***************************************************************************/
+
+Coordinator *coord_create(Similarity *similarity)
+{
+  Coordinator *self = ALLOC(Coordinator);
+  ZEROSET(self, Coordinator, 1);
+  self->similarity = similarity;
+  return self;
+}
+
+Coordinator *coord_init(Coordinator *self)
+{
+  int i;
+  self->coord_factors = ALLOC_N(float, self->max_coord + 1);
+
+  for (i = 0; i <= self->max_coord; i++) {
+    self->coord_factors[i] = sim_coord(self->similarity, i, self->max_coord);
+  }
+
+  return self;
+}
+
+/***************************************************************************
+ * DisjunctionSumScorer
+ ***************************************************************************/
+
+float dssc_score(Scorer *self)
+{
+  DisjunctionSumScorer *dssc = (DisjunctionSumScorer *)self->data;
+  return dssc->cum_score;
+}
+
+void dssc_init_scorer_queue(DisjunctionSumScorer *dssc)
+{
+  int i;
+  Scorer *sub_scorer;
+  PriorityQueue *pq = dssc->scorer_queue =
+    pq_create(dssc->ss_cnt, &scorer_doc_less_than);
+
+  for (i = 0; i < dssc->ss_cnt; i++) {
+    sub_scorer = dssc->sub_scorers[i];
+    if (sub_scorer->next(sub_scorer)) {
+      pq_insert(pq, sub_scorer);
+    }
+  }
+}
+
+bool dssc_advance_after_current(Scorer *self)
+{
+  DisjunctionSumScorer *dssc = (DisjunctionSumScorer *)self->data;
+  PriorityQueue *scorer_queue = dssc->scorer_queue;
+  Scorer *top;
+  while (true) { // repeat until minimum nr of matches
+    top = (Scorer *)pq_top(scorer_queue);
+    self->doc = top->doc;
+    dssc->cum_score = top->score(top);
+    dssc->num_matches = 1;
+    while (true) { // Until all subscorers are after self->hit.doc
+      if (top->next(top)) {
+        pq_down(scorer_queue);
+      } else {
+        pq_pop(scorer_queue);
+        if (scorer_queue->count < (dssc->min_num_matches - dssc->num_matches)) {
+          // Not enough subscorers left for a match on this document,
+          // and also no more chance of any further match.
+          return false;
+        }
+        if (scorer_queue->count == 0) {
+          break; // nothing more to advance, check for last match.
+        }
+      }
+      top = pq_top(scorer_queue);
+      if (top->doc != self->doc) {
+        break; // All remaining subscorers are after self->hit.doc.
+      } else {
+        dssc->cum_score += top->score(top);
+        dssc->num_matches++;
+      }
+    }
+
+    if (dssc->num_matches >= dssc->min_num_matches) { 
+      return true;
+    } else if (scorer_queue->count < dssc->min_num_matches) {
+      return false;
+    }
+  }
+}
+
+bool dssc_next(Scorer *self)
+{
+  DisjunctionSumScorer *dssc = (DisjunctionSumScorer *)self->data;
+
+  if (dssc->scorer_queue == NULL) {
+    dssc_init_scorer_queue(dssc);
+  }
+
+  if (dssc->scorer_queue->count < dssc->min_num_matches) {
+    return false;
+  } else {
+    return dssc_advance_after_current(self);
+  }
+}
+
+bool dssc_skip_to(Scorer *self, int doc_num)
+{
+  DisjunctionSumScorer *dssc = (DisjunctionSumScorer *)self->data;
+  PriorityQueue *scorer_queue = dssc->scorer_queue;
+  Scorer *top;
+
+  if (scorer_queue == NULL) {
+    dssc_init_scorer_queue(dssc);
+    scorer_queue = dssc->scorer_queue;
+  }
+
+  if (scorer_queue->count < dssc->min_num_matches) {
+    return false;
+  }
+  if (doc_num <= self->doc) {
+    doc_num = self->doc + 1;
+  }
+  while (true) { 
+    top = pq_top(scorer_queue);
+    if (top->doc >= doc_num) {
+      return dssc_advance_after_current(self);
+    } else if (top->skip_to(top, doc_num)) {
+      pq_down(scorer_queue);
+    } else {
+      pq_pop(scorer_queue);
+      if (scorer_queue->count < dssc->min_num_matches) {
+        return false;
+      }
+    }
+  }
+}
+
+Explanation *dssc_explain(Scorer *self, int doc_num)
+{
+  int i;
+  DisjunctionSumScorer *dssc = (DisjunctionSumScorer *)self->data;
+  Scorer *sub_scorer;
+  Explanation *e = expl_create(0.0,
+      epstrdup("At least %d of:", 20, dssc->min_num_matches));
+  for (i = 0; i < dssc->ss_cnt; i++) {
+    sub_scorer = dssc->sub_scorers[i];
+    expl_add_detail(e, sub_scorer->explain(sub_scorer, doc_num));
+  }
+  return e;
+}
+
+void dssc_destroy(void *p)
+{
+  Scorer *self = (Scorer *)p;
+  DisjunctionSumScorer *dssc = (DisjunctionSumScorer *)self->data;
+  int i;
+  for (i = 0; i < dssc->ss_cnt; i++) {
+    dssc->sub_scorers[i]->destroy(dssc->sub_scorers[i]);
+  }
+  pq_destroy(dssc->scorer_queue);
+  scorer_destroy(self);
+}
+
+Scorer *disjunction_sum_scorer_create(Scorer **sub_scorers, int ss_cnt,
+    int min_num_matches) 
+{
+  Scorer *self = scorer_create(NULL);
+  DisjunctionSumScorer *dssc = ALLOC(DisjunctionSumScorer);
+  self->data = dssc;
+  dssc->ss_cnt = ss_cnt;
+
+  // The document number of the current match. 
+  self->doc = -1;
+  dssc->cum_score = -1.0;
+
+  // The number of subscorers that provide the current match. 
+  dssc->num_matches = -1;
+  dssc->coordinator = NULL;
+
+  if (min_num_matches <= 0) {
+    eprintf(ARG_ERROR, "Minimum nr of matches must be positive");
+  }
+  if (ss_cnt <= 1) {
+    eprintf(ARG_ERROR, "There must be at least 2 sub_scorers");
+  }
+
+  dssc->min_num_matches = min_num_matches;
+  dssc->sub_scorers = sub_scorers;
+
+  dssc->scorer_queue = NULL;
+
+  self->score   = &dssc_score;
+  self->next    = &dssc_next;
+  self->skip_to = &dssc_skip_to;
+  self->explain = &dssc_explain;
+  self->destroy = &dssc_destroy;
+
+  return self;
+}
+
+float cdssc_score(Scorer *self)
+{
+  DisjunctionSumScorer *dssc = (DisjunctionSumScorer *)self->data;
+  dssc->coordinator->num_matches += dssc->num_matches;
+  return dssc->cum_score;
+}
+
+Scorer *counting_disjunction_sum_scorer_create(Coordinator *coordinator,
+    Scorer **sub_scorers, int ss_cnt, int min_num_matches) 
+{
+  Scorer *self = disjunction_sum_scorer_create(
+      sub_scorers, ss_cnt, min_num_matches);
+  DisjunctionSumScorer *dssc = (DisjunctionSumScorer *)self->data;
+  dssc->coordinator = coordinator;
+  self->score = &cdssc_score;
+  return self;
+}
+
+/***************************************************************************
+ * ConjunctionScorer
+ ***************************************************************************/
+
+void csc_sort_scorers(ConjunctionScorer *csc)
+{
+  qsort(csc->sub_scorers, csc->ss_cnt, sizeof(Scorer *), &scorer_doc_cmp);
+  csc->first = 0;
+  csc->last = csc->ss_cnt - 1;
+}
+
+void csc_init(Scorer *self, bool init_scorers)
+{
+  ConjunctionScorer *csc = (ConjunctionScorer *)self->data;
+  Scorer *sub_scorer;
+  int i;
+  //  compute coord factor
+  csc->coord = sim_coord(self->similarity, csc->ss_cnt, csc->ss_cnt);
+
+  csc->more = (csc->ss_cnt > 0);
+
+  if (init_scorers) {
+    // move each scorer to its first entry
+
+    for (i = 0; i < csc->ss_cnt; i++) {
+      sub_scorer = csc->sub_scorers[i];
+      if (!csc->more) break;
+      csc->more = sub_scorer->next(sub_scorer);
+    }
+    if (csc->more) csc_sort_scorers(csc);
+  }
+
+  csc->first_time = false;
+}
+
+void csc_add_scorer(ConjunctionScorer *csc, Scorer *scorer)
+{
+  RECAPA(csc, ss_cnt, ss_capa, sub_scorers, Scorer *);
+  csc->sub_scorers[csc->ss_cnt++] = scorer;
+}
+
+float csc_score(Scorer *self)
+{
+  ConjunctionScorer *csc = (ConjunctionScorer *)self->data;
+  Scorer *sub_scorer;
+  float score = 0.0; // sum scores
+  int i;
+  for (i = 0; i < csc->ss_cnt; i++) {
+    sub_scorer = csc->sub_scorers[i];
+    score += sub_scorer->score(sub_scorer);
+  }
+  score *= csc->coord;
+  return score;
+}
+
+bool csc_do_next(Scorer *self)
+{
+  ConjunctionScorer *csc = (ConjunctionScorer *)self->data;
+  Scorer *first = csc->sub_scorers[csc->first];
+  Scorer *last = csc->sub_scorers[csc->last];
+
+  // find doc w/ all clauses
+  while (csc->more && (first->doc < last->doc)) {
+    csc->more = first->skip_to(first, last->doc); // skip first upto last
+    // move first to last
+    csc->last = csc->first;
+    last = first;
+    csc->first = (csc->first + 1) % csc->ss_cnt;
+    first = csc->sub_scorers[csc->first];
+  }
+  self->doc = first->doc;
+  return csc->more;
+}
+
+bool csc_next(Scorer *self)
+{
+  ConjunctionScorer *csc = (ConjunctionScorer *)self->data;
+  Scorer *sub_scorer;
+  if (csc->first_time) {
+    csc_init(self, true);
+  } else if (csc->more) {
+    sub_scorer = csc->sub_scorers[csc->last];
+    csc->more = sub_scorer->next(sub_scorer); // trigger further scanning
+  }
+  return csc_do_next(self);
+}
+
+bool csc_skip_to(Scorer *self, int doc_num)
+{
+  ConjunctionScorer *csc = (ConjunctionScorer *)self->data;
+  Scorer *sub_scorer;
+  int i;
+
+  if (csc->first_time) {
+    csc_init(self, true);
+  }
+
+  for (i = 0; i < csc->ss_cnt; i++) {
+    if (!csc->more) break;
+    sub_scorer = csc->sub_scorers[i];
+    csc->more = sub_scorer->skip_to(sub_scorer, doc_num);
+  }
+  if (csc->more) csc_sort_scorers(csc); // resort the scorers
+
+  return csc_do_next(self);
+}
+
+void csc_destroy(void *p)
+{
+  Scorer *self = (Scorer *)p;
+  ConjunctionScorer *csc = (ConjunctionScorer *)self->data;
+  int i;
+  for (i = 0; i < csc->ss_cnt; i++) {
+    csc->sub_scorers[i]->destroy(csc->sub_scorers[i]);
+  }
+  free(csc->sub_scorers);
+  scorer_destroy(self);
+}
+
+Scorer *conjunction_scorer_create(Similarity *similarity) 
+{
+  Scorer *self = scorer_create(similarity);
+  ConjunctionScorer *csc = ALLOC(ConjunctionScorer);
+  ZEROSET(csc, ConjunctionScorer, 1);
+  self->data = csc;
+  csc->first_time = true;
+  csc->more = true;
+  csc->coordinator = NULL;
+
+  self->score   = &csc_score;
+  self->next    = &csc_next;
+  self->skip_to = &csc_skip_to;
+  self->destroy = &csc_destroy;
+
+  return self;
+}
+
+float ccsc_score(Scorer *self)
+{
+  ConjunctionScorer *csc = (ConjunctionScorer *)self->data;
+
+  int doc;
+  if ((doc = self->doc) > csc->last_scored_doc) {
+    csc->last_scored_doc = doc;
+    csc->coordinator->num_matches += csc->ss_cnt;
+  }
+
+  return csc_score(self);
+}
+
+Scorer *counting_conjunction_sum_scorer_create(Coordinator *coordinator,
+    Scorer **sub_scorers, int ss_cnt)
+{
+  Scorer *self = conjunction_scorer_create(sim_create_default());
+  ConjunctionScorer *csc = (ConjunctionScorer *)self->data;
+  csc->coordinator = coordinator;
+  csc->last_scored_doc = -1;
+  csc->sub_scorers = ALLOC_N(Scorer *, ss_cnt);
+  memcpy(csc->sub_scorers, sub_scorers, sizeof(Scorer *) * ss_cnt);
+  csc->ss_capa = csc->ss_cnt = ss_cnt;
+
+  self->score = &ccsc_score;
+
+  return self;
+}
+
+/***************************************************************************
+ * SingleMatchScorer
+ ***************************************************************************/
+
+float smsc_score(Scorer *self)
+{
+  SingleMatchScorer *smsc = (SingleMatchScorer *)self->data;
+  smsc->coordinator->num_matches++;
+  return smsc->scorer->score(smsc->scorer);
+}
+
+bool smsc_next(Scorer *self)
+{
+  Scorer *scorer = ((SingleMatchScorer *)self->data)->scorer;
+  if (scorer->next(scorer)) {
+    self->doc = scorer->doc;
+    return true;
+  }
+  return false;
+}
+
+bool smsc_skip_to(Scorer *self, int doc_num)
+{
+  Scorer *scorer = ((SingleMatchScorer *)self->data)->scorer;
+  if (scorer->skip_to(scorer, doc_num)) {
+    self->doc = scorer->doc;
+    return true;
+  }
+  return false;
+}
+
+Explanation *smsc_explain(Scorer *self, int doc_num)
+{
+  Scorer *scorer = ((SingleMatchScorer *)self->data)->scorer;
+  return scorer->explain(scorer, doc_num);
+}
+
+void smsc_destroy(void *p)
+{
+  Scorer *self = (Scorer *)p;
+  Scorer *scorer = ((SingleMatchScorer *)self->data)->scorer;
+  scorer->destroy(scorer);
+  scorer_destroy(self);
+}
+
+Scorer *single_match_scorer_create(Coordinator *coordinator, Scorer *scorer)
+{
+  Scorer *self = scorer_create(scorer->similarity);
+  SingleMatchScorer *smsc = ALLOC(SingleMatchScorer);
+  smsc->coordinator = coordinator;
+  smsc->scorer = scorer;
+  self->data = smsc;
+
+  self->score   = &smsc_score;
+  self->next    = &smsc_next;
+  self->skip_to = &smsc_skip_to;
+  self->explain = &smsc_explain;
+  self->destroy = &smsc_destroy;
+  return self;
+}
+
+/***************************************************************************
+ * ReqOptSumScorer
+ ***************************************************************************/
+
+float rossc_score(Scorer *self)
+{
+  ReqOptSumScorer *rossc = (ReqOptSumScorer *)self->data;
+  Scorer *req_scorer = rossc->req_scorer;
+  Scorer *opt_scorer = rossc->opt_scorer;
+  int cur_doc = req_scorer->doc;
+  float req_score = req_scorer->score(req_scorer);
+
+  if (rossc->first_time_opt) {
+    rossc->first_time_opt = false;
+    if (! opt_scorer->skip_to(opt_scorer, cur_doc)) {
+      SCORER_NULLIFY(rossc->opt_scorer);
+      return req_score;
+    }
+  } else if (opt_scorer == NULL) {
+    return req_score;
+  } else if ((opt_scorer->doc < cur_doc) &&
+      ! opt_scorer->skip_to(opt_scorer, cur_doc)) {
+    SCORER_NULLIFY(rossc->opt_scorer);
+    return req_score;
+  }
+  // assert (@opt_scorer != nil) and (@opt_scorer.doc() >= cur_doc)
+  return (opt_scorer->doc == cur_doc)
+    ? req_score + opt_scorer->score(opt_scorer)
+    : req_score;
+}
+
+bool rossc_next(Scorer *self)
+{
+  Scorer *req_scorer = ((ReqOptSumScorer *)self->data)->req_scorer;
+  if (req_scorer->next(req_scorer)) {
+    self->doc = req_scorer->doc;
+    return true;
+  }
+  return false;
+}
+
+bool rossc_skip_to(Scorer *self, int doc_num)
+{
+  Scorer *req_scorer = ((ReqOptSumScorer *)self->data)->req_scorer;
+  if (req_scorer->skip_to(req_scorer, doc_num)) {
+    self->doc = req_scorer->doc;
+    return true;
+  }
+  return false;
+}
+
+Explanation *rossc_explain(Scorer *self, int doc_num)
+{
+  ReqOptSumScorer *rossc = (ReqOptSumScorer *)self->data;
+  Scorer *req_scorer = rossc->req_scorer;
+  Scorer *opt_scorer = rossc->opt_scorer;
+
+  Explanation *e = expl_create(self->score(self), estrdup("required, optional:"));
+  expl_add_detail(e, req_scorer->explain(req_scorer, doc_num));
+  expl_add_detail(e, opt_scorer->explain(opt_scorer, doc_num));
+  return e;
+}
+
+void rossc_destroy(void *p)
+{
+  Scorer *self = (Scorer *)p;
+  ReqOptSumScorer *rossc = (ReqOptSumScorer *)self->data;
+  if (rossc->req_scorer) rossc->req_scorer->destroy(rossc->req_scorer);
+  if (rossc->opt_scorer) rossc->opt_scorer->destroy(rossc->opt_scorer);
+  scorer_destroy(self);
+}
+
+
+Scorer *req_opt_sum_scorer_create(Scorer *req_scorer, Scorer *opt_scorer)
+{
+  Scorer *self = scorer_create(NULL);
+  ReqOptSumScorer *rossc = ALLOC(ReqOptSumScorer);
+  self->data = rossc;
+  rossc->req_scorer = req_scorer;
+  rossc->opt_scorer = opt_scorer;
+  rossc->first_time_opt = true;
+  
+  self->score   = &rossc_score;
+  self->next    = &rossc_next;
+  self->skip_to = &rossc_skip_to;
+  self->explain = &rossc_explain;
+  self->destroy = &rossc_destroy;
+
+  return self;
+}
+
+/***************************************************************************
+ * ReqExclScorer
+ ***************************************************************************/
+
+bool rxsc_to_non_excluded(Scorer *self)
+{
+  ReqExclScorer *rxsc = (ReqExclScorer *)self->data;
+  Scorer *req_scorer = rxsc->req_scorer;
+  Scorer *excl_scorer = rxsc->excl_scorer;
+  int excl_doc = excl_scorer->doc, req_doc;
+
+  do { 
+    req_doc = req_scorer->doc; // may be excluded
+    if (req_doc < excl_doc) {
+      // req_scorer advanced to before excl_scorer, ie. not excluded
+      self->doc = req_doc;
+      return true;
+    } else if (req_doc > excl_doc) {
+      if (! excl_scorer->skip_to(excl_scorer, req_doc)) {
+        SCORER_NULLIFY(rxsc->excl_scorer); // exhausted, no more exclusions
+        self->doc = req_doc;
+        return true;
+      }
+      excl_doc = excl_scorer->doc;
+      if (excl_doc > req_doc) {
+        self->doc = req_doc;
+        return true; // not excluded
+      }
+    }
+  } while (req_scorer->next(req_scorer));
+  SCORER_NULLIFY(rxsc->req_scorer); // exhausted, nothing left
+  return false;
+}
+
+bool rxsc_next(Scorer *self)
+{
+  ReqExclScorer *rxsc = (ReqExclScorer *)self->data;
+  Scorer *req_scorer = rxsc->req_scorer;
+  Scorer *excl_scorer = rxsc->excl_scorer;
+
+  if (rxsc->first_time) {
+    if (! excl_scorer->next(excl_scorer)) {
+      SCORER_NULLIFY(rxsc->excl_scorer); // exhausted at start
+      excl_scorer = NULL;
+    }
+    rxsc->first_time = false;
+  }
+  if (req_scorer == NULL) {
+    return false;
+  }
+  if (! req_scorer->next(req_scorer)) {
+    SCORER_NULLIFY(rxsc->req_scorer); // exhausted, nothing left
+    return false;
+  }
+  if (excl_scorer == NULL) {
+    self->doc = req_scorer->doc;
+    return true; // req_scorer->next() already returned true
+  }
+  return rxsc_to_non_excluded(self);
+}
+
+bool rxsc_skip_to(Scorer *self, int doc_num)
+{
+  ReqExclScorer *rxsc = (ReqExclScorer *)self->data;
+  Scorer *req_scorer = rxsc->req_scorer;
+  Scorer *excl_scorer = rxsc->excl_scorer;
+
+  if (rxsc->first_time) {
+    rxsc->first_time = false;
+    if (! excl_scorer->skip_to(excl_scorer, doc_num)) {
+      SCORER_NULLIFY(rxsc->excl_scorer); // exhausted
+      excl_scorer = NULL;
+    }
+  }
+  if (req_scorer == NULL) {
+    return false;
+  }
+  if (excl_scorer == NULL) {
+    if (req_scorer->skip_to(req_scorer, doc_num)) {
+      self->doc = req_scorer->doc;
+      return true;
+    }
+    return false;
+  }
+  if (! req_scorer->skip_to(req_scorer, doc_num)) {
+    SCORER_NULLIFY(rxsc->req_scorer);
+    return false;
+  }
+  return rxsc_to_non_excluded(self);
+}
+
+float rxsc_score(Scorer *self)
+{
+  Scorer *req_scorer = ((ReqExclScorer *)self->data)->req_scorer;
+  return req_scorer->score(req_scorer);
+}
+
+Explanation *rxsc_explain(Scorer *self, int doc_num)
+{
+  ReqExclScorer *rxsc = (ReqExclScorer *)self->data;
+  Scorer *req_scorer = rxsc->req_scorer;
+  Scorer *excl_scorer = rxsc->excl_scorer;
+
+  Explanation *e;
+  if (excl_scorer->skip_to(excl_scorer, doc_num) && excl_scorer->doc == doc_num) {
+    e = expl_create(0.0, estrdup("excluded:"));
+  } else {
+    e = expl_create(0.0, estrdup("not excluded:"));
+    expl_add_detail(e, req_scorer->explain(req_scorer, doc_num));
+  }
+  return e;
+}
+
+void rxsc_destroy(void *p)
+{
+  Scorer *self = (Scorer *)p;
+  ReqExclScorer *rxsc = (ReqExclScorer *)self->data;
+  if (rxsc->req_scorer) rxsc->req_scorer->destroy(rxsc->req_scorer);
+  if (rxsc->excl_scorer) rxsc->excl_scorer->destroy(rxsc->excl_scorer);
+  scorer_destroy(self);
+}
+
+Scorer *req_excl_scorer_create(Scorer *req_scorer, Scorer *excl_scorer)
+{
+  Scorer *self = scorer_create(NULL);
+  ReqExclScorer *rxsc = ALLOC(ReqExclScorer);
+  self->data = rxsc;
+  rxsc->req_scorer = req_scorer;
+  rxsc->excl_scorer = excl_scorer;
+  rxsc->first_time = true;
+  
+  self->score   = &rxsc_score;
+  self->next    = &rxsc_next;
+  self->skip_to = &rxsc_skip_to;
+  self->explain = &rxsc_explain;
+  self->destroy = &rxsc_destroy;
+
+  return self;
+}
+
+/***************************************************************************
+ * NonMatchScorer
+ ***************************************************************************/
+
+float nmsc_score(Scorer *self)
+{
+  return 0.0;
+}
+
+bool nmsc_next(Scorer *self)
+{
+  return false;
+}
+
+bool nmsc_skip_to(Scorer *self, int doc_num)
+{
+  return false;
+}
+
+Explanation *nmsc_explain(Scorer *self, int doc_num)
+{
+  return expl_create(0.0, estrdup("No documents matched"));
+}
+
+Scorer *non_matching_scorer_create()
+{
+  Scorer *self = scorer_create(NULL);
+  self->score   = &nmsc_score;
+  self->next    = &nmsc_next;
+  self->skip_to = &nmsc_skip_to;
+  self->explain = &nmsc_explain;
+
+  return self;
+}
+
+
+/***************************************************************************
+ * BooleanScorer
+ ***************************************************************************/
+
+Scorer *counting_sum_scorer_create3(BooleanScorer *bsc, Scorer *req_scorer,
+    Scorer *opt_scorer)
+{
+  if (bsc->ps_cnt == 0) { // no prohibited
+    return req_opt_sum_scorer_create(req_scorer, opt_scorer);
+  } else if (bsc->ps_cnt == 1) { // 1 prohibited
+    return req_opt_sum_scorer_create(
+        req_excl_scorer_create(req_scorer, bsc->prohibited_scorers[0]),
+        opt_scorer);
+  } else { // more prohibited
+    return req_opt_sum_scorer_create(
+        req_excl_scorer_create(req_scorer,
+          disjunction_sum_scorer_create(bsc->prohibited_scorers, bsc->ps_cnt, 1)),
+        opt_scorer);
+  }
+}
+
+Scorer *counting_sum_scorer_create2(BooleanScorer *bsc, Scorer *req_scorer,
+    Scorer **optional_scorers, int os_cnt)
+{
+  if (os_cnt == 0) {
+    if (bsc->ps_cnt == 0) {
+      return req_scorer;
+    } else if (bsc->ps_cnt == 1) {
+      return req_excl_scorer_create(req_scorer,
+          bsc->prohibited_scorers[0]);
+    } else { // no optional, more than 1 prohibited
+      return req_excl_scorer_create(req_scorer,
+          disjunction_sum_scorer_create(bsc->prohibited_scorers, bsc->ps_cnt, 1));
+    }
+  } else if (os_cnt == 1) {
+    return counting_sum_scorer_create3(
+        bsc,
+        req_scorer,
+        single_match_scorer_create(bsc->coordinator, optional_scorers[0]));
+  } else { // more optional
+    return counting_sum_scorer_create3(
+        bsc,
+        req_scorer,
+        counting_disjunction_sum_scorer_create(bsc->coordinator,
+          optional_scorers, os_cnt, 1));
+  }
+}
+
+Scorer *counting_sum_scorer_create(BooleanScorer *bsc)
+{
+  if (bsc->rs_cnt == 0) {
+    if (bsc->os_cnt == 0) {
+      int i;
+      // only prohibited_scorers so free them and return non_matching scorer
+      for (i = 0; i < bsc->ps_cnt; i++) {
+        bsc->prohibited_scorers[i]->destroy(bsc->prohibited_scorers[i]);
+      }
+      return non_matching_scorer_create();
+    } else if (bsc->os_cnt == 1) {
+      return counting_sum_scorer_create2( // the only optional scorer is required
+          bsc,
+          single_match_scorer_create(bsc->coordinator, bsc->optional_scorers[0]),
+          NULL, 0); // no optional scorers left
+    } else { // more than 1 @optional_scorers, no required scorers
+      return counting_sum_scorer_create2( // at least one optional scorer is required
+          bsc,
+          counting_disjunction_sum_scorer_create(bsc->coordinator,
+            bsc->optional_scorers, bsc->os_cnt, 1), 
+          NULL, 0); // no optional scorers left
+    }
+  } else if (bsc->rs_cnt == 1) { // 1 required
+    return counting_sum_scorer_create2(
+        bsc,
+        single_match_scorer_create(bsc->coordinator, bsc->required_scorers[0]),
+        bsc->optional_scorers, bsc->os_cnt);
+  } else {// more required scorers
+    return counting_sum_scorer_create2(
+        bsc,
+        counting_conjunction_sum_scorer_create(bsc->coordinator,
+          bsc->required_scorers, bsc->rs_cnt),
+        bsc->optional_scorers, bsc->os_cnt);
+  }
+}
+
+void bsc_init_counting_sum_scorer(BooleanScorer *bsc)
+{
+  coord_init(bsc->coordinator);
+  bsc->counting_sum_scorer = counting_sum_scorer_create(bsc);
+}
+
+void bsc_add_scorer(Scorer *self, Scorer *scorer, unsigned int occur) 
+{
+  BooleanScorer *bsc = (BooleanScorer *)self->data;
+  if (occur != BC_MUST_NOT) {
+    bsc->coordinator->max_coord++;
+  }
+
+  switch (occur) {
+    case BC_MUST:
+      RECAPA(bsc, rs_cnt, rs_capa, required_scorers, Scorer *);
+      bsc->required_scorers[bsc->rs_cnt++] = scorer;
+      break;
+    case BC_SHOULD:
+      RECAPA(bsc, os_cnt, os_capa, optional_scorers, Scorer *);
+      bsc->optional_scorers[bsc->os_cnt++] = scorer;
+      break;
+    case BC_MUST_NOT:
+      RECAPA(bsc, ps_cnt, ps_capa, prohibited_scorers, Scorer *);
+      bsc->prohibited_scorers[bsc->ps_cnt++] = scorer;
+      break;
+    default:
+      eprintf(ARG_ERROR, "Unknown value for occur <%d>\n", occur);
+  }
+}
+
+float bsc_score(Scorer *self)
+{
+  BooleanScorer *bsc = (BooleanScorer *)self->data;
+  Coordinator *coord = bsc->coordinator;
+  float sum;
+  coord->num_matches = 0;
+  sum = bsc->counting_sum_scorer->score(bsc->counting_sum_scorer);
+  return sum * coord->coord_factors[coord->num_matches];
+}
+
+bool bsc_next(Scorer *self)
+{
+  BooleanScorer *bsc = (BooleanScorer *)self->data;
+
+  if (!bsc->counting_sum_scorer) {
+    bsc_init_counting_sum_scorer(bsc);
+  }
+  if (bsc->counting_sum_scorer->next(bsc->counting_sum_scorer)) {
+    self->doc = bsc->counting_sum_scorer->doc;
+    return true;
+  } else {
+    return false;
+  }
+}
+
+bool bsc_skip_to(Scorer *self, int doc_num)
+{
+  BooleanScorer *bsc = (BooleanScorer *)self->data;
+
+  if (!bsc->counting_sum_scorer) {
+    bsc_init_counting_sum_scorer(bsc);
+  }
+  if (bsc->counting_sum_scorer->skip_to(bsc->counting_sum_scorer, doc_num)) {
+    self->doc = bsc->counting_sum_scorer->doc;
+    return true;
+  } else {
+    return false;
+  }
+}
+
+void bsc_destroy(void *p)
+{
+  Scorer *self = (Scorer *)p;
+  BooleanScorer *bsc = (BooleanScorer *)self->data;
+  Coordinator *coord = bsc->coordinator;
+
+  free(coord->coord_factors);
+  free(coord);
+
+  if (bsc->counting_sum_scorer) {
+    bsc->counting_sum_scorer->destroy(bsc->counting_sum_scorer);
+  } else {
+    int i;
+    for (i = 0; i < bsc->rs_cnt; i++) {
+      bsc->required_scorers[i]->destroy(bsc->required_scorers[i]);
+    }
+    
+    for (i = 0; i < bsc->os_cnt; i++) {
+      bsc->optional_scorers[i]->destroy(bsc->optional_scorers[i]);
+    }
+
+    for (i = 0; i < bsc->ps_cnt; i++) {
+      bsc->prohibited_scorers[i]->destroy(bsc->prohibited_scorers[i]);
+    }
+  }
+  free(bsc->required_scorers);
+  free(bsc->optional_scorers);
+  free(bsc->prohibited_scorers);
+  scorer_destroy(self);
+}
+
+Explanation *bsc_explain(Scorer *self, int doc_num)
+{
+  return expl_create(0.0, estrdup("This explanation is not supported"));
+}
+
+Scorer *bsc_create(Similarity *similarity)
+{
+  Scorer *self = scorer_create(similarity);
+  BooleanScorer *bsc = ALLOC(BooleanScorer);
+  ZEROSET(bsc, BooleanScorer, 1);
+  bsc->coordinator = coord_create(similarity);
+  bsc->counting_sum_scorer = NULL;
+  self->data = bsc;
+
+  self->score = &bsc_score;
+  self->next = &bsc_next;
+  self->skip_to = &bsc_skip_to;
+  self->explain = &bsc_explain;
+  self->destroy = &bsc_destroy;
+  return self;
+}
+
+