ferret 0.9.0 → 0.9.1

data/ext/lang.h

@@ -2,6 +2,7 @@
 #define FRT_LANG_H
 
 #include <ruby.h>
+#include "hash.h"
 
 #define FERRET_EXT
 
@@ -14,28 +15,37 @@ extern void setprogname(const char *str);
 
 extern VALUE cQueryParseException;
 
-#define ERROR rb_eException
-#define IO_ERROR rb_eIOError
-#define ARG_ERROR rb_eArgError
-#define EOF_ERROR rb_eEOFError
-#define UNSUPPORTED_ERROR rb_eNotImpError
-#define STATE_ERROR rb_eException
-#define PARSE_ERROR cQueryParseException
-#define MEM_ERROR rb_eNoMemError
+#define EXCEPTION_CODE rb_eException
+//#define IO_ERROR rb_eIOError
+//#define ARG_ERROR rb_eArgError
+//#define EOF_ERROR rb_eEOFError
+//#define UNSUPPORTED_ERROR rb_eNotImpError
+//#define STATE_ERROR rb_eException
+//#define PARSE_ERROR cQueryParseException
+//#define MEM_ERROR rb_eNoMemError
 
 typedef void * mutex_t;
-typedef void * thread_key_t;
+typedef struct HshTable * thread_key_t;
+typedef int thread_once_t;
 #define MUTEX_INITIALIZER NULL
 #define MUTEX_RECURSIVE_INITIALIZER NULL
+#define THREAD_ONCE_INIT 1;
 #define mutex_init(a, b)
 #define mutex_lock(a)
 #define mutex_trylock(a)
 #define mutex_unlock(a)
 #define mutex_destroy(a)
-#define thread_key_create(a, b)
-#define thread_key_delete(a)
-#define thread_setspecific(a, b)
-#define thread_getspecific(a) NULL
+#define thread_key_create(a, b) frt_thread_key_create(a, b)
+#define thread_key_delete(a) frt_thread_key_delete(a)
+#define thread_setspecific(a, b) frt_thread_setspecific(a, b)
+#define thread_getspecific(a) frt_thread_getspecific(a)
 #define thread_exit(a)
+#define thread_once(a, b) frt_thread_once(a, b)
+
+void frt_thread_once(int *once_control, void (*init_routine) (void));
+void frt_thread_key_create(thread_key_t *key, void (*destr_function) (void *));
+void frt_thread_key_delete(thread_key_t key);
+void frt_thread_setspecific(thread_key_t key, const void *pointer);
+void *frt_thread_getspecific(thread_key_t key);
 
 #endif

data/ext/libstemmer.c

