ferret 0.9.1 → 0.9.2

data/ext/lang.c

@@ -29,3 +29,13 @@ void ft_raise(char *file, int line_num, VALUE etype, const char *fmt, ...)
   sprintf(buf_ptr, "\n");
   rb_raise(etype, buf); /* conventional value for failed execution */
 }
+
+#ifdef WIN32
+void eprintf(VALUE etype, const char *fmt, ...)
+{
+  va_list args;
+  va_start(args, fmt);
+  ft_raise("Windows", -1, etype, fmt, args);
+  va_end(args);
+}
+#endif

data/ext/lang.h

@@ -7,7 +7,17 @@
 #define FERRET_EXT
 
 #define MAX_ERROR_LEN 2048
-#define eprintf(...) ft_raise(__FILE__, __LINE__, __VA_ARGS__)
+
+typedef LONG_LONG llong;
+typedef unsigned LONG_LONG ullong;
+
+#ifdef WIN32
+# undef close
+# undef rename
+extern void eprintf(VALUE etype, const char *fmt, ...);
+#else
+# define eprintf(...) ft_raise(__FILE__, __LINE__, __VA_ARGS__)
+#endif
 extern void ft_raise(char *file, int line_num, VALUE etype, const char *fmt, ...);
 extern void weprintf(const char *fmt, ...);
 extern char *progname(void);

data/ext/nix_io.c

@@ -0,0 +1,135 @@
+#ifndef WIN32
+
+#include "global.h"
+#include "store.h"
+#include <sys/dir.h>
+#include <dirent.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <fcntl.h>
+
+/**
+ * Create a filepath for a file in the store using the operating systems
+ * default file seperator.
+ */
+char *join_path(char *buf, const char *base, const char *filename)
+{
+  sprintf(buf, "%s/%s", base, filename);
+  return buf;
+}
+
+bool exists(char *path)
+{
+  int fd = open(path, 0);
+  if (fd < 0) {
+    if (errno != ENOENT) {
+      RAISE(IO_ERROR, strerror(errno));
+    }
+    return false;
+  }
+  close(fd);
+  return true;
+}
+
+int fcount(char *path)
+{
+  int cnt = 0;
+  struct dirent *de;
+  DIR *d = opendir(path);
+
+  if (!d) RAISE(IO_ERROR, strerror(errno));
+
+  while ((de = readdir(d)) != NULL) {
+    if (de->d_name[0] != '.') {
+      cnt++;
+    }
+  }
+  closedir(d);
+
+  return cnt;
+}
+
+void dir_each(char *path, void (*func)(char *fname, void *arg), void *arg)
+{
+  struct dirent *de;
+  DIR *d = opendir(path);
+
+  if (!d) RAISE(IO_ERROR, strerror(errno));
+
+  while ((de = readdir(d)) != NULL) {
+    if (de->d_name[0] != '.' && !file_is_lock(de->d_name)) {
+      func(de->d_name, arg);
+    }
+  }
+  closedir(d);
+}
+
+/**
+ * Clear all the locks in the store.
+ *
+ * @param store the store to clear the locks from
+ * @throws IO_ERROR if there is an error opening the directory
+ */
+void fs_clear_locks(Store *store)
+{
+  struct dirent *de;
+  DIR *d = opendir(store->dir.path);
+
+  if (!d) RAISE(IO_ERROR, strerror(errno));
+
+  while ((de = readdir(d)) != NULL) {
+    if (file_is_lock(de->d_name)) {
+      char buf[MAX_FILE_PATH];
+      remove(join_path(buf, store->dir.path, de->d_name));
+    }
+  }
+  closedir(d);
+}
+
+/**
+ * Clear all files from the store except the lock files.
+ *
+ * @param store the store to clear all the files from
+ * @throws IO_ERROR if there is an error deleting the files
+ */
+void fs_clear(Store *store)
+{
+  struct dirent *de;
+  DIR *d = opendir(store->dir.path);
+
+  if (!d) RAISE(IO_ERROR, strerror(errno));
+
+  while ((de = readdir(d)) != NULL) {
+    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));
+    }
+  }
+  closedir(d);
+}
+
+/**
+ * Clear all files from the store including the lock files.
+ *
+ * @param store the store to clear all the files from
+ * @throws IO_ERROR if there is an error deleting the files
+ */
+void fs_clear_all(Store *store)
+{
+  struct dirent *de;
+  DIR *d = opendir(store->dir.path);
+
+  if (!d) RAISE(IO_ERROR, strerror(errno));
+
+  while ((de = readdir(d)) != NULL) {
+    if (de->d_name[0] != '.') {
+      char buf[MAX_FILE_PATH];
+      remove(join_path(buf, store->dir.path, de->d_name));
+    }
+  }
+  closedir(d);
+}
+
+#endif
+

