ferret 0.9.6 → 0.10.0

data/ext/q_boolean.c

@@ -1,1390 +1,1587 @@
 #include <string.h>
 #include "search.h"
+#include "array.h"
 
-static char * const INVALID_BC_ERROR_MSG = "Invalid value for BooleanClause Type";
-static char * const TOO_MANY_CLAUSES_ERROR_MSG = "Too many clauses";
-static char * const MIN_NUM_MATCHES_ERROR_MSG = "Minimum nr of matches must be positive";
-static char * const TWO_SUB_ERROR_MSG = "There must be at least 2 sub_scorers";
-static char * const UNKNOWN_OCCUR_VAL_ERROR_MSG = "Unknown value for occur";
+#define BQ(query) ((BooleanQuery *)(query))
+#define BW(weight) ((BooleanWeight *)(weight))
 
 /***************************************************************************
  *
- * BooleanWeight
+ * BooleanScorer
  *
  ***************************************************************************/
 
-float bw_sum_of_squared_weights(Weight *self)
+/***************************************************************************
+ * Coordinator
+ ***************************************************************************/
+
+typedef struct Coordinator
 {
-  BooleanWeight *bw = (BooleanWeight *)self->data;
-  BooleanQuery *bq = (BooleanQuery *)self->query->data;
-  Weight *weight;
+    int max_coord;
+    float *coord_factors;
+    Similarity *similarity;
+    int num_matches;
+} Coordinator;
 
-  float sum = 0.0;
-  int i;
+static Coordinator *coord_new(Similarity *similarity)
+{
+    Coordinator *self = ALLOC_AND_ZERO(Coordinator);
+    self->similarity = similarity;
+    return self;
+}
 
-  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
-    }
-  }
+static Coordinator *coord_init(Coordinator *self)
+{
+    int i;
+    self->coord_factors = ALLOC_N(float, self->max_coord + 1);
 
-  sum *= self->value * self->value;        // boost each sub-weight
+    for (i = 0; i <= self->max_coord; i++) {
+        self->coord_factors[i]
+            = sim_coord(self->similarity, i, self->max_coord);
+    }
 
-  return sum;
+    return self;
 }
 
-void bw_normalize(Weight *self, float normalization_factor)
+/***************************************************************************
+ * DisjunctionSumScorer
+ ***************************************************************************/
+
+#define DSSc(scorer) ((DisjunctionSumScorer *)(scorer))
+
+typedef struct DisjunctionSumScorer
 {
-  BooleanWeight *bw = (BooleanWeight *)self->data;
-  BooleanQuery *bq = (BooleanQuery *)self->query->data;
-  Weight *weight;
-  int i;
-  normalization_factor *= self->value; /* multiply by query boost */
+    Scorer          super;
+    float           cum_score;
+    int             num_matches;
+    int             min_num_matches;
+    Scorer        **sub_scorers;
+    int             ss_cnt;
+    PriorityQueue  *scorer_queue;
+    Coordinator    *coordinator;
+} DisjunctionSumScorer;
 
-  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
-    }
-  }
+static float dssc_score(Scorer *self)
+{
+    return DSSc(self)->cum_score;
 }
 
-Scorer *bw_scorer(Weight *self, IndexReader *ir)
+static void dssc_init_scorer_queue(DisjunctionSumScorer *dssc)
 {
-  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;
+    int i;
+    Scorer *sub_scorer;
+    PriorityQueue *pq = dssc->scorer_queue
+        = pq_new(dssc->ss_cnt, (lt_ft)&scorer_doc_less_than, NULL);
+
+    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);
+        }
     }
-  }
+}
+
+static bool dssc_advance_after_current(Scorer *self)
+{
+    DisjunctionSumScorer *dssc = DSSc(self);
+    PriorityQueue *scorer_queue = dssc->scorer_queue;
+
+    /* repeat until minimum number of matches is found */
+    while (true) {
+        Scorer *top = (Scorer *)pq_top(scorer_queue);
+        self->doc = top->doc;
+        dssc->cum_score = top->score(top);
+        dssc->num_matches = 1;
+        /* Until all sub-scorers are after self->doc */
+        while (true) {
+            if (top->next(top)) {
+                pq_down(scorer_queue);
+            }
+            else {
+                pq_pop(scorer_queue);
+                if (scorer_queue->size
+                    < (dssc->min_num_matches - dssc->num_matches)) {
+                    /* Not enough subscorers left for a match on this
+                     * document, also no more chance of any further match */
+                    return false;
+                }
+                if (scorer_queue->size == 0) {
+                    /* nothing more to advance, check for last match. */
+                    break;
+                }
+            }
+            top = pq_top(scorer_queue);
+            if (top->doc != self->doc) {
+                /* All remaining subscorers are after self->doc */
+                break;
+            }
+            else {
+                dssc->cum_score += top->score(top);
+                dssc->num_matches++;
+            }
+        }
 
-  return bsc;
+        if (dssc->num_matches >= dssc->min_num_matches) { 
+            return true;
+        }
+        else if (scorer_queue->size < dssc->min_num_matches) {
+            return false;
+        }
+    }
 }
 
-char *bw_to_s(Weight *self)
+static bool dssc_next(Scorer *self)
 {
-  return strfmt("BooleanWeight(%f)", self->value);
+    if (DSSc(self)->scorer_queue == NULL) {
+        dssc_init_scorer_queue(DSSc(self));
+    }
+
+    if (DSSc(self)->scorer_queue->size < DSSc(self)->min_num_matches) {
+        return false;
+    }
+    else {
+        return dssc_advance_after_current(self);
+    }
 }
 
-void bw_destroy(Weight *self)
+static bool dssc_skip_to(Scorer *self, int doc_num)
 {
-  int i;
-  BooleanWeight *bw = (BooleanWeight *)self->data;
+    DisjunctionSumScorer *dssc = DSSc(self);
+    PriorityQueue *scorer_queue = dssc->scorer_queue;
 
-  for (i = 0; i < bw->w_cnt; i++) {
-    bw->weights[i]->destroy(bw->weights[i]);
-  }
+    if (scorer_queue == NULL) {
+        dssc_init_scorer_queue(dssc);
+        scorer_queue = dssc->scorer_queue;
+    }
 
-  free(bw->weights);
-  free(bw);
-  w_destroy(self);
+    if (scorer_queue->size < dssc->min_num_matches) {
+        return false;
+    }
+    if (doc_num <= self->doc) {
+        doc_num = self->doc + 1;
+    }
+    while (true) { 
+        Scorer *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->size < dssc->min_num_matches) {
+                return false;
+            }
+        }
+    }
 }
 
-Explanation *bw_explain(Weight *self, IndexReader *ir, int doc_num)
+static Explanation *dssc_explain(Scorer *self, 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;
+    int i;
+    DisjunctionSumScorer *dssc = DSSc(self);
+    Scorer *sub_scorer;
+    Explanation *e
+        = expl_new(0.0, "At least %d of:", 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;
+}
 
-  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);
+static void dssc_destroy(Scorer *self)
+{
+    DisjunctionSumScorer *dssc = DSSc(self);
+    int i;
+    for (i = 0; i < dssc->ss_cnt; i++) {
+        dssc->sub_scorers[i]->destroy(dssc->sub_scorers[i]);
     }
-  }
-  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, 
-          strfmt("coord(%d/%d)", coord, max_coord)));
-    return explanation;
-  }
-}
-
-Weight *bw_create(Query *query, Searcher *searcher)
-{
-  int i;
-  Weight *self = w_create(query);
-  BooleanWeight *bw = ALLOC(BooleanWeight);
-  BooleanQuery *bq = (BooleanQuery *)query->data;
-
-  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);
-  }
-  self->data = bw;
-
-  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->value = query->boost;
-
-  return self;
+    if (dssc->scorer_queue) {
+        pq_destroy(dssc->scorer_queue);
+    }
+    scorer_destroy_i(self);
 }
 