@@ -0,0 +1,92 @@
+
+#include <stdlib.h>
+#include <string.h>
+#include "libstemmer.h"
+#include "api.h"
+#include "modules.h"
+
+struct sb_stemmer {
+    struct SN_env * (*create)(void);
+    void (*close)(struct SN_env *);
+    int (*stem)(struct SN_env *);
+
+    struct SN_env * env;
+};
+
+extern const char **
+sb_stemmer_list(void)
+{
+    return algorithm_names;
+}
+
+static stemmer_encoding sb_getenc(const char * charenc)
+{
+    struct stemmer_encoding * encoding;
+    if (charenc == NULL) return ENC_UTF_8;
+    for (encoding = encodings; encoding->name != 0; encoding++) {
+        if (strcmp(encoding->name, charenc) == 0) break;
+    }
+    if (encoding->name == NULL) return ENC_UNKNOWN;
+    return encoding->enc;
+}
+
+extern struct sb_stemmer *
+sb_stemmer_new(const char * algorithm, const char * charenc)
+{
+    stemmer_encoding enc;
+    struct stemmer_modules * module;
+    struct sb_stemmer * stemmer =
+            (struct sb_stemmer *) malloc(sizeof(struct sb_stemmer));
+    if (stemmer == NULL) return NULL;
+    enc = sb_getenc(charenc);
+    if (enc == ENC_UNKNOWN) return NULL;
+
+    for (module = modules; module->name != 0; module++) {
+        if (strcmp(module->name, algorithm) == 0 && module->enc == enc) break;
+    }
+    if (module->name == NULL) return NULL;
+    
+    stemmer->create = module->create;
+    stemmer->close = module->close;
+    stemmer->stem = module->stem;
+
+    stemmer->env = stemmer->create();
+    if (stemmer->env == NULL)
+    {
+        sb_stemmer_delete(stemmer);
+        return NULL;
+    }
+
+    return stemmer;
+}
+
+void
+sb_stemmer_delete(struct sb_stemmer * stemmer)
+{
+    if (stemmer == 0) return;
+    if (stemmer->close == 0) return;
+    stemmer->close(stemmer->env);
+    stemmer->close = 0;
+    free(stemmer);
+}
+
+const sb_symbol *
+sb_stemmer_stem(struct sb_stemmer * stemmer, const sb_symbol * word, int size)
+{
+    int ret;
+    if (SN_set_current(stemmer->env, size, (const symbol *)(word)))
+    {
+        stemmer->env->l = 0;
+        return NULL;
+    }
+    ret = stemmer->stem(stemmer->env);
+    if (ret < 0) return NULL;
+    stemmer->env->p[stemmer->env->l] = 0;
+    return (const sb_symbol *)(stemmer->env->p);
+}
+
+int
+sb_stemmer_length(struct sb_stemmer * stemmer)
+{
+    return stemmer->env->l;
+}

data/ext/libstemmer.h

@@ -0,0 +1,79 @@
+
+/* Make header file work when included from C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct sb_stemmer;
+typedef unsigned char sb_symbol;
+
+/* FIXME - should be able to get a version number for each stemming
+ * algorithm (which will be incremented each time the output changes). */
+
+/** Returns an array of the names of the available stemming algorithms.
+ *  Note that these are the canonical names - aliases (ie, other names for
+ *  the same algorithm) will not be included in the list.
+ *  The list is terminated with a null pointer.
+ *
+ *  The list must not be modified in any way.
+ */
+const char ** sb_stemmer_list(void);
+
+/** Create a new stemmer object, using the specified algorithm, for the
+ *  specified character encoding.
+ *
+ *  All algorithms will usually be available in UTF-8, but may also be
+ *  available in other character encodings.
+ *
+ *  @param algorithm The algorithm name.  This is either the english
+ *  name of the algorithm, or the 2 or 3 letter ISO 639 codes for the
+ *  language.  Note that case is significant in this parameter - the
+ *  value should be supplied in lower case.
+ *
+ *  @param charenc The character encoding.  NULL may be passed as
+ *  this value, in which case UTF-8 encoding will be assumed. Otherwise,
+ *  the argument may be one of "UTF_8", "ISO_8859_1" (ie, Latin 1),
+ *  "CP850" (ie, MS-DOS Latin 1) or "KOI8_R" (Russian).  Note that
+ *  case is significant in this parameter.
+ *
+ *  @return NULL if the specified algorithm is not recognised, or the
+ *  algorithm is not available for the requested encoding.  Otherwise,
+ *  returns a pointer to a newly created stemmer for the requested algorithm.
+ *  The returned pointer must be deleted by calling sb_stemmer_delete().
+ *
+ *  @note NULL will also be returned if an out of memory error occurs.
+ */
+struct sb_stemmer * sb_stemmer_new(const char * algorithm, const char * charenc);
+
+/** Delete a stemmer object.
+ *
+ *  This frees all resources allocated for the stemmer.  After calling
+ *  this function, the supplied stemmer may no longer be used in any way.
+ *
+ *  It is safe to pass a null pointer to this function - this will have
+ *  no effect.
+ */
+void                sb_stemmer_delete(struct sb_stemmer * stemmer);
+
+/** Stem a word.
+ *
+ *  The return value is owned by the stemmer - it must not be freed or
+ *  modified, and it will become invalid when the stemmer is called again,
+ *  or if the stemmer is freed.
+ *
+ *  The length of the return value can be obtained using sb_stemmer_length().
+ *
+ *  If an out-of-memory error occurs, this will return NULL.
+ */
+const sb_symbol *   sb_stemmer_stem(struct sb_stemmer * stemmer,
+				    const sb_symbol * word, int size);
+
+/** Get the length of the result of the last stemmed word.
+ *  This should not be called before sb_stemmer_stem() has been called.
+ */
+int                 sb_stemmer_length(struct sb_stemmer * stemmer);
+
+#ifdef __cplusplus
+}
+#endif
+

