ferret 0.9.6 → 0.10.0

data/ext/q_span.c

@@ -1,807 +1,1038 @@
 #include <string.h>
+#include <limits.h>
 #include "search.h"
+#include "hashset.h"
 
-/*****************************************************************************
- *
- * NearSpanEnum
- *
- *****************************************************************************/
+#define CLAUSE_INIT_CAPA 4
 
 /*****************************************************************************
  *
- * SpanWeight
+ * SpanQuery
  *
  *****************************************************************************/
 
-Explanation *spanw_explain(Weight *self, IndexReader *ir, int target)
-{
-  Explanation *expl;
-  Explanation *idf_expl1;
-  Explanation *idf_expl2;
-  Explanation *query_expl;
-  Explanation *qnorm_expl;
-  Explanation *field_expl;
-  Explanation *tf_expl;
-  Scorer *scorer;
-  uchar *field_norms;
-  float field_norm;
-  Explanation *field_norm_expl;
-
-  char *query_str = self->query->to_s(self->query, "");
-  HashSet *terms = (HashSet *)self->data;
-  char *field = ((SpanQuery *)self->query->data)->field;
-  char *doc_freqs = NULL;
-  size_t df_i = 0;
-  int i;
-  Term *t;
-
-
-  for (i = 0; i < terms->size; i++) {
-    t = (Term *)terms->elems[i];
-    REALLOC_N(doc_freqs, char, df_i + strlen(t->text) + 23);
-    sprintf(doc_freqs + df_i, "%s=%d, ", t->text, ir->doc_freq(ir, t));
-    df_i = strlen(doc_freqs);
-  }
-  /* remove the ',' at the end of the string if it exists */
-  if (terms->size > 0) {
-    df_i -= 2;
-    doc_freqs[df_i] = '\0';
-  } else {
-    doc_freqs = "";
-  }
+/***************************************************************************
+ * SpanQuery
+ ***************************************************************************/
 
-  expl = expl_create(0.0,
-      strfmt("weight(%s in %d), product of:", query_str, target));
+#define SpQ(query) ((SpanQuery *)(query))
 
-  /* We need two of these as it's included in both the query explanation
-   * and the field explanation */
-  idf_expl1 = expl_create(self->idf,
-      strfmt("idf(%s: %s)", field, doc_freqs));
-  idf_expl2 = expl_create(self->idf,
-      strfmt("idf(%s: %s)", field, doc_freqs));
-  if (terms->size > 0) {
-    free(doc_freqs); /* only free if allocated */
-  }
+static ulong spanq_hash(Query *self)
+{
+    return str_hash(SpQ(self)->field);
+}
 
-  /* explain query weight */
-  query_expl = expl_create(0.0,
-      strfmt("query_weight(%s), product of:", query_str));
+static int spanq_eq(Query *self, Query *o)
+{
+    return strcmp(SpQ(self)->field, SpQ(o)->field) == 0;
+}
 
-  if (self->query->boost != 1.0) {
-    expl_add_detail(query_expl, expl_create(self->query->boost, estrdup("boost")));
-  }
+static void spanq_destroy_i(Query *self)
+{
+    q_destroy_i(self);
+}
 
-  expl_add_detail(query_expl, idf_expl1);
+static MatchVector *mv_to_term_mv(MatchVector *term_mv, MatchVector *full_mv,
+                                  HashSet *terms, TermVector *tv)
+{
+    int i;
+    for (i = 0; i < terms->size; i++) {
+        char *term = (char *)terms->elems[i];
+        TVTerm *tv_term = tv_get_tv_term(tv, term);
+        if (tv_term) {
+            int j;
+            int m_idx = 0;
+            for (j = 0; j < tv_term->freq; j++) {
+                int pos = tv_term->positions[j];
+                for (; m_idx < full_mv->size; m_idx++) {
+                    if (pos <= full_mv->matches[m_idx].end) {
+                        if (pos >= full_mv->matches[m_idx].start) {
+                            matchv_add(term_mv, pos, pos);
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+    }
 
-  qnorm_expl = expl_create(self->qnorm, estrdup("query_norm"));
-  expl_add_detail(query_expl, qnorm_expl);
+    return term_mv;
+}
 
-  query_expl->value = self->query->boost * idf_expl1->value * qnorm_expl->value;
+/***************************************************************************
+ * TVTermDocEnum
+ * dummy TermDocEnum used by the highlighter to find matches
+ ***************************************************************************/
 
-  expl_add_detail(expl, query_expl);
+#define TV_TDE(tde) ((TVTermDocEnum *)(tde))
 
-  /* explain field weight */
-  field_expl = expl_create(0.0, 
-      strfmt("field_weight(%s:%s in %d), product of:", field, query_str, target));
-  free(query_str);
+typedef struct TVTermDocEnum
+{
+    TermDocEnum super;
+    int         doc;
+    int         index;
+    int         freq;
+    int        *positions;
+    TermVector *tv;
+} TVTermDocEnum;
 
-  scorer = self->scorer(self, ir);
-  tf_expl = scorer->explain(scorer, target);
-  scorer->destroy(scorer);
-  expl_add_detail(field_expl, tf_expl);
-  expl_add_detail(field_expl, idf_expl2);
+static void tv_tde_seek(TermDocEnum *tde, int field_num, const char *term)
+{
+    TVTermDocEnum *tv_tde = TV_TDE(tde);
+    TVTerm *tv_term = tv_get_tv_term(tv_tde->tv, term);
+    (void)field_num;
+    if (tv_term) {
+        tv_tde->doc = -1;
+        tv_tde->index = 0;
+        tv_tde->freq = tv_term->freq;
+        tv_tde->positions = tv_term->positions;
+    }
+    else {
+        tv_tde->doc = INT_MAX;
+    }
+}
+
+static bool tv_tde_next(TermDocEnum *tde)
+{
+    if (TV_TDE(tde)->doc == -1) {
+        TV_TDE(tde)->doc = 0;
+        return true;
+    }
+    else {
+        TV_TDE(tde)->doc = INT_MAX;
+        return false;
+    }
+}
 
-  field_norms = ir->get_norms(ir, field);
-  field_norm = (field_norms 
-    ? sim_decode_norm(self->similarity, field_norms[target]) 
-    : (float)0.0);
-  field_norm_expl = expl_create(field_norm,
-      strfmt("field_norm(field=%s, doc=%d)", field, target));
-  expl_add_detail(field_expl, field_norm_expl);
+static bool tv_tde_skip_to(TermDocEnum *tde, int doc_num)
+{
+    if (doc_num == 0) {
+        TV_TDE(tde)->doc = 0;
+        return true;
+    }
+    else {
+        TV_TDE(tde)->doc = INT_MAX;
+        return false;
+    }
+}
+
+static int tv_tde_next_position(TermDocEnum *tde)
+{
+    return TV_TDE(tde)->positions[TV_TDE(tde)->index++];
+}
+
+static int tv_tde_freq(TermDocEnum *tde)
+{
+    return TV_TDE(tde)->freq;
+}
+
+static int tv_tde_doc_num(TermDocEnum *tde)
+{
+    return TV_TDE(tde)->doc;
+}
 
-  field_expl->value = tf_expl->value * idf_expl2->value * field_norm_expl->value;
+static TermDocEnum *spanq_ir_term_positions(IndexReader *ir)
+{
+    TVTermDocEnum *tv_tde = ALLOC(TVTermDocEnum);
+    TermDocEnum *tde = (TermDocEnum *)tv_tde;
+    tv_tde->tv = (TermVector *)ir->store;
+    tde->seek           = &tv_tde_seek;
+    tde->doc_num        = &tv_tde_doc_num;
+    tde->freq           = &tv_tde_freq;
+    tde->next           = &tv_tde_next;
+    tde->skip_to        = &tv_tde_skip_to;
+    tde->next_position  = &tv_tde_next_position;
+    tde->close          = (void (*)(TermDocEnum *tde))&free;
+    
+    return tde;
+}
 
-  /* combine them */
-  if (query_expl->value == 1.0) {
-    expl_destoy(expl);
-    return field_expl;
-  } else {
-    expl->value = (query_expl->value * field_expl->value);
-    expl_add_detail(expl, field_expl);
-    return expl;
-  }
+static MatchVector *spanq_get_matchv_i(Query *self, MatchVector *mv,
+                                       TermVector *tv)
+{
+    if (strcmp(SpQ(self)->field, tv->field) == 0) {
+        SpanEnum *sp_enum;
+        IndexReader *ir = ALLOC(IndexReader);
+        MatchVector *full_mv = matchv_new();
+        HashSet *terms = SpQ(self)->get_terms(self);
+        ir->fis = fis_new(0, 0, 0);
+        fis_add_field(ir->fis, fi_new(tv->field, 0, 0, 0));
+        ir->store = (Store *)tv;
+        ir->term_positions = &spanq_ir_term_positions;
+        sp_enum = SpQ(self)->get_spans(self, ir);
+        while (sp_enum->next(sp_enum)) {
+            matchv_add(full_mv,
+                       sp_enum->start(sp_enum),
+                       sp_enum->end(sp_enum) - 1);
+        }
+        sp_enum->destroy(sp_enum);
+        
+        fis_deref(ir->fis);
+        free(ir);
+
+        matchv_compact(full_mv);
+        mv_to_term_mv(mv, full_mv, terms, tv);
+        matchv_destroy(full_mv);
+        hs_destroy(terms);
+    }
+    return mv;
 }
 
-char *spanw_to_s(Weight *self)
+/***************************************************************************
+ *
+ * SpanScorer
+ *
+ ***************************************************************************/
+
+#define SpSc(scorer) ((SpanScorer *)(scorer))
+typedef struct SpanScorer
+{
+    Scorer          super;
+    IndexReader    *ir;
+    SpanEnum       *spans;
+    Similarity     *sim;
+    uchar          *norms;
+    Weight         *weight;
+    float           value;
+    float           freq;
+    bool            first_time : 1;
+    bool            more : 1;
+} SpanScorer;
+
+static float spansc_score(Scorer *self)
 {
-  return strfmt("SpanWeight(%f)", self->value);
+    SpanScorer *spansc = SpSc(self);
+    float raw = sim_tf(spansc->sim, spansc->freq) * spansc->value;
+
+    /* normalize */
+    return raw * sim_decode_norm(self->similarity, spansc->norms[self->doc]);
 }
 
-void spanw_destroy(Weight *self)
+static bool spansc_next(Scorer *self)
 {
-  hs_destroy_all(self->data);
-  w_destroy(self);
+    SpanScorer *spansc = SpSc(self);
+    SpanEnum *se = spansc->spans;
+    int match_length;
+
+    if (spansc->first_time) {
+        spansc->more = se->next(se);
+        spansc->first_time = false;
+    }
+
+    if (!spansc->more) {
+        return false;
+    }
+
+    spansc->freq = 0.0;
+    self->doc = se->doc(se);
+
+    while (spansc->more && (self->doc == se->doc(se))) {
+        match_length = se->end(se) - se->start(se);
+        spansc->freq += sim_sloppy_freq(spansc->sim, match_length);
+        spansc->more = se->next(se);
+    }
+
+    return (spansc->more || (spansc->freq != 0.0));
 }
 
-Weight *spanw_create(Query *query, Searcher *searcher)
+static bool spansc_skip_to(Scorer *self, int target)
 {
-  Weight *self = w_create(query);
-  SpanQuery *spanq = (SpanQuery *)query->data;
-  HashSet *terms = spanq->get_terms(query);
+    SpanScorer *spansc = SpSc(self);
+    SpanEnum *se = spansc->spans;
 
-  self->data = terms;
-  self->scorer    = &spansc_create;
-  self->explain   = &spanw_explain;
-  self->to_s      = &spanw_to_s;
-  self->destroy   = &spanw_destroy;
-  self->sum_of_squared_weights = &w_sum_of_squared_weights;
+    spansc->more = se->skip_to(se, target);
 
-  self->similarity = query->get_similarity(query, searcher);
+    if (!spansc->more) {
+        return false;
+    }
 
-  self->idf = sim_idf_phrase(self->similarity, (Term **)terms->elems,
-      terms->size, searcher);
+    spansc->freq = 0.0;
+    self->doc = se->doc(se);
 
-  return self;
+    while (spansc->more && (se->doc(se) == target)) {
+        spansc->freq += sim_sloppy_freq(spansc->sim, se->end(se) - se->start(se));
+        spansc->more = se->next(se);
+    }
+
+    return (spansc->more || (spansc->freq != 0.0));
+}
+
+static Explanation *spansc_explain(Scorer *self, int target)
+{
+    Explanation *tf_explanation;
+    SpanScorer *spansc = SpSc(self);
+    float phrase_freq;
+    self->skip_to(self, target);
+    phrase_freq = (self->doc == target) ? spansc->freq : (float)0.0;
+
+    tf_explanation = expl_new(sim_tf(self->similarity, phrase_freq),
+                              "tf(phrase_freq(%f)", phrase_freq);
+
+    return tf_explanation;
 }
 
+static void spansc_destroy(Scorer *self)
+{
+    SpanScorer *spansc = SpSc(self);
+    if (spansc->spans) {
+        spansc->spans->destroy(spansc->spans);
+    }
+    scorer_destroy_i(self);
+}
+
+Scorer *spansc_new(Weight *weight, IndexReader *ir)
+{
+    Scorer *self = NULL;
+    const int field_num = fis_get_field_num(ir->fis, SpQ(weight->query)->field);
+    if (field_num >= 0) {
+        Query *spanq = weight->query;
+        self = scorer_new(SpanScorer, weight->similarity);
+
+        SpSc(self)->first_time  = true;
+        SpSc(self)->more        = true;
+        SpSc(self)->spans       = SpQ(spanq)->get_spans(spanq, ir);
+        SpSc(self)->sim         = weight->similarity;
+        SpSc(self)->norms       = ir->get_norms(ir, field_num);
+        SpSc(self)->weight      = weight;
+        SpSc(self)->value       = weight->value;
+        SpSc(self)->freq        = 0.0;
+
+        self->score             = &spansc_score;
+        self->next              = &spansc_next;
+        self->skip_to           = &spansc_skip_to;
+        self->explain           = &spansc_explain;
+        self->destroy           = &spansc_destroy;
+    }
+    return self;
+}
 
 /*****************************************************************************
- *
  * SpanTermEnum
- *
  *****************************************************************************/
 
-bool spante_next(SpanEnum *self)
+#define SpTEn(span_enum) ((SpanTermEnum *)(span_enum))
+#define SpTQ(query) ((SpanTermQuery *)(query))
+
+typedef struct SpanTermEnum
+{
+    SpanEnum     super;
+    TermDocEnum *positions;
+    int          position;
+    int          doc;
+    int          count;
+    int          freq;
+} SpanTermEnum;
+
+
+static bool spante_next(SpanEnum *self)
 {
-  SpanTermEnum *ste = (SpanTermEnum *)self->data;
-  TermDocEnum *tde = ste->positions;
+    SpanTermEnum *ste = SpTEn(self);
+    TermDocEnum *tde = ste->positions;
 
-  if (ste->count == ste->freq) {
-    if (! tde->next(tde)) {
-      ste->doc = INT_MAX;
-      return false;
+    if (ste->count == ste->freq) {
+        if (! tde->next(tde)) {
+            ste->doc = INT_MAX;
+            return false;
+        }
+        ste->doc = tde->doc_num(tde);
+        ste->freq = tde->freq(tde);
+        ste->count = 0;
     }
-    ste->doc = tde->doc_num(tde);
-    ste->freq = tde->freq(tde);
-    ste->count = 0;
-  }
-  ste->position = tde->next_position(tde);
-  ste->count++;
-  return true;
+    ste->position = tde->next_position(tde);
+    ste->count++;
+    return true;
 }
 
-bool spante_skip_to(SpanEnum *self, int target)
+static bool spante_skip_to(SpanEnum *self, int target)
 {
-  SpanTermEnum *ste = (SpanTermEnum *)self->data;
-  TermDocEnum *tde = ste->positions;
+    SpanTermEnum *ste = SpTEn(self);
+    TermDocEnum *tde = ste->positions;
 
-  /* are we already at the correct position? */
-  if (ste->doc >= target) return true;
+    /* are we already at the correct position? */
+    if (ste->doc >= target) {
+        return true;
+    }
 
-  if (! tde->skip_to(tde, target)) {
-    ste->doc = INT_MAX;
-    return false;
-  }
+    if (! tde->skip_to(tde, target)) {
+        ste->doc = INT_MAX;
+        return false;
+    }
 
-  ste->doc = tde->doc_num(tde);
-  ste->freq = tde->freq(tde);
-  ste->count = 0;
+    ste->doc = tde->doc_num(tde);
+    ste->freq = tde->freq(tde);
+    ste->count = 0;
 
-  ste->position = tde->next_position(tde);
-  ste->count++;
-  return true;
+    ste->position = tde->next_position(tde);
+    ste->count++;
+    return true;
 }
 
-int  spante_doc(SpanEnum *self)
+static int spante_doc(SpanEnum *self)
 {
-  SpanTermEnum *ste = (SpanTermEnum *)self->data;
-  return ste->doc;
+    return SpTEn(self)->doc;
 }
 
-int  spante_start(SpanEnum *self)
+static int spante_start(SpanEnum *self)
 {
-  SpanTermEnum *ste = (SpanTermEnum *)self->data;
-  return ste->position;
+    return SpTEn(self)->position;
 }
 
-int  spante_end(SpanEnum *self)
+static int spante_end(SpanEnum *self)
 {
-  SpanTermEnum *ste = (SpanTermEnum *)self->data;
-  return ste->position + 1;
+    return SpTEn(self)->position + 1;
 }
 
-char *spante_to_s(SpanEnum *self) 
+static char *spante_to_s(SpanEnum *self) 
 {
-  char *field = ((SpanQuery *)self->query->data)->field;
-  char *query_str = self->query->to_s(self->query, field);
-  char pos_str[20];
-  size_t len = strlen(query_str);
-  int pos;
-  char *str = ALLOC_N(char, len + 40);
+    char *field = SpQ(self->query)->field;
+    char *query_str = self->query->to_s(self->query, field);
+    char pos_str[20];
+    size_t len = strlen(query_str);
+    int pos;
+    char *str = ALLOC_N(char, len + 40);
 
-  if (self->doc(self) < 0) {
-      sprintf(pos_str, "START");
-  } else {
-    if (self->doc(self) == INT_MAX) {
-      sprintf(pos_str, "END");
-    } else {
-      pos = ((SpanTermEnum *)self->data)->position;
-      sprintf(pos_str, "%d", self->doc(self) - pos);
+    if (self->doc(self) < 0) {
+        sprintf(pos_str, "START");
     }
-  }
-  sprintf("SpanTermEnum(%s)@%s", query_str, pos_str);
-  free(query_str);
-  return str;
+    else {
+        if (self->doc(self) == INT_MAX) {
+            sprintf(pos_str, "END");
+        }
+        else {
+            pos = SpTEn(self)->position;
+            sprintf(pos_str, "%d", self->doc(self) - pos);
+        }
+    }
+    sprintf("SpanTermEnum(%s)@%s", query_str, pos_str);
+    free(query_str);
+    return str;
 }
 
-void spante_destroy(SpanEnum *self)
+static void spante_destroy(SpanEnum *self)
 {
-  SpanTermEnum *ste = (SpanTermEnum *)self->data;
-  TermDocEnum *tde = ste->positions;
-  tde->close(tde);
-  free(ste);
-  free(self);
+    TermDocEnum *tde = SpTEn(self)->positions;
+    tde->close(tde);
+    free(self);
 }
 
-SpanEnum *spante_create(Query *query, IndexReader *ir)
+static SpanEnum *spante_new(Query *query, IndexReader *ir)
 {
-  Term *term = (Term *)((SpanQuery *)query->data)->data;
-  SpanEnum *self = ALLOC(SpanEnum);
+    char *term = SpTQ(query)->term;
+    char *field = SpQ(query)->field;
+    SpanEnum *self = (SpanEnum *)emalloc(sizeof(SpanTermEnum));
 
-  SpanTermEnum *ste = ALLOC(SpanTermEnum);
-  ste->positions = ir_term_positions_for(ir, term);
-  ste->position = -1;
-  ste->doc = -1;
-  ste->count = 0;
-  ste->freq = 0;
+    SpTEn(self)->positions  = ir_term_positions_for(ir, field, term);
+    SpTEn(self)->position   = -1;
+    SpTEn(self)->doc        = -1;
+    SpTEn(self)->count      = 0;
+    SpTEn(self)->freq       = 0;
 
-  self->data = ste;
+    self->query             = query;
+    self->next              = &spante_next;
+    self->skip_to           = &spante_skip_to;
+    self->doc               = &spante_doc;
+    self->start             = &spante_start;
+    self->end               = &spante_end;
+    self->destroy           = &spante_destroy;
+    self->to_s              = &spante_to_s;
 
-  self->query = query;
-  self->next = &spante_next;
-  self->skip_to = &spante_skip_to;
-  self->doc = &spante_doc;
-  self->start = &spante_start;
-  self->end = &spante_end;
-  self->destroy = &spante_destroy;
-  self->to_s = &spante_to_s;
-
-  return self;
+    return self;
 }
 
 
 /*****************************************************************************
- *
  * SpanFirstEnum
- *
  *****************************************************************************/
 
-bool spanfe_next(SpanEnum *self)
+#define SpFEn(span_enum) ((SpanFirstEnum *)(span_enum))
+#define SpFQ(query) ((SpanFirstQuery *)(query))
+
+typedef struct SpanFirstEnum
+{
+    SpanEnum    super;
+    SpanEnum   *sub_enum;
+} SpanFirstEnum;
+
+
+static bool spanfe_next(SpanEnum *self)
 {
-  SpanEnum *se = (SpanEnum *)(self->data);
-  int end = ((SpanFirstQuery *)((SpanQuery *)self->query->data)->data)->end;
-  while (se->next(se)) { /* scan to next match */
-    if (se->end(se) <= end) return true;
-  }
-  return false;
+    SpanEnum *sub_enum = SpFEn(self)->sub_enum;
+    int end = SpFQ(self->query)->end;
+    while (sub_enum->next(sub_enum)) { /* scan to next match */
+        if (sub_enum->end(sub_enum) <= end) {
+            return true;
+        }
+    }
+    return false;
 }
 
-bool spanfe_skip_to(SpanEnum *self, int target)
+static bool spanfe_skip_to(SpanEnum *self, int target)
 {
-  SpanEnum *se = (SpanEnum *)(self->data);
-  int end = ((SpanFirstQuery *)((SpanQuery *)self->query->data)->data)->end;
+    SpanEnum *sub_enum = SpFEn(self)->sub_enum;
+    int end = SpFQ(self->query)->end;
 
-  if (! se->skip_to(se, target)) return false;
+    if (! sub_enum->skip_to(sub_enum, target)) {
+        return false;
+    }
 
-  if (se->end(se) <= end) /* there is a match */
-    return true;
+    if (sub_enum->end(sub_enum) <= end) {   /* there is a match */
+        return true;
+    }
 
-  return se->next(se);    /* scan to next match */
+    return sub_enum->next(sub_enum);        /* scan to next match */
 }
 
-int  spanfe_doc(SpanEnum *self)
+static int spanfe_doc(SpanEnum *self)
 {
-  SpanEnum *se = (SpanEnum *)(self->data);
-  return se->doc(se);
+    SpanEnum *sub_enum = SpFEn(self)->sub_enum;
+    return sub_enum->doc(sub_enum);
 }
 
-int  spanfe_start(SpanEnum *self)
+static int spanfe_start(SpanEnum *self)
 {
-  SpanEnum *se = (SpanEnum *)(self->data);
-  return se->start(se);
+    SpanEnum *sub_enum = SpFEn(self)->sub_enum;
+    return sub_enum->start(sub_enum);
 }
 
-int  spanfe_end(SpanEnum *self)
+static int spanfe_end(SpanEnum *self)
 {
-  SpanEnum *se = (SpanEnum *)(self->data);
-  return se->end(se);
+    SpanEnum *sub_enum = SpFEn(self)->sub_enum;
+    return sub_enum->end(sub_enum);
 }
 
-char *spanfe_to_s(SpanEnum *self) 
+static char *spanfe_to_s(SpanEnum *self) 
 {
-  char *field = ((SpanQuery *)self->query->data)->field;
-  char *query_str = self->query->to_s(self->query, field);
-  char *res = strfmt("SpanFirstEnum(%s)", query_str);
-  free(query_str);
-  return res;
+    char *field = SpQ(self->query)->field;
+    char *query_str = self->query->to_s(self->query, field);
+    char *res = strfmt("SpanFirstEnum(%s)", query_str);
+    free(query_str);
+    return res;
 }
 
-void spanfe_destroy(SpanEnum *self)
+static void spanfe_destroy(SpanEnum *self)
 {
-  SpanEnum *se = (SpanEnum *)self->data;
-  se->destroy(se);
-  free(self);
+    SpanEnum *sub_enum = SpFEn(self)->sub_enum;
+    sub_enum->destroy(sub_enum);
+    free(self);
 }
 
-SpanEnum *spanfe_create(Query *query, IndexReader *ir)
+static SpanEnum *spanfe_new(Query *query, IndexReader *ir)
 {
-  SpanEnum *self = ALLOC(SpanEnum);
-  SpanFirstQuery *sfq = (SpanFirstQuery *)((SpanQuery *)query->data)->data;
+    SpanEnum *self          = (SpanEnum *)emalloc(sizeof(SpanFirstEnum));
+    SpanFirstQuery *sfq     = SpFQ(query);
 
-  self->data = ((SpanQuery *)sfq->match->data)->get_spans(sfq->match, ir);
+    SpFEn(self)->sub_enum   = SpQ(sfq->match)->get_spans(sfq->match, ir);
 
-  self->query = query;
-  self->next = &spanfe_next;
-  self->skip_to = &spanfe_skip_to;
-  self->doc = &spanfe_doc;
-  self->start = &spanfe_start;
-  self->end = &spanfe_end;
-  self->destroy = &spanfe_destroy;
-  self->to_s = &spanfe_to_s;
+    self->query     = query;
+    self->next      = &spanfe_next;
+    self->skip_to   = &spanfe_skip_to;
+    self->doc       = &spanfe_doc;
+    self->start     = &spanfe_start;
+    self->end       = &spanfe_end;
+    self->destroy   = &spanfe_destroy;
+    self->to_s      = &spanfe_to_s;
 
-  return self;
+    return self;
 }
 
 
 /*****************************************************************************
- *
  * SpanOrEnum
- *
  *****************************************************************************/
 
-bool span_less_than(void *p1, void *p2)
+#define SpOEn(span_enum) ((SpanOrEnum *)(span_enum))
+#define SpOQ(query) ((SpanOrQuery *)(query))
+
+typedef struct SpanOrEnum
+{
+    SpanEnum        super;
+    PriorityQueue  *queue;
+    SpanEnum      **span_enums;
+    int             s_cnt;
+    bool            first_time : 1;
+} SpanOrEnum;
+
+
+static bool span_less_than(SpanEnum *s1, SpanEnum *s2)
 {
-  SpanEnum *s1 = (SpanEnum *)p1;
-  SpanEnum *s2 = (SpanEnum *)p2;
-  int doc_diff, start_diff;
-  doc_diff = s1->doc(s1) - s2->doc(s2);
-  if (doc_diff == 0) {
-    start_diff = s1->start(s1) - s2->start(s2);
-    if (start_diff == 0) {
-      return s1->end(s1) < s2->end(s2);
-    } else {
-      return start_diff < 0;
+    int doc_diff, start_diff;
+    doc_diff = s1->doc(s1) - s2->doc(s2);
+    if (doc_diff == 0) {
+        start_diff = s1->start(s1) - s2->start(s2);
+        if (start_diff == 0) {
+            return s1->end(s1) < s2->end(s2);
+        }
+        else {
+            return start_diff < 0;
+        }
+    }
+    else {
+        return doc_diff < 0;
     }
-  } else {
-    return doc_diff < 0;
-  }
 }
 
-bool spanoe_next(SpanEnum *self)
+static bool spanoe_next(SpanEnum *self)
 {
-  SpanOrEnum *soe = (SpanOrEnum *)self->data;
-  SpanEnum *se;
-  int i;
+    SpanOrEnum *soe = SpOEn(self);
+    SpanEnum *se;
+    int i;
 
-  if (soe->first_time) { /* first time -- initialize */
-    for (i = 0; i < soe->s_cnt; i++) {
-      se = soe->span_enums[i];
-      if (se->next(se)) /* move to first entry */
-        pq_push(soe->queue, se);
+    if (soe->first_time) { /* first time -- initialize */
+        for (i = 0; i < soe->s_cnt; i++) {
+            se = soe->span_enums[i];
+            if (se->next(se)) { /* move to first entry */
+                pq_push(soe->queue, se);
+            }
+        }
+        soe->first_time = false;
+        return soe->queue->size != 0;
     }
-    soe->first_time = false;
-    return soe->queue->count != 0;
-  }
 
-  if (soe->queue->count == 0) return false; /* all done */
+    if (soe->queue->size == 0) {
+        return false; /* all done */
+    }
 
-  se = (SpanEnum *)pq_top(soe->queue);
-  if (se->next(se)) { /* move to next */
-    pq_down(soe->queue);
-    return true;
-  }
+    se = (SpanEnum *)pq_top(soe->queue);
+    if (se->next(se)) { /* move to next */
+        pq_down(soe->queue);
+        return true;
+    }
 
-  pq_pop(soe->queue); /* exhausted a clause */
+    pq_pop(soe->queue); /* exhausted a clause */
 
-  return soe->queue->count != 0;
+    return soe->queue->size != 0;
 }
 
-bool spanoe_skip_to(SpanEnum *self, int target)
+static bool spanoe_skip_to(SpanEnum *self, int target)
 {
-  SpanOrEnum *soe = (SpanOrEnum *)self->data;
-  SpanEnum *se;
-  int i;
+    SpanOrEnum *soe = SpOEn(self);
+    SpanEnum *se;
+    int i;
 
-  if (soe->first_time) { /* first time -- initialize */
-    for (i = 0; i < soe->s_cnt; i++) {
-      se = soe->span_enums[i];
-      if (se->skip_to(se, target)) /* move to target */
-        pq_push(soe->queue, se);
-    }
-    soe->first_time = false;
-  } else {
-    while ((soe->queue->count != 0) &&
-        ((se=(SpanEnum *)pq_top(soe->queue))->doc(se) < target)) {
-      if (se->skip_to(se, target)) {
-        pq_down(soe->queue);
-      } else {
-        pq_pop(soe->queue);
-      }
+    if (soe->first_time) { /* first time -- initialize */
+        for (i = 0; i < soe->s_cnt; i++) {
+            se = soe->span_enums[i];
+            if (se->skip_to(se, target)) {/* move to target */
+                pq_push(soe->queue, se);
+            }
+        }
+        soe->first_time = false;
+    }
+    else {
+        while ((soe->queue->size != 0) &&
+               ((se = (SpanEnum *)pq_top(soe->queue))->doc(se) < target)) {
+            if (se->skip_to(se, target)) {
+                pq_down(soe->queue);
+            }
+            else {
+                pq_pop(soe->queue);
+            }
+        }
     }
-  }
 
-  return soe->queue->count != 0;
+    return soe->queue->size != 0;
 }
 
-#define GET_TOP_SOE SpanOrEnum *soe = (SpanOrEnum *)self->data;\
-                    SpanEnum *se = (SpanEnum *)pq_top(soe->queue)
-int  spanoe_doc(SpanEnum *self)
+#define SpOEn_Top_SE(self) (SpanEnum *)pq_top(SpOEn(self)->queue)
+
+static int spanoe_doc(SpanEnum *self)
 {
-  GET_TOP_SOE;
-  return se->doc(se);
+    SpanEnum *se = SpOEn_Top_SE(self);
+    return se->doc(se);
 }
 
-int  spanoe_start(SpanEnum *self)
+static int spanoe_start(SpanEnum *self)
 {
-  GET_TOP_SOE;
-  return se->start(se);
+    SpanEnum *se = SpOEn_Top_SE(self);
+    return se->start(se);
 }
 
-int  spanoe_end(SpanEnum *self)
+static int spanoe_end(SpanEnum *self)
 {
-  GET_TOP_SOE;
-  return se->end(se);
+    SpanEnum *se = SpOEn_Top_SE(self);
+    return se->end(se);
 }
 
-char *spanoe_to_s(SpanEnum *self) 
+static char *spanoe_to_s(SpanEnum *self) 
 {
-  SpanOrEnum *soe = (SpanOrEnum *)self->data;
-  char *field = ((SpanQuery *)self->query->data)->field;
-  char *query_str = self->query->to_s(self->query, field);
-  char doc_str[62];
-  size_t len = strlen(query_str);
-  char *str = ALLOC_N(char, len + 80);
+    SpanOrEnum *soe = SpOEn(self);
+    char *field = SpQ(self->query)->field;
+    char *query_str = self->query->to_s(self->query, field);
+    char doc_str[62];
+    size_t len = strlen(query_str);
+    char *str = ALLOC_N(char, len + 80);
 
-  if (soe->first_time) {
-      sprintf(doc_str, "START");
-  } else {
-    if (soe->queue->count == 0) {
-      sprintf(doc_str, "END");
-    } else {
-      sprintf(doc_str, "%d:%d-%d", self->doc(self),
-          self->start(self), self->end(self));
+    if (soe->first_time) {
+        sprintf(doc_str, "START");
     }
-  }
-  sprintf("SpanOrEnum(%s)@%s", query_str, doc_str);
-  free(query_str);
-  return str;
+    else {
+        if (soe->queue->size == 0) {
+            sprintf(doc_str, "END");
+        }
+        else {
+            sprintf(doc_str, "%d:%d-%d", self->doc(self),
+                    self->start(self), self->end(self));
+        }
+    }
+    sprintf("SpanOrEnum(%s)@%s", query_str, doc_str);
+    free(query_str);
+    return str;
 }
 
-void spanoe_destroy(SpanEnum *self)
+static void spanoe_destroy(SpanEnum *self)
 {
-  SpanEnum *se;
-  SpanOrEnum *soe = (SpanOrEnum *)self->data;
-  int i;
-  pq_destroy(soe->queue);
-  for (i = 0; i < soe->s_cnt; i++) {
-    se = soe->span_enums[i];
-    se->destroy(se);
-  }
-  free(soe->span_enums);
-  free(soe);
-  free(self);
+    SpanEnum *se;
+    SpanOrEnum *soe = SpOEn(self);
+    int i;
+    pq_destroy(soe->queue);
+    for (i = 0; i < soe->s_cnt; i++) {
+        se = soe->span_enums[i];
+        se->destroy(se);
+    }
+    free(soe->span_enums);
+    free(self);
 }
 
-SpanEnum *spanoe_create(Query *query, IndexReader *ir)
+SpanEnum *spanoe_new(Query *query, IndexReader *ir)
 {
-  Query *clause;
-  SpanEnum *self = ALLOC(SpanEnum);
-  SpanOrQuery *soq = (SpanOrQuery *)((SpanQuery *)query->data)->data;
-  SpanOrEnum *soe = ALLOC(SpanOrEnum);
-  int i;
-  soe->first_time = true;
-  soe->s_cnt = soq->c_cnt;
-  soe->span_enums = ALLOC_N(SpanEnum *, soe->s_cnt);
-  for (i = 0; i < soe->s_cnt; i++) {
-    clause = soq->clauses[i];
-    soe->span_enums[i] = ((SpanQuery *)clause->data)->get_spans(clause, ir);
-  }
-  
-  soe->queue = pq_create(soe->s_cnt, &span_less_than);
+    Query *clause;
+    SpanEnum *self      = (SpanEnum *)emalloc(sizeof(SpanOrEnum));
+    SpanOrQuery *soq    = SpOQ(query);
+    int i;
+
+    SpOEn(self)->first_time = true;
+    SpOEn(self)->s_cnt      = soq->c_cnt;
+    SpOEn(self)->span_enums = ALLOC_N(SpanEnum *, SpOEn(self)->s_cnt);
 
-  self->data = soe;
+    for (i = 0; i < SpOEn(self)->s_cnt; i++) {
+        clause = soq->clauses[i];
+        SpOEn(self)->span_enums[i] = SpQ(clause)->get_spans(clause, ir);
+    }
+
+    SpOEn(self)->queue      = pq_new(SpOEn(self)->s_cnt, (lt_ft)&span_less_than,
+                                     (free_ft)NULL);
 
-  self->query = query;
-  self->next = &spanoe_next;
-  self->skip_to = &spanoe_skip_to;
-  self->doc = &spanoe_doc;
-  self->start = &spanoe_start;
-  self->end = &spanoe_end;
-  self->destroy = &spanoe_destroy;
-  self->to_s = &spanoe_to_s;
+    self->query             = query;
+    self->next              = &spanoe_next;
+    self->skip_to           = &spanoe_skip_to;
+    self->doc               = &spanoe_doc;
+    self->start             = &spanoe_start;
+    self->end               = &spanoe_end;
+    self->destroy           = &spanoe_destroy;
+    self->to_s              = &spanoe_to_s;
 
-  return self;
+    return self;
 }
 
 /*****************************************************************************
- *
  * SpanNearEnum
- *
  *****************************************************************************/
 
-#define SNE_NEXT() do {\
-  sne->current = (sne->current+1) % sne->s_cnt;\
-  se = sne->span_enums[sne->current];\
+#define SpNEn(span_enum) ((SpanNearEnum *)(span_enum))
+#define SpNQ(query) ((SpanNearQuery *)(query))
+
+typedef struct SpanNearEnum
+{
+    SpanEnum    super;
+    SpanEnum  **span_enums;
+    int         s_cnt;
+    int         slop;
+    int         current;
+    int         doc;
+    int         start;
+    int         end;
+    bool        first_time : 1;
+    bool        in_order : 1;
+} SpanNearEnum;
+
+
+#define SpNEn_NEXT() do {\
+    sne->current = (sne->current+1) % sne->s_cnt;\
+    se = sne->span_enums[sne->current];\
 } while (0);
 
-bool sne_init(SpanNearEnum *sne)
+static bool sne_init(SpanNearEnum *sne)
 {
-  SpanEnum *se = sne->span_enums[sne->current];
-  int prev_doc = se->doc(se);
-  int i;
+    SpanEnum *se = sne->span_enums[sne->current];
+    int prev_doc = se->doc(se);
+    int i;
 
-  for (i = 1; i < sne->s_cnt; i++) {
-    SNE_NEXT();
-    if (!se->skip_to(se, prev_doc)) return false;
-    prev_doc = se->doc(se);
-  }
-  return true;
+    for (i = 1; i < sne->s_cnt; i++) {
+        SpNEn_NEXT();
+        if (!se->skip_to(se, prev_doc)) {
+            return false;
+        }
+        prev_doc = se->doc(se);
+    }
+    return true;
 }
 
-bool sne_goto_next_doc(SpanNearEnum *sne)
+static bool sne_goto_next_doc(SpanNearEnum *sne)
 {
-  SpanEnum *se = sne->span_enums[sne->current];
-  int prev_doc = se->doc(se);
+    SpanEnum *se = sne->span_enums[sne->current];
+    int prev_doc = se->doc(se);
 
-  SNE_NEXT();
+    SpNEn_NEXT();
 
-  while (se->doc(se) < prev_doc) {
-    if (! se->skip_to(se, prev_doc)) return false;
-    prev_doc = se->doc(se);
-    SNE_NEXT();
-  }
-  return true;
+    while (se->doc(se) < prev_doc) {
+        if (! se->skip_to(se, prev_doc)) {
+            return false;
+        }
+        prev_doc = se->doc(se);
+        SpNEn_NEXT();
+    }
+    return true;
 }
 
-bool sne_next_unordered_match(SpanEnum *self)
+static bool sne_next_unordered_match(SpanEnum *self)
 {
-  SpanNearEnum *sne = (SpanNearEnum *)self->data;
-  SpanEnum *se, *min_se = NULL;
-  int i;
-  int max_end, end, min_start, start, doc;
-  int lengths_sum;
+    SpanNearEnum *sne = SpNEn(self);
+    SpanEnum *se, *min_se = NULL;
+    int i;
+    int max_end, end, min_start, start, doc;
+    int lengths_sum;
+
+    while (true) {
+        max_end = 0;
+        min_start = INT_MAX;
+        lengths_sum = 0;
+
+        for (i = 0; i < sne->s_cnt; i++) {
+            se = sne->span_enums[i];
+            if ((end=se->end(se)) > max_end) {
+                max_end = end;
+            }
+            if ((start=se->start(se)) < min_start) {
+                min_start = start;
+                min_se = se;
+                sne->current = i; /* current should point to the minimum span */
+            }
+            lengths_sum += end - start;
+        }
 
-  while (true) {
+        if ((max_end - min_start - lengths_sum) <= sne->slop) {
+            /* we have a match */
+            sne->start = min_start;
+            sne->end = max_end;
+            sne->doc = min_se->doc(min_se);
+            return true;
+        }
 
-    max_end = 0;
-    min_start = INT_MAX;
-    lengths_sum = 0;
+        /* increment the minimum span_enum and try again */
+        doc = min_se->doc(min_se);
+        if (!min_se->next(min_se)) {
+            return false;
+        }
+        if (doc < min_se->doc(min_se)) {
+            if (!sne_goto_next_doc(sne)) return false;
+        }
+    }
+}
 
-    for (i = 0; i < sne->s_cnt; i++) {
-      se = sne->span_enums[i];
-      if ((end=se->end(se)) > max_end) max_end = end;
-      if ((start=se->start(se)) < min_start) {
-        min_start = start;
-        min_se = se;
-        sne->current = i; /* current should point to the minimum span */
-      }
-      lengths_sum += end - start;
-    }
-
-    if ((max_end - min_start - lengths_sum) <= sne->slop) {
-      /* we have a match */
-      sne->start = min_start;
-      sne->end = max_end;
-      sne->doc = min_se->doc(min_se);
-      return true;
-    }
-
-    /* increment the minimum span_enum and try again */
-    doc = min_se->doc(min_se);
-    if (!min_se->next(min_se)) return false;
-    if (doc < min_se->doc(min_se)) {
-      if (!sne_goto_next_doc(sne)) return false;
-    }
-  }
-}
-
-bool sne_next_ordered_match(SpanEnum *self)
-{
-  SpanNearEnum *sne = (SpanNearEnum *)self->data;
-  SpanEnum *se;
-  int i;
-  int prev_doc, prev_start, prev_end;
-  int doc=0, start=0, end=0;
-  int lengths_sum;
-
-  while (true) {
-    se = sne->span_enums[0];
-
-    prev_doc = se->doc(se);
-    sne->start = prev_start = se->start(se);
-    prev_end = se->end(se);
-
-    i = 1;
-    lengths_sum = prev_end - prev_start;
-
-    while (i < sne->s_cnt) {
-      se = sne->span_enums[i];
-      doc = se->doc(se);
-      start = se->start(se);
-      end = se->end(se);
-      while ((doc == prev_doc) && ((start < prev_start) ||
-           ((start == prev_start) && (end < prev_end)))) {
-        if (!se->next(se)) return false;
-        doc = se->doc(se);
-        start = se->start(se);
-        end = se->end(se);
-      }
-      if (doc != prev_doc) {
-        sne->current = i;
-        if (!sne_goto_next_doc(sne)) return false;
-        break;
-      }
-      i++;
-      lengths_sum += end - start;
-      prev_doc = doc;
-      prev_start = start;
-      prev_end = end;
-    }
-    if (i == sne->s_cnt) {
-      if ((end - sne->start - lengths_sum) <= sne->slop) {
-        /* we have a match */
-        sne->end = end;
-        sne->doc = doc;
-
-        /* the minimum span is always the first span so it needs to be
-         * incremented next time around */
-        sne->current = 0;
-        return true;
+static bool sne_next_ordered_match(SpanEnum *self)
+{
+    SpanNearEnum *sne = SpNEn(self);
+    SpanEnum *se;
+    int i;
+    int prev_doc, prev_start, prev_end;
+    int doc=0, start=0, end=0;
+    int lengths_sum;
 
-      } else {
+    while (true) {
         se = sne->span_enums[0];
-        if (!se->next(se)) return false;
-        if (se->doc(se) != prev_doc) {
-          sne->current = 0;
-          if (!sne_goto_next_doc(sne)) return false;
+
+        prev_doc = se->doc(se);
+        sne->start = prev_start = se->start(se);
+        prev_end = se->end(se);
+
+        i = 1;
+        lengths_sum = prev_end - prev_start;
+
+        while (i < sne->s_cnt) {
+            se = sne->span_enums[i];
+            doc = se->doc(se);
+            start = se->start(se);
+            end = se->end(se);
+            while ((doc == prev_doc) && ((start < prev_start) ||
+                                         ((start == prev_start) && (end < prev_end)))) {
+                if (!se->next(se)) {
+                    return false;
+                }
+                doc = se->doc(se);
+                start = se->start(se);
+                end = se->end(se);
+            }
+            if (doc != prev_doc) {
+                sne->current = i;
+                if (!sne_goto_next_doc(sne)) {
+                    return false;
+                }
+                break;
+            }
+            i++;
+            lengths_sum += end - start;
+            prev_doc = doc;
+            prev_start = start;
+            prev_end = end;
+        }
+        if (i == sne->s_cnt) {
+            if ((end - sne->start - lengths_sum) <= sne->slop) {
+                /* we have a match */
+                sne->end = end;
+                sne->doc = doc;
+
+                /* the minimum span is always the first span so it needs to be
+                 * incremented next time around */
+                sne->current = 0;
+                return true;
+
+            }
+            else {
+                se = sne->span_enums[0];
+                if (!se->next(se)) {
+                    return false;
+                }
+                if (se->doc(se) != prev_doc) {
+                    sne->current = 0;
+                    if (!sne_goto_next_doc(sne)) {
+                        return false;
+                    }
+                }
+            }
         }
-      }
     }
-  }
 }
-  
-bool sne_next_match(SpanEnum *self)
+
+static bool sne_next_match(SpanEnum *self)
 {
-  SpanNearEnum *sne = (SpanNearEnum *)self->data;
-  SpanEnum *se_curr, *se_next;
+    SpanNearEnum *sne = SpNEn(self);
+    SpanEnum *se_curr, *se_next;
 
-  if (!sne->first_time) {
-    if (!sne_init(sne)) return false;
-    sne->first_time = false;
-  }
-  se_curr = sne->span_enums[sne->current];
-  se_next = sne->span_enums[(sne->current+1)%sne->s_cnt];
-  if (se_curr->doc(se_curr) > se_next->doc(se_next)) {
-    if (!sne_goto_next_doc(sne)) return false;
-  }
+    if (!sne->first_time) {
+        if (!sne_init(sne)) {
+            return false;
+        }
+        sne->first_time = false;
+    }
+    se_curr = sne->span_enums[sne->current];
+    se_next = sne->span_enums[(sne->current+1)%sne->s_cnt];
+    if (se_curr->doc(se_curr) > se_next->doc(se_next)) {
+        if (!sne_goto_next_doc(sne)) {
+            return false;
+        }
+    }
 
-  if (sne->in_order) {
-    return sne_next_ordered_match(self);
-  } else {
-    return sne_next_unordered_match(self);
-  }
+    if (sne->in_order) {
+        return sne_next_ordered_match(self);
+    }
+    else {
+        return sne_next_unordered_match(self);
+    }
 }
 
-bool spanne_next(SpanEnum *self)
+static bool spanne_next(SpanEnum *self)
 {
-  SpanNearEnum *sne = (SpanNearEnum *)self->data;
-  SpanEnum *se;
+    SpanNearEnum *sne = SpNEn(self);
+    SpanEnum *se;
 
-  se = sne->span_enums[sne->current];
-  if (!se->next(se)) return false;
+    se = sne->span_enums[sne->current];
+    if (!se->next(se)) return false;
 
-  return sne_next_match(self);
+    return sne_next_match(self);
 }
 
-bool spanne_skip_to(SpanEnum *self, int target)
+static bool spanne_skip_to(SpanEnum *self, int target)
 {
-  SpanNearEnum *sne = (SpanNearEnum *)self->data;
-  SpanEnum *se;
-
-  se = sne->span_enums[sne->current];
-  if (!se->skip_to(se, target)) return false;
+    SpanEnum *se = SpNEn(self)->span_enums[SpNEn(self)->current];
+    if (!se->skip_to(se, target)) {
+        return false;
+    }
 
-  return sne_next_match(self);
+    return sne_next_match(self);
 }
 
-#define GET_TOP_SNE SpanNearEnum *sne = (SpanNearEnum *)self->data;
-
-int  spanne_doc(SpanEnum *self)
+static int spanne_doc(SpanEnum *self)
 {
-  GET_TOP_SNE;
-  return sne->doc;
+    return SpNEn(self)->doc;
 }
 
-int  spanne_start(SpanEnum *self)
+static int spanne_start(SpanEnum *self)
 {
-  GET_TOP_SNE;
-  return sne->start;
+    return SpNEn(self)->start;
 }
 
-int  spanne_end(SpanEnum *self)
+static int spanne_end(SpanEnum *self)
 {
-  GET_TOP_SNE;
-  return sne->end;
+    return SpNEn(self)->end;
 }
 
-char *spanne_to_s(SpanEnum *self) 
+static char *spanne_to_s(SpanEnum *self) 
 {
-  SpanNearEnum *sne = (SpanNearEnum *)self->data;
-  char *field = ((SpanQuery *)self->query->data)->field;
-  char *query_str = self->query->to_s(self->query, field);
-  char doc_str[62];
-  size_t len = strlen(query_str);
-  char *str = ALLOC_N(char, len + 80);
+    SpanNearEnum *sne = SpNEn(self);
+    char *field = SpQ(self->query)->field;
+    char *query_str = self->query->to_s(self->query, field);
+    char doc_str[62];
+    size_t len = strlen(query_str);
+    char *str = ALLOC_N(char, len + 80);
 
-  if (sne->first_time) {
-    sprintf(doc_str, "START");
-  } else {
-    sprintf(doc_str, "%d:%d-%d", self->doc(self),
-          self->start(self), self->end(self));
-  }
-  sprintf("SpanNearEnum(%s)@%s", query_str, doc_str);
-  free(query_str);
-  return str;
+    if (sne->first_time) {
+        sprintf(doc_str, "START");
+    }
+    else {
+        sprintf(doc_str, "%d:%d-%d", self->doc(self),
+                self->start(self), self->end(self));
+    }
+    sprintf("SpanNearEnum(%s)@%s", query_str, doc_str);
+    free(query_str);
+    return str;
 }
 
-void spanne_destroy(SpanEnum *self)
+static void spanne_destroy(SpanEnum *self)
 {
-  SpanEnum *se;
-  SpanNearEnum *sne = (SpanNearEnum *)self->data;
-  int i;
-  for (i = 0; i < sne->s_cnt; i++) {
-    se = sne->span_enums[i];
-    se->destroy(se);
-  }
-  free(sne->span_enums);
-  free(sne);
-  free(self);
+    SpanEnum *se;
+    SpanNearEnum *sne = SpNEn(self);
+    int i;
+    for (i = 0; i < sne->s_cnt; i++) {
+        se = sne->span_enums[i];
+        se->destroy(se);
+    }
+    free(sne->span_enums);
+    free(self);
 }
 
-SpanEnum *spanne_create(Query *query, IndexReader *ir)
+static SpanEnum *spanne_new(Query *query, IndexReader *ir)
 {
-  Query *clause;
-  SpanEnum *self = ALLOC(SpanEnum);
-  SpanNearQuery *snq = (SpanNearQuery *)((SpanQuery *)query->data)->data;
-  SpanNearEnum *sne = ALLOC(SpanNearEnum);
-  int i;
-  sne->first_time = true;
-  sne->in_order = snq->in_order;
-  sne->slop = snq->slop;
-  sne->s_cnt = snq->c_cnt;
-  sne->span_enums = ALLOC_N(SpanEnum *, sne->s_cnt);
-  for (i = 0; i < sne->s_cnt; i++) {
-    clause = snq->clauses[i];
-    sne->span_enums[i] = ((SpanQuery *)clause->data)->get_spans(clause, ir);
-  }
-  sne->current = 0;
-  
-  sne->doc = -1;
-  sne->start = -1;
-  sne->end = -1;
+    int i;
+    Query *clause;
+    SpanEnum *self          = (SpanEnum *)emalloc(sizeof(SpanNearEnum));
+    SpanNearQuery *snq      = SpNQ(query);
+
+    SpNEn(self)->first_time = true;
+    SpNEn(self)->in_order   = snq->in_order;
+    SpNEn(self)->slop       = snq->slop;
+    SpNEn(self)->s_cnt      = snq->c_cnt;
+    SpNEn(self)->span_enums = ALLOC_N(SpanEnum *, SpNEn(self)->s_cnt);
+
+    for (i = 0; i < SpNEn(self)->s_cnt; i++) {
+        clause = snq->clauses[i];
+        SpNEn(self)->span_enums[i] = SpQ(clause)->get_spans(clause, ir);
+    }
+    SpNEn(self)->current    = 0;
 
-  self->data = sne;
+    SpNEn(self)->doc        = -1;
+    SpNEn(self)->start      = -1;
+    SpNEn(self)->end        = -1;
 
-  self->query = query;
-  self->next = &spanne_next;
-  self->skip_to = &spanne_skip_to;
-  self->doc = &spanne_doc;
-  self->start = &spanne_start;
-  self->end = &spanne_end;
-  self->destroy = &spanne_destroy;
-  self->to_s = &spanne_to_s;
+    self->query             = query;
+    self->next              = &spanne_next;
+    self->skip_to           = &spanne_skip_to;
+    self->doc               = &spanne_doc;
+    self->start             = &spanne_start;
+    self->end               = &spanne_end;
+    self->destroy           = &spanne_destroy;
+    self->to_s              = &spanne_to_s;
 
-  return self;
+    return self;
 }
 
 /*****************************************************************************
@@ -810,211 +1041,348 @@ SpanEnum *spanne_create(Query *query, IndexReader *ir)
  *
  *****************************************************************************/
 
-bool spanxe_next(SpanEnum *self)
+#define SpXEn(span_enum) ((SpanNotEnum *)(span_enum))
+#define SpXQ(query) ((SpanNotQuery *)(query))
+
+typedef struct SpanNotEnum
 {
-  SpanNotEnum *sxe = (SpanNotEnum *)(self->data);
-  SpanEnum *inc = sxe->inc, *exc = sxe->exc;
-  if (sxe->more_inc) {                       // move to next incl
-    sxe->more_inc = inc->next(inc);
-  }
+    SpanEnum    super;
+    SpanEnum   *inc;
+    SpanEnum   *exc;
+    bool        more_inc : 1;
+    bool        more_exc : 1;
+} SpanNotEnum;
 
-  while (sxe->more_inc && sxe->more_exc) {
-    if (inc->doc(inc) > exc->doc(exc)) {     // skip excl
-      sxe->more_exc = exc->skip_to(exc, inc->doc(inc));
-    }
 
-    while (sxe->more_exc &&                  // while excl is before
-           (inc->doc(inc) == exc->doc(exc)) &&
-           (exc->end(exc) <= inc->start(inc))) {
-      sxe->more_exc = exc->next(exc);        // increment excl
+static bool spanxe_next(SpanEnum *self)
+{
+    SpanNotEnum *sxe = SpXEn(self);
+    SpanEnum *inc = sxe->inc, *exc = sxe->exc;
+    if (sxe->more_inc) {                        /*  move to next incl */
+        sxe->more_inc = inc->next(inc);
     }
 
-    if (! sxe->more_exc ||                   // if no intersection
-        (inc->doc(inc) != exc->doc(exc)) ||
-        inc->end(inc) <= exc->start(exc)) {
-      break;                                 // we found a match
-    }
+    while (sxe->more_inc && sxe->more_exc) {
+        if (inc->doc(inc) > exc->doc(exc)) {    /*  skip excl */
+            sxe->more_exc = exc->skip_to(exc, inc->doc(inc));
+        }
+
+        while (sxe->more_exc                    /*  while excl is before */
+               && (inc->doc(inc) == exc->doc(exc))
+               && (exc->end(exc) <= inc->start(inc))) {
+            sxe->more_exc = exc->next(exc);     /*  increment excl */
+        }
+
+        if (! sxe->more_exc ||                  /*  if no intersection */
+            (inc->doc(inc) != exc->doc(exc)) ||
+            inc->end(inc) <= exc->start(exc)) {
+            break;                              /*  we found a match */
+        }
 
-    sxe->more_inc = inc->next(inc);          // intersected: keep scanning
-  }
-  return sxe->more_inc;
+        sxe->more_inc = inc->next(inc);         /*  intersected: keep scanning */
+    }
+    return sxe->more_inc;
 }
 
-bool spanxe_skip_to(SpanEnum *self, int target)
+static bool spanxe_skip_to(SpanEnum *self, int target)
 {
-  SpanNotEnum *sxe = (SpanNotEnum *)(self->data);
-  SpanEnum *inc = sxe->inc, *exc = sxe->exc;
-  int doc;
+    SpanNotEnum *sxe = SpXEn(self);
+    SpanEnum *inc = sxe->inc, *exc = sxe->exc;
+    int doc;
 
-  if (sxe->more_inc) {                       // move to next incl
-    if (!(sxe->more_inc=sxe->inc->skip_to(sxe->inc, target))) return false;
-  }
+    if (sxe->more_inc) {                        /*  move to next incl */
+        if (!(sxe->more_inc=sxe->inc->skip_to(sxe->inc, target))) return false;
+    }
 
-  if (sxe->more_inc && ((doc=inc->doc(inc)) > exc->doc(exc))) {
-    sxe->more_exc = exc->skip_to(exc, doc);
-  }
+    if (sxe->more_inc && ((doc=inc->doc(inc)) > exc->doc(exc))) {
+        sxe->more_exc = exc->skip_to(exc, doc);
+    }
 
-  while (sxe->more_exc &&                    // while excl is before
-         inc->doc(inc) == exc->doc(exc) &&
-         exc->end(exc) <= inc->start(inc)) {
-    sxe->more_exc = exc->next(exc);          // increment excl
-  }
+    while (sxe->more_exc                       /*  while excl is before */
+           && inc->doc(inc) == exc->doc(exc)
+           && exc->end(exc) <= inc->start(inc)) {
+        sxe->more_exc = exc->next(exc);        /*  increment excl */
+    }
 
-  if (!sxe->more_exc ||                      // if no intersection
+    if (!sxe->more_exc ||                      /*  if no intersection */
         inc->doc(inc) != exc->doc(exc) ||
         inc->end(inc) <= exc->start(exc)) {
-    return true;                             // we found a match
-  }
+        return true;                           /*  we found a match */
+    }
 
-  return spanxe_next(self);                  // scan to next match
+    return spanxe_next(self);                  /*  scan to next match */
 }
 
-int  spanxe_doc(SpanEnum *self)
+static int spanxe_doc(SpanEnum *self)
 {
-  SpanEnum *inc = ((SpanNotEnum *)(self->data))->inc;
-  return inc->doc(inc);
+    SpanEnum *inc = SpXEn(self)->inc;
+    return inc->doc(inc);
 }
 
-int  spanxe_start(SpanEnum *self)
+static int spanxe_start(SpanEnum *self)
 {
-  SpanEnum *inc = ((SpanNotEnum *)(self->data))->inc;
-  return inc->start(inc);
+    SpanEnum *inc = SpXEn(self)->inc;
+    return inc->start(inc);
 }
 
-int  spanxe_end(SpanEnum *self)
+static int spanxe_end(SpanEnum *self)
 {
-  SpanEnum *inc = ((SpanNotEnum *)(self->data))->inc;
-  return inc->end(inc);
+    SpanEnum *inc = SpXEn(self)->inc;
+    return inc->end(inc);
 }
 
-char *spanxe_to_s(SpanEnum *self) 
+static char *spanxe_to_s(SpanEnum *self) 
 {
-  char *field = ((SpanQuery *)self->query->data)->field;
-  char *query_str = self->query->to_s(self->query, field);
-  char *res = strfmt("SpanNotEnum(%s)", query_str);
-  free(query_str);
-  return res;
+    char *field = SpQ(self->query)->field;
+    char *query_str = self->query->to_s(self->query, field);
+    char *res = strfmt("SpanNotEnum(%s)", query_str);
+    free(query_str);
+    return res;
 }
 
-void spanxe_destroy(SpanEnum *self)
+static void spanxe_destroy(SpanEnum *self)
 {
-  SpanNotEnum *sxe = (SpanNotEnum *)self->data;
-  sxe->inc->destroy(sxe->inc);
-  sxe->exc->destroy(sxe->exc);
-  free(sxe);
-  free(self);
+    SpanNotEnum *sxe = SpXEn(self);
+    sxe->inc->destroy(sxe->inc);
+    sxe->exc->destroy(sxe->exc);
+    free(self);
 }
 
-SpanEnum *spanxe_create(Query *query, IndexReader *ir)
+static SpanEnum *spanxe_new(Query *query, IndexReader *ir)
 {
-  SpanEnum *self = ALLOC(SpanEnum);
-  SpanNotQuery *sxq = (SpanNotQuery *)((SpanQuery *)query->data)->data;
+    SpanEnum *self      = (SpanEnum *)emalloc(sizeof(SpanNotEnum));
+    SpanNotEnum *sxe    = SpXEn(self);
+    SpanNotQuery *sxq   = SpXQ(query);
 
-  SpanNotEnum *sxe = self->data = ALLOC(SpanNotEnum);
-  sxe->inc = ((SpanQuery *)sxq->inc->data)->get_spans(sxq->inc, ir);
-  sxe->exc = ((SpanQuery *)sxq->exc->data)->get_spans(sxq->exc, ir);
-  sxe->more_inc = true;
-  sxe->more_exc = sxe->exc->next(sxe->exc);
+    sxe->inc            = SpQ(sxq->inc)->get_spans(sxq->inc, ir);
+    sxe->exc            = SpQ(sxq->exc)->get_spans(sxq->exc, ir);
+    sxe->more_inc       = true;
+    sxe->more_exc       = sxe->exc->next(sxe->exc);
 
-  self->query = query;
-  self->next = &spanxe_next;
-  self->skip_to = &spanxe_skip_to;
-  self->doc = &spanxe_doc;
-  self->start = &spanxe_start;
-  self->end = &spanxe_end;
-  self->destroy = &spanxe_destroy;
-  self->to_s = &spanxe_to_s;
+    self->query         = query;
+    self->next          = &spanxe_next;
+    self->skip_to       = &spanxe_skip_to;
+    self->doc           = &spanxe_doc;
+    self->start         = &spanxe_start;
+    self->end           = &spanxe_end;
+    self->destroy       = &spanxe_destroy;
+    self->to_s          = &spanxe_to_s;
 
-  return self;
+    return self;
 }
+
 /*****************************************************************************
  *
- * SpanQuery
+ * SpanWeight
  *
  *****************************************************************************/
 
-void spanq_destroy(Query *self)
+#define SpW(weight) ((SpanWeight *)(weight))
+typedef struct SpanWeight
+{
+    Weight      super;
+    HashSet    *terms;
+} SpanWeight;
+
+static Explanation *spanw_explain(Weight *self, IndexReader *ir, int target)
+{
+    Explanation *expl;
+    Explanation *idf_expl1;
+    Explanation *idf_expl2;
+    Explanation *query_expl;
+    Explanation *qnorm_expl;
+    Explanation *field_expl;
+    Explanation *tf_expl;
+    Scorer *scorer;
+    uchar *field_norms;
+    float field_norm;
+    Explanation *field_norm_expl;
+
+    char *query_str;
+    HashSet *terms = SpW(self)->terms;
+    char *field = SpQ(self->query)->field;
+    const int field_num = fis_get_field_num(ir->fis, field);
+    char *doc_freqs = NULL;
+    size_t df_i = 0;
+    int i;
+
+    if (field_num < 0) {
+        return expl_new(0.0, "field \"%s\" does not exist in the index", field);
+    }
+
+    query_str = self->query->to_s(self->query, "");
+
+    for (i = 0; i < terms->size; i++) {
+        char *term = (char *)terms->elems[i];
+        REALLOC_N(doc_freqs, char, df_i + strlen(term) + 23);
+        sprintf(doc_freqs + df_i, "%s=%d, ", term,
+                ir->doc_freq(ir, field_num, term));
+        df_i = strlen(doc_freqs);
+    }
+    /* remove the ',' at the end of the string if it exists */
+    if (terms->size > 0) {
+        df_i -= 2;
+        doc_freqs[df_i] = '\0';
+    }
+    else {
+        doc_freqs = "";
+    }
+
+    expl = expl_new(0.0, "weight(%s in %d), product of:", query_str, target);
+
+    /* We need two of these as it's included in both the query explanation
+     * and the field explanation */
+    idf_expl1 = expl_new(self->idf, "idf(%s: %s)", field, doc_freqs);
+    idf_expl2 = expl_new(self->idf, "idf(%s: %s)", field, doc_freqs);
+    if (terms->size > 0) {
+        free(doc_freqs); /* only free if allocated */
+    }
+
+    /* explain query weight */
+    query_expl = expl_new(0.0, "query_weight(%s), product of:", query_str);
+
+    if (self->query->boost != 1.0) {
+        expl_add_detail(query_expl, expl_new(self->query->boost, "boost"));
+    }
+
+    expl_add_detail(query_expl, idf_expl1);
+
+    qnorm_expl = expl_new(self->qnorm, "query_norm");
+    expl_add_detail(query_expl, qnorm_expl);
+
+    query_expl->value = self->query->boost * idf_expl1->value * qnorm_expl->value;
+
+    expl_add_detail(expl, query_expl);
+
+    /* explain field weight */
+    field_expl = expl_new(0.0, "field_weight(%s:%s in %d), product of:",
+                          field, query_str, target);
+    free(query_str);
+
+    scorer = self->scorer(self, ir);
+    tf_expl = scorer->explain(scorer, target);
+    scorer->destroy(scorer);
+    expl_add_detail(field_expl, tf_expl);
+    expl_add_detail(field_expl, idf_expl2);
+
+    field_norms = ir->get_norms(ir, field_num);
+    field_norm = (field_norms 
+                  ? sim_decode_norm(self->similarity, field_norms[target]) 
+                  : (float)0.0);
+    field_norm_expl = expl_new(field_norm, "field_norm(field=%s, doc=%d)",
+                               field, target);
+    expl_add_detail(field_expl, field_norm_expl);
+
+    field_expl->value = tf_expl->value * idf_expl2->value * field_norm_expl->value;
+
+    /* combine them */
+    if (query_expl->value == 1.0) {
+        expl_destroy(expl);
+        return field_expl;
+    }
+    else {
+        expl->value = (query_expl->value * field_expl->value);
+        expl_add_detail(expl, field_expl);
+        return expl;
+    }
+}
+
+static char *spanw_to_s(Weight *self)
+{
+    return strfmt("SpanWeight(%f)", self->value);
+}
+
+static void spanw_destroy(Weight *self)
 {
-  SpanQuery *sq = (SpanQuery *)self->data;
-  free(sq);
-  q_destroy_i(self);
+    hs_destroy(SpW(self)->terms);
+    w_destroy(self);
+}
+
+static Weight *spanw_new(Query *query, Searcher *searcher)
+{
+    int i;
+    Weight *self        = w_new(SpanWeight, query);
+    HashSet *terms      = SpQ(query)->get_terms(query);
+
+    SpW(self)->terms    = terms;
+    self->scorer        = &spansc_new;
+    self->explain       = &spanw_explain;
+    self->to_s          = &spanw_to_s;
+    self->destroy       = &spanw_destroy;
+
+    self->similarity    = query->get_similarity(query, searcher);
+
+    self->idf           = 0.0;
+    
+    for (i = terms->size - 1; i >= 0; i--) {
+        self->idf += sim_idf_term(self->similarity, SpQ(query)->field, 
+                                  (char *)terms->elems[i], searcher);
+    }
+
+    return self;
 }
 
 /*****************************************************************************
- *
  * SpanTermQuery
- *
  *****************************************************************************/
 
-char *spantq_to_s(Query *self, char *field)
+static char *spantq_to_s(Query *self, const char *field)
 {
-  Term *term = (Term *)((SpanQuery *)self->data)->data;
-  char *term_str, *res;
-  if (field == term->field) {
-    term_str = estrdup(term->text);
-  } else {
-    term_str = term_to_s(term);
-  }
-  res = strfmt("span_term(%s)", term_str);
-  free(term_str);
-  return res;
+    if (field == SpQ(self)->field) {
+        return strfmt("span_terms(%s)", SpTQ(self)->term);
+    }
+    else {
+        return strfmt("span_terms(%s:%s)", SpQ(self)->field, SpTQ(self)->term);
+    }
 }
 
-static void spantq_destroy(Query *self)
+static void spantq_destroy_i(Query *self)
 {
-  SpanQuery *sq = (SpanQuery *)self->data;
-  if (self->destroy_all) {
-    Term *term = (Term *)sq->data;
-    term_destroy(term);
-  }
-  free(sq);
-  q_destroy_i(self);
+    free(SpTQ(self)->term);
+    free(SpQ(self)->field);
+    spanq_destroy_i(self);
 }
 
 static void spantq_extract_terms(Query *self, HashSet *terms)
 {
-  Term *term = (Term *)((SpanQuery *)self->data)->data;
-  hs_add(terms, term_clone(term));
+    hs_add(terms, term_new(SpQ(self)->field, SpTQ(self)->term));
 }
 
 static HashSet *spantq_get_terms(Query *self)
 {
-  Term *term = (Term *)((SpanQuery *)self->data)->data;
-  HashSet *terms = term_set_create();
-  hs_add(terms, term_clone(term));
-  return terms;
+    HashSet *terms = hs_new_str(&free);
+    hs_add(terms, estrdup(SpTQ(self)->term));
+    return terms;
 }
 
-static uint spantq_hash(Query *self)
+static ulong spantq_hash(Query *self)
 {
-  return term_hash((Term *)((SpanQuery *)self->data)->data);
+    return spanq_hash(self) ^ str_hash(SpTQ(self)->term);
 }
 
 static int spantq_eq(Query *self, Query *o)
 {
-  return term_eq((Term *)((SpanQuery *)self->data)->data,
-                 (Term *)((SpanQuery *)o->data)->data);
+    return spanq_eq(self, o) && strcmp(SpTQ(self)->term, SpTQ(o)->term) == 0;
 }
 
-Query *spantq_create(Term *term)
+Query *spantq_new(const char *field, const char *term)
 {
-  Query *self = q_create();
+    Query *self             = q_new(SpanTermQuery);
 
-  SpanQuery *sq = ALLOC(SpanQuery);
-  sq->data = term;
-  sq->get_spans = &spante_create;
-  sq->get_terms = &spantq_get_terms;
-  sq->field = term->field;
-  self->data = sq;
+    SpTQ(self)->term        = estrdup(term);
+    SpQ(self)->field        = estrdup(field);
+    SpQ(self)->get_spans    = &spante_new;
+    SpQ(self)->get_terms    = &spantq_get_terms;
 
-  self->type = SPAN_TERM_QUERY;
-  self->extract_terms = &spantq_extract_terms;
-  self->to_s = &spantq_to_s;
-  self->hash = &spantq_hash;
-  self->eq = &spantq_eq;
-  self->destroy_i = &spantq_destroy;
-  self->create_weight_i = &spanw_create;
-  return self;
+    self->type              = SPAN_TERM_QUERY;
+    self->extract_terms     = &spantq_extract_terms;
+    self->to_s              = &spantq_to_s;
+    self->hash              = &spantq_hash;
+    self->eq                = &spantq_eq;
+    self->destroy_i         = &spantq_destroy_i;
+    self->create_weight_i   = &spanw_new;
+    self->get_matchv_i      = &spanq_get_matchv_i;
+    return self;
 }
 
 /*****************************************************************************
@@ -1023,91 +1391,87 @@ Query *spantq_create(Term *term)
  *
  *****************************************************************************/
 
-char *spanfq_to_s(Query *self, char *field)
+static char *spanfq_to_s(Query *self, const char *field)
 {
-  SpanFirstQuery *sfq = (SpanFirstQuery *)((SpanQuery *)self->data)->data;
-  Query *match = sfq->match;
-  char *q_str = match->to_s(match, field);
-  char *res = strfmt("span_first(%s, %d)", q_str, sfq->end);
-  free(q_str);
-  return res;
+    Query *match = SpFQ(self)->match;
+    char *q_str = match->to_s(match, field);
+    char *res = strfmt("span_first(%s, %d)", q_str, SpFQ(self)->end);
+    free(q_str);
+    return res;
 }
 
-void spanfq_extract_terms(Query *self, HashSet *terms)
+static void spanfq_extract_terms(Query *self, HashSet *terms)
 {
-  SpanFirstQuery *sfq = (SpanFirstQuery *)((SpanQuery *)self->data)->data;
-  sfq->match->extract_terms(sfq->match, terms);
+    SpFQ(self)->match->extract_terms(SpFQ(self)->match, terms);
 }
 
-HashSet *spanfq_get_terms(Query *self)
+static HashSet *spanfq_get_terms(Query *self)
 {
-  SpanFirstQuery *sfq = (SpanFirstQuery *)((SpanQuery *)self->data)->data;
-  SpanQuery *match_sq = (SpanQuery *)sfq->match->data;
-  return match_sq->get_terms(sfq->match);
+    SpanFirstQuery *sfq = SpFQ(self);
+    return SpQ(sfq->match)->get_terms(sfq->match);
 }
 
-Query *spanfq_rewrite(Query *self, IndexReader *ir)
+static Query *spanfq_rewrite(Query *self, IndexReader *ir)
 {
-  SpanFirstQuery *sfq = (SpanFirstQuery *)((SpanQuery *)self->data)->data;
-  Query *q, *rq;
+    Query *q, *rq;
 
-  q = sfq->match;
-  rq = q->rewrite(q, ir);
-  if (rq == q || self->destroy_all) q_deref(q);
-  sfq->match = rq;
+    q = SpFQ(self)->match;
+    rq = q->rewrite(q, ir);
+    q_deref(q);
+    SpFQ(self)->match = rq;
 
-  self->ref_cnt++;
-  return self;                    /* no clauses rewrote */
+    self->ref_cnt++;
+    return self;                    /* no clauses rewrote */
 }
 
-void spanfq_destroy(Query *self)
+static void spanfq_destroy_i(Query *self)
 {
-  SpanQuery *sq = (SpanQuery *)self->data;
-  SpanFirstQuery *sfq = (SpanFirstQuery *)sq->data;
-  if (self->destroy_all) q_deref(sfq->match);
-  free(sfq);
-  free(sq);
-  q_destroy_i(self);
+    q_deref(SpFQ(self)->match);
+    spanq_destroy_i(self);
 }
 
-static uint spanfq_hash(Query *self)
+static ulong spanfq_hash(Query *self)
 {
-  SpanFirstQuery *sfq = (SpanFirstQuery *)((SpanQuery *)self->data)->data;
-  return sfq->match->hash(sfq->match) ^ sfq->end;
+    return spanq_hash(self) ^ SpFQ(self)->match->hash(SpFQ(self)->match)
+        ^ SpFQ(self)->end;
 }
 
 static int spanfq_eq(Query *self, Query *o)
 {
-  SpanFirstQuery *sfq1 = (SpanFirstQuery *)((SpanQuery *)self->data)->data;
-  SpanFirstQuery *sfq2 = (SpanFirstQuery *)((SpanQuery *)o->data)->data;
-  return sfq1->match->eq(sfq1->match, sfq2->match) && (sfq1->end == sfq2->end);
+    SpanFirstQuery *sfq1 = SpFQ(self);
+    SpanFirstQuery *sfq2 = SpFQ(o);
+    return spanq_eq(self, o) && sfq1->match->eq(sfq1->match, sfq2->match)
+        && (sfq1->end == sfq2->end);
 }
 
-Query *spanfq_create(Query *match, int end)
+Query *spanfq_new_nr(Query *match, int end)
 {
-  Query *self = q_create();
+    Query *self = q_new(SpanFirstQuery);
 
-  SpanQuery *sq = ALLOC(SpanQuery);
+    SpFQ(self)->match       = match;
+    SpFQ(self)->end         = end;
 
-  SpanFirstQuery *sfq = ALLOC(SpanFirstQuery);
-  sfq->match = match;
-  sfq->end = end;
-  sq->data = sfq;
+    SpQ(self)->field        = SpQ(match)->field;
+    SpQ(self)->get_spans    = &spanfe_new;
+    SpQ(self)->get_terms    = &spanfq_get_terms;
 
-  sq->get_spans = &spanfe_create;
-  sq->get_terms = &spanfq_get_terms;
-  sq->field = ((SpanQuery *)match->data)->field;
-  self->data = sq;
+    self->type              = SPAN_FIRST_QUERY;
+    self->rewrite           = &spanfq_rewrite;
+    self->extract_terms     = &spanfq_extract_terms;
+    self->to_s              = &spanfq_to_s;
+    self->hash              = &spanfq_hash;
+    self->eq                = &spanfq_eq;
+    self->destroy_i         = &spanfq_destroy_i;
+    self->create_weight_i   = &spanw_new;
+    self->get_matchv_i      = &spanq_get_matchv_i;
+
+    return self;
+}
 
-  self->type = SPAN_FIRST_QUERY;
-  self->rewrite = &spanfq_rewrite;
-  self->extract_terms = &spanfq_extract_terms;
-  self->to_s = &spanfq_to_s;
-  self->hash = &spanfq_hash;
-  self->eq = &spanfq_eq;
-  self->destroy_i = &spanfq_destroy;
-  self->create_weight_i = &spanw_create;
-  return self;
+Query *spanfq_new(Query *match, int end)
+{
+    REF(match);
+    return spanfq_new_nr(match, end);
 }
 
 /*****************************************************************************
@@ -1116,154 +1480,182 @@ Query *spanfq_create(Query *match, int end)
  *
  *****************************************************************************/
 
-char *spanoq_to_s(Query *self, char *field)
-{
-  SpanOrQuery *soq = (SpanOrQuery *)((SpanQuery *)self->data)->data;
-  char *res = estrdup("span_or["), *q_str;
-  Query *clause;
-  int i;
-  for (i = 0; i < soq->c_cnt; i++) {
-    clause = soq->clauses[i];
-    q_str = clause->to_s(clause, field);
-    REALLOC_N(res, char, strlen(res) + strlen(q_str) + 10);
-    if (i > 0) strcat(res, ", ");
-    strcat(res, q_str);
-    free(q_str);
-  }
-  strcat(res, "]");
+static char *spanoq_to_s(Query *self, const char *field)
+{
+    int i;
+    SpanOrQuery *soq = SpOQ(self);
+    char *res, *res_p;
+    char **q_strs = ALLOC_N(char *, soq->c_cnt);
+    int len = 50;
+    for (i = 0; i < soq->c_cnt; i++) {
+        Query *clause = soq->clauses[i];
+        q_strs[i] = clause->to_s(clause, field);
+        len += strlen(q_strs[i])  + 2;
+    }
 
-  return res;
+    res_p = res = ALLOC_N(char, len);
+    sprintf(res_p, "span_or[ ");
+    res_p += strlen(res_p);
+    for (i = 0; i < soq->c_cnt; i++) {
+        sprintf(res_p, "%s, ", q_strs[i]);
+        free(q_strs[i]);
+        res_p += strlen(res_p);
+    }
+    free(q_strs);
+
+    sprintf(res_p - 2, " ]");
+    return res;
 }
 
-void spanoq_extract_terms(Query *self, HashSet *terms)
+static void spanoq_extract_terms(Query *self, HashSet *terms)
 {
-  SpanOrQuery *soq = (SpanOrQuery *)((SpanQuery *)self->data)->data;
-  Query *clause;
-  int i;
-  for (i = 0; i < soq->c_cnt; i++) {
-    clause = soq->clauses[i];
-    clause->extract_terms(clause, terms);
-  }
+    SpanOrQuery *soq = SpOQ(self);
+    int i;
+    for (i = 0; i < soq->c_cnt; i++) {
+        Query *clause = soq->clauses[i];
+        clause->extract_terms(clause, terms);
+    }
 }
 
-HashSet *spanoq_get_terms(Query *self)
+static HashSet *spanoq_get_terms(Query *self)
 {
-  SpanOrQuery *soq = (SpanOrQuery *)((SpanQuery *)self->data)->data;
-  HashSet *terms = term_set_create();
-  Query *clause;
-  int i;
-  for (i = 0; i < soq->c_cnt; i++) {
-    clause = soq->clauses[i];
-    clause->extract_terms(clause, terms);
-  }
+    SpanOrQuery *soq = SpOQ(self);
+    HashSet *terms = hs_new_str(&free);
+    int i;
+    for (i = 0; i < soq->c_cnt; i++) {
+        Query *clause = soq->clauses[i];
+        HashSet *sub_terms = SpQ(clause)->get_terms(clause);
+        hs_merge(terms, sub_terms);
+    }
 
-  return terms;
+    return terms;
 }
 
-SpanEnum *spanoq_get_spans(Query *self, IndexReader *ir)
+static SpanEnum *spanoq_get_spans(Query *self, IndexReader *ir)
 {
-  SpanOrQuery *soq = (SpanOrQuery *)((SpanQuery *)self->data)->data;
-  Query *q;
-  if (soq->c_cnt == 1) {
-    q = soq->clauses[0];
-    return ((SpanQuery *)q->data)->get_spans(q, ir);
-  }
+    SpanOrQuery *soq = SpOQ(self);
+    if (soq->c_cnt == 1) {
+        Query *q = soq->clauses[0];
+        return SpQ(q)->get_spans(q, ir);
+    }
 
-  return spanoe_create(self, ir);
+    return spanoe_new(self, ir);
 }
 
-Query *spanoq_rewrite(Query *self, IndexReader *ir)
+static Query *spanoq_rewrite(Query *self, IndexReader *ir)
 {
-  SpanOrQuery *soq = (SpanOrQuery *)((SpanQuery *)self->data)->data;
-  Query *clause, *rewritten;
-  int i;
-  /* replace clauses with their rewritten queries */
-  for (i = 0; i < soq->c_cnt; i++) {
-    clause = soq->clauses[i];
-    rewritten = clause->rewrite(clause, ir);
-    if ((rewritten == clause) || self->destroy_all) q_deref(clause);
-    soq->clauses[i] = rewritten;
-  }
+    SpanOrQuery *soq = SpOQ(self);
+    int i;
 
-  self->ref_cnt++;
-  return self;
+    /* replace clauses with their rewritten queries */
+    for (i = 0; i < soq->c_cnt; i++) {
+        Query *clause = soq->clauses[i];
+        Query *rewritten = clause->rewrite(clause, ir);
+        q_deref(clause);
+        soq->clauses[i] = rewritten;
+    }
+
+    self->ref_cnt++;
+    return self;
 }
 
-void spanoq_destroy(Query *self)
+static void spanoq_destroy_i(Query *self)
 {
-  SpanQuery *sq = (SpanQuery *)self->data;
-  SpanOrQuery *soq = (SpanOrQuery *)sq->data;
+    SpanOrQuery *soq = SpOQ(self);
 
-  if (self->destroy_all) {
-    Query *clause;
     int i;
     for (i = 0; i < soq->c_cnt; i++) {
-      clause = soq->clauses[i];
-      q_deref(clause);
+        Query *clause = soq->clauses[i];
+        q_deref(clause);
     }
     free(soq->clauses);
-  }
 
-
-  free(soq);
-  free(sq);
-  q_destroy_i(self);
+    spanq_destroy_i(self);
 }
 
-static uint spanoq_hash(Query *self)
+static ulong spanoq_hash(Query *self)
 {
-  int i;
-  uint hash = 0;
-  Query *q;
-  SpanOrQuery *soq = (SpanOrQuery *)((SpanQuery *)self->data)->data;
+    int i;
+    ulong hash = spanq_hash(self);
+    SpanOrQuery *soq = SpOQ(self);
 
-  for (i = 0; i < soq->c_cnt; i++) {
-    q = soq->clauses[i];
-    hash ^= q->hash(q);
-  }
-  return hash;
+    for (i = 0; i < soq->c_cnt; i++) {
+        Query *q = soq->clauses[i];
+        hash ^= q->hash(q);
+    }
+    return hash;
 }
 
 static int spanoq_eq(Query *self, Query *o)
 {
-  int i;
-  Query *q1, *q2;
-  SpanOrQuery *soq1 = (SpanOrQuery *)((SpanQuery *)self->data)->data;
-  SpanOrQuery *soq2 = (SpanOrQuery *)((SpanQuery *)o->data)->data;
-  if (soq1->c_cnt != soq2->c_cnt) return false;
-  for (i = 0; i < soq1->c_cnt; i++) {
-    q1 = soq1->clauses[i];
-    q2 = soq2->clauses[i];
-    if (!q1->eq(q1, q2)) return false;
-  }
-  return true;
+    int i;
+    Query *q1, *q2;
+    SpanOrQuery *soq1 = SpOQ(self);
+    SpanOrQuery *soq2 = SpOQ(o);
+
+    if (!spanq_eq(self, o) || soq1->c_cnt != soq2->c_cnt) {
+        return false;
+    }
+    for (i = 0; i < soq1->c_cnt; i++) {
+        q1 = soq1->clauses[i];
+        q2 = soq2->clauses[i];
+        if (!q1->eq(q1, q2)) {
+            return false;
+        }
+    }
+    return true;
 }
 
-Query *spanoq_create(Query **clauses, int c_cnt)
+Query *spanoq_new()
 {
-  Query *self = q_create();
+    Query *self             = q_new(SpanOrQuery);
+    SpOQ(self)->clauses     = ALLOC_N(Query *, CLAUSE_INIT_CAPA);
+    SpOQ(self)->c_capa      = CLAUSE_INIT_CAPA;
+
+    SpQ(self)->field        = (char *)EMPTY_STRING;
+    SpQ(self)->get_spans    = &spanoq_get_spans;
+    SpQ(self)->get_terms    = &spanoq_get_terms;
 
-  SpanQuery *sq = ALLOC(SpanQuery);
+    self->type              = SPAN_OR_QUERY;
+    self->rewrite           = &spanoq_rewrite;
+    self->extract_terms     = &spanoq_extract_terms;
+    self->to_s              = &spanoq_to_s;
+    self->hash              = &spanoq_hash;
+    self->eq                = &spanoq_eq;
+    self->destroy_i         = &spanoq_destroy_i;
+    self->create_weight_i   = &spanw_new;
+    self->get_matchv_i      = &spanq_get_matchv_i;
 
-  SpanOrQuery *soq = ALLOC(SpanOrQuery);
-  soq->clauses = clauses;
-  soq->c_cnt = c_cnt;
-  sq->data = soq;
+    return self;
+}
 
-  sq->get_spans = &spanoq_get_spans;
-  sq->get_terms = &spanoq_get_terms;
-  sq->field = ((SpanQuery *)clauses[0]->data)->field;
-  self->data = sq;
+Query *spanoq_add_clause_nr(Query *self, Query *clause)
+{
+    const int curr_index = SpOQ(self)->c_cnt++;
+    if (clause->type < SPAN_TERM_QUERY || clause->type > SPAN_NEAR_QUERY) {
+        RAISE(ARG_ERROR, "Tried to add a %s to a SpanOrQuery. This is not a "
+              "SpanQuery.", q_get_query_name(clause->type));
+    }
+    if (curr_index == 0) {
+        SpQ(self)->field = SpQ(clause)->field;
+    }
+    else if (strcmp(SpQ(self)->field, SpQ(clause)->field) != 0) {
+        RAISE(ARG_ERROR, "All clauses in a SpanQuery must have the same field. "
+              "Attempted to add a SpanQuery with field \"%s\" to a SpanOrQuery "
+              "with field \"%s\"", SpQ(clause)->field, SpQ(self)->field);
+    }
+    if (curr_index >= SpOQ(self)->c_capa) {
+        SpOQ(self)->c_capa <<= 1;
+        REALLOC_N(SpOQ(self)->clauses, Query *, SpOQ(self)->c_capa);
+    }
+    SpOQ(self)->clauses[curr_index] = clause;
+    return clause;
+}
 
-  self->type = SPAN_OR_QUERY;
-  self->rewrite = &spanoq_rewrite;
-  self->extract_terms = &spanoq_extract_terms;
-  self->to_s = &spanoq_to_s;
-  self->hash = &spanoq_hash;
-  self->eq = &spanoq_eq;
-  self->destroy_i = &spanoq_destroy;
-  self->create_weight_i = &spanw_create;
-  return self;
+Query *spanoq_add_clause(Query *self, Query *clause)
+{
+    REF(clause);
+    return spanoq_add_clause_nr(self, clause);
 }
 
 /*****************************************************************************
@@ -1272,163 +1664,188 @@ Query *spanoq_create(Query **clauses, int c_cnt)
  *
  *****************************************************************************/
 
-char *spannq_to_s(Query *self, char *field)
-{
-  SpanNearQuery *snq = (SpanNearQuery *)((SpanQuery *)self->data)->data;
-  char *res = estrdup("span_near(["), *q_str;
-  Query *clause;
-  int i;
-  for (i = 0; i < snq->c_cnt; i++) {
-    clause = snq->clauses[i];
-    q_str = clause->to_s(clause, field);
-    REALLOC_N(res, char, strlen(res) + strlen(q_str) + 10);
-    if (i > 0) strcat(res, ", ");
-    strcat(res, q_str);
-    free(q_str);
-  }
-  REALLOC_N(res, char, strlen(res) + 40);
-  sprintf(res + strlen(res), "], %d, %s)", snq->slop,
-      snq->in_order ? "Ordered" : "Unordered");
+static char *spannq_to_s(Query *self, const char *field)
+{
+    int i;
+    SpanNearQuery *snq = SpNQ(self);
+    char *res, *res_p;
+    char **q_strs = ALLOC_N(char *, snq->c_cnt);
+    int len = 50;
+    for (i = 0; i < snq->c_cnt; i++) {
+        Query *clause = snq->clauses[i];
+        q_strs[i] = clause->to_s(clause, field);
+        len += strlen(q_strs[i]);
+    }
 
-  return res;
+    res_p = res = ALLOC_N(char, len);
+    sprintf(res_p, "span_near[ ");
+    res_p += strlen(res_p);
+    for (i = 0; i < snq->c_cnt; i++) {
+        sprintf(res_p, "%s, ", q_strs[i]);
+        free(q_strs[i]);
+        res_p += strlen(res_p);
+    }
+    free(q_strs);
+
+    sprintf(res_p - 2, " ]");
+    return res;
 }
 
-void spannq_extract_terms(Query *self, HashSet *terms)
+static void spannq_extract_terms(Query *self, HashSet *terms)
 {
-  SpanNearQuery *snq = (SpanNearQuery *)((SpanQuery *)self->data)->data;
-  Query *clause;
-  int i;
-  for (i = 0; i < snq->c_cnt; i++) {
-    clause = snq->clauses[i];
-    clause->extract_terms(clause, terms);
-  }
+    SpanNearQuery *snq = SpNQ(self);
+    int i;
+    for (i = 0; i < snq->c_cnt; i++) {
+        Query *clause = snq->clauses[i];
+        clause->extract_terms(clause, terms);
+    }
 }
 
-HashSet *spannq_get_terms(Query *self)
+static HashSet *spannq_get_terms(Query *self)
 {
-  SpanNearQuery *snq = (SpanNearQuery *)((SpanQuery *)self->data)->data;
-  HashSet *terms = term_set_create();
-  Query *clause;
-  int i;
-  for (i = 0; i < snq->c_cnt; i++) {
-    clause = snq->clauses[i];
-    clause->extract_terms(clause, terms);
-  }
+    SpanNearQuery *snq = SpNQ(self);
+    HashSet *terms = hs_new_str(&free);
+    int i;
+    for (i = 0; i < snq->c_cnt; i++) {
+        Query *clause = snq->clauses[i];
+        HashSet *sub_terms = SpQ(clause)->get_terms(clause);
+        hs_merge(terms, sub_terms);
+    }
 
-  return terms;
+    return terms;
 }
 
-SpanEnum *spannq_get_spans(Query *self, IndexReader *ir)
+static SpanEnum *spannq_get_spans(Query *self, IndexReader *ir)
 {
-  SpanNearQuery *snq = (SpanNearQuery *)((SpanQuery *)self->data)->data;
-  Query *q;
+    SpanNearQuery *snq = SpNQ(self);
 
-  if (snq->c_cnt == 1) {
-    q = snq->clauses[0];
-    return ((SpanQuery *)q->data)->get_spans(q, ir);
-  }
+    if (snq->c_cnt == 1) {
+        Query *q = snq->clauses[0];
+        return SpQ(q)->get_spans(q, ir);
+    }
 
-  return spanne_create(self, ir);
+    return spanne_new(self, ir);
 }
 
-Query *spannq_rewrite(Query *self, IndexReader *ir)
+static Query *spannq_rewrite(Query *self, IndexReader *ir)
 {
-  SpanNearQuery *snq = (SpanNearQuery *)((SpanQuery *)self->data)->data;
-  Query *clause, *rewritten;
-  int i;
-  for (i = 0; i < snq->c_cnt; i++) {
-    clause = snq->clauses[i];
-    rewritten = clause->rewrite(clause, ir);
-    if ((rewritten == clause) || self->destroy_all) q_deref(clause);
-    snq->clauses[i] = rewritten;
-  }
+    SpanNearQuery *snq = SpNQ(self);
+    int i;
+    for (i = 0; i < snq->c_cnt; i++) {
+        Query *clause = snq->clauses[i];
+        Query *rewritten = clause->rewrite(clause, ir);
+        q_deref(clause);
+        snq->clauses[i] = rewritten;
+    }
 
-  self->ref_cnt++;
-  return self;
+    self->ref_cnt++;
+    return self;
 }
 
-void spannq_destroy(Query *self)
+static void spannq_destroy(Query *self)
 {
-  SpanQuery *sq = (SpanQuery *)self->data;
-  SpanNearQuery *snq = (SpanNearQuery *)sq->data;
+    SpanNearQuery *snq = SpNQ(self);
 
-  if (self->destroy_all) {
-    Query *clause;
     int i;
     for (i = 0; i < snq->c_cnt; i++) {
-      clause = snq->clauses[i];
-      q_deref(clause);
+        Query *clause = snq->clauses[i];
+        q_deref(clause);
     }
     free(snq->clauses);
-  }
 
-  free(snq);
-  free(sq);
-  q_destroy_i(self);
+    spanq_destroy_i(self);
 }
 
-static uint spannq_hash(Query *self)
+static ulong spannq_hash(Query *self)
 {
-  int i;
-  uint hash = 0;
-  Query *q;
-  SpanNearQuery *snq = (SpanNearQuery *)((SpanQuery *)self->data)->data;
+    int i;
+    ulong hash = spanq_hash(self);
+    SpanNearQuery *snq = SpNQ(self);
 
-  for (i = 0; i < snq->c_cnt; i++) {
-    q = snq->clauses[i];
-    hash ^= q->hash(q);
-  }
-  return ((hash ^ snq->slop) << 1) | snq->in_order;
+    for (i = 0; i < snq->c_cnt; i++) {
+        Query *q = snq->clauses[i];
+        hash ^= q->hash(q);
+    }
+    return ((hash ^ snq->slop) << 1) | snq->in_order;
 }
 
 static int spannq_eq(Query *self, Query *o)
 {
-  int i;
-  Query *q1, *q2;
-  SpanNearQuery *snq1 = (SpanNearQuery *)((SpanQuery *)self->data)->data;
-  SpanNearQuery *snq2 = (SpanNearQuery *)((SpanQuery *)o->data)->data;
-  if (snq1->c_cnt != snq2->c_cnt ||
-      snq1->slop != snq2->slop ||
-      snq1->in_order != snq2->in_order) {
-    return false;
-  }
+    int i;
+    Query *q1, *q2;
+    SpanNearQuery *snq1 = SpNQ(self);
+    SpanNearQuery *snq2 = SpNQ(o);
+    if (! spanq_eq(self, o)
+        || (snq1->c_cnt != snq2->c_cnt)
+        || (snq1->slop != snq2->slop)
+        || (snq1->in_order != snq2->in_order)) {
+        return false;
+    }
 
-  for (i = 0; i < snq1->c_cnt; i++) {
-    q1 = snq1->clauses[i];
-    q2 = snq2->clauses[i];
-    if (!q1->eq(q1, q2)) return false;
-  }
+    for (i = 0; i < snq1->c_cnt; i++) {
+        q1 = snq1->clauses[i];
+        q2 = snq2->clauses[i];
+        if (!q1->eq(q1, q2)) {
+            return false;
+        }
+    }
 
-  return true;
+    return true;
 }
 
-Query *spannq_create(Query **clauses, int c_cnt, int slop, bool in_order)
+Query *spannq_new(int slop, bool in_order)
 {
-  Query *self = q_create();
+    Query *self             = q_new(SpanNearQuery);
 
-  SpanQuery *sq = ALLOC(SpanQuery);
+    SpNQ(self)->clauses     = ALLOC_N(Query *, CLAUSE_INIT_CAPA);
+    SpNQ(self)->c_capa      = CLAUSE_INIT_CAPA;
+    SpNQ(self)->slop        = slop;
+    SpNQ(self)->in_order    = in_order;
 
-  SpanNearQuery *snq = ALLOC(SpanNearQuery);
-  snq->clauses = clauses;
-  snq->c_cnt = c_cnt;
-  snq->slop = slop;
-  snq->in_order = in_order;
-  sq->data = snq;
+    SpQ(self)->get_spans    = &spannq_get_spans;
+    SpQ(self)->get_terms    = &spannq_get_terms;
+    SpQ(self)->field        = (char *)EMPTY_STRING;
 
-  sq->get_spans = &spannq_get_spans;
-  sq->get_terms = &spannq_get_terms;
-  sq->field = ((SpanQuery *)clauses[0]->data)->field;
-  self->data = sq;
+    self->type              = SPAN_NEAR_QUERY;
+    self->rewrite           = &spannq_rewrite;
+    self->extract_terms     = &spannq_extract_terms;
+    self->to_s              = &spannq_to_s;
+    self->hash              = &spannq_hash;
+    self->eq                = &spannq_eq;
+    self->destroy_i         = &spannq_destroy;
+    self->create_weight_i   = &spanw_new;
+    self->get_matchv_i      = &spanq_get_matchv_i;
 
-  self->type = SPAN_NEAR_QUERY;
-  self->rewrite = &spannq_rewrite;
-  self->extract_terms = &spannq_extract_terms;
-  self->to_s = &spannq_to_s;
-  self->hash = &spannq_hash;
-  self->eq = &spannq_eq;
-  self->destroy_i = &spannq_destroy;
-  self->create_weight_i = &spanw_create;
-  return self;
+    return self;
+}
+
+Query *spannq_add_clause_nr(Query *self, Query *clause)
+{
+    const int curr_index = SpNQ(self)->c_cnt++;
+    if (clause->type < SPAN_TERM_QUERY || clause->type > SPAN_NEAR_QUERY) {
+        RAISE(ARG_ERROR, "Tried to add a %s to a SpanNearQuery. This is not a "
+              "SpanQuery.", q_get_query_name(clause->type));
+    }
+    if (curr_index == 0) {
+        SpQ(self)->field = SpQ(clause)->field;
+    }
+    else if (strcmp(SpQ(self)->field, SpQ(clause)->field) != 0) {
+        RAISE(ARG_ERROR, "All clauses in a SpanQuery must have the same field. "
+              "Attempted to add a SpanQuery with field \"%s\" to SpanNearQuery "
+              "with field \"%s\"", SpQ(clause)->field, SpQ(self)->field);
+    }
+    if (curr_index >= SpNQ(self)->c_capa) {
+        SpNQ(self)->c_capa <<= 1;
+        REALLOC_N(SpNQ(self)->clauses, Query *, SpNQ(self)->c_capa);
+    }
+    SpNQ(self)->clauses[curr_index] = clause;
+    return clause;
+}
+
+Query *spannq_add_clause(Query *self, Query *clause)
+{
+    REF(clause);
+    return spannq_add_clause_nr(self, clause);
 }
 
 /*****************************************************************************
@@ -1437,213 +1854,110 @@ Query *spannq_create(Query **clauses, int c_cnt, int slop, bool in_order)
  *
  *****************************************************************************/
 
-char *spanxq_to_s(Query *self, char *field)
+static char *spanxq_to_s(Query *self, const char *field)
 {
-  SpanNotQuery *sxq = (SpanNotQuery *)((SpanQuery *)self->data)->data;
-  char *inc_s = sxq->inc->to_s(sxq->inc, field);
-  char *exc_s = sxq->exc->to_s(sxq->exc, field);
-  char *res = strfmt("span_not(inc:<%s>, exc:<%s>)", inc_s, exc_s);
-  
-  free(inc_s);
-  free(exc_s);
-  return res;
+    SpanNotQuery *sxq = SpXQ(self);
+    char *inc_s = sxq->inc->to_s(sxq->inc, field);
+    char *exc_s = sxq->exc->to_s(sxq->exc, field);
+    char *res = strfmt("span_not(inc:<%s>, exc:<%s>)", inc_s, exc_s);
+
+    free(inc_s);
+    free(exc_s);
+    return res;
 }
 
-void spanxq_extract_terms(Query *self, HashSet *terms)
+static void spanxq_extract_terms(Query *self, HashSet *terms)
 {
-  SpanNotQuery *sxq = (SpanNotQuery *)((SpanQuery *)self->data)->data;
-  sxq->inc->extract_terms(sxq->inc, terms);
+    SpXQ(self)->inc->extract_terms(SpXQ(self)->inc, terms);
 }
 
-HashSet *spanxq_get_terms(Query *self)
+static HashSet *spanxq_get_terms(Query *self)
 {
-  SpanNotQuery *sxq = (SpanNotQuery *)((SpanQuery *)self->data)->data;
-  HashSet *terms = term_set_create();
-  sxq->inc->extract_terms(sxq->inc, terms);
-  return terms;
+    return SpQ(SpXQ(self)->inc)->get_terms(SpXQ(self)->inc);
 }
 
-Query *spanxq_rewrite(Query *self, IndexReader *ir)
+static Query *spanxq_rewrite(Query *self, IndexReader *ir)
 {
-  SpanNotQuery *sxq = (SpanNotQuery *)((SpanQuery *)self->data)->data;
-  Query *q, *rq;
+    SpanNotQuery *sxq = SpXQ(self);
+    Query *q, *rq;
 
-  /* rewrite inclusive query */
-  q = sxq->inc;
-  rq = q->rewrite(q, ir);
-  if (rq == q || self->destroy_all) q_deref(q);
-  sxq->inc = rq;
+    /* rewrite inclusive query */
+    q = sxq->inc;
+    rq = q->rewrite(q, ir);
+    q_deref(q);
+    sxq->inc = rq;
 
-  /* rewrite exclusive query */
-  q = sxq->exc;
-  rq = q->rewrite(q, ir);
-  if (rq == q || self->destroy_all) q_deref(q);
-  sxq->exc = rq;
+    /* rewrite exclusive query */
+    q = sxq->exc;
+    rq = q->rewrite(q, ir);
+    q_deref(q);
+    sxq->exc = rq;
 
-  self->ref_cnt++;
-  return self;
+    self->ref_cnt++;
+    return self;
 }
 
-void spanxq_destroy(Query *self)
+static void spanxq_destroy(Query *self)
 {
-  SpanQuery *sq = (SpanQuery *)self->data;
-  SpanNotQuery *sxq = (SpanNotQuery *)sq->data;
+    SpanNotQuery *sxq = SpXQ(self);
 
-  if (self->destroy_all) {
     q_deref(sxq->inc);
     q_deref(sxq->exc);
-  }
 
-  free(sxq);
-  free(sq);
-  q_destroy_i(self);
+    spanq_destroy_i(self);
 }
 
-static uint spanxq_hash(Query *self)
+static ulong spanxq_hash(Query *self)
 {
-  SpanNotQuery *sxq = (SpanNotQuery *)((SpanQuery *)self->data)->data;
-  return sxq->inc->hash(sxq->inc) ^ sxq->exc->hash(sxq->exc);
+    SpanNotQuery *sxq = SpXQ(self);
+    return spanq_hash(self) ^ sxq->inc->hash(sxq->inc)
+        ^ sxq->exc->hash(sxq->exc);
 }
 
 static int spanxq_eq(Query *self, Query *o)
 {
-  SpanNotQuery *sxq1 = (SpanNotQuery *)((SpanQuery *)self->data)->data;
-  SpanNotQuery *sxq2 = (SpanNotQuery *)((SpanQuery *)o->data)->data;
-  return sxq1->inc->eq(sxq1->inc, sxq2->inc) && 
-         sxq1->exc->eq(sxq1->exc, sxq2->exc);
-}
-
-
-Query *spanxq_create(Query *inc, Query *exc)
-{
-  Query *self = q_create();
-
-  SpanQuery *sq = ALLOC(SpanQuery);
-
-  SpanNotQuery *sxq = ALLOC(SpanNotQuery);
-  sxq->inc = inc;
-  sxq->exc = exc;
-  sq->data = sxq;
-
-  sq->get_spans = &spanxe_create;
-  sq->get_terms = &spanxq_get_terms;
-  sq->field = ((SpanQuery *)inc->data)->field;
-  self->data = sq;
-
-  self->type = SPAN_NOT_QUERY;
-  self->rewrite = &spanxq_rewrite;
-  self->extract_terms = &spanxq_extract_terms;
-  self->to_s = &spanxq_to_s;
-  self->hash = &spanxq_hash;
-  self->eq = &spanxq_eq;
-  self->destroy_i = &spanxq_destroy;
-  self->create_weight_i = &spanw_create;
-
-  return self;
-}
-
-/***************************************************************************
- *
- * SpanScorer
- *
- ***************************************************************************/
-
-float spansc_score(Scorer *self)
-{
-  SpanScorer *spansc = (SpanScorer *)self->data;
-  float raw = sim_tf(spansc->sim, spansc->freq) * spansc->value;
-
-  /* normalize */
-  return raw * sim_decode_norm(self->similarity, spansc->norms[self->doc]);
+    SpanNotQuery *sxq1 = SpXQ(self);
+    SpanNotQuery *sxq2 = SpXQ(o);
+    return spanq_eq(self, o) && sxq1->inc->eq(sxq1->inc, sxq2->inc)
+        && sxq1->exc->eq(sxq1->exc, sxq2->exc);
 }
 
-bool spansc_next(Scorer *self)
-{
-  SpanScorer *spansc = (SpanScorer *)self->data;
-  SpanEnum *se = spansc->spans;
-  int match_length;
-
-  if (spansc->first_time) {
-    spansc->more = se->next(se);
-    spansc->first_time = false;
-  }
-
-  if (!spansc->more) return false;
-
-  spansc->freq = 0.0;
-  self->doc = se->doc(se);
-
-  while (spansc->more && (self->doc == se->doc(se))) {
-    match_length = se->end(se) - se->start(se);
-    spansc->freq += sim_sloppy_freq(spansc->sim, match_length);
-    spansc->more = se->next(se);
-  }
-
-  return (spansc->more || (spansc->freq != 0.0));
-}
 
-bool spansc_skip_to(Scorer *self, int target)
+Query *spanxq_new_nr(Query *inc, Query *exc)
 {
-  SpanScorer *spansc = (SpanScorer *)self->data;
-  SpanEnum *se = spansc->spans;
-
-  spansc->more = se->skip_to(se, target);
+    Query *self;
+    if (strcmp(SpQ(inc)->field, SpQ(inc)->field) != 0) {
+        RAISE(ARG_ERROR, "All clauses in a SpanQuery must have the same field. "
+              "Attempted to add a SpanQuery with field \"%s\" along with a "
+              "SpanQuery with field \"%s\" to an SpanNotQuery",
+              SpQ(inc)->field, SpQ(exc)->field);
+    }
+    self = q_new(SpanNotQuery);
 
-  if (!spansc->more) return false;
+    SpXQ(self)->inc         = inc;
+    SpXQ(self)->exc         = exc;
 
-  spansc->freq = 0.0;
-  self->doc = se->doc(se);
+    SpQ(self)->field        = SpQ(inc)->field;
+    SpQ(self)->get_spans    = &spanxe_new;
+    SpQ(self)->get_terms    = &spanxq_get_terms;
 
-  while (spansc->more && (se->doc(se) == target)) {
-    spansc->freq += sim_sloppy_freq(spansc->sim, se->end(se) - se->start(se));
-    spansc->more = se->next(se);
-  }
+    self->type              = SPAN_NOT_QUERY;
+    self->rewrite           = &spanxq_rewrite;
+    self->extract_terms     = &spanxq_extract_terms;
+    self->to_s              = &spanxq_to_s;
+    self->hash              = &spanxq_hash;
+    self->eq                = &spanxq_eq;
+    self->destroy_i         = &spanxq_destroy;
+    self->create_weight_i   = &spanw_new;
+    self->get_matchv_i      = &spanq_get_matchv_i;
 
-  return (spansc->more || (spansc->freq != 0.0));
+    return self;
 }
 
-Explanation *spansc_explain(Scorer *self, int target)
+Query *spanxq_new(Query *inc, Query *exc)
 {
-  Explanation *tf_explanation;
-  SpanScorer *spansc = (SpanScorer *)self->data;
-  float phrase_freq;
-  self->skip_to(self, target);
-  phrase_freq = (self->doc == target) ? spansc->freq : (float)0.0;
-
-  tf_explanation = expl_create(sim_tf(self->similarity, phrase_freq),
-      strfmt("tf(phrase_freq(%f)", phrase_freq));
-
-  return tf_explanation;
+    REF(inc);
+    REF(exc);
+    return spanxq_new_nr(inc, exc);
 }
 
-void spansc_destroy(Scorer *self)
-{
-  SpanScorer *spansc = (SpanScorer *)self->data;
-  if (spansc->spans) spansc->spans->destroy(spansc->spans);
-  scorer_destroy_i(self);
-}
-
-Scorer *spansc_create(Weight *weight, IndexReader *ir)
-{
-  Scorer *self = scorer_create(weight->similarity);
-  SpanScorer *spansc = ALLOC(SpanScorer);
-  SpanQuery *spanq = (SpanQuery *)weight->query->data;
-  ZEROSET(spansc, SpanScorer, 1);
-  spansc->first_time = true;
-  spansc->more = true;
-  spansc->spans = spanq->get_spans(weight->query, ir);
-  spansc->sim = weight->similarity;
-  spansc->norms = ir->get_norms(ir, spanq->field);
-  spansc->weight = weight;
-  spansc->value = weight->value;
-  spansc->freq = 0.0;
-
-  self->data = spansc;
-
-  self->score = &spansc_score;
-  self->next = &spansc_next;
-  self->skip_to = &spansc_skip_to;
-  self->explain = &spansc_explain;
-  self->destroy = &spansc_destroy;
-  return self;
-}