-/***************************************************************************
- *
- * BooleanClause
- *
- ***************************************************************************/
+static Scorer *disjunction_sum_scorer_new(Scorer **sub_scorers, int ss_cnt,
+                                          int min_num_matches) 
+{
+    Scorer *self = scorer_new(DisjunctionSumScorer, NULL);
+    DSSc(self)->ss_cnt = ss_cnt;
+
+    /* The document number of the current match */
+    self->doc = -1;
+    DSSc(self)->cum_score = -1.0;
+
+    /* The number of subscorers that provide the current match. */
+    DSSc(self)->num_matches = -1;
+    DSSc(self)->coordinator = NULL;
 
-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:
-      RAISE(ARG_ERROR, INVALID_BC_ERROR_MSG);
-  }
+#ifdef DEBUG
+    if (min_num_matches <= 0) {
+        RAISE(ARG_ERROR, "The min_num_matches value <%d> should not be less "
+              "than 0\n", min_num_matches);
+    }
+    if (ss_cnt <= 1) {
+        RAISE(ARG_ERROR, "There should be at least 2 sub_scorers in a "
+              "DiscjunctionSumScorer. <%d> is not enough", ss_cnt);
+    }
+#endif
+
+    DSSc(self)->min_num_matches = min_num_matches;
+    DSSc(self)->sub_scorers     = sub_scorers;
+    DSSc(self)->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;
 }
 
-void bc_deref(BooleanClause *self)
+static float cdssc_score(Scorer *self)
 {
-  if (--self->ref_cnt <= 0) {
-    q_deref(self->query);
-    free(self);
-  }
+    DSSc(self)->coordinator->num_matches += DSSc(self)->num_matches;
+    return DSSc(self)->cum_score;
 }
 
-uint bc_hash(BooleanClause *self)
+static Scorer *counting_disjunction_sum_scorer_new(
+    Coordinator *coordinator, Scorer **sub_scorers, int ss_cnt,
+    int min_num_matches)
 {
-  return ((q_hash(self->query) << 2) | self->occur);
+    Scorer *self = disjunction_sum_scorer_new(sub_scorers, ss_cnt,
+                                              min_num_matches);
+    DSSc(self)->coordinator = coordinator;
+    self->score = &cdssc_score;
+    return self;
 }
 
-int  bc_eq(BooleanClause *self, BooleanClause *o)
+/***************************************************************************
+ * ConjunctionScorer
+ ***************************************************************************/
+
+#define CSc(scorer) ((ConjunctionScorer *)(scorer))
+
+typedef struct ConjunctionScorer
 {
-  return ((self->occur == o->occur) && q_eq(self->query, o->query)); 
-}
+    Scorer          super;
+    bool            first_time : 1;
+    bool            more : 1;
+    float           coord;
+    Scorer        **sub_scorers;
+    int             ss_cnt;
+    int             first_idx;
+    Coordinator    *coordinator;
+    int             last_scored_doc;
+} ConjunctionScorer;
 
-BooleanClause *bc_create(Query *query, unsigned int occur)
+static void csc_sort_scorers(ConjunctionScorer *csc)
 {
-  BooleanClause *self = ALLOC(BooleanClause);
-  self->ref_cnt = 1;
-  self->query = query;
-  bc_set_occur(self, occur);
-  return self;
+    qsort(csc->sub_scorers, csc->ss_cnt, sizeof(Scorer *), &scorer_doc_cmp);
+    csc->first_idx = 0;
 }
 
