isomorfeus-ferret 0.17.3 → 0.17.5

data/ext/isomorfeus_ferret_ext/frt_q_span.c

@@ -62,11 +62,11 @@ static FrtMatchVector *mv_to_term_mv(FrtMatchVector *term_mv, FrtMatchVector *fu
 
 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) {
@@ -74,31 +74,31 @@ static void tv_tde_seek(FrtTermDocEnum *tde, int field_num, const char *term) {
     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;
+        tv_tde->doc_num = INT_MAX;
     }
 }
 
 static bool tv_tde_next(FrtTermDocEnum *tde) {
-    if (TV_TDE(tde)->doc == -1) {
-        TV_TDE(tde)->doc = 0;
+    if (TV_TDE(tde)->doc_num == -1) {
+        TV_TDE(tde)->doc_num = 0;
         return true;
     } else {
-        TV_TDE(tde)->doc = INT_MAX;
+        TV_TDE(tde)->doc_num = INT_MAX;
         return false;
     }
 }
 
 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;
+        TV_TDE(tde)->doc_num = INT_MAX;
         return false;
     }
 }
@@ -112,7 +112,7 @@ static int tv_tde_freq(FrtTermDocEnum *tde) {
 }
 
 static int tv_tde_doc_num(FrtTermDocEnum *tde) {
-    return TV_TDE(tde)->doc;
+    return TV_TDE(tde)->doc_num;
 }
 
 static FrtTermDocEnum *spanq_ir_term_positions(FrtIndexReader *ir) {
@@ -167,12 +167,12 @@ 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;
+    FrtScorer       super;
+    FrtIndexReader  *ir;
+    FrtSpanEnum     *spans;
+    FrtSimilarity   *sim;
+    frt_uchar       *norms;
+    FrtWeight       *weight;
     float           value;
     float           freq;
     bool            first_time : 1;
@@ -184,7 +184,7 @@ static float spansc_score(FrtScorer *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) {
@@ -202,13 +202,13 @@ 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));
 }
@@ -223,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) {
@@ -241,7 +241,7 @@ static FrtExplanation *spansc_explain(FrtScorer *self, int target) {
     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);
@@ -264,20 +264,20 @@ static FrtScorer *spansc_new(FrtWeight *weight, FrtIndexReader *ir) {
         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;
 }
@@ -290,25 +290,24 @@ static FrtScorer *spansc_new(FrtWeight *weight, FrtIndexReader *ir) {
 #define SpTQ(query) ((FrtSpanTermQuery *)(query))
 
 typedef struct SpanTermEnum {
-    FrtSpanEnum     super;
+    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) {
     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;
     }
@@ -330,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;
 
@@ -343,8 +342,8 @@ 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) {
@@ -362,14 +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) {
+        if (self->doc_num(self) == INT_MAX) {
             sprintf(pos_str, "END");
         } 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);
@@ -387,21 +386,21 @@ 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;
 }
@@ -414,23 +413,23 @@ static FrtSpanEnum *spante_new(FrtQuery *query, FrtIndexReader *ir) {
 #define TPE_READ_SIZE 16
 
 typedef struct TermPosEnumWrapper {
-    const char  *term;
+    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);
+    return (tpew1->doc_num < tpew2->doc_num)
+        || (tpew1->doc_num == tpew2->doc_num && tpew1->pos < tpew2->pos);
 }
 
 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;
@@ -440,7 +439,7 @@ 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 {
@@ -457,7 +456,7 @@ 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;
 }
@@ -465,16 +464,16 @@ static TermPosEnumWrapper *tpew_new(const char *term, FrtTermDocEnum *tpe) {
 #define SpMTQ(query) ((FrtSpanMultiTermQuery *)(query))
 
 typedef struct SpanMultiTermEnum {
-    FrtSpanEnum             super;
-    FrtPriorityQueue       *tpew_pq;
+    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;
+    int curr_doc_num, curr_pos;
     TermPosEnumWrapper *tpew;
     SpanMultiTermEnum *mte = SpMTEn(self);
     FrtPriorityQueue *tpew_pq = mte->tpew_pq;
@@ -495,7 +494,7 @@ 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 {
@@ -505,7 +504,7 @@ static bool spanmte_next(FrtSpanEnum *self) {
             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;
 }
 
@@ -524,11 +523,11 @@ 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 {
@@ -538,8 +537,8 @@ static bool spanmte_skip_to(FrtSpanEnum *self, int target) {
     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) {
@@ -577,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;
@@ -631,9 +630,9 @@ 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) {
@@ -668,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;
@@ -696,7 +695,7 @@ typedef struct SpanOrEnum {
 
 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) {
@@ -756,7 +755,7 @@ static bool spanoe_skip_to(FrtSpanEnum *self, int target) {
     } 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 {
@@ -770,9 +769,9 @@ 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) {
@@ -798,7 +797,7 @@ static char *spanoe_to_s(FrtSpanEnum *self) {
         if (soe->queue->size == 0) {
             sprintf(doc_str, "END");
         } else {
-            sprintf(doc_str, "%d:%d-%d", self->doc(self),
+            sprintf(doc_str, "%d:%d-%d", self->doc_num(self),
                     self->start(self), self->end(self));
         }
     }
@@ -841,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;
@@ -858,12 +857,12 @@ static FrtSpanEnum *spanoe_new(FrtQuery *query, FrtIndexReader *ir) {
 #define SpNQ(query) ((FrtSpanNearQuery *)(query))
 
 typedef struct SpanNearEnum {
-    FrtSpanEnum    super;
-    FrtSpanEnum  **span_enums;
+    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;
@@ -878,30 +877,30 @@ typedef struct SpanNearEnum {
 
 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) {
     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;
@@ -911,7 +910,7 @@ 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) {
@@ -936,16 +935,16 @@ 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;
         }
     }
@@ -955,14 +954,14 @@ 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);
 
@@ -971,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;
@@ -992,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;
         }
@@ -1000,7 +999,7 @@ 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 */
@@ -1012,7 +1011,7 @@ static bool sne_next_ordered_match(FrtSpanEnum *self) {
                 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;
@@ -1035,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;
         }
@@ -1067,8 +1066,8 @@ 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) {
@@ -1089,7 +1088,7 @@ 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),
+        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);
@@ -1112,8 +1111,8 @@ static void spanne_destroy(FrtSpanEnum *self) {
 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;
@@ -1127,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;
@@ -1169,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 */
         }
@@ -1193,24 +1192,24 @@ static bool spanxe_next(FrtSpanEnum *self) {
 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 */
     }
@@ -1218,9 +1217,9 @@ 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) {
@@ -1248,9 +1247,9 @@ static void spanxe_destroy(FrtSpanEnum *self) {
 }
 
 static FrtSpanEnum *spanxe_new(FrtQuery *query, FrtIndexReader *ir) {
-    FrtSpanEnum *self      = (FrtSpanEnum *)FRT_ALLOC(SpanNotEnum);
+    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);
@@ -1260,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;