data/ext/modules.h

@@ -0,0 +1,162 @@
+/* libstemmer/modules.h: List of stemming modules.
+ *
+ * This file is generated by mkmodules.pl from a list of module names.
+ * Do not edit manually.
+ *
+ * Modules included by this file are: danish, dutch, english, finnish, french,
+ * german, italian, norwegian, porter, portuguese, russian, spanish, swedish
+ */
+
+#include "stem_ISO_8859_1_danish.h"
+#include "stem_UTF_8_danish.h"
+#include "stem_ISO_8859_1_dutch.h"
+#include "stem_UTF_8_dutch.h"
+#include "stem_ISO_8859_1_english.h"
+#include "stem_UTF_8_english.h"
+#include "stem_ISO_8859_1_finnish.h"
+#include "stem_UTF_8_finnish.h"
+#include "stem_ISO_8859_1_french.h"
+#include "stem_UTF_8_french.h"
+#include "stem_ISO_8859_1_german.h"
+#include "stem_UTF_8_german.h"
+#include "stem_ISO_8859_1_italian.h"
+#include "stem_UTF_8_italian.h"
+#include "stem_ISO_8859_1_norwegian.h"
+#include "stem_UTF_8_norwegian.h"
+#include "stem_ISO_8859_1_porter.h"
+#include "stem_UTF_8_porter.h"
+#include "stem_ISO_8859_1_portuguese.h"
+#include "stem_UTF_8_portuguese.h"
+#include "stem_KOI8_R_russian.h"
+#include "stem_UTF_8_russian.h"
+#include "stem_ISO_8859_1_spanish.h"
+#include "stem_UTF_8_spanish.h"
+#include "stem_ISO_8859_1_swedish.h"
+#include "stem_UTF_8_swedish.h"
+
+typedef enum {
+  ENC_UNKNOWN,
+  ENC_ISO_8859_1,
+  ENC_KOI8_R,
+  ENC_UTF_8
+} stemmer_encoding;
+
+struct stemmer_encoding {
+  const char * name;
+  stemmer_encoding enc;
+};
+static struct stemmer_encoding encodings[] = {
+  {"ISO_8859_1", ENC_ISO_8859_1},
+  {"KOI8_R", ENC_KOI8_R},
+  {"UTF_8", ENC_UTF_8},
+  {0,0}
+};
+
+struct stemmer_modules {
+  const char * name;
+  stemmer_encoding enc; 
+  struct SN_env * (*create)(void);
+  void (*close)(struct SN_env *);
+  int (*stem)(struct SN_env *);
+};
+static struct stemmer_modules modules[] = {
+  {"da", ENC_ISO_8859_1, danish_ISO_8859_1_create_env, danish_ISO_8859_1_close_env, danish_ISO_8859_1_stem},
+  {"da", ENC_UTF_8, danish_UTF_8_create_env, danish_UTF_8_close_env, danish_UTF_8_stem},
+  {"dan", ENC_ISO_8859_1, danish_ISO_8859_1_create_env, danish_ISO_8859_1_close_env, danish_ISO_8859_1_stem},
+  {"dan", ENC_UTF_8, danish_UTF_8_create_env, danish_UTF_8_close_env, danish_UTF_8_stem},
+  {"danish", ENC_ISO_8859_1, danish_ISO_8859_1_create_env, danish_ISO_8859_1_close_env, danish_ISO_8859_1_stem},
+  {"danish", ENC_UTF_8, danish_UTF_8_create_env, danish_UTF_8_close_env, danish_UTF_8_stem},
+  {"de", ENC_ISO_8859_1, german_ISO_8859_1_create_env, german_ISO_8859_1_close_env, german_ISO_8859_1_stem},
+  {"de", ENC_UTF_8, german_UTF_8_create_env, german_UTF_8_close_env, german_UTF_8_stem},
+  {"deu", ENC_ISO_8859_1, german_ISO_8859_1_create_env, german_ISO_8859_1_close_env, german_ISO_8859_1_stem},
+  {"deu", ENC_UTF_8, german_UTF_8_create_env, german_UTF_8_close_env, german_UTF_8_stem},
+  {"dut", ENC_ISO_8859_1, dutch_ISO_8859_1_create_env, dutch_ISO_8859_1_close_env, dutch_ISO_8859_1_stem},
+  {"dut", ENC_UTF_8, dutch_UTF_8_create_env, dutch_UTF_8_close_env, dutch_UTF_8_stem},
+  {"dutch", ENC_ISO_8859_1, dutch_ISO_8859_1_create_env, dutch_ISO_8859_1_close_env, dutch_ISO_8859_1_stem},
+  {"dutch", ENC_UTF_8, dutch_UTF_8_create_env, dutch_UTF_8_close_env, dutch_UTF_8_stem},
+  {"en", ENC_ISO_8859_1, english_ISO_8859_1_create_env, english_ISO_8859_1_close_env, english_ISO_8859_1_stem},
+  {"en", ENC_UTF_8, english_UTF_8_create_env, english_UTF_8_close_env, english_UTF_8_stem},
+  {"eng", ENC_ISO_8859_1, english_ISO_8859_1_create_env, english_ISO_8859_1_close_env, english_ISO_8859_1_stem},
+  {"eng", ENC_UTF_8, english_UTF_8_create_env, english_UTF_8_close_env, english_UTF_8_stem},
+  {"english", ENC_ISO_8859_1, english_ISO_8859_1_create_env, english_ISO_8859_1_close_env, english_ISO_8859_1_stem},
+  {"english", ENC_UTF_8, english_UTF_8_create_env, english_UTF_8_close_env, english_UTF_8_stem},
+  {"es", ENC_ISO_8859_1, spanish_ISO_8859_1_create_env, spanish_ISO_8859_1_close_env, spanish_ISO_8859_1_stem},
+  {"es", ENC_UTF_8, spanish_UTF_8_create_env, spanish_UTF_8_close_env, spanish_UTF_8_stem},
+  {"esl", ENC_ISO_8859_1, spanish_ISO_8859_1_create_env, spanish_ISO_8859_1_close_env, spanish_ISO_8859_1_stem},
+  {"esl", ENC_UTF_8, spanish_UTF_8_create_env, spanish_UTF_8_close_env, spanish_UTF_8_stem},
+  {"fi", ENC_ISO_8859_1, finnish_ISO_8859_1_create_env, finnish_ISO_8859_1_close_env, finnish_ISO_8859_1_stem},
+  {"fi", ENC_UTF_8, finnish_UTF_8_create_env, finnish_UTF_8_close_env, finnish_UTF_8_stem},
+  {"fin", ENC_ISO_8859_1, finnish_ISO_8859_1_create_env, finnish_ISO_8859_1_close_env, finnish_ISO_8859_1_stem},
+  {"fin", ENC_UTF_8, finnish_UTF_8_create_env, finnish_UTF_8_close_env, finnish_UTF_8_stem},
+  {"finnish", ENC_ISO_8859_1, finnish_ISO_8859_1_create_env, finnish_ISO_8859_1_close_env, finnish_ISO_8859_1_stem},
+  {"finnish", ENC_UTF_8, finnish_UTF_8_create_env, finnish_UTF_8_close_env, finnish_UTF_8_stem},
+  {"fr", ENC_ISO_8859_1, french_ISO_8859_1_create_env, french_ISO_8859_1_close_env, french_ISO_8859_1_stem},
+  {"fr", ENC_UTF_8, french_UTF_8_create_env, french_UTF_8_close_env, french_UTF_8_stem},
+  {"fra", ENC_ISO_8859_1, french_ISO_8859_1_create_env, french_ISO_8859_1_close_env, french_ISO_8859_1_stem},
+  {"fra", ENC_UTF_8, french_UTF_8_create_env, french_UTF_8_close_env, french_UTF_8_stem},
+  {"fre", ENC_ISO_8859_1, french_ISO_8859_1_create_env, french_ISO_8859_1_close_env, french_ISO_8859_1_stem},
+  {"fre", ENC_UTF_8, french_UTF_8_create_env, french_UTF_8_close_env, french_UTF_8_stem},
+  {"french", ENC_ISO_8859_1, french_ISO_8859_1_create_env, french_ISO_8859_1_close_env, french_ISO_8859_1_stem},
+  {"french", ENC_UTF_8, french_UTF_8_create_env, french_UTF_8_close_env, french_UTF_8_stem},
+  {"ger", ENC_ISO_8859_1, german_ISO_8859_1_create_env, german_ISO_8859_1_close_env, german_ISO_8859_1_stem},
+  {"ger", ENC_UTF_8, german_UTF_8_create_env, german_UTF_8_close_env, german_UTF_8_stem},
+  {"german", ENC_ISO_8859_1, german_ISO_8859_1_create_env, german_ISO_8859_1_close_env, german_ISO_8859_1_stem},
+  {"german", ENC_UTF_8, german_UTF_8_create_env, german_UTF_8_close_env, german_UTF_8_stem},
+  {"it", ENC_ISO_8859_1, italian_ISO_8859_1_create_env, italian_ISO_8859_1_close_env, italian_ISO_8859_1_stem},
+  {"it", ENC_UTF_8, italian_UTF_8_create_env, italian_UTF_8_close_env, italian_UTF_8_stem},
+  {"ita", ENC_ISO_8859_1, italian_ISO_8859_1_create_env, italian_ISO_8859_1_close_env, italian_ISO_8859_1_stem},
+  {"ita", ENC_UTF_8, italian_UTF_8_create_env, italian_UTF_8_close_env, italian_UTF_8_stem},
+  {"italian", ENC_ISO_8859_1, italian_ISO_8859_1_create_env, italian_ISO_8859_1_close_env, italian_ISO_8859_1_stem},
+  {"italian", ENC_UTF_8, italian_UTF_8_create_env, italian_UTF_8_close_env, italian_UTF_8_stem},
+  {"nl", ENC_ISO_8859_1, dutch_ISO_8859_1_create_env, dutch_ISO_8859_1_close_env, dutch_ISO_8859_1_stem},
+  {"nl", ENC_UTF_8, dutch_UTF_8_create_env, dutch_UTF_8_close_env, dutch_UTF_8_stem},
+  {"nld", ENC_ISO_8859_1, dutch_ISO_8859_1_create_env, dutch_ISO_8859_1_close_env, dutch_ISO_8859_1_stem},
+  {"nld", ENC_UTF_8, dutch_UTF_8_create_env, dutch_UTF_8_close_env, dutch_UTF_8_stem},
+  {"no", ENC_ISO_8859_1, norwegian_ISO_8859_1_create_env, norwegian_ISO_8859_1_close_env, norwegian_ISO_8859_1_stem},
+  {"no", ENC_UTF_8, norwegian_UTF_8_create_env, norwegian_UTF_8_close_env, norwegian_UTF_8_stem},
+  {"nor", ENC_ISO_8859_1, norwegian_ISO_8859_1_create_env, norwegian_ISO_8859_1_close_env, norwegian_ISO_8859_1_stem},
+  {"nor", ENC_UTF_8, norwegian_UTF_8_create_env, norwegian_UTF_8_close_env, norwegian_UTF_8_stem},
+  {"norwegian", ENC_ISO_8859_1, norwegian_ISO_8859_1_create_env, norwegian_ISO_8859_1_close_env, norwegian_ISO_8859_1_stem},
+  {"norwegian", ENC_UTF_8, norwegian_UTF_8_create_env, norwegian_UTF_8_close_env, norwegian_UTF_8_stem},
+  {"por", ENC_ISO_8859_1, portuguese_ISO_8859_1_create_env, portuguese_ISO_8859_1_close_env, portuguese_ISO_8859_1_stem},
+  {"por", ENC_UTF_8, portuguese_UTF_8_create_env, portuguese_UTF_8_close_env, portuguese_UTF_8_stem},
+  {"porter", ENC_ISO_8859_1, porter_ISO_8859_1_create_env, porter_ISO_8859_1_close_env, porter_ISO_8859_1_stem},
+  {"porter", ENC_UTF_8, porter_UTF_8_create_env, porter_UTF_8_close_env, porter_UTF_8_stem},
+  {"portuguese", ENC_ISO_8859_1, portuguese_ISO_8859_1_create_env, portuguese_ISO_8859_1_close_env, portuguese_ISO_8859_1_stem},
+  {"portuguese", ENC_UTF_8, portuguese_UTF_8_create_env, portuguese_UTF_8_close_env, portuguese_UTF_8_stem},
+  {"pt", ENC_ISO_8859_1, portuguese_ISO_8859_1_create_env, portuguese_ISO_8859_1_close_env, portuguese_ISO_8859_1_stem},
+  {"pt", ENC_UTF_8, portuguese_UTF_8_create_env, portuguese_UTF_8_close_env, portuguese_UTF_8_stem},
+  {"ru", ENC_KOI8_R, russian_KOI8_R_create_env, russian_KOI8_R_close_env, russian_KOI8_R_stem},
+  {"ru", ENC_UTF_8, russian_UTF_8_create_env, russian_UTF_8_close_env, russian_UTF_8_stem},
+  {"rus", ENC_KOI8_R, russian_KOI8_R_create_env, russian_KOI8_R_close_env, russian_KOI8_R_stem},
+  {"rus", ENC_UTF_8, russian_UTF_8_create_env, russian_UTF_8_close_env, russian_UTF_8_stem},
+  {"russian", ENC_KOI8_R, russian_KOI8_R_create_env, russian_KOI8_R_close_env, russian_KOI8_R_stem},
+  {"russian", ENC_UTF_8, russian_UTF_8_create_env, russian_UTF_8_close_env, russian_UTF_8_stem},
+  {"spa", ENC_ISO_8859_1, spanish_ISO_8859_1_create_env, spanish_ISO_8859_1_close_env, spanish_ISO_8859_1_stem},
+  {"spa", ENC_UTF_8, spanish_UTF_8_create_env, spanish_UTF_8_close_env, spanish_UTF_8_stem},
+  {"spanish", ENC_ISO_8859_1, spanish_ISO_8859_1_create_env, spanish_ISO_8859_1_close_env, spanish_ISO_8859_1_stem},
+  {"spanish", ENC_UTF_8, spanish_UTF_8_create_env, spanish_UTF_8_close_env, spanish_UTF_8_stem},
+  {"sv", ENC_ISO_8859_1, swedish_ISO_8859_1_create_env, swedish_ISO_8859_1_close_env, swedish_ISO_8859_1_stem},
+  {"sv", ENC_UTF_8, swedish_UTF_8_create_env, swedish_UTF_8_close_env, swedish_UTF_8_stem},
+  {"swe", ENC_ISO_8859_1, swedish_ISO_8859_1_create_env, swedish_ISO_8859_1_close_env, swedish_ISO_8859_1_stem},
+  {"swe", ENC_UTF_8, swedish_UTF_8_create_env, swedish_UTF_8_close_env, swedish_UTF_8_stem},
+  {"swedish", ENC_ISO_8859_1, swedish_ISO_8859_1_create_env, swedish_ISO_8859_1_close_env, swedish_ISO_8859_1_stem},
+  {"swedish", ENC_UTF_8, swedish_UTF_8_create_env, swedish_UTF_8_close_env, swedish_UTF_8_stem},
+  {0,0,0,0,0}
+};
+static const char * algorithm_names[] = {
+  "danish", 
+  "dutch", 
+  "english", 
+  "finnish", 
+  "french", 
+  "german", 
+  "italian", 
+  "norwegian", 
+  "porter", 
+  "portuguese", 
+  "russian", 
+  "spanish", 
+  "swedish", 
+  0
+};