-/***************************************************************************
- *
- * BooleanQuery
- *
- ***************************************************************************/
+static void csc_init(Scorer *self, bool init_scorers)
+{
+    ConjunctionScorer *csc = CSc(self);
+    const int sub_sc_cnt = csc->ss_cnt;
 
-Query *bq_rewrite(Query *self, IndexReader *ir)
-{
-  BooleanQuery *bq = (BooleanQuery *)self->data;
-  BooleanClause *clause;
-  Query *q, *rq;
-  int i;
-
-  if (bq->clause_cnt == 1) { // optimize 1-clause queries
-    clause = bq->clauses[0];
-    if (! clause->is_prohibited) { // just return clause
-      q = 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 ((q == clause->query) && bq->original_boost) {
-          /* rewrite was no-op */
-          q->boost = bq->original_boost * self->boost;
-        } else {
-          bq->original_boost = q->boost; /* save original boost */
-          q->boost *= self->boost;
+    /* compute coord factor */
+    csc->coord = sim_coord(self->similarity, sub_sc_cnt, sub_sc_cnt);
+
+    csc->more = (sub_sc_cnt > 0);
+
+    if (init_scorers) {
+        int i;
+        /* move each scorer to its first entry */
+        for (i = 0; i < sub_sc_cnt; i++) {
+            Scorer *sub_scorer = csc->sub_scorers[i];
+            if (!csc->more) {
+                break;
+            }
+            csc->more = sub_scorer->next(sub_scorer);
         }
-      }
-
-      return q;
-    }
-  }
-
-  /* replace each clause's query with its rewritten query */
-  for (i = 0; i < bq->clause_cnt; i++) {
-    clause = bq->clauses[i];
-    rq = clause->query->rewrite(clause->query, ir);
-    q_deref(clause->query);
-    clause->query = rq;
-  }
-
-  self->ref_cnt++;
-  return self;
-}
-
-void bq_extract_terms(Query *self, HashSet *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)
-{
-  int i;
-  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++;
-  }
-
-  for (i = 0; i < bq->clause_cnt; i++) {
-    clause = bq->clauses[i];
-    clause_str = clause->query->to_s(clause->query, field);
-    clause_len = (int)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 *boost_str = strfmt(")^%f", self->boost);
-    int boost_len = (int)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;
+        if (csc->more) {
+            csc_sort_scorers(csc);
+        }
+    }
+
+    csc->first_time = false;
 }
 
-static void bq_destroy(Query *self)
+static float csc_score(Scorer *self)
 {
-  BooleanQuery *bq = (BooleanQuery *)self->data;
-  int i;
-  for (i = 0; i < bq->clause_cnt; i++) {
-    bc_deref(bq->clauses[i]);
-  }
-  free(bq->clauses);
-  if (bq->similarity) {
-    bq->similarity->destroy(bq->similarity);
-  }
-  free(bq);
-  q_destroy_i(self);
+    ConjunctionScorer *csc = CSc(self);
+    const int sub_sc_cnt = csc->ss_cnt;
+    float score = 0.0; /* sum scores */
+    int i;
+    for (i = 0; i < sub_sc_cnt; i++) {
+        Scorer *sub_scorer = csc->sub_scorers[i];
+        score += sub_scorer->score(sub_scorer);
+    }
+    score *= csc->coord;
+    return score;
+}
+
+static bool csc_do_next(Scorer *self)
+{
+    ConjunctionScorer *csc = CSc(self);
+    const int sub_sc_cnt = csc->ss_cnt;
+    int first_idx = csc->first_idx;
+    Scorer *first_sc = csc->sub_scorers[first_idx];
+    Scorer *last_sc = csc->sub_scorers[PREV_NUM(first_idx, sub_sc_cnt)];
+
+    /* skip to doc with all clauses */
+    while (csc->more && (first_sc->doc < last_sc->doc)) {
+        /* skip first upto last */
+        csc->more = first_sc->skip_to(first_sc, last_sc->doc);
+        /* move first to last */
+        last_sc = first_sc;
+        first_idx = NEXT_NUM(first_idx, sub_sc_cnt);
+        first_sc = csc->sub_scorers[first_idx];
+    }
+    self->doc = first_sc->doc;
+    csc->first_idx = first_idx;
+    return csc->more;
 }
 
-float bq_coord_disabled(Similarity *sim, int overlap, int max_overlap)
+static bool csc_next(Scorer *self)
 {
-  return 1.0;
+    ConjunctionScorer *csc = CSc(self);
+    if (csc->first_time) {
+        csc_init(self, true);
+    }
+    else if (csc->more) {
+        /* trigger further scanning */
+        const int last_idx = PREV_NUM(csc->first_idx, csc->ss_cnt);
+        Scorer *sub_scorer = csc->sub_scorers[last_idx];
+        csc->more = sub_scorer->next(sub_scorer);
+    }
+    return csc_do_next(self);
 }
 
-Similarity *bq_get_similarity(Query *self, Searcher *searcher)
+static bool csc_skip_to(Scorer *self, int doc_num)
 {
-  BooleanQuery *bq = (BooleanQuery *)self->data;
-  if (!bq->similarity) {
-    Similarity *sim = q_get_similarity_i(self, searcher); 
-    bq->similarity = ALLOC(Similarity);
-    memcpy(bq->similarity, sim, sizeof(Similarity));
-    bq->similarity->coord = &bq_coord_disabled;
-    bq->similarity->destroy = (void (*)(Similarity *))&free;
-  }
+    ConjunctionScorer *csc = CSc(self);
+    const int sub_sc_cnt = csc->ss_cnt;
+    int i;
+    bool more = csc->more;
 
-  return bq->similarity;
-}
+    if (csc->first_time) {
+        csc_init(self, true);
+    }
 
-static uint bq_hash(Query *self)
-{
-  int i;
-  uint hash = 0;
-  BooleanQuery *bq = (BooleanQuery *)self->data;
-  for (i = 0; i < bq->clause_cnt; i++) {
-    hash ^= bc_hash(bq->clauses[i]);
-  }
-  return (hash << 1) | bq->coord_disabled;
+    for (i = 0; i < sub_sc_cnt; i++) {
+        if (!more) {
+            break;
+        }
+        else {
+            Scorer *sub_scorer = csc->sub_scorers[i];
+            more = sub_scorer->skip_to(sub_scorer, doc_num);
+        }
+    }
+    if (more) {
+        /* resort the scorers */
+        csc_sort_scorers(csc);
+    }
+
+    more = csc->more;
+    return csc_do_next(self);
 }
 
-static int  bq_eq(Query *self, Query *o)
+static void csc_destroy(Scorer *self)
 {
-  int i;
-  BooleanQuery *bq1 = (BooleanQuery *)self->data;
-  BooleanQuery *bq2 = (BooleanQuery *)o->data;
-  if ((bq1->coord_disabled != bq2->coord_disabled) ||
-      (bq1->max_clause_cnt != bq1->max_clause_cnt) ||
-      (bq1->clause_cnt != bq2->clause_cnt)) {
-    return false;
-  }
-
-  for (i = 0; i < bq1->clause_cnt; i++) {
-    if (!bc_eq(bq1->clauses[i], bq2->clauses[i])) {
-      return false;
-    }
-  }
-  return true;
-}
-
-Query *bq_create(bool coord_disabled)
-{
-  Query *self = q_create();
-  BooleanQuery *bq = ALLOC(BooleanQuery);
-  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;
-  bq->original_boost = 0.0;
-  self->data = bq;
-
-  self->type = BOOLEAN_QUERY;
-  self->rewrite = &bq_rewrite;
-  self->extract_terms = &bq_extract_terms;
-  self->to_s = &bq_to_s;
-  self->hash = &bq_hash;
-  self->eq = &bq_eq;
-  self->destroy_i = &bq_destroy;
-  self->create_weight_i = &bw_create;
-  return self;
+    ConjunctionScorer *csc = CSc(self);
+    const int sub_sc_cnt = csc->ss_cnt;
+    int i;
+    for (i = 0; i < sub_sc_cnt; i++) {
+        csc->sub_scorers[i]->destroy(csc->sub_scorers[i]);
+    }
+    free(csc->sub_scorers);
+    scorer_destroy_i(self);
 }
 
-BooleanClause *bq_add_clause(Query *self, BooleanClause *bc)
+static Scorer *conjunction_scorer_new(Similarity *similarity) 
 {
-  BooleanQuery *bq = (BooleanQuery *)self->data;
-  if (!self->destroy_all) ref(bc);
-  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) {
-    RAISE(STATE_ERROR, TOO_MANY_CLAUSES_ERROR_MSG);
-  }
-  bq->clauses[bq->clause_cnt] = bc;
-  bq->clause_cnt++;
-  return bc;
-}
-
-BooleanClause *bq_add_query(Query *self, Query *sub_query, unsigned int occur)
-{
-  BooleanClause *bc = bc_create(sub_query, occur);
-  bq_add_clause(self, bc);
-  if (!self->destroy_all) {
-    ref(sub_query);
-    bc_deref(bc); /* bc would have been referenced unnecessarily */
-  }
-  return bc;
-}
+    Scorer *self = scorer_new(ConjunctionScorer, similarity);
 
-/***************************************************************************
- *
- * BooleanScorer
- *
- ***************************************************************************/
+    CSc(self)->first_time   = true;
+    CSc(self)->more         = true;
+    CSc(self)->coordinator  = NULL;
 
-/***************************************************************************
- * Coordinator
- ***************************************************************************/
+    self->score             = &csc_score;
+    self->next              = &csc_next;
+    self->skip_to           = &csc_skip_to;
+    self->destroy           = &csc_destroy;
 
-Coordinator *coord_create(Similarity *similarity)
+    return self;
+}
+
+static float ccsc_score(Scorer *self)
 {
-  Coordinator *self = ALLOC(Coordinator);
-  ZEROSET(self, Coordinator, 1);
-  self->similarity = similarity;
-  return self;
+    ConjunctionScorer *csc = CSc(self);
+
+    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);
 }
 
-Coordinator *coord_init(Coordinator *self)
+static Scorer *counting_conjunction_sum_scorer_new(
+    Coordinator *coordinator, Scorer **sub_scorers, int ss_cnt)
 {
-  int i;
-  self->coord_factors = ALLOC_N(float, self->max_coord + 1);
+    Scorer *self = conjunction_scorer_new(sim_create_default());
+    ConjunctionScorer *csc = CSc(self);
+    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_cnt = ss_cnt;
 
-  for (i = 0; i <= self->max_coord; i++) {
-    self->coord_factors[i] = sim_coord(self->similarity, i, self->max_coord);
-  }
+    self->score = &ccsc_score;
 
-  return self;
+    return self;
 }
 
 /***************************************************************************
- * DisjunctionSumScorer
+ * SingleMatchScorer
  ***************************************************************************/
 
-float dssc_score(Scorer *self)
+#define SMSc(scorer) ((SingleMatchScorer *)(scorer))
+
+typedef struct SingleMatchScorer
 {
-  DisjunctionSumScorer *dssc = (DisjunctionSumScorer *)self->data;
-  return dssc->cum_score;
-}
+    Scorer          super;
+    Coordinator    *coordinator;
+    Scorer         *scorer;
+} SingleMatchScorer;
+
 
-void dssc_init_scorer_queue(DisjunctionSumScorer *dssc)
+static float smsc_score(Scorer *self)
 {
-  int i;
-  Scorer *sub_scorer;
-  PriorityQueue *pq = dssc->scorer_queue =
-    pq_create(dssc->ss_cnt, &scorer_doc_less_than);
+    SMSc(self)->coordinator->num_matches++;
+    return SMSc(self)->scorer->score(SMSc(self)->scorer);
+}
 
-  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);
+static bool smsc_next(Scorer *self)
+{
+    Scorer *scorer = SMSc(self)->scorer;
+    if (scorer->next(scorer)) {
+        self->doc = scorer->doc;
+        return true;
     }
-  }
+    return false;
 }
 
