ferret 0.9.1 → 0.9.2

data/ext/search.h

@@ -9,6 +9,9 @@ typedef struct Scorer Scorer;
 #include "bitvector.h"
 #include "similarity.h"
 
+#define term_set_create() \
+  hs_create((hash_ft)&term_hash, (eq_ft)&term_eq, (free_ft)&term_destroy)
+
 /***************************************************************************
  *
  * Explanation
@@ -24,11 +27,11 @@ typedef struct Explanation {
   int dcapa;
 } Explanation;
 
-Explanation *expl_create(float value, char *description);
-void expl_destoy(void *p);
-Explanation *expl_add_detail(Explanation *self, Explanation *detail);
-char *expl_to_s(Explanation *self, int depth);
-char *expl_to_html(Explanation *self);
+extern Explanation *expl_create(float value, char *description);
+extern void expl_destoy(void *p);
+extern Explanation *expl_add_detail(Explanation *self, Explanation *detail);
+extern char *expl_to_s(Explanation *self, int depth);
+extern char *expl_to_html(Explanation *self);
 
 /***************************************************************************
  *
@@ -41,7 +44,7 @@ typedef struct Hit {
   float score;
 } Hit;
 
-bool hit_less_than(void *p1, void *p2);
+extern bool hit_less_than(void *p1, void *p2);
  
 /***************************************************************************
  *
@@ -55,9 +58,9 @@ typedef struct TopDocs {
   Hit **hits;
 } TopDocs;
 
-TopDocs *td_create(int total_hits, int size, Hit **hits);
-void td_destroy(void *p);
-char *td_to_s(TopDocs *td);
+extern TopDocs *td_create(int total_hits, int size, Hit **hits);
+extern void td_destroy(TopDocs *td);
+extern char *td_to_s(TopDocs *td);
 
 /***************************************************************************
  *
@@ -71,13 +74,17 @@ typedef struct Filter {
   HshTable *cache;
   BitVector *(*get_bv)(struct Filter *self, IndexReader *ir);
   char      *(*to_s)(struct Filter *self);
-  void       (*destroy)(void *p);
+  uint       (*hash)(struct Filter *self);
+  int        (*eq)(struct Filter *self, struct Filter *o);
+  void       (*destroy)(struct Filter *self);
 } Filter;
 
-Filter *filt_create(char *name);
-char *filt_to_s(Filter *self);
-BitVector *filt_get_bv(Filter *self, IndexReader *ir);
-void filt_destroy(void *p);
+extern Filter *filt_create(char *name);
+extern char *filt_to_s_i(Filter *self);
+extern BitVector *filt_get_bv(Filter *self, IndexReader *ir);
+extern void filt_destroy(Filter *self);
+extern uint filt_hash(Filter *self);
+extern int filt_eq(Filter *self, Filter *o);
 
 /***************************************************************************
  *
@@ -85,9 +92,8 @@ void filt_destroy(void *p);
  *
  ***************************************************************************/
 
-Filter *rfilt_create(const char *field, char *lower_term, char *upper_term,
-    bool include_lower, bool include_upper);
-void rfilt_destroy(void *p);
+extern Filter *rfilt_create(const char *field, char *lower_term,
+    char *upper_term, bool include_lower, bool include_upper);
 
 /***************************************************************************
  *
@@ -99,8 +105,7 @@ typedef struct QueryFilter {
   Query *query;
 } QueryFilter;
 
-Filter *qfilt_create(Query *query);
-
+extern Filter *qfilt_create(Query *query);
 
 /***************************************************************************
  *
@@ -123,13 +128,16 @@ struct Weight {
   Explanation *(*explain)(Weight *self, IndexReader *ir, int doc_num);
   float        (*sum_of_squared_weights)(Weight *self);
   char        *(*to_s)(Weight *self);
-  void         (*destroy)(void *p);
+  void         (*destroy)(Weight *self);
 };
 
-Query *w_get_query(Weight *self);
-float w_get_value(Weight *self);
-float w_sum_of_squared_weights(Weight *self);
-void w_normalize(Weight *self, float normalization_factor);
+extern Weight *w_create(Query *query);
+extern void w_destroy(Weight *self);
+
+extern Query *w_get_query(Weight *self);
+extern float w_get_value(Weight *self);
+extern float w_sum_of_squared_weights(Weight *self);
+extern void w_normalize(Weight *self, float normalization_factor);
 
 /***************************************************************************
  *
@@ -137,7 +145,7 @@ void w_normalize(Weight *self, float normalization_factor);
  *
  ***************************************************************************/
 
