isomorfeus-ferret 0.17.2 → 0.17.4

data/ext/isomorfeus_ferret_ext/frt_q_span.c

@@ -16,13 +16,11 @@
 
 #define SpQ(query) ((FrtSpanQuery *)(query))
 
-static unsigned long long spanq_hash(FrtQuery *self)
-{
+static unsigned long long spanq_hash(FrtQuery *self) {
     return SpQ(self)->field ? frt_str_hash(rb_id2name(SpQ(self)->field)) : 0;
 }
 
-static int spanq_eq(FrtQuery *self, FrtQuery *o)
-{
+static int spanq_eq(FrtQuery *self, FrtQuery *o) {
     return SpQ(self)->field == SpQ(o)->field;
 }
 
@@ -31,8 +29,7 @@ static void spanq_destroy_i(FrtQuery *self) {
 }
 
 static FrtMatchVector *mv_to_term_mv(FrtMatchVector *term_mv, FrtMatchVector *full_mv,
-                                  FrtHashSet *terms, FrtTermVector *tv)
-{
+                                  FrtHashSet *terms, FrtTermVector *tv) {
     FrtHashSetEntry *hse;
     for (hse = terms->first; hse; hse = hse->next) {
         char *term = (char *)hse->elem;
@@ -63,73 +60,62 @@ static FrtMatchVector *mv_to_term_mv(FrtMatchVector *term_mv, FrtMatchVector *fu
 
 #define TV_TDE(tde) ((TVTermDocEnum *)(tde))
 
-typedef struct TVTermDocEnum
-{
+typedef struct TVTermDocEnum {
     FrtTermDocEnum super;
-    int            doc;
-    int            index;
-    int            freq;
-    int            *positions;
-    FrtTermVector  *tv;
+    int           doc_num;
+    int           index;
+    int           freq;
+    int           *positions;
+    FrtTermVector *tv;
 } TVTermDocEnum;
 
-static void tv_tde_seek(FrtTermDocEnum *tde, int field_num, const char *term)
-{
+static void tv_tde_seek(FrtTermDocEnum *tde, int field_num, const char *term) {
     TVTermDocEnum *tv_tde = TV_TDE(tde);
     FrtTVTerm *tv_term = frt_tv_get_tv_term(tv_tde->tv, term);
     (void)field_num;
     if (tv_term) {
-        tv_tde->doc = -1;
+        tv_tde->doc_num = -1;
         tv_tde->index = 0;
         tv_tde->freq = tv_term->freq;
         tv_tde->positions = tv_term->positions;
-    }
-    else {
-        tv_tde->doc = INT_MAX;
+    } else {
+        tv_tde->doc_num = INT_MAX;
     }
 }
 
-static bool tv_tde_next(FrtTermDocEnum *tde)
-{
-    if (TV_TDE(tde)->doc == -1) {
-        TV_TDE(tde)->doc = 0;
+static bool tv_tde_next(FrtTermDocEnum *tde) {
+    if (TV_TDE(tde)->doc_num == -1) {
+        TV_TDE(tde)->doc_num = 0;
         return true;
-    }
-    else {
-        TV_TDE(tde)->doc = INT_MAX;
+    } else {
+        TV_TDE(tde)->doc_num = INT_MAX;
         return false;
     }
 }
 
-static bool tv_tde_skip_to(FrtTermDocEnum *tde, int doc_num)
-{
+static bool tv_tde_skip_to(FrtTermDocEnum *tde, int doc_num) {
     if (doc_num == 0) {
-        TV_TDE(tde)->doc = 0;
+        TV_TDE(tde)->doc_num = 0;
         return true;
-    }
-    else {
-        TV_TDE(tde)->doc = INT_MAX;
+    } else {
+        TV_TDE(tde)->doc_num = INT_MAX;
         return false;
     }
 }
 
-static int tv_tde_next_position(FrtTermDocEnum *tde)
-{
+static int tv_tde_next_position(FrtTermDocEnum *tde) {
     return TV_TDE(tde)->positions[TV_TDE(tde)->index++];
 }
 
-static int tv_tde_freq(FrtTermDocEnum *tde)
-{
+static int tv_tde_freq(FrtTermDocEnum *tde) {
     return TV_TDE(tde)->freq;
 }
 
-static int tv_tde_doc_num(FrtTermDocEnum *tde)
-{
-    return TV_TDE(tde)->doc;
+static int tv_tde_doc_num(FrtTermDocEnum *tde) {
+    return TV_TDE(tde)->doc_num;
 }
 
-static FrtTermDocEnum *spanq_ir_term_positions(FrtIndexReader *ir)
-{
+static FrtTermDocEnum *spanq_ir_term_positions(FrtIndexReader *ir) {
     TVTermDocEnum *tv_tde = FRT_ALLOC(TVTermDocEnum);
     FrtTermDocEnum *tde   = (FrtTermDocEnum *)tv_tde;
     tv_tde->tv            = (FrtTermVector *)ir->store;
@@ -180,31 +166,28 @@ static FrtMatchVector *spanq_get_matchv_i(FrtQuery *self, FrtMatchVector *mv, Fr
  ***************************************************************************/
 
 #define SpSc(scorer) ((SpanScorer *)(scorer))
-typedef struct SpanScorer
-{
-    FrtScorer          super;
-    FrtIndexReader    *ir;
-    FrtSpanEnum       *spans;
-    FrtSimilarity     *sim;
-    frt_uchar          *norms;
-    FrtWeight         *weight;
+typedef struct SpanScorer {
+    FrtScorer       super;
+    FrtIndexReader  *ir;
+    FrtSpanEnum     *spans;
+    FrtSimilarity   *sim;
+    frt_uchar       *norms;
+    FrtWeight       *weight;
     float           value;
     float           freq;
     bool            first_time : 1;
     bool            more : 1;
 } SpanScorer;
 
-static float spansc_score(FrtScorer *self)
-{
+static float spansc_score(FrtScorer *self) {
     SpanScorer *spansc = SpSc(self);
     float raw = frt_sim_tf(spansc->sim, spansc->freq) * spansc->value;
 
     /* normalize */
-    return raw * frt_sim_decode_norm(self->similarity, spansc->norms[self->doc]);
+    return raw * frt_sim_decode_norm(self->similarity, spansc->norms[self->doc_num]);
 }
 
-static bool spansc_next(FrtScorer *self)
-{
+static bool spansc_next(FrtScorer *self) {
     SpanScorer *spansc = SpSc(self);
     FrtSpanEnum *se = spansc->spans;
     int match_length;
@@ -219,19 +202,18 @@ static bool spansc_next(FrtScorer *self)
     }
 
     spansc->freq = 0.0f;
-    self->doc = se->doc(se);
+    self->doc_num = se->doc_num(se);
 
     do {
         match_length = se->end(se) - se->start(se);
         spansc->freq += frt_sim_sloppy_freq(spansc->sim, match_length);
         spansc->more = se->next(se);
-    } while (spansc->more && (self->doc == se->doc(se)));
+    } while (spansc->more && (self->doc_num == se->doc_num(se)));
 
     return (spansc->more || (spansc->freq != 0.0));
 }
 
-static bool spansc_skip_to(FrtScorer *self, int target)
-{
+static bool spansc_skip_to(FrtScorer *self, int target) {
     SpanScorer *spansc = SpSc(self);
     FrtSpanEnum *se = spansc->spans;
 
@@ -241,9 +223,9 @@ static bool spansc_skip_to(FrtScorer *self, int target)
     }
 
     spansc->freq = 0.0f;
-    self->doc = se->doc(se);
+    self->doc_num = se->doc_num(se);
 
-    while (spansc->more && (se->doc(se) == target)) {
+    while (spansc->more && (se->doc_num(se) == target)) {
         spansc->freq += frt_sim_sloppy_freq(spansc->sim, se->end(se) - se->start(se));
         spansc->more = se->next(se);
         if (spansc->first_time) {
@@ -254,13 +236,12 @@ static bool spansc_skip_to(FrtScorer *self, int target)
     return (spansc->more || (spansc->freq != 0.0));
 }
 
-static FrtExplanation *spansc_explain(FrtScorer *self, int target)
-{
+static FrtExplanation *spansc_explain(FrtScorer *self, int target) {
     FrtExplanation *tf_explanation;
     SpanScorer *spansc = SpSc(self);
     float phrase_freq;
     self->skip_to(self, target);
-    phrase_freq = (self->doc == target) ? spansc->freq : (float)0.0;
+    phrase_freq = (self->doc_num == target) ? spansc->freq : (float)0.0;
 
     tf_explanation = frt_expl_new(frt_sim_tf(self->similarity, phrase_freq),
                               "tf(phrase_freq(%f)", phrase_freq);
@@ -268,8 +249,7 @@ static FrtExplanation *spansc_explain(FrtScorer *self, int target)
     return tf_explanation;
 }
 
-static void spansc_destroy(FrtScorer *self)
-{
+static void spansc_destroy(FrtScorer *self) {
     SpanScorer *spansc = SpSc(self);
     if (spansc->spans) {
         spansc->spans->destroy(spansc->spans);
@@ -277,28 +257,27 @@ static void spansc_destroy(FrtScorer *self)
     frt_scorer_destroy_i(self);
 }
 
-static FrtScorer *spansc_new(FrtWeight *weight, FrtIndexReader *ir)
-{
+static FrtScorer *spansc_new(FrtWeight *weight, FrtIndexReader *ir) {
     FrtScorer *self = NULL;
     const int field_num = frt_fis_get_field_num(ir->fis, SpQ(weight->query)->field);
     if (field_num >= 0) {
         FrtQuery *spanq = weight->query;
         self = frt_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.0f;
-
-        self->score             = &spansc_score;
-        self->next              = &spansc_next;
-        self->skip_to           = &spansc_skip_to;
-        self->explain           = &spansc_explain;
-        self->destroy           = &spansc_destroy;
+        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.0f;
+
+        self->score            = &spansc_score;
+        self->next             = &spansc_next;
+        self->skip_to          = &spansc_skip_to;
+        self->explain          = &spansc_explain;
+        self->destroy          = &spansc_destroy;
     }
     return self;
 }
@@ -310,28 +289,25 @@ static FrtScorer *spansc_new(FrtWeight *weight, FrtIndexReader *ir)
 #define SpTEn(span_enum) ((SpanTermEnum *)(span_enum))
 #define SpTQ(query) ((FrtSpanTermQuery *)(query))
 
-typedef struct SpanTermEnum
-{
-    FrtSpanEnum     super;
+typedef struct SpanTermEnum {
+    FrtSpanEnum    super;
     FrtTermDocEnum *positions;
-    int          position;
-    int          doc;
-    int          count;
-    int          freq;
+    int            position;
+    int            doc_num;
+    int            count;
+    int            freq;
 } SpanTermEnum;
 
-
-static bool spante_next(FrtSpanEnum *self)
-{
+static bool spante_next(FrtSpanEnum *self) {
     SpanTermEnum *ste = SpTEn(self);
     FrtTermDocEnum *tde = ste->positions;
 
     if (ste->count == ste->freq) {
         if (! tde->next(tde)) {
-            ste->doc = INT_MAX;
+            ste->doc_num = INT_MAX;
             return false;
         }
-        ste->doc = tde->doc_num(tde);
+        ste->doc_num = tde->doc_num(tde);
         ste->freq = tde->freq(tde);
         ste->count = 0;
     }
@@ -340,8 +316,7 @@ static bool spante_next(FrtSpanEnum *self)
     return true;
 }
 
-static bool spante_skip_to(FrtSpanEnum *self, int target)
-{
+static bool spante_skip_to(FrtSpanEnum *self, int target) {
     SpanTermEnum *ste = SpTEn(self);
     FrtTermDocEnum *tde = ste->positions;
 
@@ -354,11 +329,11 @@ static bool spante_skip_to(FrtSpanEnum *self, int target)
     */
 
     if (! tde->skip_to(tde, target)) {
-        ste->doc = INT_MAX;
+        ste->doc_num = INT_MAX;
         return false;
     }
 
-    ste->doc = tde->doc_num(tde);
+    ste->doc_num = tde->doc_num(tde);
     ste->freq = tde->freq(tde);
     ste->count = 0;
 
@@ -367,18 +342,15 @@ static bool spante_skip_to(FrtSpanEnum *self, int target)
     return true;
 }
 
-static int spante_doc(FrtSpanEnum *self)
-{
-    return SpTEn(self)->doc;
+static int spante_doc_num(FrtSpanEnum *self) {
+    return SpTEn(self)->doc_num;
 }
 
-static int spante_start(FrtSpanEnum *self)
-{
+static int spante_start(FrtSpanEnum *self) {
     return SpTEn(self)->position;
 }
 
-static int spante_end(FrtSpanEnum *self)
-{
+static int spante_end(FrtSpanEnum *self) {
     return SpTEn(self)->position + 1;
 }
 
@@ -389,16 +361,14 @@ static char *spante_to_s(FrtSpanEnum *self) {
     int pos;
     char *str = FRT_ALLOC_N(char, len + 40);
 
-    if (self->doc(self) < 0) {
+    if (self->doc_num(self) < 0) {
         sprintf(pos_str, "START");
-    }
-    else {
-        if (self->doc(self) == INT_MAX) {
+    } else {
+        if (self->doc_num(self) == INT_MAX) {
             sprintf(pos_str, "END");
-        }
-        else {
+        } else {
             pos = SpTEn(self)->position;
-            sprintf(pos_str, "%d", self->doc(self) - pos);
+            sprintf(pos_str, "%d", self->doc_num(self) - pos);
         }
     }
     sprintf(str, "SpanTermEnum(%s)@%s", query_str, pos_str);
@@ -406,33 +376,31 @@ static char *spante_to_s(FrtSpanEnum *self) {
     return str;
 }
 
-static void spante_destroy(FrtSpanEnum *self)
-{
+static void spante_destroy(FrtSpanEnum *self) {
     FrtTermDocEnum *tde = SpTEn(self)->positions;
     tde->close(tde);
     free(self);
 }
 
-static FrtSpanEnum *spante_new(FrtQuery *query, FrtIndexReader *ir)
-{
+static FrtSpanEnum *spante_new(FrtQuery *query, FrtIndexReader *ir) {
     char *term = SpTQ(query)->term;
     FrtSpanEnum *self = (FrtSpanEnum *)FRT_ALLOC(SpanTermEnum);
 
-    SpTEn(self)->positions  = frt_ir_term_positions_for(ir, SpQ(query)->field,
+    SpTEn(self)->positions = frt_ir_term_positions_for(ir, SpQ(query)->field,
                                                     term);
-    SpTEn(self)->position   = -1;
-    SpTEn(self)->doc        = -1;
-    SpTEn(self)->count      = 0;
-    SpTEn(self)->freq       = 0;
-
-    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;
+    SpTEn(self)->position  = -1;
+    SpTEn(self)->doc_num   = -1;
+    SpTEn(self)->count     = 0;
+    SpTEn(self)->freq      = 0;
+
+    self->query            = query;
+    self->next             = &spante_next;
+    self->skip_to          = &spante_skip_to;
+    self->doc_num          = &spante_doc_num;
+    self->start            = &spante_start;
+    self->end              = &spante_end;
+    self->destroy          = &spante_destroy;
+    self->to_s             = &spante_to_s;
 
     return self;
 }
@@ -444,77 +412,68 @@ static FrtSpanEnum *spante_new(FrtQuery *query, FrtIndexReader *ir)
 /* * TermPosEnumWrapper * */
 #define TPE_READ_SIZE 16
 
-typedef struct TermPosEnumWrapper
-{
-    const char  *term;
+typedef struct TermPosEnumWrapper {
+    const char     *term;
     FrtTermDocEnum *tpe;
-    int          doc;
-    int          pos;
+    int            doc_num;
+    int            pos;
 } TermPosEnumWrapper;
 
 static bool tpew_less_than(const TermPosEnumWrapper *tpew1,
-                           const TermPosEnumWrapper *tpew2)
-{
-    return (tpew1->doc < tpew2->doc)
-        || (tpew1->doc == tpew2->doc && tpew1->pos < tpew2->pos);
+                           const TermPosEnumWrapper *tpew2) {
+    return (tpew1->doc_num < tpew2->doc_num)
+        || (tpew1->doc_num == tpew2->doc_num && tpew1->pos < tpew2->pos);
 }
 
-static bool tpew_next(TermPosEnumWrapper *self)
-{
+static bool tpew_next(TermPosEnumWrapper *self) {
     FrtTermDocEnum *tpe = self->tpe;
     if (0 > (self->pos = tpe->next_position(tpe))) {
         if (!tpe->next(tpe)) return false;
-        self->doc = tpe->doc_num(tpe);
+        self->doc_num = tpe->doc_num(tpe);
         self->pos = tpe->next_position(tpe);
     }
     return true;
 }
 
-static bool tpew_skip_to(TermPosEnumWrapper *self, int doc_num)
-{
+static bool tpew_skip_to(TermPosEnumWrapper *self, int doc_num) {
     FrtTermDocEnum *tpe = self->tpe;
 
     if (tpe->skip_to(tpe, doc_num)) {
-        self->doc = tpe->doc_num(tpe);
+        self->doc_num = tpe->doc_num(tpe);
         self->pos = tpe->next_position(tpe);
         return true;
-    }
-    else {
+    } else {
         return false;
     }
 }
 
-static void tpew_destroy(TermPosEnumWrapper *self)
-{
+static void tpew_destroy(TermPosEnumWrapper *self) {
     self->tpe->close(self->tpe);
     free(self);
 }
 
-static TermPosEnumWrapper *tpew_new(const char *term, FrtTermDocEnum *tpe)
-{
+static TermPosEnumWrapper *tpew_new(const char *term, FrtTermDocEnum *tpe) {
     TermPosEnumWrapper *self = FRT_ALLOC_AND_ZERO(TermPosEnumWrapper);
     self->term = term;
     self->tpe = tpe;
-    self->doc = -1;
+    self->doc_num = -1;
     self->pos = -1;
     return self;
 }
 #define SpMTEn(span_enum) ((SpanMultiTermEnum *)(span_enum))
 #define SpMTQ(query) ((FrtSpanMultiTermQuery *)(query))
 
-typedef struct SpanMultiTermEnum
-{
-    FrtSpanEnum             super;
-    FrtPriorityQueue       *tpew_pq;
+typedef struct SpanMultiTermEnum {
+    FrtSpanEnum        super;
+    FrtPriorityQueue   *tpew_pq;
     TermPosEnumWrapper **tpews;
-    int                  tpew_cnt;
-    int                  pos;
-    int                  doc;
+    int                tpew_cnt;
+    int                pos;
+    int                doc_num;
 } SpanMultiTermEnum;
 
-static bool spanmte_next(FrtSpanEnum *self)
-{
-    int curr_doc, curr_pos;
+static bool spanmte_next(FrtSpanEnum *self) {
+    int curr_doc_num, curr_pos;
     TermPosEnumWrapper *tpew;
     SpanMultiTermEnum *mte = SpMTEn(self);
     FrtPriorityQueue *tpew_pq = mte->tpew_pq;
@@ -535,23 +494,21 @@ static bool spanmte_next(FrtSpanEnum *self)
         return false;
     }
 
-    mte->doc = curr_doc = tpew->doc;
+    mte->doc_num = curr_doc_num = tpew->doc_num;
     mte->pos = curr_pos = tpew->pos;
 
     do {
         if (tpew_next(tpew)) {
             frt_pq_down(tpew_pq);
-        }
-        else {
+        } else {
             frt_pq_pop(tpew_pq);
         }
     } while (((tpew = (TermPosEnumWrapper *)frt_pq_top(tpew_pq)) != NULL)
-             && tpew->doc == curr_doc && tpew->pos == curr_pos);
+             && tpew->doc_num == curr_doc_num && tpew->pos == curr_pos);
     return true;
 }
 
-static bool spanmte_skip_to(FrtSpanEnum *self, int target)
-{
+static bool spanmte_skip_to(FrtSpanEnum *self, int target) {
     SpanMultiTermEnum *mte = SpMTEn(self);
     FrtPriorityQueue *tpew_pq = mte->tpew_pq;
     TermPosEnumWrapper *tpew;
@@ -566,38 +523,33 @@ static bool spanmte_skip_to(FrtSpanEnum *self, int target)
         mte->tpew_pq = tpew_pq;
     }
     if (tpew_pq->size == 0) {
-        mte->doc = -1;
+        mte->doc_num = -1;
         return false;
     }
     while ((tpew = (TermPosEnumWrapper *)frt_pq_top(tpew_pq)) != NULL
-           && (target > tpew->doc)) {
+           && (target > tpew->doc_num)) {
         if (tpew_skip_to(tpew, target)) {
             frt_pq_down(tpew_pq);
-        }
-        else {
+        } else {
             frt_pq_pop(tpew_pq);
         }
     }
     return spanmte_next(self);
 }
 
-static int spanmte_doc(FrtSpanEnum *self)
-{
-    return SpMTEn(self)->doc;
+static int spanmte_doc_num(FrtSpanEnum *self) {
+    return SpMTEn(self)->doc_num;
 }
 
-static int spanmte_start(FrtSpanEnum *self)
-{
+static int spanmte_start(FrtSpanEnum *self) {
     return SpMTEn(self)->pos;
 }
 
-static int spanmte_end(FrtSpanEnum *self)
-{
+static int spanmte_end(FrtSpanEnum *self) {
     return SpMTEn(self)->pos + 1;
 }
 
-static void spanmte_destroy(FrtSpanEnum *self)
-{
+static void spanmte_destroy(FrtSpanEnum *self) {
     SpanMultiTermEnum *mte = SpMTEn(self);
     int i;
     if (mte->tpew_pq) frt_pq_destroy(mte->tpew_pq);
@@ -608,8 +560,7 @@ static void spanmte_destroy(FrtSpanEnum *self)
     free(self);
 }
 
-static FrtSpanEnum *spanmte_new(FrtQuery *query, FrtIndexReader *ir)
-{
+static FrtSpanEnum *spanmte_new(FrtQuery *query, FrtIndexReader *ir) {
     FrtSpanEnum *self = (FrtSpanEnum *)FRT_ALLOC(SpanMultiTermEnum);
     SpanMultiTermEnum *smte = SpMTEn(self);
     FrtSpanMultiTermQuery *smtq = SpMTQ(query);
@@ -625,12 +576,12 @@ static FrtSpanEnum *spanmte_new(FrtQuery *query, FrtIndexReader *ir)
     smte->tpew_cnt          = smtq->term_cnt;
     smte->tpew_pq           = NULL;
     smte->pos               = -1;
-    smte->doc               = -1;
+    smte->doc_num           = -1;
 
     self->query             = query;
     self->next              = &spanmte_next;
     self->skip_to           = &spanmte_skip_to;
-    self->doc               = &spanmte_doc;
+    self->doc_num           = &spanmte_doc_num;
     self->start             = &spanmte_start;
     self->end               = &spanmte_end;
     self->destroy           = &spanmte_destroy;
@@ -647,15 +598,13 @@ static FrtSpanEnum *spanmte_new(FrtQuery *query, FrtIndexReader *ir)
 #define SpFEn(span_enum) ((SpanFirstEnum *)(span_enum))
 #define SpFQ(query) ((FrtSpanFirstQuery *)(query))
 
-typedef struct SpanFirstEnum
-{
+typedef struct SpanFirstEnum {
     FrtSpanEnum    super;
     FrtSpanEnum   *sub_enum;
 } SpanFirstEnum;
 
 
-static bool spanfe_next(FrtSpanEnum *self)
-{
+static bool spanfe_next(FrtSpanEnum *self) {
     FrtSpanEnum *sub_enum = SpFEn(self)->sub_enum;
     int end = SpFQ(self->query)->end;
     while (sub_enum->next(sub_enum)) { /* scan to next match */
@@ -666,8 +615,7 @@ static bool spanfe_next(FrtSpanEnum *self)
     return false;
 }
 
-static bool spanfe_skip_to(FrtSpanEnum *self, int target)
-{
+static bool spanfe_skip_to(FrtSpanEnum *self, int target) {
     FrtSpanEnum *sub_enum = SpFEn(self)->sub_enum;
     int end = SpFQ(self->query)->end;
 
@@ -682,20 +630,17 @@ static bool spanfe_skip_to(FrtSpanEnum *self, int target)
     return spanfe_next(self);        /* scan to next match */
 }
 
-static int spanfe_doc(FrtSpanEnum *self)
-{
+static int spanfe_doc_num(FrtSpanEnum *self) {
     FrtSpanEnum *sub_enum = SpFEn(self)->sub_enum;
-    return sub_enum->doc(sub_enum);
+    return sub_enum->doc_num(sub_enum);
 }
 
-static int spanfe_start(FrtSpanEnum *self)
-{
+static int spanfe_start(FrtSpanEnum *self) {
     FrtSpanEnum *sub_enum = SpFEn(self)->sub_enum;
     return sub_enum->start(sub_enum);
 }
 
-static int spanfe_end(FrtSpanEnum *self)
-{
+static int spanfe_end(FrtSpanEnum *self) {
     FrtSpanEnum *sub_enum = SpFEn(self)->sub_enum;
     return sub_enum->end(sub_enum);
 }
@@ -707,15 +652,13 @@ static char *spanfe_to_s(FrtSpanEnum *self) {
     return res;
 }
 
-static void spanfe_destroy(FrtSpanEnum *self)
-{
+static void spanfe_destroy(FrtSpanEnum *self) {
     FrtSpanEnum *sub_enum = SpFEn(self)->sub_enum;
     sub_enum->destroy(sub_enum);
     free(self);
 }
 
-static FrtSpanEnum *spanfe_new(FrtQuery *query, FrtIndexReader *ir)
-{
+static FrtSpanEnum *spanfe_new(FrtQuery *query, FrtIndexReader *ir) {
     FrtSpanEnum *self          = (FrtSpanEnum *)FRT_ALLOC(SpanFirstEnum);
     FrtSpanFirstQuery *sfq     = SpFQ(query);
 
@@ -724,7 +667,7 @@ static FrtSpanEnum *spanfe_new(FrtQuery *query, FrtIndexReader *ir)
     self->query     = query;
     self->next      = &spanfe_next;
     self->skip_to   = &spanfe_skip_to;
-    self->doc       = &spanfe_doc;
+    self->doc_num   = &spanfe_doc_num;
     self->start     = &spanfe_start;
     self->end       = &spanfe_end;
     self->destroy   = &spanfe_destroy;
@@ -741,8 +684,7 @@ static FrtSpanEnum *spanfe_new(FrtQuery *query, FrtIndexReader *ir)
 #define SpOEn(span_enum) ((SpanOrEnum *)(span_enum))
 #define SpOQ(query) ((FrtSpanOrQuery *)(query))
 
-typedef struct SpanOrEnum
-{
+typedef struct SpanOrEnum {
     FrtSpanEnum        super;
     FrtPriorityQueue  *queue;
     FrtSpanEnum      **span_enums;
@@ -751,26 +693,22 @@ typedef struct SpanOrEnum
 } SpanOrEnum;
 
 
-static bool span_less_than(FrtSpanEnum *s1, FrtSpanEnum *s2)
-{
+static bool span_less_than(FrtSpanEnum *s1, FrtSpanEnum *s2) {
     int doc_diff, start_diff;
-    doc_diff = s1->doc(s1) - s2->doc(s2);
+    doc_diff = s1->doc_num(s1) - s2->doc_num(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 {
+        } else {
             return start_diff < 0;
         }
-    }
-    else {
+    } else {
         return doc_diff < 0;
     }
 }
 
-static bool spanoe_next(FrtSpanEnum *self)
-{
+static bool spanoe_next(FrtSpanEnum *self) {
     SpanOrEnum *soe = SpOEn(self);
     FrtSpanEnum *se;
     int i;
@@ -801,8 +739,7 @@ static bool spanoe_next(FrtSpanEnum *self)
     return soe->queue->size != 0;
 }
 
-static bool spanoe_skip_to(FrtSpanEnum *self, int target)
-{
+static bool spanoe_skip_to(FrtSpanEnum *self, int target) {
     SpanOrEnum *soe = SpOEn(self);
     FrtSpanEnum *se;
     int i;
@@ -815,15 +752,13 @@ static bool spanoe_skip_to(FrtSpanEnum *self, int target)
             }
         }
         soe->first_time = false;
-    }
-    else {
+    } else {
         while ((soe->queue->size != 0) &&
                ((se = (FrtSpanEnum *)frt_pq_top(soe->queue)) != NULL) &&
-               (se->doc(se) < target)) {
+               (se->doc_num(se) < target)) {
             if (se->skip_to(se, target)) {
                 frt_pq_down(soe->queue);
-            }
-            else {
+            } else {
                 frt_pq_pop(soe->queue);
             }
         }
@@ -834,20 +769,17 @@ static bool spanoe_skip_to(FrtSpanEnum *self, int target)
 
 #define SpOEn_Top_SE(self) (FrtSpanEnum *)frt_pq_top(SpOEn(self)->queue)
 
-static int spanoe_doc(FrtSpanEnum *self)
-{
+static int spanoe_doc_num(FrtSpanEnum *self) {
     FrtSpanEnum *se = SpOEn_Top_SE(self);
-    return se->doc(se);
+    return se->doc_num(se);
 }
 
-static int spanoe_start(FrtSpanEnum *self)
-{
+static int spanoe_start(FrtSpanEnum *self) {
     FrtSpanEnum *se = SpOEn_Top_SE(self);
     return se->start(se);
 }
 
-static int spanoe_end(FrtSpanEnum *self)
-{
+static int spanoe_end(FrtSpanEnum *self) {
     FrtSpanEnum *se = SpOEn_Top_SE(self);
     return se->end(se);
 }
@@ -861,13 +793,11 @@ static char *spanoe_to_s(FrtSpanEnum *self) {
 
     if (soe->first_time) {
         sprintf(doc_str, "START");
-    }
-    else {
+    } else {
         if (soe->queue->size == 0) {
             sprintf(doc_str, "END");
-        }
-        else {
-            sprintf(doc_str, "%d:%d-%d", self->doc(self),
+        } else {
+            sprintf(doc_str, "%d:%d-%d", self->doc_num(self),
                     self->start(self), self->end(self));
         }
     }
@@ -876,8 +806,7 @@ static char *spanoe_to_s(FrtSpanEnum *self) {
     return str;
 }
 
-static void spanoe_destroy(FrtSpanEnum *self)
-{
+static void spanoe_destroy(FrtSpanEnum *self) {
     FrtSpanEnum *se;
     SpanOrEnum *soe = SpOEn(self);
     int i;
@@ -890,8 +819,7 @@ static void spanoe_destroy(FrtSpanEnum *self)
     free(self);
 }
 
-static FrtSpanEnum *spanoe_new(FrtQuery *query, FrtIndexReader *ir)
-{
+static FrtSpanEnum *spanoe_new(FrtQuery *query, FrtIndexReader *ir) {
     FrtQuery *clause;
     FrtSpanEnum *self      = (FrtSpanEnum *)FRT_ALLOC(SpanOrEnum);
     FrtSpanOrQuery *soq    = SpOQ(query);
@@ -912,7 +840,7 @@ static FrtSpanEnum *spanoe_new(FrtQuery *query, FrtIndexReader *ir)
     self->query             = query;
     self->next              = &spanoe_next;
     self->skip_to           = &spanoe_skip_to;
-    self->doc               = &spanoe_doc;
+    self->doc_num           = &spanoe_doc_num;
     self->start             = &spanoe_start;
     self->end               = &spanoe_end;
     self->destroy           = &spanoe_destroy;
@@ -928,14 +856,13 @@ static FrtSpanEnum *spanoe_new(FrtQuery *query, FrtIndexReader *ir)
 #define SpNEn(span_enum) ((SpanNearEnum *)(span_enum))
 #define SpNQ(query) ((FrtSpanNearQuery *)(query))
 
-typedef struct SpanNearEnum
-{
-    FrtSpanEnum    super;
-    FrtSpanEnum  **span_enums;
+typedef struct SpanNearEnum {
+    FrtSpanEnum super;
+    FrtSpanEnum **span_enums;
     int         s_cnt;
     int         slop;
     int         current;
-    int         doc;
+    int         doc_num;
     int         start;
     int         end;
     bool        first_time : 1;
@@ -948,45 +875,42 @@ typedef struct SpanNearEnum
     se = sne->span_enums[sne->current];\
 } while (0);
 
-static bool sne_init(SpanNearEnum *sne)
-{
+static bool sne_init(SpanNearEnum *sne) {
     FrtSpanEnum *se = sne->span_enums[sne->current];
-    int prev_doc = se->doc(se);
+    int prev_doc_num = se->doc_num(se);
     int i;
 
     for (i = 1; i < sne->s_cnt; i++) {
         SpNEn_NEXT();
-        if (!se->skip_to(se, prev_doc)) {
+        if (!se->skip_to(se, prev_doc_num)) {
             return false;
         }
-        prev_doc = se->doc(se);
+        prev_doc_num = se->doc_num(se);
     }
     return true;
 }
 
-static bool sne_goto_next_doc(SpanNearEnum *sne)
-{
+static bool sne_goto_next_doc(SpanNearEnum *sne) {
     FrtSpanEnum *se = sne->span_enums[sne->current];
-    int prev_doc = se->doc(se);
+    int prev_doc_num = se->doc_num(se);
 
     SpNEn_NEXT();
 
-    while (se->doc(se) < prev_doc) {
-        if (! se->skip_to(se, prev_doc)) {
+    while (se->doc_num(se) < prev_doc_num) {
+        if (! se->skip_to(se, prev_doc_num)) {
             return false;
         }
-        prev_doc = se->doc(se);
+        prev_doc_num = se->doc_num(se);
         SpNEn_NEXT();
     }
     return true;
 }
 
-static bool sne_next_unordered_match(FrtSpanEnum *self)
-{
+static bool sne_next_unordered_match(FrtSpanEnum *self) {
     SpanNearEnum *sne = SpNEn(self);
     FrtSpanEnum *se, *min_se = NULL;
     int i;
-    int max_end, end, min_start, start, doc;
+    int max_end, end, min_start, start, doc_num;
     int lengths_sum;
 
     while (true) {
@@ -1011,34 +935,33 @@ static bool sne_next_unordered_match(FrtSpanEnum *self)
             /* we have a match */
             sne->start = min_start;
             sne->end = max_end;
-            sne->doc = min_se->doc(min_se);
+            sne->doc_num = min_se->doc_num(min_se);
             return true;
         }
 
         /* increment the minimum span_enum and try again */
-        doc = min_se->doc(min_se);
+        doc_num = min_se->doc_num(min_se);
         if (!min_se->next(min_se)) {
             return false;
         }
-        if (doc < min_se->doc(min_se)) {
+        if (doc_num < min_se->doc_num(min_se)) {
             if (!sne_goto_next_doc(sne)) return false;
         }
     }
 }
 
-static bool sne_next_ordered_match(FrtSpanEnum *self)
-{
+static bool sne_next_ordered_match(FrtSpanEnum *self) {
     SpanNearEnum *sne = SpNEn(self);
     FrtSpanEnum *se;
     int i;
-    int prev_doc, prev_start, prev_end;
-    int doc=0, start=0, end=0;
+    int prev_doc_num, prev_start, prev_end;
+    int doc_num = 0, start = 0, end = 0;
     int lengths_sum;
 
     while (true) {
         se = sne->span_enums[0];
 
-        prev_doc = se->doc(se);
+        prev_doc_num = se->doc_num(se);
         sne->start = prev_start = se->start(se);
         prev_end = se->end(se);
 
@@ -1047,19 +970,19 @@ static bool sne_next_ordered_match(FrtSpanEnum *self)
 
         while (i < sne->s_cnt) {
             se = sne->span_enums[i];
-            doc = se->doc(se);
+            doc_num = se->doc_num(se);
             start = se->start(se);
             end = se->end(se);
-            while ((doc == prev_doc) && ((start < prev_start) ||
+            while ((doc_num == prev_doc_num) && ((start < prev_start) ||
                                          ((start == prev_start) && (end < prev_end)))) {
                 if (!se->next(se)) {
                     return false;
                 }
-                doc = se->doc(se);
+                doc_num = se->doc_num(se);
                 start = se->start(se);
                 end = se->end(se);
             }
-            if (doc != prev_doc) {
+            if (doc_num != prev_doc_num) {
                 sne->current = i;
                 if (!sne_goto_next_doc(sne)) {
                     return false;
@@ -1068,7 +991,7 @@ static bool sne_next_ordered_match(FrtSpanEnum *self)
             }
             i++;
             lengths_sum += end - start;
-            prev_doc = doc;
+            prev_doc_num = doc_num;
             prev_start = start;
             prev_end = end;
         }
@@ -1076,20 +999,19 @@ static bool sne_next_ordered_match(FrtSpanEnum *self)
             if ((end - sne->start - lengths_sum) <= sne->slop) {
                 /* we have a match */
                 sne->end = end;
-                sne->doc = doc;
+                sne->doc_num = doc_num;
 
                 /* the minimum span is always the first span so it needs to be
                  * incremented next time around */
                 sne->current = 0;
                 return true;
 
-            }
-            else {
+            } else {
                 se = sne->span_enums[0];
                 if (!se->next(se)) {
                     return false;
                 }
-                if (se->doc(se) != prev_doc) {
+                if (se->doc_num(se) != prev_doc_num) {
                     sne->current = 0;
                     if (!sne_goto_next_doc(sne)) {
                         return false;
@@ -1100,8 +1022,7 @@ static bool sne_next_ordered_match(FrtSpanEnum *self)
     }
 }
 
-static bool sne_next_match(FrtSpanEnum *self)
-{
+static bool sne_next_match(FrtSpanEnum *self) {
     SpanNearEnum *sne = SpNEn(self);
     FrtSpanEnum *se_curr, *se_next;
 
@@ -1113,7 +1034,7 @@ static bool sne_next_match(FrtSpanEnum *self)
     }
     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 (se_curr->doc_num(se_curr) > se_next->doc_num(se_next)) {
         if (!sne_goto_next_doc(sne)) {
             return false;
         }
@@ -1121,14 +1042,12 @@ static bool sne_next_match(FrtSpanEnum *self)
 
     if (sne->in_order) {
         return sne_next_ordered_match(self);
-    }
-    else {
+    } else {
         return sne_next_unordered_match(self);
     }
 }
 
-static bool spanne_next(FrtSpanEnum *self)
-{
+static bool spanne_next(FrtSpanEnum *self) {
     SpanNearEnum *sne = SpNEn(self);
     FrtSpanEnum *se;
 
@@ -1138,8 +1057,7 @@ static bool spanne_next(FrtSpanEnum *self)
     return sne_next_match(self);
 }
 
-static bool spanne_skip_to(FrtSpanEnum *self, int target)
-{
+static bool spanne_skip_to(FrtSpanEnum *self, int target) {
     FrtSpanEnum *se = SpNEn(self)->span_enums[SpNEn(self)->current];
     if (!se->skip_to(se, target)) {
         return false;
@@ -1148,18 +1066,15 @@ static bool spanne_skip_to(FrtSpanEnum *self, int target)
     return sne_next_match(self);
 }
 
-static int spanne_doc(FrtSpanEnum *self)
-{
-    return SpNEn(self)->doc;
+static int spanne_doc_num(FrtSpanEnum *self) {
+    return SpNEn(self)->doc_num;
 }
 
-static int spanne_start(FrtSpanEnum *self)
-{
+static int spanne_start(FrtSpanEnum *self) {
     return SpNEn(self)->start;
 }
 
-static int spanne_end(FrtSpanEnum *self)
-{
+static int spanne_end(FrtSpanEnum *self) {
     return SpNEn(self)->end;
 }
 
@@ -1172,9 +1087,8 @@ static char *spanne_to_s(FrtSpanEnum *self) {
 
     if (sne->first_time) {
         sprintf(doc_str, "START");
-    }
-    else {
-        sprintf(doc_str, "%d:%d-%d", self->doc(self),
+    } else {
+        sprintf(doc_str, "%d:%d-%d", self->doc_num(self),
                 self->start(self), self->end(self));
     }
     sprintf(str, "SpanNearEnum(%s)@%s", query_str, doc_str);
@@ -1182,8 +1096,7 @@ static char *spanne_to_s(FrtSpanEnum *self) {
     return str;
 }
 
-static void spanne_destroy(FrtSpanEnum *self)
-{
+static void spanne_destroy(FrtSpanEnum *self) {
     FrtSpanEnum *se;
     SpanNearEnum *sne = SpNEn(self);
     int i;
@@ -1195,12 +1108,11 @@ static void spanne_destroy(FrtSpanEnum *self)
     free(self);
 }
 
-static FrtSpanEnum *spanne_new(FrtQuery *query, FrtIndexReader *ir)
-{
+static FrtSpanEnum *spanne_new(FrtQuery *query, FrtIndexReader *ir) {
     int i;
     FrtQuery *clause;
-    FrtSpanEnum *self          = (FrtSpanEnum *)FRT_ALLOC(SpanNearEnum);
-    FrtSpanNearQuery *snq      = SpNQ(query);
+    FrtSpanEnum *self       = (FrtSpanEnum *)FRT_ALLOC(SpanNearEnum);
+    FrtSpanNearQuery *snq   = SpNQ(query);
 
     SpNEn(self)->first_time = true;
     SpNEn(self)->in_order   = snq->in_order;
@@ -1214,14 +1126,14 @@ static FrtSpanEnum *spanne_new(FrtQuery *query, FrtIndexReader *ir)
     }
     SpNEn(self)->current    = 0;
 
-    SpNEn(self)->doc        = -1;
+    SpNEn(self)->doc_num    = -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->doc_num           = &spanne_doc_num;
     self->start             = &spanne_start;
     self->end               = &spanne_end;
     self->destroy           = &spanne_destroy;
@@ -1239,8 +1151,7 @@ static FrtSpanEnum *spanne_new(FrtQuery *query, FrtIndexReader *ir)
 #define SpXEn(span_enum) ((SpanNotEnum *)(span_enum))
 #define SpXQ(query) ((FrtSpanNotQuery *)(query))
 
-typedef struct SpanNotEnum
-{
+typedef struct SpanNotEnum {
     FrtSpanEnum    super;
     FrtSpanEnum   *inc;
     FrtSpanEnum   *exc;
@@ -1249,8 +1160,7 @@ typedef struct SpanNotEnum
 } SpanNotEnum;
 
 
-static bool spanxe_next(FrtSpanEnum *self)
-{
+static bool spanxe_next(FrtSpanEnum *self) {
     SpanNotEnum *sxe = SpXEn(self);
     FrtSpanEnum *inc = sxe->inc, *exc = sxe->exc;
     if (sxe->more_inc) {                        /*  move to next incl */
@@ -1258,18 +1168,18 @@ static bool spanxe_next(FrtSpanEnum *self)
     }
 
     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));
+        if (inc->doc_num(inc) > exc->doc_num(exc)) {    /*  skip excl */
+            sxe->more_exc = exc->skip_to(exc, inc->doc_num(inc));
         }
 
         while (sxe->more_exc                    /*  while excl is before */
-               && (inc->doc(inc) == exc->doc(exc))
+               && (inc->doc_num(inc) == exc->doc_num(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->doc_num(inc) != exc->doc_num(exc)) ||
             inc->end(inc) <= exc->start(exc)) {
             break;                              /*  we found a match */
         }
@@ -1279,28 +1189,27 @@ static bool spanxe_next(FrtSpanEnum *self)
     return sxe->more_inc;
 }
 
-static bool spanxe_skip_to(FrtSpanEnum *self, int target)
-{
+static bool spanxe_skip_to(FrtSpanEnum *self, int target) {
     SpanNotEnum *sxe = SpXEn(self);
     FrtSpanEnum *inc = sxe->inc, *exc = sxe->exc;
-    int doc;
+    int doc_num;
 
     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_num = inc->doc_num(inc)) > exc->doc_num(exc))) {
+        sxe->more_exc = exc->skip_to(exc, doc_num);
     }
 
     while (sxe->more_exc                       /*  while excl is before */
-           && inc->doc(inc) == exc->doc(exc)
+           && inc->doc_num(inc) == exc->doc_num(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->doc_num(inc) != exc->doc_num(exc) ||
         inc->end(inc) <= exc->start(exc)) {
         return true;                           /*  we found a match */
     }
@@ -1308,20 +1217,17 @@ static bool spanxe_skip_to(FrtSpanEnum *self, int target)
     return spanxe_next(self);                  /*  scan to next match */
 }
 
-static int spanxe_doc(FrtSpanEnum *self)
-{
+static int spanxe_doc_num(FrtSpanEnum *self) {
     FrtSpanEnum *inc = SpXEn(self)->inc;
-    return inc->doc(inc);
+    return inc->doc_num(inc);
 }
 
-static int spanxe_start(FrtSpanEnum *self)
-{
+static int spanxe_start(FrtSpanEnum *self) {
     FrtSpanEnum *inc = SpXEn(self)->inc;
     return inc->start(inc);
 }
 
-static int spanxe_end(FrtSpanEnum *self)
-{
+static int spanxe_end(FrtSpanEnum *self) {
     FrtSpanEnum *inc = SpXEn(self)->inc;
     return inc->end(inc);
 }
@@ -1333,19 +1239,17 @@ static char *spanxe_to_s(FrtSpanEnum *self) {
     return res;
 }
 
-static void spanxe_destroy(FrtSpanEnum *self)
-{
+static void spanxe_destroy(FrtSpanEnum *self) {
     SpanNotEnum *sxe = SpXEn(self);
     sxe->inc->destroy(sxe->inc);
     sxe->exc->destroy(sxe->exc);
     free(self);
 }
 
-static FrtSpanEnum *spanxe_new(FrtQuery *query, FrtIndexReader *ir)
-{
-    FrtSpanEnum *self      = (FrtSpanEnum *)FRT_ALLOC(SpanNotEnum);
+static FrtSpanEnum *spanxe_new(FrtQuery *query, FrtIndexReader *ir) {
+    FrtSpanEnum *self   = (FrtSpanEnum *)FRT_ALLOC(SpanNotEnum);
     SpanNotEnum *sxe    = SpXEn(self);
-    FrtSpanNotQuery *sxq   = SpXQ(query);
+    FrtSpanNotQuery *sxq = SpXQ(query);
 
     sxe->inc            = SpQ(sxq->inc)->get_spans(sxq->inc, ir);
     sxe->exc            = SpQ(sxq->exc)->get_spans(sxq->exc, ir);
@@ -1355,7 +1259,7 @@ static FrtSpanEnum *spanxe_new(FrtQuery *query, FrtIndexReader *ir)
     self->query         = query;
     self->next          = &spanxe_next;
     self->skip_to       = &spanxe_skip_to;
-    self->doc           = &spanxe_doc;
+    self->doc_num       = &spanxe_doc_num;
     self->start         = &spanxe_start;
     self->end           = &spanxe_end;
     self->destroy       = &spanxe_destroy;
@@ -1413,8 +1317,7 @@ static FrtExplanation *spanw_explain(FrtWeight *self, FrtIndexReader *ir, int ta
     if (terms->size > 0) {
         df_i -= 2;
         doc_freqs[df_i] = '\0';
-    }
-    else {
+    } else {
         doc_freqs = frt_estrdup("");
     }
 
@@ -1468,27 +1371,23 @@ static FrtExplanation *spanw_explain(FrtWeight *self, FrtIndexReader *ir, int ta
     if (query_expl->value == 1.0) {
         frt_expl_destroy(expl);
         return field_expl;
-    }
-    else {
+    } else {
         expl->value = (query_expl->value * field_expl->value);
         frt_expl_add_detail(expl, field_expl);
         return expl;
     }
 }
 
-static char *spanw_to_s(FrtWeight *self)
-{
+static char *spanw_to_s(FrtWeight *self) {
     return frt_strfmt("SpanWeight(%f)", self->value);
 }
 
-static void spanw_destroy(FrtWeight *self)
-{
+static void spanw_destroy(FrtWeight *self) {
     frt_hs_destroy(SpW(self)->terms);
     frt_w_destroy(self);
 }
 
-static FrtWeight *spanw_new(FrtQuery *query, FrtSearcher *searcher)
-{
+static FrtWeight *spanw_new(FrtQuery *query, FrtSearcher *searcher) {
     FrtHashSetEntry *hse;
     FrtWeight *self        = w_new(SpanWeight, query);
     FrtHashSet *terms      = SpQ(query)->get_terms(query);
@@ -1943,8 +1842,7 @@ FrtQuery *frt_spanoq_new(void) {
     return frt_spanoq_init(self);
 }
 
-FrtQuery *frt_spanoq_add_clause_nr(FrtQuery *self, FrtQuery *clause)
-{
+FrtQuery *frt_spanoq_add_clause_nr(FrtQuery *self, FrtQuery *clause) {
     const int curr_index = SpOQ(self)->c_cnt++;
     if (clause->type < SPAN_TERM_QUERY || clause->type > SPAN_NEAR_QUERY) {
         FRT_RAISE(FRT_ARG_ERROR, "Tried to add a %s to a SpanOrQuery. This is not a "
@@ -1952,8 +1850,7 @@ FrtQuery *frt_spanoq_add_clause_nr(FrtQuery *self, FrtQuery *clause)
     }
     if (curr_index == 0) {
         SpQ(self)->field = SpQ(clause)->field;
-    }
-    else if (SpQ(self)->field != SpQ(clause)->field) {
+    } else if (SpQ(self)->field != SpQ(clause)->field) {
         FRT_RAISE(FRT_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\"", rb_id2name(SpQ(clause)->field), rb_id2name(SpQ(self)->field));
@@ -1966,8 +1863,7 @@ FrtQuery *frt_spanoq_add_clause_nr(FrtQuery *self, FrtQuery *clause)
     return clause;
 }
 
-FrtQuery *frt_spanoq_add_clause(FrtQuery *self, FrtQuery *clause)
-{
+FrtQuery *frt_spanoq_add_clause(FrtQuery *self, FrtQuery *clause) {
     FRT_REF(clause);
     return frt_spanoq_add_clause_nr(self, clause);
 }
@@ -2004,8 +1900,7 @@ static char *spannq_to_s(FrtQuery *self, ID field) {
     return res;
 }
 
-static void spannq_extract_terms(FrtQuery *self, FrtHashSet *terms)
-{
+static void spannq_extract_terms(FrtQuery *self, FrtHashSet *terms) {
     FrtSpanNearQuery *snq = SpNQ(self);
     int i;
     for (i = 0; i < snq->c_cnt; i++) {
@@ -2014,8 +1909,7 @@ static void spannq_extract_terms(FrtQuery *self, FrtHashSet *terms)
     }
 }
 
-static FrtHashSet *spannq_get_terms(FrtQuery *self)
-{
+static FrtHashSet *spannq_get_terms(FrtQuery *self) {
     FrtSpanNearQuery *snq = SpNQ(self);
     FrtHashSet *terms = frt_hs_new_str(&free);
     int i;
@@ -2028,8 +1922,7 @@ static FrtHashSet *spannq_get_terms(FrtQuery *self)
     return terms;
 }
 
-static FrtSpanEnum *spannq_get_spans(FrtQuery *self, FrtIndexReader *ir)
-{
+static FrtSpanEnum *spannq_get_spans(FrtQuery *self, FrtIndexReader *ir) {
     FrtSpanNearQuery *snq = SpNQ(self);
 
     if (snq->c_cnt == 1) {
@@ -2040,8 +1933,7 @@ static FrtSpanEnum *spannq_get_spans(FrtQuery *self, FrtIndexReader *ir)
     return spanne_new(self, ir);
 }
 
-static FrtQuery *spannq_rewrite(FrtQuery *self, FrtIndexReader *ir)
-{
+static FrtQuery *spannq_rewrite(FrtQuery *self, FrtIndexReader *ir) {
     FrtSpanNearQuery *snq = SpNQ(self);
     int i;
     for (i = 0; i < snq->c_cnt; i++) {
@@ -2055,8 +1947,7 @@ static FrtQuery *spannq_rewrite(FrtQuery *self, FrtIndexReader *ir)
     return self;
 }
 
-static void spannq_destroy(FrtQuery *self)
-{
+static void spannq_destroy(FrtQuery *self) {
     FrtSpanNearQuery *snq = SpNQ(self);
 
     int i;
@@ -2069,8 +1960,7 @@ static void spannq_destroy(FrtQuery *self)
     spanq_destroy_i(self);
 }
 
-static unsigned long long spannq_hash(FrtQuery *self)
-{
+static unsigned long long spannq_hash(FrtQuery *self) {
     int i;
     unsigned long long hash = spanq_hash(self);
     FrtSpanNearQuery *snq = SpNQ(self);
@@ -2082,8 +1972,7 @@ static unsigned long long spannq_hash(FrtQuery *self)
     return ((hash ^ snq->slop) << 1) | snq->in_order;
 }
 
-static int spannq_eq(FrtQuery *self, FrtQuery *o)
-{
+static int spannq_eq(FrtQuery *self, FrtQuery *o) {
     int i;
     FrtQuery *q1, *q2;
     FrtSpanNearQuery *snq1 = SpNQ(self);
@@ -2138,8 +2027,7 @@ FrtQuery *frt_spannq_new(int slop, bool in_order) {
     return frt_spannq_init(self, slop, in_order);
 }
 
-FrtQuery *frt_spannq_add_clause_nr(FrtQuery *self, FrtQuery *clause)
-{
+FrtQuery *frt_spannq_add_clause_nr(FrtQuery *self, FrtQuery *clause) {
     const int curr_index = SpNQ(self)->c_cnt++;
     if (clause->type < SPAN_TERM_QUERY || clause->type > SPAN_NEAR_QUERY) {
         FRT_RAISE(FRT_ARG_ERROR, "Tried to add a %s to a SpanNearQuery. This is not a "
@@ -2147,8 +2035,7 @@ FrtQuery *frt_spannq_add_clause_nr(FrtQuery *self, FrtQuery *clause)
     }
     if (curr_index == 0) {
         SpQ(self)->field = SpQ(clause)->field;
-    }
-    else if (SpQ(self)->field != SpQ(clause)->field) {
+    } else if (SpQ(self)->field != SpQ(clause)->field) {
         FRT_RAISE(FRT_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\"", rb_id2name(SpQ(clause)->field), rb_id2name(SpQ(self)->field));
@@ -2161,8 +2048,7 @@ FrtQuery *frt_spannq_add_clause_nr(FrtQuery *self, FrtQuery *clause)
     return clause;
 }
 
-FrtQuery *frt_spannq_add_clause(FrtQuery *self, FrtQuery *clause)
-{
+FrtQuery *frt_spannq_add_clause(FrtQuery *self, FrtQuery *clause) {
     FRT_REF(clause);
     return frt_spannq_add_clause_nr(self, clause);
 }