-bool dssc_advance_after_current(Scorer *self)
+static bool smsc_skip_to(Scorer *self, int doc_num)
 {
-  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++;
-      }
+    Scorer *scorer = SMSc(self)->scorer;
+    if (scorer->skip_to(scorer, doc_num)) {
+        self->doc = scorer->doc;
+        return true;
     }
+    return false;
+}
 
-    if (dssc->num_matches >= dssc->min_num_matches) { 
-      return true;
-    } else if (scorer_queue->count < dssc->min_num_matches) {
-      return false;
-    }
-  }
+static Explanation *smsc_explain(Scorer *self, int doc_num)
+{
+    Scorer *scorer = SMSc(self)->scorer;
+    return scorer->explain(scorer, doc_num);
 }
 
-bool dssc_next(Scorer *self)
+static void smsc_destroy(Scorer *self)
 {
-  DisjunctionSumScorer *dssc = (DisjunctionSumScorer *)self->data;
+    Scorer *scorer = SMSc(self)->scorer;
+    scorer->destroy(scorer);
+    scorer_destroy_i(self);
+}
 
-  if (dssc->scorer_queue == NULL) {
-    dssc_init_scorer_queue(dssc);
-  }
+static Scorer *single_match_scorer_new(Coordinator *coordinator,
+                                       Scorer *scorer)
+{
+    Scorer *self = scorer_new(SingleMatchScorer, scorer->similarity);
+    SMSc(self)->coordinator = coordinator;
+    SMSc(self)->scorer      = scorer;
 
-  if (dssc->scorer_queue->count < dssc->min_num_matches) {
-    return false;
-  } else {
-    return dssc_advance_after_current(self);
-  }
+    self->score             = &smsc_score;
+    self->next              = &smsc_next;
+    self->skip_to           = &smsc_skip_to;
+    self->explain           = &smsc_explain;
+    self->destroy           = &smsc_destroy;
+    return self;
 }
 
-bool dssc_skip_to(Scorer *self, int doc_num)
+/***************************************************************************
+ * ReqOptSumScorer
+ ***************************************************************************/
+
+#define ROSSc(scorer) ((ReqOptSumScorer *)(scorer))
+
+typedef struct ReqOptSumScorer
 {
-  DisjunctionSumScorer *dssc = (DisjunctionSumScorer *)self->data;
-  PriorityQueue *scorer_queue = dssc->scorer_queue;
-  Scorer *top;
+    Scorer  super;
+    Scorer *req_scorer;
+    Scorer *opt_scorer;
+    bool    first_time_opt;
+} ReqOptSumScorer;
 
-  if (scorer_queue == NULL) {
-    dssc_init_scorer_queue(dssc);
-    scorer_queue = dssc->scorer_queue;
-  }
+static float rossc_score(Scorer *self)
+{
+    ReqOptSumScorer *rossc = ROSSc(self);
+    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 (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;
-      }
+    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;
 }
 
-Explanation *dssc_explain(Scorer *self, int doc_num)
+static bool rossc_next(Scorer *self)
 {
-  int i;
-  DisjunctionSumScorer *dssc = (DisjunctionSumScorer *)self->data;
-  Scorer *sub_scorer;
-  Explanation *e = expl_create(0.0,
-      strfmt("At least %d of:", 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;
+    Scorer *req_scorer = ROSSc(self)->req_scorer;
+    if (req_scorer->next(req_scorer)) {
+        self->doc = req_scorer->doc;
+        return true;
+    }
+    return false;
 }
 
-void dssc_destroy(Scorer *self)
+static bool rossc_skip_to(Scorer *self, int doc_num)
 {
-  DisjunctionSumScorer *dssc = (DisjunctionSumScorer *)self->data;
-  int i;
-  for (i = 0; i < dssc->ss_cnt; i++) {
-    dssc->sub_scorers[i]->destroy(dssc->sub_scorers[i]);
-  }
-  if (dssc->scorer_queue) pq_destroy(dssc->scorer_queue);
-  scorer_destroy_i(self);
+    Scorer *req_scorer = ROSSc(self)->req_scorer;
+    if (req_scorer->skip_to(req_scorer, doc_num)) {
+        self->doc = req_scorer->doc;
+        return true;
+    }
+    return false;
 }
 
-Scorer *disjunction_sum_scorer_create(Scorer **sub_scorers, int ss_cnt,
-    int min_num_matches) 
+static Explanation *rossc_explain(Scorer *self, int doc_num)
 {
-  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;
+    Scorer *req_scorer = ROSSc(self)->req_scorer;
+    Scorer *opt_scorer = ROSSc(self)->opt_scorer;
 
-  // The number of subscorers that provide the current match. 
-  dssc->num_matches = -1;
-  dssc->coordinator = NULL;
-
-  if (min_num_matches <= 0) {
-    RAISE(ARG_ERROR, MIN_NUM_MATCHES_ERROR_MSG);
-  }
-  if (ss_cnt <= 1) {
-    RAISE(ARG_ERROR, TWO_SUB_ERROR_MSG);
-  }
-
-  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;
+    Explanation *e = expl_new(self->score(self),"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;
 }
 
-float cdssc_score(Scorer *self)
+static void rossc_destroy(Scorer *self)
 {
-  DisjunctionSumScorer *dssc = (DisjunctionSumScorer *)self->data;
-  dssc->coordinator->num_matches += dssc->num_matches;
-  return dssc->cum_score;
+    ReqOptSumScorer *rossc = ROSSc(self);
+    if (rossc->req_scorer) {
+        rossc->req_scorer->destroy(rossc->req_scorer);
+    }
+    if (rossc->opt_scorer) {
+        rossc->opt_scorer->destroy(rossc->opt_scorer);
+    }
+    scorer_destroy_i(self);
 }
 
-Scorer *counting_disjunction_sum_scorer_create(Coordinator *coordinator,
-    Scorer **sub_scorers, int ss_cnt, int min_num_matches) 
+
+static Scorer *req_opt_sum_scorer_new(Scorer *req_scorer, Scorer *opt_scorer)
 {
-  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;
+    Scorer *self = scorer_new(ReqOptSumScorer, NULL);
+
+    ROSSc(self)->req_scorer     = req_scorer;
+    ROSSc(self)->opt_scorer     = opt_scorer;
+    ROSSc(self)->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;
 }
 
 /***************************************************************************
- * ConjunctionScorer
+ * ReqExclScorer
  ***************************************************************************/
 
-void csc_sort_scorers(ConjunctionScorer *csc)
+#define RXSc(scorer) ((ReqExclScorer *)(scorer))
+typedef struct ReqExclScorer
 {
-  qsort(csc->sub_scorers, csc->ss_cnt, sizeof(Scorer *), &scorer_doc_cmp);
-  csc->first = 0;
-  csc->last = csc->ss_cnt - 1;
-}
+    Scorer  super;
+    Scorer *req_scorer;
+    Scorer *excl_scorer;
+    bool    first_time;
+} ReqExclScorer;
 
-void csc_init(Scorer *self, bool init_scorers)
+static bool rxsc_to_non_excluded(Scorer *self)
 {
-  ConjunctionScorer *csc = (ConjunctionScorer *)self->data;
-  Scorer *sub_scorer;
-  int i;
+    Scorer *req_scorer = RXSc(self)->req_scorer;
+    Scorer *excl_scorer = RXSc(self)->excl_scorer;
+    int excl_doc = excl_scorer->doc, req_doc;
 
-  /* compute coord factor */
-  csc->coord = sim_coord(self->similarity, csc->ss_cnt, csc->ss_cnt);
-
-  csc->more = (csc->ss_cnt > 0);
+    do { 
+        /* may be excluded */
+        req_doc = req_scorer->doc;
+        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)) {
+                /* emptied, no more exclusions */
+                SCORER_NULLIFY(RXSc(self)->excl_scorer);
+                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));
+    /* emptied, nothing left */
+    SCORER_NULLIFY(RXSc(self)->req_scorer);
+    return false;
+}
 