-Weight *tw_create(Query *query, Searcher *searcher);
+extern Weight *tw_create(Query *query, Searcher *searcher);
 
 /***************************************************************************
  *
@@ -149,7 +157,8 @@ typedef struct BooleanWeight {
   Weight **weights;
   int w_cnt;
 } BooleanWeight;
-Weight *bw_create(Query *query, Searcher *searcher);
+
+extern Weight *bw_create(Query *query, Searcher *searcher);
 
 /***************************************************************************
  *
@@ -157,7 +166,7 @@ Weight *bw_create(Query *query, Searcher *searcher);
  *
  ***************************************************************************/
 
-Weight *phw_create(Query *query, Searcher *searcher);
+extern Weight *phw_create(Query *query, Searcher *searcher);
 
 /***************************************************************************
  *
@@ -165,7 +174,7 @@ Weight *phw_create(Query *query, Searcher *searcher);
  *
  ***************************************************************************/
 
-Weight *csw_create(Query *query, Searcher *searcher);
+extern Weight *csw_create(Query *query, Searcher *searcher);
 
 /***************************************************************************
  *
@@ -173,7 +182,7 @@ Weight *csw_create(Query *query, Searcher *searcher);
  *
  ***************************************************************************/
 
-Weight *maw_create(Query *query, Searcher *searcher);
+extern Weight *maw_create(Query *query, Searcher *searcher);
 
 /***************************************************************************
  *
@@ -181,7 +190,7 @@ Weight *maw_create(Query *query, Searcher *searcher);
  *
  ***************************************************************************/
 
