ferret 0.9.4 → 0.9.5

data/ext/index_io.c

@@ -252,14 +252,23 @@ is_read_vint(InStream *is)
 }
 
 inline void
-is_read_chars(InStream *is, char* buffer, int off, int len)
+is_skip_vints(InStream *is, register int cnt)
 {
-	int end, i;
-
-	end = off + len;
+  for (; cnt > 0; cnt--) {
+    while ((is_read_byte(is) & 0x80) != 0) {
+    }
+  }
+}
 
-	for(i = off; i < end; i++) {
-		buffer[i] = is_read_byte(is);
+inline void
+is_read_chars(InStream *is, char* buffer, int off, int len)
+{
+  int end, i;
+  
+  end = off + len;
+  
+  for(i = off; i < end; i++) {
+	buffer[i] = is_read_byte(is);
   }
 }
 

data/ext/index_rw.c

@@ -186,6 +186,8 @@ void dw_invert_doc(DocumentWriter *self, Document *doc)
   TokenStream *stream;
   Token *token;
   FieldInfo *fi;
+  char text_buf[MAX_WORD_SIZE];
+  text_buf[MAX_WORD_SIZE - 1] = '\0';
 
   DocField **fields = doc->df_arr, *field;
   for (i = 0; i < dfcnt; i++) {
@@ -202,6 +204,10 @@ void dw_invert_doc(DocumentWriter *self, Document *doc)
       if (!field->is_tokenized) { /* un-tokenized field */
         text = field->data;
         slen = (int)strlen(text);
+        if (slen >= MAX_WORD_SIZE) {
+            slen = MAX_WORD_SIZE - 1;
+            text = strncpy(text_buf, text, MAX_WORD_SIZE - 1);
+        }
         if (fi->store_offset) {
           dw_add_position(self, field_name, text, position,
               tvoi_create(offset, offset+slen));

data/ext/nix_io.c

@@ -40,7 +40,7 @@ int fcount(char *path)
   if (!d) RAISE(IO_ERROR, strerror(errno));
 
   while ((de = readdir(d)) != NULL) {
-    if ((de->d_name[0] != '\0') && (de->d_name[0] != '.')) {
+    if (de->d_name[0] != '.') {
       cnt++;
     }
   }
@@ -57,8 +57,7 @@ void dir_each(char *path, void (*func)(char *fname, void *arg), void *arg)
   if (!d) RAISE(IO_ERROR, strerror(errno));
 
   while ((de = readdir(d)) != NULL) {
-    if ((de->d_name[0] != '\0') && (de->d_name[0] != '.')
-        && !file_is_lock(de->d_name)) {
+    if (de->d_name[0] != '.' && !file_is_lock(de->d_name)) {
       func(de->d_name, arg);
     }
   }
@@ -101,8 +100,7 @@ void fs_clear(Store *store)
   if (!d) RAISE(IO_ERROR, strerror(errno));
 
   while ((de = readdir(d)) != NULL) {
-    if ((de->d_name[0] != '\0') && (de->d_name[0] != '.')
-        && !file_is_lock(de->d_name)) {
+    if (de->d_name[0] != '.' && !file_is_lock(de->d_name)) {
       char buf[MAX_FILE_PATH];
       remove(join_path(buf, store->dir.path, de->d_name));
     }
@@ -124,7 +122,7 @@ void fs_clear_all(Store *store)
   if (!d) RAISE(IO_ERROR, strerror(errno));
 
   while ((de = readdir(d)) != NULL) {
-    if ((de->d_name[0] != '\0') && (de->d_name[0] != '.')) {
+    if (de->d_name[0] != '.') {
       char buf[MAX_FILE_PATH];
       remove(join_path(buf, store->dir.path, de->d_name));
     }

data/ext/q_boolean.c

@@ -731,12 +731,6 @@ void csc_init(Scorer *self, bool init_scorers)
   csc->first_time = false;
 }
 
-void csc_add_scorer(ConjunctionScorer *csc, Scorer *scorer)
-{
-  RECAPA(csc, ss_cnt, ss_capa, sub_scorers, Scorer *);
-  csc->sub_scorers[csc->ss_cnt++] = scorer;
-}
-
 float csc_score(Scorer *self)
 {
   ConjunctionScorer *csc = (ConjunctionScorer *)self->data;

data/ext/q_fuzzy.c

@@ -63,14 +63,15 @@ float fuzq_score(FuzzyQuery *fuzq, char *target)
   /* Let's make sure we have enough room in our array to do the distance
    * calculations. */
   if (((m+1) * (n+1)) >= fuzq->da_capa) {
-    fuzq->da_capa = (m * (fuzq->text_len+1)) * 2;
+    fuzq->da_capa = ((m+1) * (n+1)) * 2;
     REALLOC_N(fuzq->da, int, fuzq->da_capa);
+    printf("making capa %d -> %d\n", fuzq->da_capa, (int)fuzq->da);
     d = fuzq->da;
   }
 
   /* init matrix d */
-  for (i = 0; i <= n; i++) d[i + m * 0] = i;
-  for (j = 0; j <= m; j++) d[0 + m * j] = j;
+  for (i = 0; i <= n; i++) d[i + n * 0] = i;
+  for (j = 0; j <= m; j++) d[0 + n * j] = j;
   
   /* start computing edit distance */
   for (i = 1; i <= n; i++) {
@@ -78,11 +79,11 @@ float fuzq_score(FuzzyQuery *fuzq, char *target)
     char s_i = text[i - 1];
     for (j = 1; j <= m; j++) {
       if (s_i != target[j-1]) {
-        d[i + m*j] = min3(d[i-1 + m*j], d[i + m*(j-1)], d[i-1 + m*(j-1)])+1;
+        d[i + n*j] = min3(d[i-1 + n*j], d[i + n*(j-1)], d[i-1 + n*(j-1)])+1;
       } else {
-        d[i + m*j] = min3(d[i-1 + m*j]+1, d[i + m*(j-1)]+1, d[i-1 + m*(j-1)]);
+        d[i + n*j] = min3(d[i-1 + n*j]+1, d[i + n*(j-1)]+1, d[i-1 + n*(j-1)]);
       }
-      best_pos_ed_dist = min2(best_pos_ed_dist, d[i + m*j]);
+      best_pos_ed_dist = min2(best_pos_ed_dist, d[i + n*j]);
     }
     //printf("(bped = %d, i = %d, md = %d)", best_pos_ed_dist, i, max_distance);
 
@@ -104,7 +105,7 @@ float fuzq_score(FuzzyQuery *fuzq, char *target)
    * number of characters in the shorter word.  but this was the formula that
    * was previously used in FuzzyTermEnum, so it has not been changed (even
    * though min_sim must be greater than 0.0) */
-  return 1.0f - ((float)d[n + m*m] / (float) (fuzq->pre_len + min2(n, m)));
+  return 1.0f - ((float)d[n + n*m] / (float) (fuzq->pre_len + min2(n, m)));
 }
 
 /****************************************************************************
@@ -252,7 +253,9 @@ void fuzq_destroy(Query *self)
 {
   FuzzyQuery *fuzq = (FuzzyQuery *)self->data;
   if (self->destroy_all) term_destroy((Term *)fuzq->term);
+printf("freeing %d -> %d\n", fuzq->da_capa, (int)fuzq->da);
   free(fuzq->da);
+printf("success\n");
   free(fuzq);
   q_destroy_i(self);
 }

data/ext/q_multi_phrase.c

@@ -34,7 +34,7 @@ Scorer *mphw_scorer(Weight *self, IndexReader *ir)
       tps[i] = mtdpe_create(ir, mphq->terms[i], mphq->pt_cnt[i]);
     }
     if (tps[i] == NULL) {
-      // free everything we just created and return NULL
+      /* free everything we just created and return NULL */
       int j;
       for (j = 0; j < i; j++) {
         tps[i]->close(tps[i]);
@@ -44,7 +44,7 @@ Scorer *mphw_scorer(Weight *self, IndexReader *ir)
     }
   }
 
-  if (mphq->slop == 0) {       // optimize exact case
+  if (mphq->slop == 0) {       /* optimize exact case */
     phsc = exact_phrase_scorer_create(self, tps, mphq->positions, mphq->t_cnt,
                                       self->similarity,
                                       ir->get_norms(ir, mphq->field));

data/ext/q_term.c

@@ -212,12 +212,12 @@ bool tsc_next(Scorer *self)
 
   ts->pointer++;
   if (ts->pointer >= ts->pointer_max) {
-    // refill buffer
+    /* refill buffer */
     ts->pointer_max = ts->tde->read(ts->tde, ts->docs, ts->freqs, TDE_READ_SIZE);
     if (ts->pointer_max != 0) {
       ts->pointer = 0;
     } else {
-      ts->tde->close(ts->tde); // close stream
+      ts->tde->close(ts->tde); /* close stream */
       ts->tde = NULL;
       return false;
     }

data/ext/q_wildcard.c

@@ -77,16 +77,17 @@ Query *wcq_rewrite(Query *self, IndexReader *ir)
   Term *term = (Term *)self->data;
   char *text = term->text;
   char *field = term->field;
-  char *first_star = strrchr(text, WILD_STRING);
-  char *first_ques = strrchr(text, WILD_CHAR);
-  if (!first_star && !first_ques) {
+  char *first_star = strchr(text, WILD_STRING);
+  char *first_ques = strchr(text, WILD_CHAR);
+
+  if (first_star == NULL && first_ques == NULL) {
     q = tq_create(term_clone(term));
   } else {
     TermEnum *te;
     Term prefix_term;
     char *prefix = NULL;
 
-    char *pattern = (first_ques && first_star > first_ques)
+    char *pattern = (first_ques && (!first_star || (first_star > first_ques)))
       ? first_ques : first_star;
 
     int prefix_len = (int)(pattern - text);

data/ext/search.c

@@ -562,8 +562,7 @@ static void s_search_each_w(Searcher *self, Weight *weight, Filter *filter,
 static void s_search_each(Searcher *self, Query *query, Filter *filter,
     void (*fn)(Searcher *, int, float, void *), void *arg)
 {
-  Weight *weight;
-  weight = q_weight(query, self);
+  Weight *weight = q_weight(query, self);
   s_search_each_w(self, weight, filter, fn, arg);
   weight->destroy(weight);
 }
@@ -602,8 +601,9 @@ static Similarity *s_get_similarity(Searcher *self)
 
 static void s_close(Searcher *self)
 {
-  if (self->ir && self->close_ir)
+  if (self->ir && self->close_ir) {
     ir_close(self->ir);
+  }
   free(self);
 }
 
@@ -865,7 +865,6 @@ static void msea_search_each(Searcher *self, Query *query, Filter *filter,
 
 struct MultiSearchArg {
   int total_hits, max_size;
-  float min_score;
   PriorityQueue *hq;
   void (*hq_insert)(PriorityQueue *pq, Hit *hit);
 };
@@ -919,7 +918,6 @@ static TopDocs *msea_search(Searcher *self, Query *query, int first_doc,
   ms_arg.hq = hq;
   ms_arg.total_hits = 0;
   ms_arg.max_size = max_size;
-  ms_arg.min_score = 0.0;
   ms_arg.hq_insert = hq_insert;
 
   msea_search_each_w(self, weight, filter, msea_search_i, &ms_arg);

data/ext/search.h

@@ -10,7 +10,7 @@ typedef struct Scorer Scorer;
 #include "similarity.h"
 
 #define term_set_create() \
-  hs_create((hash_ft)&term_hash, (eq_ft)&term_eq, (free_ft)&term_destroy)
+    hs_create((hash_ft)&term_hash, (eq_ft)&term_eq, (free_ft)&term_destroy)
 
 /***************************************************************************
  *
@@ -19,12 +19,13 @@ typedef struct Scorer Scorer;
  ***************************************************************************/
 
 #define EXPLANATION_DETAILS_START_SIZE 4
-typedef struct Explanation {
-  float value;
-  char *description;
-  struct Explanation **details;
-  int dcnt;
-  int dcapa;
+typedef struct Explanation
+{
+    float value;
+    char *description;
+    struct Explanation **details;
+    int dcnt;
+    int dcapa;
 } Explanation;
 
 extern Explanation *expl_create(float value, char *description);
@@ -39,23 +40,25 @@ extern char *expl_to_html(Explanation *self);
  *
  ***************************************************************************/
 
-typedef struct Hit {
-  int doc;
-  float score;
+typedef struct Hit
+{
+    int doc;
+    float score;
 } Hit;
 
 extern bool hit_less_than(void *p1, void *p2);
- 
+
 /***************************************************************************
  *
  * TopDocs
  *
  ***************************************************************************/
 
-typedef struct TopDocs {
-  int total_hits;
-  int size;
-  Hit **hits;
+typedef struct TopDocs
+{
+    int total_hits;
+    int size;
+    Hit **hits;
 } TopDocs;
 
 extern TopDocs *td_create(int total_hits, int size, Hit **hits);
@@ -68,15 +71,16 @@ extern char *td_to_s(TopDocs *td);
  *
  ***************************************************************************/
 
-typedef struct Filter {
-  void *data;
-  char *name;
-  HshTable *cache;
-  BitVector *(*get_bv)(struct Filter *self, IndexReader *ir);
-  char      *(*to_s)(struct Filter *self);
-  uint       (*hash)(struct Filter *self);
-  int        (*eq)(struct Filter *self, struct Filter *o);
-  void       (*destroy)(struct Filter *self);
+typedef struct Filter
+{
+    void *data;
+    char *name;
+    HshTable *cache;
+    BitVector *(*get_bv)(struct Filter *self, IndexReader *ir);
+    char      *(*to_s)(struct Filter *self);
+    uint       (*hash)(struct Filter *self);
+    int        (*eq)(struct Filter *self, struct Filter *o);
+    void       (*destroy)(struct Filter *self);
 } Filter;
 
 extern Filter *filt_create(char *name);
@@ -93,7 +97,7 @@ extern int filt_eq(Filter *self, Filter *o);
  ***************************************************************************/
 
 extern Filter *rfilt_create(const char *field, char *lower_term,
-    char *upper_term, bool include_lower, bool include_upper);
+                            char *upper_term, bool include_lower, bool include_upper);
 
 /***************************************************************************
  *
@@ -101,8 +105,9 @@ extern Filter *rfilt_create(const char *field, char *lower_term,
  *
  ***************************************************************************/
 
-typedef struct QueryFilter {
-  Query *query;
+typedef struct QueryFilter
+{
+    Query *query;
 } QueryFilter;
 
 extern Filter *qfilt_create(Query *query);
@@ -113,22 +118,23 @@ extern Filter *qfilt_create(Query *query);
  *
  ***************************************************************************/
 
-struct Weight {
-  void *data;
-  float value;
-  float qweight;
-  float qnorm;
-  float idf;
-  Query *query;
-  Similarity  *similarity;
-  Query       *(*get_query)(Weight *self);
-  float        (*get_value)(Weight *self);
-  void         (*normalize)(Weight *self, float normalization_factor);
-  Scorer      *(*scorer)(Weight *self, IndexReader *ir);
-  Explanation *(*explain)(Weight *self, IndexReader *ir, int doc_num);
-  float        (*sum_of_squared_weights)(Weight *self);
-  char        *(*to_s)(Weight *self);
-  void         (*destroy)(Weight *self);
+struct Weight
+{
+    void *data;
+    float value;
+    float qweight;
+    float qnorm;
+    float idf;
+    Query *query;
+    Similarity  *similarity;
+    Query       *(*get_query)(Weight *self);
+    float        (*get_value)(Weight *self);
+    void         (*normalize)(Weight *self, float normalization_factor);
+    Scorer      *(*scorer)(Weight *self, IndexReader *ir);
+    Explanation *(*explain)(Weight *self, IndexReader *ir, int doc_num);
+    float        (*sum_of_squared_weights)(Weight *self);
+    char        *(*to_s)(Weight *self);
+    void         (*destroy)(Weight *self);
 };
 
 extern Weight *w_create(Query *query);
@@ -154,8 +160,8 @@ extern Weight *tw_create(Query *query, Searcher *searcher);
  ***************************************************************************/
 
 typedef struct BooleanWeight {
-  Weight **weights;
-  int w_cnt;
+    Weight **weights;
+    int w_cnt;
 } BooleanWeight;
 
 extern Weight *bw_create(Query *query, Searcher *searcher);
@@ -199,39 +205,40 @@ extern Weight *spanw_create(Query *query, Searcher *searcher);
  ***************************************************************************/
 
 enum QUERY_TYPE {
-  TERM_QUERY,
-  BOOLEAN_QUERY,
-  PHRASE_QUERY,
-  MULTI_PHRASE_QUERY,
-  CONSTANT_QUERY,
-  FILTERED_QUERY,
-  MATCH_ALL_QUERY,
-  RANGE_QUERY,
-  WILD_CARD_QUERY,
-  FUZZY_QUERY,
-  PREFIX_QUERY,
-  SPAN_TERM_QUERY,
-  SPAN_FIRST_QUERY,
-  SPAN_OR_QUERY,
-  SPAN_NOT_QUERY,
-  SPAN_NEAR_QUERY
+    TERM_QUERY,
+    BOOLEAN_QUERY,
+    PHRASE_QUERY,
+    MULTI_PHRASE_QUERY,
+    CONSTANT_QUERY,
+    FILTERED_QUERY,
+    MATCH_ALL_QUERY,
+    RANGE_QUERY,
+    WILD_CARD_QUERY,
+    FUZZY_QUERY,
+    PREFIX_QUERY,
+    SPAN_TERM_QUERY,
+    SPAN_FIRST_QUERY,
+    SPAN_OR_QUERY,
+    SPAN_NOT_QUERY,
+    SPAN_NEAR_QUERY
 };
 
-struct Query {
-  bool destroy_all : 1;
-  uchar type;
-  int ref_cnt;
-  void *data;
-  float boost;
-  Weight *weight;
-  Query      *(*rewrite)(Query *self, IndexReader *ir);
-  void        (*extract_terms)(Query *self, HashSet *terms);
-  Similarity *(*get_similarity)(Query *self, Searcher *searcher);
-  char       *(*to_s)(Query *self, char *field);
-  uint        (*hash)(Query *self);
-  int         (*eq)(Query *self, Query *o);
-  void        (*destroy_i)(Query *self);
-  Weight     *(*create_weight_i)(Query *self, Searcher *searcher);
+struct Query
+{
+    uchar type;
+    int ref_cnt;
+    void *data;
+    float boost;
+    Weight *weight;
+    Query      *(*rewrite)(Query *self, IndexReader *ir);
+    void        (*extract_terms)(Query *self, HashSet *terms);
+    Similarity *(*get_similarity)(Query *self, Searcher *searcher);
+    char       *(*to_s)(Query *self, char *field);
+    uint        (*hash)(Query *self);
+    int         (*eq)(Query *self, Query *o);
+    void        (*destroy_i)(Query *self);
+    Weight     *(*create_weight_i)(Query *self, Searcher *searcher);
+    bool destroy_all : 1;
 };
 
 /* Internal Query Functions */
@@ -253,8 +260,9 @@ extern int q_eq(Query *self, Query *o);
  *
  ***************************************************************************/
 
-typedef struct TermQuery {
-  Term *term;
+typedef struct TermQuery
+{
+    Term *term;
 } TermQuery;
 
 extern Query *tq_create(Term *term);
@@ -269,19 +277,20 @@ extern Query *tq_create(Term *term);
  * BooleanClause
  ***************************************************************************/
 
-enum BC_TYPE {
-  BC_SHOULD,
-  BC_MUST,
-  BC_MUST_NOT
+enum BC_TYPE
+{
+    BC_SHOULD,
+    BC_MUST,
+    BC_MUST_NOT
 };
 
 typedef struct BooleanClause {
-  int ref_cnt;
-  Query *query;
-  Query *rewritten;
-  unsigned int occur : 4;
-  bool is_prohibited : 1;
-  bool is_required : 1;
+    int ref_cnt;
+    Query *query;
+    Query *rewritten;
+    unsigned int occur : 4;
+    bool is_prohibited : 1;
+    bool is_required : 1;
 } BooleanClause;
 
 extern BooleanClause *bc_create(Query *query, unsigned int occur);
@@ -296,19 +305,20 @@ extern void bc_set_occur(BooleanClause *self, unsigned int occur);
 #define BOOLEAN_CLAUSES_START_CAPA 4
 #define QUERY_STRING_START_SIZE 64
 
-typedef struct BooleanQuery {
-  bool coord_disabled;
-  int max_clause_cnt;
-  int clause_cnt;
-  int clause_capa;
-  float original_boost;
-  BooleanClause **clauses;
-  Similarity *similarity;
+typedef struct BooleanQuery
+{
+    bool coord_disabled;
+    int max_clause_cnt;
+    int clause_cnt;
+    int clause_capa;
+    float original_boost;
+    BooleanClause **clauses;
+    Similarity *similarity;
 } BooleanQuery;
 
 extern Query *bq_create(bool coord_disabled);
 extern BooleanClause *bq_add_query(Query *self, Query *sub_query,
-    unsigned int occur);
+                                   unsigned int occur);
 extern BooleanClause *bq_add_clause(Query *self, BooleanClause *bc);
 
 /***************************************************************************
@@ -318,13 +328,14 @@ extern BooleanClause *bq_add_clause(Query *self, BooleanClause *bc);
  ***************************************************************************/
 
 #define PHQ_INIT_CAPA 4
-typedef struct PhraseQuery {
-  int slop;
-  Term **terms;
-  int *positions;
-  int t_cnt;
-  int t_capa;
-  char *field;
+typedef struct PhraseQuery
+{
+    int slop;
+    Term **terms;
+    int *positions;
+    int t_cnt;
+    int t_capa;
+    char *field;
 } PhraseQuery;
 
 extern Query *phq_create();
@@ -336,14 +347,15 @@ extern void phq_add_term(Query *self, Term *term, int pos_inc);
  *
  ***************************************************************************/
 
-typedef struct MultiPhraseQuery {
-  int slop;
-  Term ***terms;
-  int *positions;
-  int *pt_cnt;
-  int t_cnt;
-  int t_capa;
-  char *field;
+typedef struct MultiPhraseQuery
+{
+    int slop;
+    Term ***terms;
+    int *positions;
+    int *pt_cnt;
+    int t_cnt;
+    int t_capa;
+    char *field;
 } MultiPhraseQuery;
 
 extern Query *mphq_create();
@@ -379,16 +391,17 @@ extern bool wc_match(char *pattern, char *text);
 #define DEF_PRE_LEN 0
 #define TYPICAL_LONGEST_WORD 20
 
-typedef struct FuzzyQuery {
-  Term *term;
-  char *text; /* term text after prefix */
-  int text_len;
-  int pre_len;
-  float min_sim;
-  float scale_factor;
-  int max_distances[TYPICAL_LONGEST_WORD];
-  int *da;
-  int da_capa;
+typedef struct FuzzyQuery
+{
+    Term *term;
+    char *text; /* term text after prefix */
+    int text_len;
+    int pre_len;
+    float min_sim;
+    float scale_factor;
+    int max_distances[TYPICAL_LONGEST_WORD];
+    int *da;
+    int da_capa;
 } FuzzyQuery;
 
 extern Query *fuzq_create(Term *term);
@@ -408,6 +421,12 @@ extern Query *csq_create(Filter *filter);
  *
  ***************************************************************************/
 
+typedef struct FilteredQuery
+{
+    Query *query;
+    Filter *filter;
+} FilteredQuery;
+
 extern Query *fq_create(Query *query, Filter *filter);
 
 /***************************************************************************
@@ -424,31 +443,21 @@ extern Query *maq_create();
  *
  ***************************************************************************/
 
-typedef struct Range {
-  char *field;
-  char *lower_term;
-  char *upper_term;
-  bool include_lower : 1;
-  bool include_upper : 1;
+typedef struct Range
+{
+    char *field;
+    char *lower_term;
+    char *upper_term;
+    bool include_lower : 1;
+    bool include_upper : 1;
 } Range;
 
 extern Query *rq_create(const char *field, char *lower_term,
-    char *upper_term, bool include_lower, bool include_upper);
+                        char *upper_term, bool include_lower, bool include_upper);
 extern Query *rq_create_less(const char *field, char *upper_term,
-    bool include_upper);
+                             bool include_upper);
 extern Query *rq_create_more(const char *field, char *lower_term,
-    bool include_lower);
-
-/***************************************************************************
- *
- * FilteredQuery
- *
- ***************************************************************************/
-
-typedef struct FilteredQuery {
-  Query *query;
-  Filter *filter;
-} FilteredQuery;
+                             bool include_lower);
 
 /***************************************************************************
  *
@@ -461,16 +470,17 @@ typedef struct FilteredQuery {
  ***************************************************************************/
 
 typedef struct SpanEnum SpanEnum;
-struct SpanEnum {
-  void *data;
-  Query *query;
-  bool (*next)(SpanEnum *self);
-  bool (*skip_to)(SpanEnum *self, int target_doc);
-  int  (*doc)(SpanEnum *self);
-  int  (*start)(SpanEnum *self);
-  int  (*end)(SpanEnum *self);
-  char *(*to_s)(SpanEnum *self);
-  void (*destroy)(SpanEnum *self);
+struct SpanEnum
+{
+    void *data;
+    Query *query;
+    bool (*next)(SpanEnum *self);
+    bool (*skip_to)(SpanEnum *self, int target_doc);
+    int  (*doc)(SpanEnum *self);
+    int  (*start)(SpanEnum *self);
+    int  (*end)(SpanEnum *self);
+    char *(*to_s)(SpanEnum *self);
+    void (*destroy)(SpanEnum *self);
 };
 
 /***************************************************************************
@@ -478,12 +488,13 @@ struct SpanEnum {
  ***************************************************************************/
 
 typedef struct SpanTermEnum SpanTermEnum;
-struct SpanTermEnum {
-  TermDocEnum *positions;
-  int position;
-  int doc;
-  int count;
-  int freq;
+struct SpanTermEnum
+{
+    TermDocEnum *positions;
+    int position;
+    int doc;
+    int count;
+    int freq;
 };
 
 extern SpanEnum *spante_create(Query *query, IndexReader *ir);
@@ -498,11 +509,12 @@ extern SpanEnum *spanfe_create(Query *query, IndexReader *ir);
  * SpanOrEnum
  ***************************************************************************/
 
-typedef struct SpanOrEnum {
-  PriorityQueue *queue;
-  SpanEnum **span_enums;
-  int s_cnt;
-  bool first_time;
+typedef struct SpanOrEnum
+{
+    PriorityQueue *queue;
+    SpanEnum **span_enums;
+    int s_cnt;
+    bool first_time;
 } SpanOrEnum;
 
 extern SpanEnum *spanoe_create(Query *query, IndexReader *ir);
@@ -511,11 +523,12 @@ extern SpanEnum *spanoe_create(Query *query, IndexReader *ir);
  * SpanEnumCell
  ***************************************************************************/
 
-typedef struct SpanEnumCell {
-  SpanEnum *parent;
-  SpanEnum *se;
-  int index;
-  int length;
+typedef struct SpanEnumCell
+{
+    SpanEnum *parent;
+    SpanEnum *se;
+    int index;
+    int length;
 } SpanEnumCell;
 
 extern SpanEnum *spanec_create(Query *parent, Query *child, int index);
@@ -524,16 +537,17 @@ extern SpanEnum *spanec_create(Query *parent, Query *child, int index);
  * SpanNearEnum
  ***************************************************************************/
 
-typedef struct SpanNearEnum {
-  SpanEnum **span_enums;
-  int s_cnt;
-  int slop;
-  int current;
-  bool first_time : 1;
-  bool in_order : 1;
-  int doc;
-  int start;
-  int end;
+typedef struct SpanNearEnum
+{
+    SpanEnum **span_enums;
+    int s_cnt;
+    int slop;
+    int current;
+    bool first_time : 1;
+    bool in_order : 1;
+    int doc;
+    int start;
+    int end;
 } SpanNearEnum;
 
 extern SpanEnum *spanne_create(Query *query, IndexReader *ir);
@@ -542,11 +556,12 @@ extern SpanEnum *spanne_create(Query *query, IndexReader *ir);
  * SpanNotEnum
  ***************************************************************************/
 
-typedef struct SpanNotEnum {
-  SpanEnum *inc;
-  SpanEnum *exc;
-  bool more_inc : 1;
-  bool more_exc : 1;
+typedef struct SpanNotEnum
+{
+    SpanEnum *inc;
+    SpanEnum *exc;
+    bool more_inc : 1;
+    bool more_exc : 1;
 } SpanNotEnum;
 
 extern SpanEnum *spanxe_create(Query *query, IndexReader *ir);
@@ -556,11 +571,12 @@ extern SpanEnum *spanxe_create(Query *query, IndexReader *ir);
  ***************************************************************************/
 
 typedef struct SpanQuery SpanQuery;
-struct SpanQuery {
-  void *data;
-  char *field;
-  SpanEnum *(*get_spans)(Query *self, IndexReader *ir);
-  HashSet  *(*get_terms)(Query *self);
+struct SpanQuery
+{
+    void *data;
+    char *field;
+    SpanEnum *(*get_spans)(Query *self, IndexReader *ir);
+    HashSet  *(*get_terms)(Query *self);
 };
 
 /***************************************************************************
@@ -573,9 +589,10 @@ extern Query *spantq_create(Term *term);
  * SpanFirstQuery
  ***************************************************************************/
 
-typedef struct SpanFirstQuery {
-  int end;
-  Query *match;
+typedef struct SpanFirstQuery
+{
+    int end;
+    Query *match;
 } SpanFirstQuery;
 
 extern Query *spanfq_create(Query *match, int end);
@@ -584,9 +601,10 @@ extern Query *spanfq_create(Query *match, int end);
  * SpanOrQuery
  ***************************************************************************/
 
-typedef struct SpanOrQuery {
-  Query **clauses;
-  int c_cnt;
+typedef struct SpanOrQuery
+{
+    Query **clauses;
+    int c_cnt;
 } SpanOrQuery;
 
 extern Query *spanoq_create(Query **clauses, int c_cnt);
@@ -595,24 +613,26 @@ extern Query *spanoq_create(Query **clauses, int c_cnt);
  * SpanNearQuery
  ***************************************************************************/
 
-typedef struct SpanNearQuery {
-  Query **clauses;
-  int c_cnt;
-  int slop;
-  bool in_order;
+typedef struct SpanNearQuery
+{
+    Query **clauses;
+    int c_cnt;
+    int slop;
+    bool in_order;
 } SpanNearQuery;
 
 extern Query *spannq_create(Query **clauses, int c_cnt, int slop,
-    bool in_order);
+                            bool in_order);
 
 
 /***************************************************************************
  * SpanNotQuery
  ***************************************************************************/
 
-typedef struct SpanNotQuery {
-  Query *inc;
-  Query *exc;
+typedef struct SpanNotQuery
+{
+    Query *inc;
+    Query *exc;
 } SpanNotQuery;
 
 extern Query *spanxq_create(Query *inc, Query *exc);
@@ -625,15 +645,16 @@ extern Query *spanxq_create(Query *inc, Query *exc);
 
 #define SCORER_NULLIFY(mscorer) mscorer->destroy(mscorer); mscorer = NULL
 
-struct Scorer {
-  void *data;
-  Similarity  *similarity;
-  int         doc;
-  float        (*score)(Scorer *self);
-  bool         (*next)(Scorer *self);
-  bool         (*skip_to)(Scorer *self, int doc_num);
-  Explanation *(*explain)(Scorer *self, int doc_num);
-  void         (*destroy)(Scorer *self);
+struct Scorer
+{
+    void *data;
+    Similarity  *similarity;
+    int         doc;
+    float        (*score)(Scorer *self);
+    bool         (*next)(Scorer *self);
+    bool         (*skip_to)(Scorer *self, int doc_num);
+    Explanation *(*explain)(Scorer *self, int doc_num);
+    void         (*destroy)(Scorer *self);
 };
 
 /* Internal Scorer Function */
@@ -653,16 +674,17 @@ extern int scorer_doc_cmp(const void *p1, const void *p2);
 #define SCORE_CACHE_SIZE 32
 #define TDE_READ_SIZE 32
 
-typedef struct TermScorer {
-  int docs[TDE_READ_SIZE];
-  int freqs[TDE_READ_SIZE];
-  int pointer;
-  int pointer_max;
-  float score_cache[SCORE_CACHE_SIZE];
-  Weight *weight;
-  TermDocEnum *tde;
-  uchar *norms;
-  float weight_value;
+typedef struct TermScorer
+{
+    int docs[TDE_READ_SIZE];
+    int freqs[TDE_READ_SIZE];
+    int pointer;
+    int pointer_max;
+    float score_cache[SCORE_CACHE_SIZE];
+    Weight *weight;
+    TermDocEnum *tde;
+    uchar *norms;
+    float weight_value;
 } TermScorer;
 
 extern Scorer *tsc_create(Weight *weight, TermDocEnum *tde, uchar *norms);
@@ -677,89 +699,96 @@ extern Scorer *tsc_create(Weight *weight, TermDocEnum *tde, uchar *norms);
  * Coordinator
  ***************************************************************************/
 
-typedef struct Coordinator {
-  int max_coord;
-  float *coord_factors;
-  Similarity *similarity;
-  int num_matches;
+typedef struct Coordinator
+{
+    int max_coord;
+    float *coord_factors;
+    Similarity *similarity;
+    int num_matches;
 } Coordinator;
 
 /***************************************************************************
  * DisjunctionSumScorer
  ***************************************************************************/
 
-typedef struct DisjunctionSumScorer{
-  float cum_score;
-  int num_matches;
-  int min_num_matches;
-  Scorer **sub_scorers;
-  int ss_cnt;
-  PriorityQueue *scorer_queue;
-  Coordinator *coordinator;
+typedef struct DisjunctionSumScorer
+{
+    float cum_score;
+    int num_matches;
+    int min_num_matches;
+    Scorer **sub_scorers;
+    int ss_cnt;
+    PriorityQueue *scorer_queue;
+    Coordinator *coordinator;
 } DisjunctionSumScorer;
 
 /***************************************************************************
  * ConjunctionScorer
  ***************************************************************************/
 
-typedef struct ConjunctionScorer{
-  bool first_time : 1;
-  bool more : 1;
-  float coord;
-  int ss_cnt;
-  int ss_capa;
-  Scorer **sub_scorers;
-  int first;
-  int last;
-  Coordinator *coordinator;
-  int last_scored_doc;
+typedef struct ConjunctionScorer
+{
+    bool first_time : 1;
+    bool more : 1;
+    float coord;
+    int ss_cnt;
+    int ss_capa;
+    Scorer **sub_scorers;
+    int first;
+    int last;
+    Coordinator *coordinator;
+    int last_scored_doc;
 } ConjunctionScorer;
 
 /***************************************************************************
  * SingleMatchScorer
  ***************************************************************************/
 
-typedef struct SingleMatchScorer {
-  Coordinator *coordinator;
-  Scorer *scorer;
+typedef struct SingleMatchScorer
+{
+    Coordinator *coordinator;
+    Scorer *scorer;
 } SingleMatchScorer;
 
 /***************************************************************************
  * ReqOptSumScorer
  ***************************************************************************/
 
-typedef struct ReqOptSumScorer {
-  Scorer *req_scorer;
-  Scorer *opt_scorer;
-  bool first_time_opt;
+typedef struct ReqOptSumScorer
+{
+    Scorer *req_scorer;
+    Scorer *opt_scorer;
+    bool first_time_opt;
 } ReqOptSumScorer;
 
 /***************************************************************************
  * ReqExclScorer
  ***************************************************************************/
 
-typedef struct ReqExclScorer {
-  Scorer *req_scorer;
-  Scorer *excl_scorer;
-  bool first_time;
+typedef struct ReqExclScorer
+{
+    Scorer *req_scorer;
+    Scorer *excl_scorer;
+    bool first_time;
 } ReqExclScorer;
 
 /***************************************************************************
  * BooleanScorer
  ***************************************************************************/
 
-typedef struct BooleanScorer {
-  Scorer **required_scorers;
-  int rs_cnt;
-  int rs_capa;
-  Scorer **optional_scorers;
-  int os_cnt;
-  int os_capa;
-  Scorer **prohibited_scorers;
-  int ps_cnt;
-  int ps_capa;
-  Scorer *counting_sum_scorer;
-  Coordinator *coordinator;
+typedef struct BooleanScorer
+{
+    Scorer **required_scorers;
+    int rs_cnt;
+    int rs_capa;
+    Scorer **optional_scorers;
+    int os_cnt;
+    int os_capa;
+    Scorer **prohibited_scorers;
+    int ps_cnt;
+    int ps_capa;
+    Scorer *counting_sum_scorer;
+    Coordinator *coordinator;
 } BooleanScorer;
 
 extern Scorer *bsc_create(Similarity *similarity);
@@ -774,12 +803,13 @@ extern void bsc_add_scorer(Scorer *self, Scorer *scorer, unsigned int occur);
 /***************************************************************************
  * PhrasePosition
  ***************************************************************************/
-typedef struct PhrasePosition {
-  TermDocEnum *tpe;
-  int offset;
-  int count;
-  int doc;
-  int position;
+typedef struct PhrasePosition
+{
+    TermDocEnum *tpe;
+    int offset;
+    int count;
+    int doc;
+    int position;
 } PhrasePosition;
 
 extern PhrasePosition *pp_create(TermDocEnum *tpe, int offset);
@@ -788,39 +818,40 @@ extern PhrasePosition *pp_create(TermDocEnum *tpe, int offset);
  * PhraseScorer
  ***************************************************************************/
 
-typedef struct PhraseScorer {
-  float freq;
-  uchar *norms;
-  float value;
-  Weight *weight;
-  bool first_time : 1;
-  bool more : 1;
-  int pp_first;
-  int pp_last;
-  int pp_cnt;
-  PhrasePosition **phrase_pos;
-  float (*phrase_freq)(Scorer *self);
-  int slop;
+typedef struct PhraseScorer
+{
+    float freq;
+    uchar *norms;
+    float value;
+    Weight *weight;
+    bool first_time : 1;
+    bool more : 1;
+    int pp_first;
+    int pp_last;
+    int pp_cnt;
+    PhrasePosition **phrase_pos;
+    float (*phrase_freq)(Scorer *self);
+    int slop;
 } PhraseScorer;
 
 extern Scorer *phsc_create(Weight *weight, TermDocEnum **term_pos_enum,
-    int *positions, int t_cnt, Similarity *similarity, uchar *norms);
+                           int *positions, int t_cnt, Similarity *similarity, uchar *norms);
 
 /***************************************************************************
  * ExactPhraseScorer
  ***************************************************************************/
 
 extern Scorer *exact_phrase_scorer_create(Weight *weight,
-    TermDocEnum **term_pos_enum, int *positions, int t_cnt,
-    Similarity *similarity, uchar *norms);
+                                          TermDocEnum **term_pos_enum, int *positions, int t_cnt,
+                                          Similarity *similarity, uchar *norms);
 
 /***************************************************************************
  * SloppyPhraseScorer
  ***************************************************************************/
 
 extern Scorer *sloppy_phrase_scorer_create(Weight *weight,
-    TermDocEnum **term_pos_enum, int *positions, int t_cnt,
-    Similarity *similarity, int slop, uchar *norms);
+                                           TermDocEnum **term_pos_enum, int *positions, int t_cnt,
+                                           Similarity *similarity, int slop, uchar *norms);
 
 /***************************************************************************
  *
@@ -828,9 +859,10 @@ extern Scorer *sloppy_phrase_scorer_create(Weight *weight,
  *
  ***************************************************************************/
 
-typedef struct ConstantScoreScorer {
-  BitVector *bv;
-  float score;
+typedef struct ConstantScoreScorer
+{
+    BitVector *bv;
+    float score;
 } ConstantScoreScorer;
 
 extern Scorer *cssc_create(Weight *weight, IndexReader *ir);
@@ -842,10 +874,11 @@ extern Scorer *cssc_create(Weight *weight, IndexReader *ir);
  *
  ***************************************************************************/
 
-typedef struct MatchAllScorer {
-  IndexReader *ir;
-  int max_doc;
-  float score;
+typedef struct MatchAllScorer
+{
+    IndexReader *ir;
+    int max_doc;
+    float score;
 } MatchAllScorer;
 
 extern Scorer *masc_create(Weight *weight, IndexReader *ir);
@@ -857,16 +890,17 @@ extern Scorer *masc_create(Weight *weight, IndexReader *ir);
  *
  ***************************************************************************/
 
-typedef struct SpanScorer {
-  bool first_time : 1;
-  bool more : 1;
-  IndexReader *ir;
-  SpanEnum *spans;
-  Similarity *sim;
-  uchar *norms;
-  Weight *weight;
-  float value;
-  float freq;
+typedef struct SpanScorer
+{
+    bool first_time : 1;
+    bool more : 1;
+    IndexReader *ir;
+    SpanEnum *spans;
+    Similarity *sim;
+    uchar *norms;
+    Weight *weight;
+    float value;
+    float freq;
 } SpanScorer;
 
 extern Scorer *spansc_create(Weight *weight, IndexReader *ir);
@@ -878,28 +912,29 @@ extern Scorer *spansc_create(Weight *weight, IndexReader *ir);
  ***************************************************************************/
 
 enum SORT_TYPE {
-  SORT_TYPE_SCORE,
-  SORT_TYPE_DOC,
-  SORT_TYPE_INTEGER,
-  SORT_TYPE_FLOAT,
-  SORT_TYPE_STRING,
-  SORT_TYPE_AUTO
+    SORT_TYPE_SCORE,
+    SORT_TYPE_DOC,
+    SORT_TYPE_INTEGER,
+    SORT_TYPE_FLOAT,
+    SORT_TYPE_STRING,
+    SORT_TYPE_AUTO
 };
 
 /***************************************************************************
  * SortField
  ***************************************************************************/
 
-typedef struct SortField {
-  mutex_t mutex;
-  char *field;
-  int   type;
-  bool  reverse : 1;
-  void *index;
-  int   (*compare)(void *index_ptr, Hit *hit1, Hit *hit2);
-  void *(*create_index)(int size);
-  void  (*destroy_index)(void *p);
-  void  (*handle_term)(void *index, TermDocEnum *tde, char *text);
+typedef struct SortField
+{
+    mutex_t mutex;
+    char *field;
+    int   type;
+    bool  reverse : 1;
+    void *index;
+    int   (*compare)(void *index_ptr, Hit *hit1, Hit *hit2);
+    void *(*create_index)(int size);
+    void  (*destroy_index)(void *p);
+    void  (*handle_term)(void *index, TermDocEnum *tde, char *text);
 } SortField;
 
 extern SortField *sort_field_create(char *field, int type, bool reverse);
@@ -921,11 +956,12 @@ extern SortField SORT_FIELD_DOC_REV;
  * Sort
  ***************************************************************************/
 
-typedef struct Sort {
-  SortField **sort_fields;
-  int sf_cnt;
-  int sf_capa;
-  bool destroy_all : 1;
+typedef struct Sort
+{
+    SortField **sort_fields;
+    int sf_cnt;
+    int sf_capa;
+    bool destroy_all : 1;
 } Sort;
 
 extern Sort *sort_create();
@@ -951,27 +987,27 @@ extern PriorityQueue *fshq_pq_create(int size, Sort *sort, IndexReader *ir);
  ***************************************************************************/
 
 struct Searcher {
-  void        *data;
-  IndexReader *ir;
-  Similarity  *similarity;
-  bool         close_ir : 1;
-  int          (*doc_freq)(Searcher *self, Term *term);
-  int         *(*doc_freqs)(Searcher *self, Term **terms, int tcnt);
-  Document    *(*get_doc)(Searcher *self, int doc_num);
-  int          (*max_doc)(Searcher *self);
-  Weight      *(*create_weight)(Searcher *self, Query *query);
-  TopDocs     *(*search)(Searcher *self, Query *query, int first_doc,
-                int num_docs, Filter *filter, Sort *sort);
-  void         (*search_each)(Searcher *self, Query *query, Filter *filter,
-                void (*fn)(Searcher *, int, float, void *), void *arg);
-  void         (*search_each_w)(Searcher *self, Weight *weight,
-                Filter *filter, void (*fn)(Searcher *, int, float, void *),
-                void *arg);
-  Query       *(*rewrite)(Searcher *self, Query *original);
-  Explanation *(*explain)(Searcher *self, Query *query, int doc_num);
-  Explanation *(*explain_w)(Searcher *self, Weight *weight, int doc_num);
-  Similarity  *(*get_similarity)(Searcher *self);
-  void         (*close)(Searcher *self);
+    void        *data;
+    IndexReader *ir;
+    Similarity  *similarity;
+    bool         close_ir : 1;
+    int          (*doc_freq)(Searcher *self, Term *term);
+    int         *(*doc_freqs)(Searcher *self, Term **terms, int tcnt);
+    Document    *(*get_doc)(Searcher *self, int doc_num);
+    int          (*max_doc)(Searcher *self);
+    Weight      *(*create_weight)(Searcher *self, Query *query);
+    TopDocs     *(*search)(Searcher *self, Query *query, int first_doc,
+                           int num_docs, Filter *filter, Sort *sort);
+    void         (*search_each)(Searcher *self, Query *query, Filter *filter,
+                                void (*fn)(Searcher *, int, float, void *), void *arg);
+    void         (*search_each_w)(Searcher *self, Weight *weight,
+                                  Filter *filter, void (*fn)(Searcher *, int, float, void *),
+                                  void *arg);
+    Query       *(*rewrite)(Searcher *self, Query *original);
+    Explanation *(*explain)(Searcher *self, Query *query, int doc_num);
+    Explanation *(*explain_w)(Searcher *self, Weight *weight, int doc_num);
+    Similarity  *(*get_similarity)(Searcher *self);
+    void         (*close)(Searcher *self);
 };
 
 #define sea_doc_freq(s, t)  s->doc_freq(s, t)
@@ -979,11 +1015,11 @@ struct Searcher {
 #define sea_get_doc(s, dn)  s->get_doc(s, dn)
 #define sea_max_doc(s)  s->max_doc(s)
 #define sea_search(s, q, fd, nd, filt, sort)\
-  s->search(s, q, fd, nd, filt, sort)
+    s->search(s, q, fd, nd, filt, sort)
 #define sea_search_each(s, q, filt, fn, arg)\
-  s->search_each(s, q, filt, fn, arg)
+    s->search_each(s, q, filt, fn, arg)
 #define sea_search_each_w(s, q, filt, fn, arg)\
-  s->search_each_w(s, q, filt, fn, arg)
+    s->search_each_w(s, q, filt, fn, arg)
 #define sea_rewrite(s, q)  s->rewrite(s, q)
 #define sea_explain(s, q, dn)  s->explain(s, q, dn)
 #define sea_explain_w(s, q, dn)  s->explain_w(s, q, dn)
@@ -998,16 +1034,17 @@ extern Searcher *sea_create(IndexReader *ir);
  *
  ***************************************************************************/
 
-typedef struct MultiSearcher {
-  int s_cnt;
-  Searcher **searchers;
-  int *starts;
-  int max_doc;
-  bool close_subs : 1;
+typedef struct MultiSearcher
+{
+    int s_cnt;
+    Searcher **searchers;
+    int *starts;
+    int max_doc;
+    bool close_subs : 1;
 } MultiSearcher;
 
 extern Searcher *msea_create(Searcher **searchers, int s_cnt,
-    bool close_subs);
+                             bool close_subs);
 
 /***************************************************************************
  *
@@ -1017,29 +1054,30 @@ extern Searcher *msea_create(Searcher **searchers, int s_cnt,
 
 #define CONC_WORDS 2
 
-typedef struct QParser {
-  mutex_t mutex;
-  bool or_default : 1;
-  bool wild_lower : 1;
-  bool clean_str : 1;
-  bool handle_parse_errors : 1;
-  bool allow_any_fields : 1;
-  bool close_def_fields : 1;
-  int def_slop;
-  char *qstr;
-  char *qstrp;
-  char buf[CONC_WORDS][MAX_WORD_SIZE];
-  int  buf_index;
-  HashSet *fields;
-  HashSet *fields_buf;
-  HashSet *def_fields;
-  HashSet *all_fields;
-  Analyzer *analyzer;
-  Query *result;
+typedef struct QParser
+{
+    mutex_t mutex;
+    bool or_default : 1;
+    bool wild_lower : 1;
+    bool clean_str : 1;
+    bool handle_parse_errors : 1;
+    bool allow_any_fields : 1;
+    bool close_def_fields : 1;
+    int def_slop;
+    char *qstr;
+    char *qstrp;
+    char buf[CONC_WORDS][MAX_WORD_SIZE];
+    int  buf_index;
+    HashSet *fields;
+    HashSet *fields_buf;
+    HashSet *def_fields;
+    HashSet *all_fields;
+    Analyzer *analyzer;
+    Query *result;
 } QParser;
 
 extern QParser *qp_create(HashSet *all_fields, HashSet *def_fields,
-    Analyzer *analyzer);
+                          Analyzer *analyzer);
 extern void qp_destroy(QParser *self);
 extern Query *qp_parse(QParser *self, char *qstr);
 extern char *qp_clean_str(char *str);
@@ -1050,26 +1088,27 @@ extern char *qp_clean_str(char *str);
  *
  ***************************************************************************/
 
-typedef struct Index {
-  mutex_t mutex;
-  Store *store;
-  Analyzer *analyzer;
-  IndexReader *ir;
-  IndexWriter *iw;
-  Searcher *sea;
-  QParser *qp;
-  HashSet *key;
-  char *id_field;
-  char *def_field;
-  /* for IndexWriter */
-  bool use_compound_file : 1;
-  bool auto_flush : 1;
-  bool has_writes : 1;
-  bool check_latest : 1;
+typedef struct Index
+{
+    mutex_t mutex;
+    Store *store;
+    Analyzer *analyzer;
+    IndexReader *ir;
+    IndexWriter *iw;
+    Searcher *sea;
+    QParser *qp;
+    HashSet *key;
+    char *id_field;
+    char *def_field;
+    /* for IndexWriter */
+    bool use_compound_file : 1;
+    bool auto_flush : 1;
+    bool has_writes : 1;
+    bool check_latest : 1;
 } Index;
 
 extern Index *index_create(Store *store, Analyzer *analyzer,
-    HashSet *def_fields, bool create);
+                           HashSet *def_fields, bool create);
 extern void index_destroy(Index *self);
 extern void index_flush(Index *self);
 extern int index_size(Index *self);
@@ -1081,7 +1120,7 @@ extern void index_add_doc_a(Index *self, Document *doc, Analyzer *analyzer);
 extern void index_add_string(Index *self, char *str, Analyzer *analyzer);
 extern void index_add_array(Index *self, Array *ary, Analyzer *analyzer);
 extern TopDocs *index_search_str(Index *self, char *query, int first_doc,
-    int num_docs, Filter *filter, Sort *sort);
+                                 int num_docs, Filter *filter, Sort *sort);
 extern Query *index_get_query(Index *self, char *qstr);
 extern Document *index_get_doc(Index *self, int doc_num);
 extern Document *index_get_doc_ts(Index *self, int doc_num);