-  if (init_scorers) {
-    // move each scorer to its first entry
+static bool rxsc_next(Scorer *self)
+{
+    ReqExclScorer *rxsc = RXSc(self);
+    Scorer *req_scorer = rxsc->req_scorer;
+    Scorer *excl_scorer = rxsc->excl_scorer;
 
-    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 (rxsc->first_time) {
+        if (! excl_scorer->next(excl_scorer)) {
+            /* emptied at start */
+            SCORER_NULLIFY(rxsc->excl_scorer);
+            excl_scorer = NULL;
+        }
+        rxsc->first_time = false;
+    }
+    if (req_scorer == NULL) {
+        return false;
     }
-    if (csc->more) csc_sort_scorers(csc);
-  }
+    if (! req_scorer->next(req_scorer)) {
+        /* emptied, nothing left */
+        SCORER_NULLIFY(rxsc->req_scorer);
+        return false;
+    }
+    if (excl_scorer == NULL) {
+        self->doc = req_scorer->doc;
+        /* req_scorer->next() already returned true */
+        return true;
+    }
+    return rxsc_to_non_excluded(self);
+}
+
+static bool rxsc_skip_to(Scorer *self, int doc_num)
+{
+    ReqExclScorer *rxsc = RXSc(self);
+    Scorer *req_scorer = rxsc->req_scorer;
+    Scorer *excl_scorer = rxsc->excl_scorer;
 
-  csc->first_time = false;
+    if (rxsc->first_time) {
+        rxsc->first_time = false;
+        if (! excl_scorer->skip_to(excl_scorer, doc_num)) {
+            /* emptied */
+            SCORER_NULLIFY(rxsc->excl_scorer);
+            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 csc_score(Scorer *self)
+static float rxsc_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;
+    Scorer *req_scorer = RXSc(self)->req_scorer;
+    return req_scorer->score(req_scorer);
 }
 
-bool csc_do_next(Scorer *self)
+static Explanation *rxsc_explain(Scorer *self, int doc_num)
 {
-  ConjunctionScorer *csc = (ConjunctionScorer *)self->data;
-  Scorer *first = csc->sub_scorers[csc->first];
-  Scorer *last = csc->sub_scorers[csc->last];
+    ReqExclScorer *rxsc = RXSc(self);
+    Scorer *req_scorer = rxsc->req_scorer;
+    Scorer *excl_scorer = rxsc->excl_scorer;
+    Explanation *e;
 
-  // 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;
+    if (excl_scorer->skip_to(excl_scorer, doc_num)
+        && excl_scorer->doc == doc_num) {
+        e = expl_new(0.0, "excluded:");
+    }
+    else {
+        e = expl_new(0.0, "not excluded:");
+        expl_add_detail(e, req_scorer->explain(req_scorer, doc_num));
+    }
+    return e;
 }
 
-bool csc_next(Scorer *self)
+static void rxsc_destroy(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);
+    ReqExclScorer *rxsc = RXSc(self);
+    if (rxsc->req_scorer) {
+        rxsc->req_scorer->destroy(rxsc->req_scorer);
+    }
+    if (rxsc->excl_scorer) {
+        rxsc->excl_scorer->destroy(rxsc->excl_scorer);
+    }
+    scorer_destroy_i(self);
 }
 
-bool csc_skip_to(Scorer *self, int doc_num)
+static Scorer *req_excl_scorer_new(Scorer *req_scorer, Scorer *excl_scorer)
 {
-  ConjunctionScorer *csc = (ConjunctionScorer *)self->data;
-  Scorer *sub_scorer;
-  int i;
+    Scorer *self            = scorer_new(ReqExclScorer, NULL);
+    RXSc(self)->req_scorer  = req_scorer;
+    RXSc(self)->excl_scorer = excl_scorer;
+    RXSc(self)->first_time  = true;
 
-  if (csc->first_time) {
-    csc_init(self, true);
-  }
+    self->score             = &rxsc_score;
+    self->next              = &rxsc_next;
+    self->skip_to           = &rxsc_skip_to;
+    self->explain           = &rxsc_explain;
+    self->destroy           = &rxsc_destroy;
 
-  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);
+    return self;
 }
 
-void csc_destroy(Scorer *self)
+/***************************************************************************
+ * NonMatchScorer
+ ***************************************************************************/
+
+static float nmsc_score(Scorer *self)
 {
-  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_i(self);
+    (void)self;
+    return 0.0;
 }
 
-Scorer *conjunction_scorer_create(Similarity *similarity) 
+static bool nmsc_next(Scorer *self)
 {
-  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;
+    (void)self;
+    return false;
 }
 
-float ccsc_score(Scorer *self)
+static bool nmsc_skip_to(Scorer *self, int doc_num)
 {
-  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);
+    (void)self; (void)doc_num;
+    return false;
 }
 
-Scorer *counting_conjunction_sum_scorer_create(Coordinator *coordinator,
-    Scorer **sub_scorers, int ss_cnt)
+static Explanation *nmsc_explain(Scorer *self, int doc_num)
 {
-  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;
+    (void)self; (void)doc_num;
+    return expl_new(0.0, "No documents matched");
+}
 
-  self->score = &ccsc_score;
+static Scorer *non_matching_scorer_new()
+{
+    Scorer *self    = scorer_new(Scorer, NULL);
+    self->score     = &nmsc_score;
+    self->next      = &nmsc_next;
+    self->skip_to   = &nmsc_skip_to;
+    self->explain   = &nmsc_explain;
 
-  return self;
+    return self;
 }
 
 /***************************************************************************
- * SingleMatchScorer
+ * BooleanScorer
  ***************************************************************************/
 
-float smsc_score(Scorer *self)
+#define BSc(scorer) ((BooleanScorer *)(scorer))
+typedef struct BooleanScorer
+{
+    Scorer          super;
+    Scorer        **required_scorers;
+    int             rs_cnt;
+    int             rs_capa;
+    Scorer        **optional_scorers;
+    int             os_cnt;
+    int             os_capa;
+    Scorer        **prohibited_scorers;
+    int             ps_cnt;
+    int             ps_capa;
+    Scorer         *counting_sum_scorer;
+    Coordinator    *coordinator;
+} BooleanScorer;
+
+static Scorer *counting_sum_scorer_create3(BooleanScorer *bsc,
+                                           Scorer *req_scorer,
+                                           Scorer *opt_scorer)
 {
-  SingleMatchScorer *smsc = (SingleMatchScorer *)self->data;
-  smsc->coordinator->num_matches++;
-  return smsc->scorer->score(smsc->scorer);
+    if (bsc->ps_cnt == 0) {
+        /* no prohibited */
+        return req_opt_sum_scorer_new(req_scorer, opt_scorer);
+    }
+    else if (bsc->ps_cnt == 1) {
+        /* 1 prohibited */
+        return req_opt_sum_scorer_new(
+            req_excl_scorer_new(req_scorer, bsc->prohibited_scorers[0]),
+            opt_scorer);
+    }
+    else {
+        /* more prohibited */
+        return req_opt_sum_scorer_new(
+            req_excl_scorer_new(
+                req_scorer,
+                disjunction_sum_scorer_new(bsc->prohibited_scorers,
+                                              bsc->ps_cnt, 1)),
+            opt_scorer);
+    }
 }
 