-Weight *spanw_create(Query *query, Searcher *searcher);
+extern Weight *spanw_create(Query *query, Searcher *searcher);
 
 /***************************************************************************
  *
@@ -211,24 +220,32 @@ enum QUERY_TYPE {
 struct Query {
   bool destroy_all : 1;
   uchar type;
+  int ref_cnt;
   void *data;
   float boost;
-  float original_boost;
   Weight *weight;
-  Query *rewritten;
-  Weight     *(*create_weight)(Query *self, Searcher *searcher);
   Query      *(*rewrite)(Query *self, IndexReader *ir);
-  void        (*extract_terms)(Query *self, Array *terms);
+  void        (*extract_terms)(Query *self, HashSet *terms);
   Similarity *(*get_similarity)(Query *self, Searcher *searcher);
   char       *(*to_s)(Query *self, char *field);
-  void        (*destroy)(void *p);
+  uint        (*hash)(Query *self);
+  int         (*eq)(Query *self, Query *o);
+  void        (*destroy_i)(Query *self);
+  Weight     *(*create_weight_i)(Query *self, Searcher *searcher);
 };
 
-Weight *q_weight(Query *self, Searcher *searcher);
-void q_destroy(Query *self);
-Similarity *q_get_similarity(Query *self, Searcher *searcher);
-void q_extract_terms(Query *self, Array *terms);
-Query *q_create();
+/* Internal Query Functions */
+extern Query *q_create();
+extern Similarity *q_get_similarity_i(Query *self, Searcher *searcher);
+extern void q_destroy_i(Query *self);
+extern Weight *q_create_weight_unsup(Query *self, Searcher *searcher);
+
+
+extern void q_deref(Query *self);
+extern Weight *q_weight(Query *self, Searcher *searcher);
+extern Query *q_combine(Query **queries, int q_cnt);
+extern uint q_hash(Query *self);
+extern int q_eq(Query *self, Query *o);
 
 /***************************************************************************
  *
@@ -240,7 +257,7 @@ typedef struct TermQuery {
   Term *term;
 } TermQuery;
 
-Query *tq_create(Term *term);
+extern Query *tq_create(Term *term);
 
 /***************************************************************************
  *
@@ -259,6 +276,7 @@ enum BC_TYPE {
 };
 
 typedef struct BooleanClause {
+  int ref_cnt;
   Query *query;
   Query *rewritten;
   unsigned int occur : 4;
@@ -266,9 +284,9 @@ typedef struct BooleanClause {
   bool is_required : 1;
 } BooleanClause;
 
-BooleanClause *bc_create(Query *query, unsigned int occur);
-void bc_destroy(BooleanClause *self);
-void bc_set_occur(BooleanClause *self, unsigned int occur);
+extern BooleanClause *bc_create(Query *query, unsigned int occur);
+extern void bc_deref(BooleanClause *self);
+extern void bc_set_occur(BooleanClause *self, unsigned int occur);
 
 /***************************************************************************
  * BooleanQuery
@@ -283,13 +301,15 @@ typedef struct BooleanQuery {
   int max_clause_cnt;
   int clause_cnt;
   int clause_capa;
+  float original_boost;
   BooleanClause **clauses;
   Similarity *similarity;
 } BooleanQuery;
 
-Query *bq_create(bool coord_disabled);
-BooleanClause *bq_add_query(Query *self, Query *sub_query, unsigned int occur);
-BooleanClause *bq_add_clause(Query *self, BooleanClause *bc);
+extern Query *bq_create(bool coord_disabled);
+extern BooleanClause *bq_add_query(Query *self, Query *sub_query,
+    unsigned int occur);
+extern BooleanClause *bq_add_clause(Query *self, BooleanClause *bc);
 
 /***************************************************************************
  *
@@ -307,8 +327,8 @@ typedef struct PhraseQuery {
   char *field;
 } PhraseQuery;
 
-Query *phq_create();
-void phq_add_term(Query *self, Term *term, int pos_inc);
+extern Query *phq_create();
+extern void phq_add_term(Query *self, Term *term, int pos_inc);
 
 /***************************************************************************
  *
@@ -326,8 +346,8 @@ typedef struct MultiPhraseQuery {
   char *field;
 } MultiPhraseQuery;
 
-Query *mphq_create();
-void mphq_add_terms(Query *self, Term **terms, int t_cnt, int pos_inc);
+extern Query *mphq_create();
+extern void mphq_add_terms(Query *self, Term **ts, int t_cnt, int pos_inc);
 
 /***************************************************************************
  *
@@ -335,7 +355,7 @@ void mphq_add_terms(Query *self, Term **terms, int t_cnt, int pos_inc);
  *
  ***************************************************************************/
 
-Query *prefixq_create(Term *prefix);
+extern Query *prefixq_create(Term *prefix);
 
 /***************************************************************************
  *
@@ -345,8 +365,9 @@ Query *prefixq_create(Term *prefix);
 
 #define WILD_CHAR '?'
 #define WILD_STRING '*'
-Query *wcq_create(Term *term);
-bool wc_match(char *pattern, char *text);
+
+extern Query *wcq_create(Term *term);
+extern bool wc_match(char *pattern, char *text);
 
 /***************************************************************************
  *
@@ -370,8 +391,8 @@ typedef struct FuzzyQuery {
   int da_capa;
 } FuzzyQuery;
 
-Query *fuzq_create(Term *term);
-Query *fuzq_create_mp(Term *term, float min_sim, int pre_len);
+extern Query *fuzq_create(Term *term);
+extern Query *fuzq_create_mp(Term *term, float min_sim, int pre_len);
 
 /***************************************************************************
  *
@@ -379,7 +400,7 @@ Query *fuzq_create_mp(Term *term, float min_sim, int pre_len);
  *
  ***************************************************************************/
 