data/ext/q_boolean.c

@@ -1,6 +1,12 @@
 #include <string.h>
 #include "search.h"
 
+static char * const INVALID_BC_ERROR_MSG = "Invalid value for BooleanClause Type";
+static char * const TOO_MANY_CLAUSES_ERROR_MSG = "Too many clauses";
+static char * const MIN_NUM_MATCHES_ERROR_MSG = "Minimum nr of matches must be positive";
+static char * const TWO_SUB_ERROR_MSG = "There must be at least 2 sub_scorers";
+static char * const UNKNOWN_OCCUR_VAL_ERROR_MSG = "Unknown value for occur";
+
 /***************************************************************************
  *
  * BooleanWeight
@@ -70,9 +76,7 @@ Scorer *bw_scorer(Weight *self, IndexReader *ir)
 
 char *bw_to_s(Weight *self)
 {
-  char dbuf[32];
-  dbl_to_s(dbuf, self->value);
-  return epstrdup("BooleanWeight(%s)", strlen(dbuf), dbuf);
+  return strfmt("BooleanWeight(%f)", self->value);
 }
 
 void bw_destroy(void *p)
@@ -138,7 +142,7 @@ Explanation *bw_explain(Weight *self, IndexReader *ir, int doc_num)
     explanation = expl_create(sum * coord_factor, estrdup("product of:"));
     expl_add_detail(explanation, sum_expl);
     expl_add_detail(explanation, expl_create(coord_factor, 
-          epstrdup("coord(%d/%d)", 40, coord, max_coord)));
+          strfmt("coord(%d/%d)", coord, max_coord)));
     return explanation;
   }
 }
@@ -196,10 +200,16 @@ void bc_set_occur(BooleanClause *self, unsigned int occur)
       self->is_required = false;
       break;
     default:
-      eprintf(ARG_ERROR, "Invalid value %d for BooleanClause Type", occur);
+      RAISE(ARG_ERROR, INVALID_BC_ERROR_MSG);
   }
 }
 
+void bc_destroy(BooleanClause *self)
+{
+  self->query->destroy(self->query);
+  free(self);
+}
+
 BooleanClause *bc_create(Query *query, unsigned int occur)
 {
   BooleanClause *self = ALLOC(BooleanClause);
@@ -312,9 +322,7 @@ char *bq_to_s(Query *self, char *field)
   }
 
   if (self->boost != 1.0) {
-    char dbuf[32];
-    dbl_to_s(dbuf, self->boost);
-    char *boost_str = epstrdup(")^%s", strlen(dbuf), dbuf);
+    char *boost_str = strfmt(")^%f", self->boost);
     int boost_len = strlen(boost_str);
     REALLOC_N(buffer, char, bp + boost_len + 1);
     memcpy(buffer + bp, boost_str, sizeof(char) * boost_len);
@@ -329,12 +337,11 @@ void bq_destroy(void *p)
 {
   Query *self = (Query *)p;
   BooleanQuery *bq = (BooleanQuery *)self->data;
-  BooleanClause *clause;
   int i;
-  for (i = 0; i < bq->clause_cnt; i++) {
-    clause = bq->clauses[i];
-    if (self->destroy_all) clause->query->destroy(clause->query);
-    free(clause);
+  if (self->destroy_all) {
+    for (i = 0; i < bq->clause_cnt; i++) {
+      bc_destroy(bq->clauses[i]);
+    }
   }
   free(bq->clauses);
   if (bq->similarity) {
@@ -387,19 +394,25 @@ Query *bq_create(bool coord_disabled)
   return self;
 }
 
-void bq_add_query(Query *self, Query *sub_query, unsigned int occur)
+BooleanClause *bq_add_clause(Query *self, BooleanClause *bc)
 {
   BooleanQuery *bq = (BooleanQuery *)self->data;
-  BooleanClause *bc = bc_create(sub_query, occur);
   if (bq->clause_cnt >= bq->clause_capa) {
     bq->clause_capa *= 2;
     REALLOC_N(bq->clauses, BooleanClause *, bq->clause_capa);
   }
   if (bq->clause_cnt > bq->max_clause_cnt) {
-    eprintf(STATE_ERROR, "Too many clauses.");
+    RAISE(STATE_ERROR, TOO_MANY_CLAUSES_ERROR_MSG);
   }
   bq->clauses[bq->clause_cnt] = bc;
   bq->clause_cnt++;
+  return 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);
 }
 
 /***************************************************************************
@@ -551,7 +564,7 @@ Explanation *dssc_explain(Scorer *self, int doc_num)
   DisjunctionSumScorer *dssc = (DisjunctionSumScorer *)self->data;
   Scorer *sub_scorer;
   Explanation *e = expl_create(0.0,
-      epstrdup("At least %d of:", 20, dssc->min_num_matches));
+      strfmt("At least %d of:", dssc->min_num_matches));
   for (i = 0; i < dssc->ss_cnt; i++) {
     sub_scorer = dssc->sub_scorers[i];
     expl_add_detail(e, sub_scorer->explain(sub_scorer, doc_num));
@@ -567,7 +580,7 @@ void dssc_destroy(void *p)
   for (i = 0; i < dssc->ss_cnt; i++) {
     dssc->sub_scorers[i]->destroy(dssc->sub_scorers[i]);
   }
-  pq_destroy(dssc->scorer_queue);
+  if (dssc->scorer_queue) pq_destroy(dssc->scorer_queue);
   scorer_destroy(self);
 }
 
@@ -588,10 +601,10 @@ Scorer *disjunction_sum_scorer_create(Scorer **sub_scorers, int ss_cnt,
   dssc->coordinator = NULL;
 
   if (min_num_matches <= 0) {
-    eprintf(ARG_ERROR, "Minimum nr of matches must be positive");
+    RAISE(ARG_ERROR, MIN_NUM_MATCHES_ERROR_MSG);
   }
   if (ss_cnt <= 1) {
-    eprintf(ARG_ERROR, "There must be at least 2 sub_scorers");
+    RAISE(ARG_ERROR, TWO_SUB_ERROR_MSG);
   }
 
   dssc->min_num_matches = min_num_matches;
@@ -1231,7 +1244,7 @@ void bsc_add_scorer(Scorer *self, Scorer *scorer, unsigned int occur)
       bsc->prohibited_scorers[bsc->ps_cnt++] = scorer;
       break;
     default:
-      eprintf(ARG_ERROR, "Unknown value for occur <%d>\n", occur);
+      RAISE(ARG_ERROR, UNKNOWN_OCCUR_VAL_ERROR_MSG);
   }
 }