-bool smsc_next(Scorer *self)
+static Scorer *counting_sum_scorer_create2(BooleanScorer *bsc,
+                                           Scorer *req_scorer,
+                                           Scorer **optional_scorers,
+                                           int os_cnt)
 {
-  Scorer *scorer = ((SingleMatchScorer *)self->data)->scorer;
-  if (scorer->next(scorer)) {
-    self->doc = scorer->doc;
-    return true;
-  }
-  return false;
+    if (os_cnt == 0) {
+        if (bsc->ps_cnt == 0) {
+            return req_scorer;
+        }
+        else if (bsc->ps_cnt == 1) {
+            return req_excl_scorer_new(req_scorer,
+                                       bsc->prohibited_scorers[0]);
+        }
+        else {
+            /* no optional, more than 1 prohibited */
+            return req_excl_scorer_new(
+                req_scorer,
+                disjunction_sum_scorer_new(bsc->prohibited_scorers,
+                                           bsc->ps_cnt, 1));
+        }
+    }
+    else if (os_cnt == 1) {
+        return counting_sum_scorer_create3(
+            bsc,
+            req_scorer,
+            single_match_scorer_new(bsc->coordinator, optional_scorers[0]));
+    }
+    else {
+        /* more optional */
+        return counting_sum_scorer_create3(
+            bsc,
+            req_scorer,
+            counting_disjunction_sum_scorer_new(bsc->coordinator,
+                                                optional_scorers, os_cnt, 1));
+    }
 }
 
-bool smsc_skip_to(Scorer *self, int doc_num)
+static Scorer *counting_sum_scorer_create(BooleanScorer *bsc)
 {
-  Scorer *scorer = ((SingleMatchScorer *)self->data)->scorer;
-  if (scorer->skip_to(scorer, doc_num)) {
-    self->doc = scorer->doc;
-    return true;
-  }
-  return false;
+    if (bsc->rs_cnt == 0) {
+        if (bsc->os_cnt == 0) {
+            int i;
+            /* only prohibited scorers so 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_new();
+        }
+        else if (bsc->os_cnt == 1) {
+            /* the only optional scorer is required */
+            return counting_sum_scorer_create2(
+                bsc,
+                single_match_scorer_new(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(
+                bsc,
+                counting_disjunction_sum_scorer_new(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_new(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_new(bsc->coordinator,
+                                                bsc->required_scorers,
+                                                bsc->rs_cnt),
+            bsc->optional_scorers, bsc->os_cnt);
+    }
 }
 
-Explanation *smsc_explain(Scorer *self, int doc_num)
+static Scorer *bsc_init_counting_sum_scorer(BooleanScorer *bsc)
 {
-  Scorer *scorer = ((SingleMatchScorer *)self->data)->scorer;
-  return scorer->explain(scorer, doc_num);
+    coord_init(bsc->coordinator);
+    return bsc->counting_sum_scorer = counting_sum_scorer_create(bsc);
 }
 
-void smsc_destroy(Scorer *self)
+static void bsc_add_scorer(Scorer *self, Scorer *scorer, unsigned int occur) 
 {
-  Scorer *scorer = ((SingleMatchScorer *)self->data)->scorer;
-  scorer->destroy(scorer);
-  scorer_destroy_i(self);
+    BooleanScorer *bsc = BSc(self);
+    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:
+            RAISE(ARG_ERROR, "Invalid value for :occur. Try :should, :must or "
+                  ":must_not instead");
+    }
 }
 
-Scorer *single_match_scorer_create(Coordinator *coordinator, Scorer *scorer)
+static float bsc_score(Scorer *self)
 {
-  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;
+    BooleanScorer *bsc = BSc(self);
+    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];
 }
 
-/***************************************************************************
- * ReqOptSumScorer
- ***************************************************************************/
+static bool bsc_next(Scorer *self)
+{
+    Scorer *cnt_sum_sc = BSc(self)->counting_sum_scorer;
 
-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;
+    if (!cnt_sum_sc) {
+        cnt_sum_sc = bsc_init_counting_sum_scorer(BSc(self));
+    }
+    if (cnt_sum_sc->next(cnt_sum_sc)) {
+        self->doc = cnt_sum_sc->doc;
+        return true;
+    }
+    else {
+        return false;
+    }
 }
 
-bool rossc_skip_to(Scorer *self, int doc_num)
+static bool bsc_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;
+    Scorer *cnt_sum_sc = BSc(self)->counting_sum_scorer;
+
+    if (!BSc(self)->counting_sum_scorer) {
+        cnt_sum_sc = bsc_init_counting_sum_scorer(BSc(self));
+    }
+    if (cnt_sum_sc->skip_to(cnt_sum_sc, doc_num)) {
+        self->doc = cnt_sum_sc->doc;
+        return true;
+    }
+    else {
+        return false;
+    }
 }
 
-Explanation *rossc_explain(Scorer *self, int doc_num)
+static void bsc_destroy(Scorer *self)
 {
-  ReqOptSumScorer *rossc = (ReqOptSumScorer *)self->data;
-  Scorer *req_scorer = rossc->req_scorer;
-  Scorer *opt_scorer = rossc->opt_scorer;
+    BooleanScorer *bsc = BSc(self);
+    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]);
+        }
 
-  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;
+        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_i(self);
 }
 
-void rossc_destroy(Scorer *self)
+static Explanation *bsc_explain(Scorer *self, int doc_num)
 {
-  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_i(self);
+    (void)self; (void)doc_num;
+    return expl_new(0.0, "This explanation is not supported");
 }
 
-
-Scorer *req_opt_sum_scorer_create(Scorer *req_scorer, Scorer *opt_scorer)
+static Scorer *bsc_new(Similarity *similarity)
 {
-  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;
+    Scorer *self = scorer_new(BooleanScorer, similarity);
+    BSc(self)->coordinator          = coord_new(similarity);
+    BSc(self)->counting_sum_scorer  = NULL;
 
-  return self;
+    self->score     = &bsc_score;
+    self->next      = &bsc_next;
+    self->skip_to   = &bsc_skip_to;
+    self->explain   = &bsc_explain;
+    self->destroy   = &bsc_destroy;
+    return self;
 }
 
 /***************************************************************************
- * ReqExclScorer
+ *
+ * BooleanWeight
+ *
  ***************************************************************************/
 
-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
-      }
+typedef struct BooleanWeight
+{
+    Weight w;
+    Weight **weights;
+    int w_cnt;
+} BooleanWeight;
+
+
+static float bw_sum_of_squared_weights(Weight *self)
+{
+    BooleanQuery *bq = BQ(self->query);
+    float sum = 0.0;
+    int i;
+
+    for (i = 0; i < BW(self)->w_cnt; i++) {
+        if (! bq->clauses[i]->is_prohibited) {
+            Weight *weight = BW(self)->weights[i];
+            /* sum sub-weights */
+            sum += weight->sum_of_squared_weights(weight);
+        }
     }
-  } while (req_scorer->next(req_scorer));
-  SCORER_NULLIFY(rxsc->req_scorer); // exhausted, nothing left
-  return false;
+
+    /* boost each sub-weight */
+    sum *= self->value * self->value;
+    return sum;
 }
 