-Query *csq_create(Filter *filter);
+extern Query *csq_create(Filter *filter);
 
 /***************************************************************************
  *
@@ -387,7 +408,7 @@ Query *csq_create(Filter *filter);
  *
  ***************************************************************************/
 
-Query *fq_create(Query *query, Filter *filter);
+extern Query *fq_create(Query *query, Filter *filter);
 
 /***************************************************************************
  *
@@ -395,7 +416,7 @@ Query *fq_create(Query *query, Filter *filter);
  *
  ***************************************************************************/
 
-Query *maq_create();
+extern Query *maq_create();
 
 /***************************************************************************
  *
@@ -407,14 +428,16 @@ typedef struct Range {
   char *field;
   char *lower_term;
   char *upper_term;
-  bool include_lower;
-  bool include_upper;
+  bool include_lower : 1;
+  bool include_upper : 1;
 } Range;
 
-Query *rq_create(const char *field, char *lower_term, char *upper_term,
-    bool include_lower, bool include_upper);
-Query *rq_create_less(const char *field, char *upper_term, bool include_upper);
-Query *rq_create_more(const char *field, char *lower_term, bool include_lower);
+extern Query *rq_create(const char *field, char *lower_term,
+    char *upper_term, bool include_lower, bool include_upper);
+extern Query *rq_create_less(const char *field, char *upper_term,
+    bool include_upper);
+extern Query *rq_create_more(const char *field, char *lower_term,
+    bool include_lower);
 
 /***************************************************************************
  *
@@ -447,7 +470,7 @@ struct SpanEnum {
   int  (*start)(SpanEnum *self);
   int  (*end)(SpanEnum *self);
   char *(*to_s)(SpanEnum *self);
-  void (*destroy)(void *p);
+  void (*destroy)(SpanEnum *self);
 };
 
 /***************************************************************************
@@ -463,13 +486,13 @@ struct SpanTermEnum {
   int freq;
 };
 
-SpanEnum *spante_create(Query *query, IndexReader *ir);
+extern SpanEnum *spante_create(Query *query, IndexReader *ir);
 
 /***************************************************************************
  * SpanFirstEnum
  ***************************************************************************/
 
-SpanEnum *spanfe_create(Query *query, IndexReader *ir);
+extern SpanEnum *spanfe_create(Query *query, IndexReader *ir);
 
 /***************************************************************************
  * SpanOrEnum
@@ -481,7 +504,8 @@ typedef struct SpanOrEnum {
   int s_cnt;
   bool first_time;
 } SpanOrEnum;
-SpanEnum *spanoe_create(Query *query, IndexReader *ir);
+
+extern SpanEnum *spanoe_create(Query *query, IndexReader *ir);
 
 /***************************************************************************
  * SpanEnumCell
@@ -493,7 +517,8 @@ typedef struct SpanEnumCell {
   int index;
   int length;
 } SpanEnumCell;
-SpanEnum *spanec_create(Query *parent, Query *child, int index);
+
+extern SpanEnum *spanec_create(Query *parent, Query *child, int index);
 
 /***************************************************************************
  * SpanNearEnum
@@ -511,7 +536,7 @@ typedef struct SpanNearEnum {
   int end;
 } SpanNearEnum;
 
-SpanEnum *spanne_create(Query *query, IndexReader *ir);
+extern SpanEnum *spanne_create(Query *query, IndexReader *ir);
 
 /***************************************************************************
  * SpanNotEnum
@@ -524,7 +549,7 @@ typedef struct SpanNotEnum {
   bool more_exc : 1;
 } SpanNotEnum;
 
-SpanEnum *spanxe_create(Query *query, IndexReader *ir);
+extern SpanEnum *spanxe_create(Query *query, IndexReader *ir);
 
 /***************************************************************************
  * SpanQuery
@@ -535,14 +560,14 @@ struct SpanQuery {
   void *data;
   char *field;
   SpanEnum *(*get_spans)(Query *self, IndexReader *ir);
-  Array    *(*get_terms)(Query *self);
+  HashSet  *(*get_terms)(Query *self);
 };
 
 /***************************************************************************
  * SpanTermQuery
  ***************************************************************************/
 