data/ext/priorityqueue.c

@@ -11,20 +11,20 @@ PriorityQueue *pq_create(int max_size, bool (*less_than)(void *p1, void *p2))
   return pq;
 }
 
-void pq_destroy(void *p)
+void pq_destroy(PriorityQueue *pq)
 {
-  PriorityQueue *pq = (PriorityQueue *)p;
   free(pq->heap);
-  free(p);
+  free(pq);
 }
 
 void pq_up(PriorityQueue *pq)
 {
-	int i,j;
-	i = pq->count;
-	j = i >> 1;
-  void **heap = pq->heap;
-  void *node = heap[i];
+	void **heap = pq->heap;
+  void *node;
+	int i = pq->count;
+	int j = i >> 1;
+
+  node = heap[i];
 
 	while ((j > 0) && pq->lt(node, heap[j])) {
 		heap[i] = heap[j];
@@ -117,7 +117,7 @@ int pq_insert(PriorityQueue *pq, void *elem)
 
 PriorityQueue2 *pq2_create(int max_size,
     bool (*less_than)(PriorityQueue2 *pq, void *p1, void *p2),
-    void (*destroy)(void *p))
+    free_ft destroy)
 {
   PriorityQueue2 *pq = ALLOC(PriorityQueue2);
   pq->count = 0;
@@ -129,20 +129,20 @@ PriorityQueue2 *pq2_create(int max_size,
   return pq;
 }
 
-void pq2_destroy(void *p)
+void pq2_destroy(PriorityQueue2 *pq)
 {
-  PriorityQueue2 *pq = (PriorityQueue2 *)p;
   free(pq->heap);
-  free(p);
+  free(pq);
 }
 
 void pq2_up(PriorityQueue2 *pq)
 {
-	int i,j;
-	i = pq->count;
-	j = i >> 1;
   void **heap = pq->heap;
-  void *node = heap[i];
+  void *node;
+  int i = pq->count;
+	int j = i >> 1;
+  
+  node = heap[i];
 
 	while ((j > 0) && pq->lt(pq, node, heap[j])) {
 		heap[i] = heap[j];

data/ext/priorityqueue.h

@@ -3,16 +3,19 @@
 
 #include "global.h"
 
+typedef bool (*lt_ft)(void *p1, void *p2);
+
 typedef struct PriorityQueue {
   int count;
   int size;
   void **heap;
-  bool (*lt)(void *p1, void *p2);
-  void (*free_elem)(void *p1);
+  lt_ft lt;
+  //bool (*lt)(void *p1, void *p2);
+  free_ft free_elem;
 } PriorityQueue;
 
 PriorityQueue *pq_create(int max_size, bool (*less_than)(void *p1, void *p2));
-void pq_destroy(void *p);
+void pq_destroy(PriorityQueue *pq);
 void pq_push(PriorityQueue *pq, void *elem);
 void *pq_top(PriorityQueue *pq);
 void *pq_pop(PriorityQueue *pq);
@@ -28,13 +31,13 @@ typedef struct PriorityQueue2 {
   void *data;
   bool (*lt)(struct PriorityQueue2 *pq, void *p1, void *p2);
   void (*free_elem)(void *p);
-  void (*destroy)(void *p);
+  free_ft destroy;
 } PriorityQueue2;
 
 PriorityQueue2 *pq2_create(int max_size,
     bool (*less_than)(PriorityQueue2 *pq, void *p1, void *p2),
-    void (*destroy)(void *p));
-void pq2_destroy(void *p);
+    free_ft destroy);
+void pq2_destroy(PriorityQueue2 *pq);
 void pq2_push(PriorityQueue2 *pq, void *elem);
 void *pq2_top(PriorityQueue2 *pq);
 void *pq2_pop(PriorityQueue2 *pq);

data/ext/q_boolean.c

@@ -38,9 +38,9 @@ void bw_normalize(Weight *self, float normalization_factor)
 {
   BooleanWeight *bw = (BooleanWeight *)self->data;
   BooleanQuery *bq = (BooleanQuery *)self->query->data;
-  normalization_factor *= self->value; // multiply by query boost
   Weight *weight;
   int i;
+  normalization_factor *= self->value; /* multiply by query boost */
 
   for (i = 0; i < bw->w_cnt; i++) {
     if (! bq->clauses[i]->is_prohibited) {
@@ -79,13 +79,18 @@ char *bw_to_s(Weight *self)
   return strfmt("BooleanWeight(%f)", self->value);
 }
 
-void bw_destroy(void *p)
+void bw_destroy(Weight *self)
 {
-  Weight *weight = (Weight *)p;
-  BooleanWeight *bw = (BooleanWeight *)weight->data;
+  int i;
+  BooleanWeight *bw = (BooleanWeight *)self->data;
+
+  for (i = 0; i < bw->w_cnt; i++) {
+    bw->weights[i]->destroy(bw->weights[i]);
+  }
+
   free(bw->weights);
   free(bw);
-  free(weight);
+  w_destroy(self);
 }
 
 Explanation *bw_explain(Weight *self, IndexReader *ir, int doc_num)
@@ -127,8 +132,8 @@ Explanation *bw_explain(Weight *self, IndexReader *ir, int doc_num)
   }
   sum_expl->value = sum;
 
-  if (coord == 1) {                // only one clause matched
-    explanation = sum_expl;        // eliminate wrapper
+  if (coord == 1) {                /* only one clause matched */
+    explanation = sum_expl;        /* eliminate wrapper */
     sum_expl->dcnt = 0;
     sum_expl = sum_expl->details[0];
     expl_destoy(explanation);
@@ -136,8 +141,8 @@ Explanation *bw_explain(Weight *self, IndexReader *ir, int doc_num)
 
   coord_factor = sim_coord(self->similarity, coord, max_coord);
 
-  if (coord_factor == 1.0) {       // coord is no-op
-    return sum_expl;               // eliminate wrapper
+  if (coord_factor == 1.0) {       /* coord is no-op */
+    return sum_expl;               /* eliminate wrapper */
   } else {
     explanation = expl_create(sum * coord_factor, estrdup("product of:"));
     expl_add_detail(explanation, sum_expl);
@@ -150,13 +155,17 @@ Explanation *bw_explain(Weight *self, IndexReader *ir, int doc_num)
 Weight *bw_create(Query *query, Searcher *searcher)
 {
   int i;
-  BooleanQuery *bq = (BooleanQuery *)query->data;
+  Weight *self = w_create(query);
   BooleanWeight *bw = ALLOC(BooleanWeight);
-  Weight *self = ALLOC(Weight);
-  ZEROSET(self, Weight, 1);
+  BooleanQuery *bq = (BooleanQuery *)query->data;
+
+  bw->w_cnt = bq->clause_cnt;
+  bw->weights = ALLOC_N(Weight *, bw->w_cnt);
+  for (i = 0; i < bw->w_cnt; i++) {
+    bw->weights[i] = q_weight(bq->clauses[i]->query, searcher);
+  }
   self->data = bw;
-  self->get_query = &w_get_query;
-  self->get_value = &w_get_value;
+
   self->normalize = &bw_normalize;
   self->scorer    = &bw_scorer;
   self->explain   = &bw_explain;
@@ -165,15 +174,8 @@ Weight *bw_create(Query *query, Searcher *searcher)
   self->sum_of_squared_weights = &bw_sum_of_squared_weights;
 
   self->similarity = query->get_similarity(query, searcher);
-  self->query = query;
   self->value = query->boost;
 
-  bw->w_cnt = bq->clause_cnt;
-  bw->weights = ALLOC_N(Weight *, bw->w_cnt);
-  for (i = 0; i < bw->w_cnt; i++) {
-    bw->weights[i] = q_weight(bq->clauses[i]->query, searcher);
-  }
-
   return self;
 }
 
@@ -204,15 +206,28 @@ void bc_set_occur(BooleanClause *self, unsigned int occur)
   }
 }
 
-void bc_destroy(BooleanClause *self)
+void bc_deref(BooleanClause *self)
+{
+  if (--self->ref_cnt <= 0) {
+    q_deref(self->query);
+    free(self);
+  }
+}
+
+uint bc_hash(BooleanClause *self)
+{
+  return ((q_hash(self->query) << 2) | self->occur);
+}
+
+int  bc_eq(BooleanClause *self, BooleanClause *o)
 {
-  self->query->destroy(self->query);
-  free(self);
+  return ((self->occur == o->occur) && q_eq(self->query, o->query)); 
 }
 
 BooleanClause *bc_create(Query *query, unsigned int occur)
 {
   BooleanClause *self = ALLOC(BooleanClause);
+  self->ref_cnt = 1;
   self->query = query;
   bc_set_occur(self, occur);
   return self;
@@ -228,38 +243,44 @@ Query *bq_rewrite(Query *self, IndexReader *ir)
 {
   BooleanQuery *bq = (BooleanQuery *)self->data;
   BooleanClause *clause;
-  Query *query;
+  Query *q, *rq;
   int i;
 
   if (bq->clause_cnt == 1) { // optimize 1-clause queries
     clause = bq->clauses[0];
     if (! clause->is_prohibited) { // just return clause
-      query = clause->query->rewrite(clause->query, ir); // rewrite first
+      q = clause->query->rewrite(clause->query, ir); // rewrite first
 
       if (self->boost != 1.0) {// incorporate boost
-        // original_boost is initialized to 0.0. If it has been set to
-        // something else it means this query has already been boosted before
-        // so boost from the original value
-        if ((query == clause->query) && query->original_boost) { // rewrite was no-op
-          query->boost = query->original_boost * self->boost;
+        /* original_boost is initialized to 0.0. If it has been set to
+         * something else it means this query has already been boosted before
+         * so boost from the original value */
+        if ((q == clause->query) && bq->original_boost) {
+          /* rewrite was no-op */
+          q->boost = bq->original_boost * self->boost;
         } else {
-          query->original_boost = query->boost; // save original boost
-          query->boost *= self->boost;
+          bq->original_boost = q->boost; /* save original boost */
+          q->boost *= self->boost;
         }
       }
 
-      return query;
+      return q;
     }
   }
 
+  /* replace each clause's query with its rewritten query */
   for (i = 0; i < bq->clause_cnt; i++) {
     clause = bq->clauses[i];
-    clause->rewritten = clause->query->rewrite(clause->query, ir);
+    rq = clause->query->rewrite(clause->query, ir);
+    q_deref(clause->query);
+    clause->query = rq;
   }
-  return self;  // no clauses rewritten
+
+  self->ref_cnt++;
+  return self;
 }
 
-void bq_extract_terms(Query *self, Array *terms)
+void bq_extract_terms(Query *self, HashSet *terms)
 {
   BooleanQuery *bq = (BooleanQuery *)self->data;
   BooleanClause *clause;
@@ -272,6 +293,7 @@ void bq_extract_terms(Query *self, Array *terms)
 
 char *bq_to_s(Query *self, char *field)
 {
+  int i;
   BooleanQuery *bq = (BooleanQuery *)self->data;
   BooleanClause *clause;
   Query *sub_query;
@@ -288,11 +310,10 @@ char *bq_to_s(Query *self, char *field)
     bp++;
   }
 
-  int i;
   for (i = 0; i < bq->clause_cnt; i++) {
     clause = bq->clauses[i];
     clause_str = clause->query->to_s(clause->query, field);
-    clause_len = strlen(clause_str);
+    clause_len = (int)strlen(clause_str);
     needed = clause_len + 5;
     while ((size - bp) < needed) {
       size *= 2;
@@ -323,7 +344,7 @@ char *bq_to_s(Query *self, char *field)
 
   if (self->boost != 1.0) {
     char *boost_str = strfmt(")^%f", self->boost);
-    int boost_len = strlen(boost_str);
+    int boost_len = (int)strlen(boost_str);
     REALLOC_N(buffer, char, bp + boost_len + 1);
     memcpy(buffer + bp, boost_str, sizeof(char) * boost_len);
     bp += boost_len;
@@ -333,22 +354,19 @@ char *bq_to_s(Query *self, char *field)
   return buffer;
 }
 
-void bq_destroy(void *p)
+static void bq_destroy(Query *self)
 {
-  Query *self = (Query *)p;
   BooleanQuery *bq = (BooleanQuery *)self->data;
   int i;
-  if (self->destroy_all) {
-    for (i = 0; i < bq->clause_cnt; i++) {
-      bc_destroy(bq->clauses[i]);
-    }
+  for (i = 0; i < bq->clause_cnt; i++) {
+    bc_deref(bq->clauses[i]);
   }
   free(bq->clauses);
   if (bq->similarity) {
     bq->similarity->destroy(bq->similarity);
   }
   free(bq);
-  q_destroy(self);
+  q_destroy_i(self);
 }
 
 float bq_coord_disabled(Similarity *sim, int overlap, int max_overlap)
@@ -360,27 +378,50 @@ Similarity *bq_get_similarity(Query *self, Searcher *searcher)
 {
   BooleanQuery *bq = (BooleanQuery *)self->data;
   if (!bq->similarity) {
-    Similarity *sim = q_get_similarity(self, searcher); 
+    Similarity *sim = q_get_similarity_i(self, searcher); 
     bq->similarity = ALLOC(Similarity);
     memcpy(bq->similarity, sim, sizeof(Similarity));
     bq->similarity->coord = &bq_coord_disabled;
-    bq->similarity->destroy = &free;
+    bq->similarity->destroy = (void (*)(Similarity *))&free;
   }
 
   return bq->similarity;
 }
 
+static uint bq_hash(Query *self)
+{
+  int i;
+  uint hash = 0;
+  BooleanQuery *bq = (BooleanQuery *)self->data;
+  for (i = 0; i < bq->clause_cnt; i++) {
+    hash ^= bc_hash(bq->clauses[i]);
+  }
+  return (hash << 1) | bq->coord_disabled;
+}
+
+static int  bq_eq(Query *self, Query *o)
+{
+  int i;
+  BooleanQuery *bq1 = (BooleanQuery *)self->data;
+  BooleanQuery *bq2 = (BooleanQuery *)o->data;
+  if ((bq1->coord_disabled != bq2->coord_disabled) ||
+      (bq1->max_clause_cnt != bq1->max_clause_cnt) ||
+      (bq1->clause_cnt != bq2->clause_cnt)) {
+    return false;
+  }
+
+  for (i = 0; i < bq1->clause_cnt; i++) {
+    if (!bc_eq(bq1->clauses[i], bq2->clauses[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
 Query *bq_create(bool coord_disabled)
 {
   Query *self = q_create();
   BooleanQuery *bq = ALLOC(BooleanQuery);
-  self->type = BOOLEAN_QUERY;
-  self->create_weight = &bw_create;
-  self->rewrite = &bq_rewrite;
-  self->extract_terms = &bq_extract_terms;
-  self->to_s = &bq_to_s;
-  self->destroy = &bq_destroy;
-  self->data = bq;
   bq->coord_disabled = coord_disabled;
   if (coord_disabled) {
     self->get_similarity = &bq_get_similarity;
@@ -390,13 +431,24 @@ Query *bq_create(bool coord_disabled)
   bq->clause_capa = BOOLEAN_CLAUSES_START_CAPA;
   bq->clauses = ALLOC_N(BooleanClause *, BOOLEAN_CLAUSES_START_CAPA);
   bq->similarity = NULL;
+  bq->original_boost = 0.0;
+  self->data = bq;
 
+  self->type = BOOLEAN_QUERY;
+  self->rewrite = &bq_rewrite;
+  self->extract_terms = &bq_extract_terms;
+  self->to_s = &bq_to_s;
+  self->hash = &bq_hash;
+  self->eq = &bq_eq;
+  self->destroy_i = &bq_destroy;
+  self->create_weight_i = &bw_create;
   return self;
 }
 
 BooleanClause *bq_add_clause(Query *self, BooleanClause *bc)
 {
   BooleanQuery *bq = (BooleanQuery *)self->data;
+  if (!self->destroy_all) ref(bc);
   if (bq->clause_cnt >= bq->clause_capa) {
     bq->clause_capa *= 2;
     REALLOC_N(bq->clauses, BooleanClause *, bq->clause_capa);
@@ -412,7 +464,12 @@ BooleanClause *bq_add_clause(Query *self, BooleanClause *bc)
 BooleanClause *bq_add_query(Query *self, Query *sub_query, unsigned int occur)
 {
   BooleanClause *bc = bc_create(sub_query, occur);
-  return bq_add_clause(self, bc);
+  bq_add_clause(self, bc);
+  if (!self->destroy_all) {
+    ref(sub_query);
+    bc_deref(bc); /* bc would have been referenced unnecessarily */
+  }
+  return bc;
 }
 
 /***************************************************************************
@@ -572,16 +629,15 @@ Explanation *dssc_explain(Scorer *self, int doc_num)
   return e;
 }
 
-void dssc_destroy(void *p)
+void dssc_destroy(Scorer *self)
 {
-  Scorer *self = (Scorer *)p;
   DisjunctionSumScorer *dssc = (DisjunctionSumScorer *)self->data;
   int i;
   for (i = 0; i < dssc->ss_cnt; i++) {
     dssc->sub_scorers[i]->destroy(dssc->sub_scorers[i]);
   }
   if (dssc->scorer_queue) pq_destroy(dssc->scorer_queue);
-  scorer_destroy(self);
+  scorer_destroy_i(self);
 }
 
 Scorer *disjunction_sum_scorer_create(Scorer **sub_scorers, int ss_cnt,
@@ -655,7 +711,8 @@ void csc_init(Scorer *self, bool init_scorers)
   ConjunctionScorer *csc = (ConjunctionScorer *)self->data;
   Scorer *sub_scorer;
   int i;
-  //  compute coord factor
+
+  /* compute coord factor */
   csc->coord = sim_coord(self->similarity, csc->ss_cnt, csc->ss_cnt);
 
   csc->more = (csc->ss_cnt > 0);
@@ -746,16 +803,15 @@ bool csc_skip_to(Scorer *self, int doc_num)
   return csc_do_next(self);
 }
 
-void csc_destroy(void *p)
+void csc_destroy(Scorer *self)
 {
-  Scorer *self = (Scorer *)p;
   ConjunctionScorer *csc = (ConjunctionScorer *)self->data;
   int i;
   for (i = 0; i < csc->ss_cnt; i++) {
     csc->sub_scorers[i]->destroy(csc->sub_scorers[i]);
   }
   free(csc->sub_scorers);
-  scorer_destroy(self);
+  scorer_destroy_i(self);
 }
 
 Scorer *conjunction_scorer_create(Similarity *similarity) 
@@ -842,12 +898,11 @@ Explanation *smsc_explain(Scorer *self, int doc_num)
   return scorer->explain(scorer, doc_num);
 }
 
-void smsc_destroy(void *p)
+void smsc_destroy(Scorer *self)
 {
-  Scorer *self = (Scorer *)p;
   Scorer *scorer = ((SingleMatchScorer *)self->data)->scorer;
   scorer->destroy(scorer);
-  scorer_destroy(self);
+  scorer_destroy_i(self);
 }
 
 Scorer *single_match_scorer_create(Coordinator *coordinator, Scorer *scorer)
@@ -929,13 +984,12 @@ Explanation *rossc_explain(Scorer *self, int doc_num)
   return e;
 }
 
-void rossc_destroy(void *p)
+void rossc_destroy(Scorer *self)
 {
-  Scorer *self = (Scorer *)p;
   ReqOptSumScorer *rossc = (ReqOptSumScorer *)self->data;
   if (rossc->req_scorer) rossc->req_scorer->destroy(rossc->req_scorer);
   if (rossc->opt_scorer) rossc->opt_scorer->destroy(rossc->opt_scorer);
-  scorer_destroy(self);
+  scorer_destroy_i(self);
 }
 
 
@@ -1070,13 +1124,12 @@ Explanation *rxsc_explain(Scorer *self, int doc_num)
   return e;
 }
 
-void rxsc_destroy(void *p)
+void rxsc_destroy(Scorer *self)
 {
-  Scorer *self = (Scorer *)p;
   ReqExclScorer *rxsc = (ReqExclScorer *)self->data;
   if (rxsc->req_scorer) rxsc->req_scorer->destroy(rxsc->req_scorer);
   if (rxsc->excl_scorer) rxsc->excl_scorer->destroy(rxsc->excl_scorer);
-  scorer_destroy(self);
+  scorer_destroy_i(self);
 }
 
 Scorer *req_excl_scorer_create(Scorer *req_scorer, Scorer *excl_scorer)
@@ -1288,9 +1341,8 @@ bool bsc_skip_to(Scorer *self, int doc_num)
   }
 }
 
-void bsc_destroy(void *p)
+void bsc_destroy(Scorer *self)
 {
-  Scorer *self = (Scorer *)p;
   BooleanScorer *bsc = (BooleanScorer *)self->data;
   Coordinator *coord = bsc->coordinator;
 
@@ -1316,7 +1368,7 @@ void bsc_destroy(void *p)
   free(bsc->required_scorers);
   free(bsc->optional_scorers);
   free(bsc->prohibited_scorers);
-  scorer_destroy(self);
+  scorer_destroy_i(self);
 }
 
 Explanation *bsc_explain(Scorer *self, int doc_num)