-bool rxsc_next(Scorer *self)
+static void bw_normalize(Weight *self, float normalization_factor)
 {
-  ReqExclScorer *rxsc = (ReqExclScorer *)self->data;
-  Scorer *req_scorer = rxsc->req_scorer;
-  Scorer *excl_scorer = rxsc->excl_scorer;
+    BooleanQuery *bq = BQ(self->query);
+    int i;
 
-  if (rxsc->first_time) {
-    if (! excl_scorer->next(excl_scorer)) {
-      SCORER_NULLIFY(rxsc->excl_scorer); // exhausted at start
-      excl_scorer = NULL;
+    normalization_factor *= self->value; /* multiply by query boost */
+
+    for (i = 0; i < BW(self)->w_cnt; i++) {
+        if (! bq->clauses[i]->is_prohibited) {
+            Weight *weight = BW(self)->weights[i];
+            /* sum sub-weights */
+            weight->normalize(weight, normalization_factor);
+        }
     }
-    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)
+static Scorer *bw_scorer(Weight *self, IndexReader *ir)
 {
-  ReqExclScorer *rxsc = (ReqExclScorer *)self->data;
-  Scorer *req_scorer = rxsc->req_scorer;
-  Scorer *excl_scorer = rxsc->excl_scorer;
+    Scorer *bsc = bsc_new(self->similarity);
+    BooleanQuery *bq = BQ(self->query);
+    int i;
 
-  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;
+    for (i = 0; i < BW(self)->w_cnt; i++) {
+        BooleanClause *clause = bq->clauses[i];
+        Weight *weight = BW(self)->weights[i];
+        Scorer *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 false;
-  }
-  if (! req_scorer->skip_to(req_scorer, doc_num)) {
-    SCORER_NULLIFY(rxsc->req_scorer);
-    return false;
-  }
-  return rxsc_to_non_excluded(self);
+
+    return bsc;
 }
 
-float rxsc_score(Scorer *self)
+static char *bw_to_s(Weight *self)
 {
-  Scorer *req_scorer = ((ReqExclScorer *)self->data)->req_scorer;
-  return req_scorer->score(req_scorer);
+    return strfmt("BooleanWeight(%f)", self->value);
 }
 
-Explanation *rxsc_explain(Scorer *self, int doc_num)
+static void bw_destroy(Weight *self)
 {
-  ReqExclScorer *rxsc = (ReqExclScorer *)self->data;
-  Scorer *req_scorer = rxsc->req_scorer;
-  Scorer *excl_scorer = rxsc->excl_scorer;
+    int i;
 
-  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;
+    for (i = 0; i < BW(self)->w_cnt; i++) {
+        BW(self)->weights[i]->destroy(BW(self)->weights[i]);
+    }
+
+    free(BW(self)->weights);
+    w_destroy(self);
 }
 
-void rxsc_destroy(Scorer *self)
+static Explanation *bw_explain(Weight *self, IndexReader *ir, int doc_num)
 {
-  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_i(self);
+    BooleanQuery *bq = BQ(self->query);
+    Explanation *sum_expl = expl_new(0.0, "sum of:");
+    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(self)->w_cnt; i++) {
+        Weight *weight = BW(self)->weights[i];
+        BooleanClause *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_destroy(explanation);
+                expl_destroy(sum_expl);
+                return expl_new(0.0, "match prohibited");
+            }
+        }
+        else if (clause->is_required) {
+            expl_destroy(explanation);
+            expl_destroy(sum_expl);
+            return expl_new(0.0, "match required");
+        }
+        else {
+            expl_destroy(explanation);
+        }
+    }
+    sum_expl->value = sum;
+
+    if (coord == 1) {                /* only one clause matched */
+        explanation = sum_expl;      /* eliminate wrapper */
+        ary_size(sum_expl->details) = 0;
+        sum_expl = sum_expl->details[0];
+        expl_destroy(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_new(sum * coord_factor, "product of:");
+        expl_add_detail(explanation, sum_expl);
+        expl_add_detail(explanation, expl_new(coord_factor, "coord(%d/%d)",
+                                              coord, max_coord));
+        return explanation;
+    }
 }
 
-Scorer *req_excl_scorer_create(Scorer *req_scorer, Scorer *excl_scorer)
+static Weight *bw_new(Query *query, Searcher *searcher)
 {
-  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;
+    int i;
+    Weight *self = w_new(BooleanWeight, query);
+
+    BW(self)->w_cnt = BQ(query)->clause_cnt;
+    BW(self)->weights = ALLOC_N(Weight *, BW(self)->w_cnt);
+    for (i = 0; i < BW(self)->w_cnt; i++) {
+        BW(self)->weights[i] = q_weight(BQ(query)->clauses[i]->query, searcher);
+    }
 
-  return self;
+    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->value                     = query->boost;
+
+    return self;
 }
 
 /***************************************************************************
- * NonMatchScorer
+ *
+ * BooleanClause
+ *
  ***************************************************************************/
 
-float nmsc_score(Scorer *self)
-{
-  return 0.0;
+void bc_set_occur(BooleanClause *self, enum BC_TYPE 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:
+            RAISE(ARG_ERROR, "Invalid value for :occur. Try :occur => :should, "
+                  ":must or :must_not instead");
+    }
 }
 
-bool nmsc_next(Scorer *self)
+void bc_deref(BooleanClause *self)
 {
-  return false;
+    if (--self->ref_cnt <= 0) {
+        q_deref(self->query);
+        free(self);
+    }
 }
 
-bool nmsc_skip_to(Scorer *self, int doc_num)
+static ulong bc_hash(BooleanClause *self)
 {
-  return false;
+    return ((q_hash(self->query) << 2) | self->occur);
 }
 
-Explanation *nmsc_explain(Scorer *self, int doc_num)
+static int  bc_eq(BooleanClause *self, BooleanClause *o)
 {
-  return expl_create(0.0, estrdup("No documents matched"));
+    return ((self->occur == o->occur) && q_eq(self->query, o->query)); 
 }
 
-Scorer *non_matching_scorer_create()
+BooleanClause *bc_new(Query *query, enum BC_TYPE occur)
 {
-  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;
+    BooleanClause *self = ALLOC(BooleanClause);
+    self->ref_cnt = 1;
+    self->query = query;
+    bc_set_occur(self, occur);
+    return self;
 }
 
-
 /***************************************************************************
- * BooleanScorer
+ *
+ * BooleanQuery
+ *
  ***************************************************************************/
 
-Scorer *counting_sum_scorer_create3(BooleanScorer *bsc, Scorer *req_scorer,
-    Scorer *opt_scorer)
+static MatchVector *bq_get_matchv_i(Query *self, MatchVector *mv,
+                                    TermVector *tv)
 {
-  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);
-  }
+    int i;
+    for (i = BQ(self)->clause_cnt - 1; i >= 0; i--) {
+        if (BQ(self)->clauses[i]->occur != BC_MUST_NOT) {
+            Query *q = BQ(self)->clauses[i]->query;
+            q->get_matchv_i(q, mv, tv);
+        }
+    }
+    return mv;
 }
 
-Scorer *counting_sum_scorer_create2(BooleanScorer *bsc, Scorer *req_scorer,
-    Scorer **optional_scorers, int os_cnt)
+static Query *bq_rewrite(Query *self, IndexReader *ir)
 {
-  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:
-      RAISE(ARG_ERROR, UNKNOWN_OCCUR_VAL_ERROR_MSG);
-  }
-}
-
-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;
-  }
+    int i;
+
+    bool rewritten = false;
+
+    if (BQ(self)->clause_cnt == 1) { 
+        /* optimize 1-clause queries */
+        BooleanClause *clause = BQ(self)->clauses[0];
+        if (! clause->is_prohibited) {
+            /* just return clause. Re-write first. */
+            Query *q = clause->query->rewrite(clause->query, ir);
+
+            if (self->boost != 1.0) {
+                /* 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 ((q == clause->query) && BQ(self)->original_boost) {
+                    /* rewrite was no-op */
+                    q->boost = BQ(self)->original_boost * self->boost;
+                }
+                else {
+                    /* save original boost in case query is rewritten again */
+                    BQ(self)->original_boost = q->boost;
+                    q->boost *= self->boost;
+                }
+            }
+
+            return q;
+        }
+    }
+
+    self->ref_cnt++;
+    /* replace each clause's query with its rewritten query */
+    for (i = 0; i < BQ(self)->clause_cnt; i++) {
+        BooleanClause *clause = BQ(self)->clauses[i];
+        Query *rq = clause->query->rewrite(clause->query, ir);
+        if (rq != clause->query) {
+            if (!rewritten) {
+                int j;
+                Query *new_self = q_new(BooleanQuery);
+                memcpy(new_self, self, sizeof(BooleanQuery));
+                BQ(new_self)->clauses = ALLOC_N(BooleanClause *, BQ(self)->clause_capa);
+                memcpy(BQ(new_self)->clauses, BQ(self)->clauses,
+                       BQ(self)->clause_capa * sizeof(BooleanClause *));
+                for (j = 0; j < BQ(self)->clause_cnt; j++) {
+                    REF(BQ(self)->clauses[j]);
+                }
+                self->ref_cnt--;
+                self = new_self;
+                self->ref_cnt = 1;
+                rewritten = true;
+            }
+            DEREF(clause);
+            BQ(self)->clauses[i] = bc_new(rq, clause->occur);
+        } else {
+            DEREF(rq);
+        }
+    }
+
+    return self;
+}
+
+static void bq_extract_terms(Query *self, HashSet *terms)
+{
+    int i;
+    for (i = 0; i < BQ(self)->clause_cnt; i++) {
+        BooleanClause *clause = BQ(self)->clauses[i];
+        clause->query->extract_terms(clause->query, terms);
+    }
 }
 