-Query *spantq_create(Term *term);
+extern Query *spantq_create(Term *term);
 
 /***************************************************************************
  * SpanFirstQuery
@@ -553,7 +578,7 @@ typedef struct SpanFirstQuery {
   Query *match;
 } SpanFirstQuery;
 
-Query *spanfq_create(Query *match, int end);
+extern Query *spanfq_create(Query *match, int end);
 
 /***************************************************************************
  * SpanOrQuery
@@ -564,7 +589,7 @@ typedef struct SpanOrQuery {
   int c_cnt;
 } SpanOrQuery;
 
-Query *spanoq_create(Query **clauses, int c_cnt);
+extern Query *spanoq_create(Query **clauses, int c_cnt);
 
 /***************************************************************************
  * SpanNearQuery
@@ -577,7 +602,8 @@ typedef struct SpanNearQuery {
   bool in_order;
 } SpanNearQuery;
 
-Query *spannq_create(Query **clauses, int c_cnt, int slop, bool in_order);
+extern Query *spannq_create(Query **clauses, int c_cnt, int slop,
+    bool in_order);
 
 
 /***************************************************************************
@@ -589,7 +615,7 @@ typedef struct SpanNotQuery {
   Query *exc;
 } SpanNotQuery;
 
-Query *spanxq_create(Query *inc, Query *exc);
+extern Query *spanxq_create(Query *inc, Query *exc);
 
 /***************************************************************************
  *
@@ -607,14 +633,16 @@ struct Scorer {
   bool         (*next)(Scorer *self);
   bool         (*skip_to)(Scorer *self, int doc_num);
   Explanation *(*explain)(Scorer *self, int doc_num);
-  void         (*destroy)(void *p);
+  void         (*destroy)(Scorer *self);
 };
 
-void scorer_destroy(void *p);
-Scorer *scorer_create(Similarity *similarity);
-bool scorer_less_than(void *p1, void *p2);
-bool scorer_doc_less_than(void *p1, void *p2);
-int scorer_doc_cmp(const void *p1, const void *p2);
+/* Internal Scorer Function */
+extern void scorer_destroy_i(Scorer *self);
+
+extern Scorer *scorer_create(Similarity *similarity);
+extern bool scorer_less_than(void *p1, void *p2);
+extern bool scorer_doc_less_than(void *p1, void *p2);
+extern int scorer_doc_cmp(const void *p1, const void *p2);
 
 /***************************************************************************
  *
@@ -637,7 +665,7 @@ typedef struct TermScorer {
   float weight_value;
 } TermScorer;
 
-Scorer *tsc_create(Weight *weight, TermDocEnum *tde, uchar *norms);
+extern Scorer *tsc_create(Weight *weight, TermDocEnum *tde, uchar *norms);
 
 /***************************************************************************
  *
@@ -656,9 +684,6 @@ typedef struct Coordinator {
   int num_matches;
 } Coordinator;
 
-Coordinator *coo_create(Similarity *similarity);
-Coordinator *coo_init(Coordinator *self);
-
 /***************************************************************************
  * DisjunctionSumScorer
  ***************************************************************************/