-bool bsc_skip_to(Scorer *self, int doc_num)
+static char *bq_to_s(Query *self, const char *field)
 {
-  BooleanScorer *bsc = (BooleanScorer *)self->data;
+    int i;
+    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++;
+    }
 
-  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;
-  }
+    for (i = 0; i < BQ(self)->clause_cnt; i++) {
+        clause = BQ(self)->clauses[i];
+        clause_str = clause->query->to_s(clause->query, field);
+        clause_len = (int)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 *boost_str = strfmt(")^%f", self->boost);
+        int boost_len = (int)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;
+}
+
+static void bq_destroy(Query *self)
+{
+    int i;
+    for (i = 0; i < BQ(self)->clause_cnt; i++) {
+        bc_deref(BQ(self)->clauses[i]);
+    }
+    free(BQ(self)->clauses);
+    if (BQ(self)->similarity) {
+        BQ(self)->similarity->destroy(BQ(self)->similarity);
+    }
+    q_destroy_i(self);
+}
+
+static float bq_coord_disabled(Similarity *sim, int overlap, int max_overlap)
+{
+    (void)sim; (void)overlap; (void)max_overlap;
+    return 1.0;
 }
 
-void bsc_destroy(Scorer *self)
+static Similarity *bq_get_similarity(Query *self, Searcher *searcher)
 {
-  BooleanScorer *bsc = (BooleanScorer *)self->data;
-  Coordinator *coord = bsc->coordinator;
+    if (!BQ(self)->similarity) {
+        Similarity *sim = q_get_similarity_i(self, searcher); 
+        BQ(self)->similarity = ALLOC(Similarity);
+        memcpy(BQ(self)->similarity, sim, sizeof(Similarity));
+        BQ(self)->similarity->coord = &bq_coord_disabled;
+        BQ(self)->similarity->destroy = (void (*)(Similarity *))&free;
+    }
 
-  free(coord->coord_factors);
-  free(coord);
+    return BQ(self)->similarity;
+}
 
-  if (bsc->counting_sum_scorer) {
-    bsc->counting_sum_scorer->destroy(bsc->counting_sum_scorer);
-  } else {
+static ulong bq_hash(Query *self)
+{
     int i;
-    for (i = 0; i < bsc->rs_cnt; i++) {
-      bsc->required_scorers[i]->destroy(bsc->required_scorers[i]);
+    ulong hash = 0;
+    for (i = 0; i < BQ(self)->clause_cnt; i++) {
+        hash ^= bc_hash(BQ(self)->clauses[i]);
     }
-    
-    for (i = 0; i < bsc->os_cnt; i++) {
-      bsc->optional_scorers[i]->destroy(bsc->optional_scorers[i]);
+    return (hash << 1) | BQ(self)->coord_disabled;
+}
+
+static int  bq_eq(Query *self, Query *o)
+{
+    int i;
+    BooleanQuery *bq1 = BQ(self);
+    BooleanQuery *bq2 = BQ(o);
+    if ((bq1->coord_disabled != bq2->coord_disabled)
+        || (bq1->max_clause_cnt != bq1->max_clause_cnt)
+        || (bq1->clause_cnt != bq2->clause_cnt)) {
+        return false;
     }
 
-    for (i = 0; i < bsc->ps_cnt; i++) {
-      bsc->prohibited_scorers[i]->destroy(bsc->prohibited_scorers[i]);
+    for (i = 0; i < bq1->clause_cnt; i++) {
+        if (!bc_eq(bq1->clauses[i], bq2->clauses[i])) {
+            return false;
+        }
     }
-  }
-  free(bsc->required_scorers);
-  free(bsc->optional_scorers);
-  free(bsc->prohibited_scorers);
-  scorer_destroy_i(self);
+    return true;
 }
 
-Explanation *bsc_explain(Scorer *self, int doc_num)
+Query *bq_new(bool coord_disabled)
 {
-  return expl_create(0.0, estrdup("This explanation is not supported"));
+    Query *self = q_new(BooleanQuery);
+    BQ(self)->coord_disabled = coord_disabled;
+    if (coord_disabled) {
+        self->get_similarity = &bq_get_similarity;
+    }
+    BQ(self)->max_clause_cnt = DEFAULT_MAX_CLAUSE_COUNT;
+    BQ(self)->clause_cnt = 0;
+    BQ(self)->clause_capa = BOOLEAN_CLAUSES_START_CAPA;
+    BQ(self)->clauses = ALLOC_N(BooleanClause *, BOOLEAN_CLAUSES_START_CAPA);
+    BQ(self)->similarity = NULL;
+    BQ(self)->original_boost = 0.0;
+
+    self->type = BOOLEAN_QUERY;
+    self->rewrite = &bq_rewrite;
+    self->extract_terms = &bq_extract_terms;
+    self->to_s = &bq_to_s;
+    self->hash = &bq_hash;
+    self->eq = &bq_eq;
+    self->destroy_i = &bq_destroy;
+    self->create_weight_i = &bw_new;
+    self->get_matchv_i = &bq_get_matchv_i;
+
+    return self;
+}
+
+BooleanClause *bq_add_clause_nr(Query *self, BooleanClause *bc)
+{
+    if (BQ(self)->clause_cnt >= BQ(self)->clause_capa) {
+        BQ(self)->clause_capa *= 2;
+        REALLOC_N(BQ(self)->clauses, BooleanClause *, BQ(self)->clause_capa);
+    }
+    if (BQ(self)->clause_cnt > BQ(self)->max_clause_cnt) {
+        RAISE(STATE_ERROR, "Two many clauses. The max clause limit is set to "
+              "<%d> but your query has <%d> clauses. You can try increasing "
+              ":max_clause_count for the BooleanQuery or using a different "
+              "type of query.", BQ(self)->clause_cnt, BQ(self)->max_clause_cnt);
+    }
+    BQ(self)->clauses[BQ(self)->clause_cnt] = bc;
+    BQ(self)->clause_cnt++;
+    return bc;
 }
 
-Scorer *bsc_create(Similarity *similarity)
+BooleanClause *bq_add_clause(Query *self, BooleanClause *bc)
 {
-  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;
+    REF(bc);
+    return bq_add_clause_nr(self, bc);
+}
 
-  self->score = &bsc_score;
-  self->next = &bsc_next;
-  self->skip_to = &bsc_skip_to;
-  self->explain = &bsc_explain;
-  self->destroy = &bsc_destroy;
-  return self;
+BooleanClause *bq_add_query_nr(Query *self, Query *sub_query, enum BC_TYPE occur)
+{
+    BooleanClause *bc = bc_new(sub_query, occur);
+    bq_add_clause(self, bc);
+    bc_deref(bc); /* bc would have been referenced unnecessarily */
+    return bc;
 }
 
+BooleanClause *bq_add_query(Query *self, Query *sub_query, enum BC_TYPE occur)
+{
+    REF(sub_query);
+    return bq_add_query_nr(self, sub_query, occur);
+}