@@ -680,7 +705,7 @@ typedef struct DisjunctionSumScorer{
 typedef struct ConjunctionScorer{
   bool first_time : 1;
   bool more : 1;
-  int coord;
+  float coord;
   int ss_cnt;
   int ss_capa;
   Scorer **sub_scorers;
@@ -737,8 +762,8 @@ typedef struct BooleanScorer {
   Coordinator *coordinator;
 } BooleanScorer;
 
-Scorer *bsc_create(Similarity *similarity);
-void bsc_add_scorer(Scorer *self, Scorer *scorer, unsigned int occur);
+extern Scorer *bsc_create(Similarity *similarity);
+extern void bsc_add_scorer(Scorer *self, Scorer *scorer, unsigned int occur);
 
 /***************************************************************************
  *
@@ -757,7 +782,8 @@ typedef struct PhrasePosition {
   int position;
 } PhrasePosition;
 
-PhrasePosition *pp_create(TermDocEnum *tpe, int offset);
+extern PhrasePosition *pp_create(TermDocEnum *tpe, int offset);
+
 /***************************************************************************
  * PhraseScorer
  ***************************************************************************/
@@ -777,22 +803,24 @@ typedef struct PhraseScorer {
   int slop;
 } PhraseScorer;
 
-Scorer *phsc_create(Weight *weight, TermDocEnum **term_pos_enum,
+extern Scorer *phsc_create(Weight *weight, TermDocEnum **term_pos_enum,
     int *positions, int t_cnt, Similarity *similarity, uchar *norms);
 
 /***************************************************************************
  * ExactPhraseScorer
  ***************************************************************************/
 
-Scorer *exact_phrase_scorer_create(Weight *weight, TermDocEnum **term_pos_enum,
-    int *positions, int t_cnt, Similarity *similarity, uchar *norms);
+extern Scorer *exact_phrase_scorer_create(Weight *weight,
+    TermDocEnum **term_pos_enum, int *positions, int t_cnt,
+    Similarity *similarity, uchar *norms);
 
 /***************************************************************************
  * SloppyPhraseScorer
  ***************************************************************************/
 
-Scorer *sloppy_phrase_scorer_create(Weight *weight, TermDocEnum **term_pos_enum,
-    int *positions, int t_cnt, Similarity *similarity, int slop, uchar *norms);
+extern Scorer *sloppy_phrase_scorer_create(Weight *weight,
+    TermDocEnum **term_pos_enum, int *positions, int t_cnt,
+    Similarity *similarity, int slop, uchar *norms);
 
 /***************************************************************************
  *
@@ -805,7 +833,7 @@ typedef struct ConstantScoreScorer {
   float score;
 } ConstantScoreScorer;
 
-Scorer *cssc_create(Weight *weight, IndexReader *ir);
+extern Scorer *cssc_create(Weight *weight, IndexReader *ir);
 
 
 /***************************************************************************
@@ -820,7 +848,7 @@ typedef struct MatchAllScorer {
   float score;
 } MatchAllScorer;
 
-Scorer *masc_create(Weight *weight, IndexReader *ir);
+extern Scorer *masc_create(Weight *weight, IndexReader *ir);
 
 
 /***************************************************************************
@@ -841,7 +869,7 @@ typedef struct SpanScorer {
   float freq;
 } SpanScorer;
 
-Scorer *spansc_create(Weight *weight, IndexReader *ir);
+extern Scorer *spansc_create(Weight *weight, IndexReader *ir);
 
 /***************************************************************************
  *
@@ -874,14 +902,15 @@ typedef struct SortField {
   void  (*handle_term)(void *index, TermDocEnum *tde, char *text);
 } SortField;
 
-SortField *sort_field_create(char *field, int type, bool reverse);
-SortField *sort_field_score_create(bool reverse);
-SortField *sort_field_doc_create(bool reverse);
-SortField *sort_field_int_create(char *field, bool reverse);
-SortField *sort_field_float_create(char *field, bool reverse);
-SortField *sort_field_string_create(char *field, bool reverse);
-SortField *sort_field_auto_create(char *field, bool reverse);
-void sort_field_destroy(void *p);
+extern SortField *sort_field_create(char *field, int type, bool reverse);
+extern SortField *sort_field_score_create(bool reverse);
+extern SortField *sort_field_doc_create(bool reverse);
+extern SortField *sort_field_int_create(char *field, bool reverse);
+extern SortField *sort_field_float_create(char *field, bool reverse);
+extern SortField *sort_field_string_create(char *field, bool reverse);
+extern SortField *sort_field_auto_create(char *field, bool reverse);
+extern void sort_field_destroy(void *p);
+extern char *sort_field_to_s(SortField *self);
 
 extern SortField SORT_FIELD_SCORE; 
 extern SortField SORT_FIELD_SCORE_REV; 
@@ -899,20 +928,21 @@ typedef struct Sort {
   bool destroy_all : 1;
 } Sort;
 
-Sort *sort_create();
-void sort_destroy(void *p);
-void sort_add_sort_field(Sort *self, SortField *sf);
-void sort_clear(Sort *self);
+extern Sort *sort_create();
+extern void sort_destroy(void *p);
+extern void sort_add_sort_field(Sort *self, SortField *sf);
+extern void sort_clear(Sort *self);
+extern char *sort_to_s(Sort *self);
 
 /***************************************************************************
  * FieldSortedHitQueue
  ***************************************************************************/
 
-Hit *fshq_pq_pop(PriorityQueue *pq);
-void fshq_pq_down(PriorityQueue *pq);
-void fshq_pq_push(PriorityQueue *pq, void *elem);
-void fshq_pq_destroy(void *p);
-PriorityQueue *fshq_pq_create(int size, Sort *sort, IndexReader *ir);
+extern Hit *fshq_pq_pop(PriorityQueue *pq);
+extern void fshq_pq_down(PriorityQueue *pq);
+extern void fshq_pq_insert(PriorityQueue *pq, Hit *hit);
+extern void fshq_pq_destroy(PriorityQueue *pq);
+extern PriorityQueue *fshq_pq_create(int size, Sort *sort, IndexReader *ir);
 
 /***************************************************************************
  *
@@ -921,6 +951,7 @@ PriorityQueue *fshq_pq_create(int size, Sort *sort, IndexReader *ir);
  ***************************************************************************/
 
 struct Searcher {
+  void        *data;
   IndexReader *ir;
   Similarity  *similarity;
   bool         close_ir : 1;
@@ -930,25 +961,53 @@ struct Searcher {
   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);
+                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);
 };
 
-Searcher *sea_create(IndexReader *ir);
-TopDocs *sea_search(Searcher *self, Query *query, int first_doc,
-    int num_docs, Filter *filter, Sort *sort);
-void sea_search_each(Searcher *self, Query *query, Filter *filter,
-    void (*fn)(Searcher *self, int doc_num, void *arg), void *arg);
-Explanation *sea_explain(Searcher *self, Query *query, int doc_num);
-Similarity *sea_get_similarity(Searcher *self);
-Query *sea_rewrite(Searcher *self, Query *original);
-void sea_close(Searcher *self);
-Document *sea_get_doc(Searcher *self, int doc_num);
-Weight *sea_create_weight(Searcher *self, Query *query);
-int sea_doc_freq(Searcher *self, Term *term);
+#define sea_doc_freq(s, t)  s->doc_freq(s, t)
+#define sea_doc_freqs(s, t, c)  s->doc_freqs(s, t, c)
+#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)
+#define sea_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)
+#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)
+#define sea_get_similarity(s)  s->get_similarity(s)
+#define sea_close(s)  s->close(s)
+
+extern Searcher *sea_create(IndexReader *ir);
+
+/***************************************************************************
+ *
+ * MultiSearcher
+ *
+ ***************************************************************************/
+
+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);
 
 /***************************************************************************
  *
@@ -979,10 +1038,11 @@ typedef struct QParser {
   Query *result;
 } QParser;
 
-QParser *qp_create(HashSet *all_fields, HashSet *def_fields, Analyzer *analyzer);
-void qp_destroy(void *p);
-Query *qp_parse(QParser *self, char *qstr);
-char *qp_clean_str(char *str);
+extern QParser *qp_create(HashSet *all_fields, HashSet *def_fields,
+    Analyzer *analyzer);
+extern void qp_destroy(QParser *self);
+extern Query *qp_parse(QParser *self, char *qstr);
+extern char *qp_clean_str(char *str);
 
 /***************************************************************************
  *
@@ -1001,8 +1061,6 @@ typedef struct Index {
   HashSet *key;
   char *id_field;
   char *def_field;
-  bool close_analyzer : 1;
-  bool close_store : 1;
   /* for IndexWriter */
   bool use_compound_file : 1;
   bool auto_flush : 1;
@@ -1010,32 +1068,38 @@ typedef struct Index {
   bool check_latest : 1;
 } Index;
 
-Index *index_create(Store *store, Analyzer *analyzer, HashSet *def_fields,
-    bool create);
-void index_destroy(Index *self);
-void index_flush(Index *self);
-int index_size(Index *self);
-void index_optimize(Index *self);
-bool index_has_del(Index *self);
-bool index_is_deleted(Index *self, int doc_num);
-void index_add_doc(Index *self, Document *doc);
-void index_add_doc_a(Index *self, Document *doc, Analyzer *analyzer);
-void index_add_string(Index *self, char *str, Analyzer *analyzer);
-void index_add_array(Index *self, Array *ary, Analyzer *analyzer);
-TopDocs *index_search_str(Index *self, char *query, int first_doc,
+extern Index *index_create(Store *store, Analyzer *analyzer,
+    HashSet *def_fields, bool create);
+extern void index_destroy(Index *self);
+extern void index_flush(Index *self);
+extern int index_size(Index *self);
+extern void index_optimize(Index *self);
+extern bool index_has_del(Index *self);
+extern bool index_is_deleted(Index *self, int doc_num);
+extern void index_add_doc(Index *self, Document *doc);
+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);
-Query *index_get_query(Index *self, char *qstr);
-Document *index_get_doc(Index *self, int doc_num);
-Document *index_get_doc_ts(Index *self, int doc_num);
-Document *index_get_doc_id(Index *self, char *id);
-Document *index_get_doc_term(Index *self, Term *term);
-void index_delete(Index *self, int doc_num);
-void index_delete_term(Index *self, Term *term);
-void index_delete_id(Index *self, char *id);
-void index_delete_query(Index *self, Query *q, Filter *f);
-void index_delete_query_str(Index *self, char *qstr, Filter *f);
-int index_term_id(Index *self, Term *term);
-Explanation *index_explain(Index *self, Query *q, int doc_num);
-void index_auto_flush_ir(Index *self);
-void index_auto_flush_iw(Index *self);
+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);
+extern Document *index_get_doc_id(Index *self, char *id);
+extern Document *index_get_doc_term(Index *self, Term *term);
+extern void index_delete(Index *self, int doc_num);
+extern void index_delete_term(Index *self, Term *term);
+extern void index_delete_id(Index *self, char *id);
+extern void index_delete_query(Index *self, Query *q, Filter *f);
+extern void index_delete_query_str(Index *self, char *qstr, Filter *f);
+extern int index_term_id(Index *self, Term *term);
+extern Explanation *index_explain(Index *self, Query *q, int doc_num);
+extern void index_auto_flush_ir(Index *self);
+extern void index_auto_flush_iw(Index *self);
+
+extern inline void ensure_searcher_open(Index *self);
+extern inline void ensure_reader_open(Index *self);
+extern inline void ensure_writer_open(Index *self);
+
 #endif
+