ferret 0.11.6 → 0.11.8.4

data/ext/posh.h

@@ -1,7 +1,7 @@
 /**
 @file posh.h
 @author Brian Hook
-@version 1.3.001
+@version 1.3.002
 
 Header file for POSH, the Portable Open Source Harness project.
 
@@ -62,6 +62,7 @@ REVISION:
 I've been lax about revision histories, so this starts at, um, 1.3.001.
 Sorry for any inconveniences.
 
+1.3.002 - 8/29/2006 - Removed FORCE_DOXYGEN stuff
 1.3.001 - 2/23/2006 - Incorporated fix for bug reported by Bill Cary,
                       where I was not detecting Visual Studio
                       compilation on x86-64 systems.  Added check for
@@ -522,9 +523,7 @@ Metrowerks:
 ** -----------------------------------------------------------------------------
 */
 #if !defined POSH_OS_STRING
-#  if !defined FORCE_DOXYGEN
-#    define POSH_OS_EMBEDDED 1 
-#  endif
+#  define POSH_OS_EMBEDDED 1 
 #  if defined _R5900
 #     define POSH_OS_STRING "Sony PS2(embedded)"
 #  else
@@ -617,13 +616,6 @@ Metrowerks:
 #  define POSH_IMPORTEXPORT
 #endif
 
-#if defined FORCE_DOXYGEN
-#  define POSH_DLL    
-#  define POSH_BUILDING_LIB
-#  undef POSH_DLL
-#  undef POSH_BUILDING_LIB
-#endif
-
 /*
 ** ----------------------------------------------------------------------------
 ** (Re)define POSH_PUBLIC_API export signature 
@@ -656,10 +648,6 @@ Metrowerks:
 #  define POSH_BIG_ENDIAN 1
 #endif
 
-#if defined FORCE_DOXYGEN
-#  define POSH_LITTLE_ENDIAN
-#endif
-
 /*
 ** ----------------------------------------------------------------------------
 ** Cross-platform compile time assertion macro
@@ -709,15 +697,6 @@ typedef unsigned long long posh_u64_t;
 #define POSH_I64_PRINTF_PREFIX "I64"
 #endif
 
-#ifdef FORCE_DOXYGEN
-typedef long long posh_i64_t;
-typedef unsigned long posh_u64_t;
-#  define POSH_64BIT_INTEGER
-#  define POSH_I64_PRINTF_PREFIX
-#  define POSH_I64(x)
-#  define POSH_U64(x)
-#endif
-
 /** Minimum value for a 64-bit signed integer */
 #define POSH_I64_MIN  POSH_I64(0x8000000000000000)
 /** Maximum value for a 64-bit signed integer */
@@ -810,8 +789,6 @@ typedef signed char    posh_i8_t;
 ** Sanity checks on expected sizes
 ** ----------------------------------------------------------------------------
 */
-#if !defined FORCE_DOXYGEN
-
 POSH_COMPILE_TIME_ASSERT(posh_byte_t, sizeof(posh_byte_t) == 1);
 POSH_COMPILE_TIME_ASSERT(posh_u8_t, sizeof(posh_u8_t) == 1);
 POSH_COMPILE_TIME_ASSERT(posh_i8_t, sizeof(posh_i8_t) == 1);
@@ -830,8 +807,6 @@ POSH_COMPILE_TIME_ASSERT(posh_i32_t, sizeof(posh_i32_t) == 4);
    POSH_COMPILE_TIME_ASSERT(posh_i64_t, sizeof(posh_i64_t) == 8);
 #endif
 
-#endif
-
 /*
 ** ----------------------------------------------------------------------------
 ** 64-bit pointer support
@@ -851,7 +826,7 @@ POSH_COMPILE_TIME_ASSERT(posh_i32_t, sizeof(posh_i32_t) == 4);
 
 #if defined POSH_64BIT_POINTER
    POSH_COMPILE_TIME_ASSERT( posh_64bit_pointer, sizeof( void * ) == 8 );
-#elif !defined FORCE_DOXYGEN
+#else
 /* if this assertion is hit then you're on a system that either has 64-bit
    addressing and we didn't catch it, or you're on a system with 16-bit
    pointers.  In the latter case, POSH doesn't actually care, we're just
@@ -863,10 +838,6 @@ POSH_COMPILE_TIME_ASSERT(posh_i32_t, sizeof(posh_i32_t) == 4);
    POSH_COMPILE_TIME_ASSERT( posh_32bit_pointer, sizeof( void * ) == 4 );
 #endif
 
-#if defined FORCE_DOXYGEN
-#  define POSH_64BIT_POINTER
-#endif
-
 /*
 ** ----------------------------------------------------------------------------
 ** POSH Utility Functions
@@ -907,11 +878,6 @@ double      POSH_ReadDoubleFromBig( const void *src );
 */
 #endif /* !defined POSH_NO_FLOAT */
 
-#if defined FORCE_DOXYGEN
-#  define POSH_NO_FLOAT
-#  undef  POSH_NO_FLOAT
-#endif
-
 extern posh_u16_t  POSH_SwapU16( posh_u16_t u );
 extern posh_i16_t  POSH_SwapI16( posh_i16_t u );
 extern posh_u32_t  POSH_SwapU32( posh_u32_t u );

data/ext/priorityqueue.c

@@ -1,11 +1,10 @@
 #include <string.h>
 #include "priorityqueue.h"
+#include "internal.h"
 
 #define START_CAPA 127
 
-PriorityQueue *pq_new(int capa,
-                      bool (*less_than)(const void *p1, const void *p2),
-                      void (*free_elem)(void *elem))
+PriorityQueue *pq_new(int capa, lt_ft less_than, free_ft free_elem)
 {
     PriorityQueue *pq = ALLOC(PriorityQueue);
     pq->size = 0;
@@ -111,22 +110,23 @@ void pq_push(PriorityQueue *pq, void *elem)
     pq_up(pq);
 }
 
-int pq_insert(PriorityQueue *pq, void *elem)
+PriorityQueueInsertEnum pq_insert(PriorityQueue *pq,
+                                  void *elem)
 {
     if (pq->size < pq->capa) {
         pq_push(pq, elem);
         return PQ_ADDED;
     }
-    else if (pq->size > 0 && pq->less_than_i(pq->heap[1], elem)) {
+
+    if (pq->size > 0 && pq->less_than_i(pq->heap[1], elem)) {
         pq->free_elem_i(pq->heap[1]);
         pq->heap[1] = elem;
         pq_down(pq);
         return PQ_INSERTED;
     }
-    else {
-        pq->free_elem_i(elem);
-        return PQ_DROPPED;
-    }
+
+    pq->free_elem_i(elem);
+    return PQ_DROPPED;
 }
 
 void *pq_top(PriorityQueue *pq)
@@ -144,8 +144,6 @@ void *pq_pop(PriorityQueue *pq)
         pq_down(pq);                      /* adjust heap */
         return result;
     }
-    else {
-        return NULL;
-    }
+    return NULL;
 }
 

data/ext/priorityqueue.h

@@ -1,23 +1,27 @@
 #ifndef FRT_PRIORITYQUEUE_H
 #define FRT_PRIORITYQUEUE_H
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include "global.h"
 
-typedef bool(*lt_ft) (const void *p1, const void *p2);
+typedef bool (*frt_lt_ft)(const void *p1, const void *p2);
 
 /**
  * A PriorityQueue has a fixed size and contains a less_than function and a
  * free_elem function specific to the data type to be stored in the queue.
  */
-typedef struct PriorityQueue
+typedef struct FrtPriorityQueue
 {
     int size;
     int capa;
     int mem_capa;
     void **heap;
-    lt_ft less_than_i;
-    free_ft free_elem_i;
-} PriorityQueue;
+    frt_lt_ft less_than_i;
+    frt_free_ft free_elem_i;
+} FrtPriorityQueue;
 
 /**
  * Create a new PriorityQueue setting the less_than and free_elem for this
@@ -31,9 +35,9 @@ typedef struct PriorityQueue
  *   when it is destroyed or there is insertion overflow
  * @return a newly allocated PriorityQueue
  */
-extern PriorityQueue *pq_new(int capa,
-                             bool (*less_than)(const void *p1, const void *p2),
-                             void (*free_elem)(void *elem));
+extern FrtPriorityQueue *frt_pq_new(int capa,
+                                       frt_lt_ft less_than,
+                                       frt_free_ft free_elem);
 
 /**
  * Allocate a clone of the PriorityQueue. This can be used if you want to scan
@@ -43,7 +47,7 @@ extern PriorityQueue *pq_new(int capa,
  * @param pq the priority queue to clone
  * @return a clone of the original priority queue
  */
-extern PriorityQueue *pq_clone(PriorityQueue *pq);
+extern FrtPriorityQueue *frt_pq_clone(FrtPriorityQueue *pq);
 
 /**
  * Clear all elements from the PriorityQueue and reset the size to 0. When
@@ -52,7 +56,7 @@ extern PriorityQueue *pq_clone(PriorityQueue *pq);
  *
  * @param self the PriorityQueue to clear
  */
-extern void pq_clear(PriorityQueue *self);
+extern void frt_pq_clear(FrtPriorityQueue *self);
 
 /**
  * Free the memory allocated to the PriorityQueue. This function does nothing
@@ -61,7 +65,7 @@ extern void pq_clear(PriorityQueue *self);
  *
  * @param self the PriorityQueue to free
  */
-extern void pq_free(PriorityQueue *self);
+extern void frt_pq_free(FrtPriorityQueue *self);
 
 /**
  * Destroy the PriorityQueue, freeing all memory allocated to it and also
@@ -70,7 +74,7 @@ extern void pq_free(PriorityQueue *self);
  *
  * @param the PriorityQueue to destroy
  */
-extern void pq_destroy(PriorityQueue *self);
+extern void frt_pq_destroy(FrtPriorityQueue *self);
 
 /**
  * Reorder the PriorityQueue after the top element has been modified. This
@@ -80,7 +84,7 @@ extern void pq_destroy(PriorityQueue *self);
  *
  * @param self the PriorityQueue to reorder
  */
-extern void pq_down(PriorityQueue *self);
+extern void frt_pq_down(FrtPriorityQueue *self);
 
 /**
  * Add another element to the PriorityQueue. This method should only be used
@@ -92,11 +96,14 @@ extern void pq_down(PriorityQueue *self);
  * @param self the PriorityQueue to add the element to
  * @param elem the element to add to the PriorityQueue
  */
-extern void pq_push(PriorityQueue *self, void *elem);
+extern void frt_pq_push(FrtPriorityQueue *self, void *elem);
+
+typedef enum {
+    FRT_PQ_DROPPED = 0,
+    FRT_PQ_ADDED,
+    FRT_PQ_INSERTED
+} FrtPriorityQueueInsertEnum;
 
-#define PQ_DROPPED 0
-#define PQ_ADDED 1
-#define PQ_INSERTED 2
 /**
  * Add another element to the PriorityQueue. Unlike pq_push, this method
  * handles insertion overflow. That is, when you insert more elements than the
@@ -114,7 +121,8 @@ extern void pq_push(PriorityQueue *self, void *elem);
  *                      element was dropped and destroyed
  *   </pre>
  */
-extern int pq_insert(PriorityQueue *self, void *elem);
+extern FrtPriorityQueueInsertEnum frt_pq_insert(FrtPriorityQueue *self,
+                                                   void *elem);
 
 /**
  * Get the top element in the PriorityQueue.
@@ -122,7 +130,7 @@ extern int pq_insert(PriorityQueue *self, void *elem);
  * @param self the PriorityQueue to get the top from
  * @return the top element in the PriorityQueue
  */
-extern void *pq_top(PriorityQueue *self);
+extern void *frt_pq_top(FrtPriorityQueue *self);
 
 /**
  * Remove and return the top element in the PriorityQueue.
@@ -130,7 +138,7 @@ extern void *pq_top(PriorityQueue *self);
  * @param self the PriorityQueue to get the top from
  * @return the top element in the PriorityQueue
  */
-extern void *pq_pop(PriorityQueue *self);
+extern void *frt_pq_pop(FrtPriorityQueue *self);
 
 /**
  * Return true if the PriorityQueue is full.
@@ -138,6 +146,10 @@ extern void *pq_pop(PriorityQueue *self);
  * @param self the PriorityQueue to test
  * @return true if the PriorityQueue is full.
  */
-#define pq_full(pq) ((pq)->size == (pq)->capa)
+#define frt_pq_full(pq) ((pq)->size == (pq)->capa)
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
 
 #endif

data/ext/q_boolean.c

@@ -1,6 +1,7 @@
 #include <string.h>
 #include "search.h"
 #include "array.h"
+#include "internal.h"
 
 #define BQ(query) ((BooleanQuery *)(query))
 #define BW(weight) ((BooleanWeight *)(weight))
@@ -110,7 +111,7 @@ static bool dssc_advance_after_current(Scorer *self)
                     break;
                 }
             }
-            top = pq_top(scorer_queue);
+            top = (Scorer *)pq_top(scorer_queue);
             if (top->doc != self->doc) {
                 /* All remaining subscorers are after self->doc */
                 break;
@@ -161,7 +162,7 @@ static bool dssc_skip_to(Scorer *self, int doc_num)
         doc_num = self->doc + 1;
     }
     while (true) { 
-        Scorer *top = pq_top(scorer_queue);
+        Scorer *top = (Scorer *)pq_top(scorer_queue);
         if (top->doc >= doc_num) {
             return dssc_advance_after_current(self);
         }
@@ -280,7 +281,19 @@ typedef struct ConjunctionScorer
 
 static void csc_sort_scorers(ConjunctionScorer *csc)
 {
-    qsort(csc->sub_scorers, csc->ss_cnt, sizeof(Scorer *), &scorer_doc_cmp);
+    int i;
+    Scorer *current = csc->sub_scorers[0], *previous;
+    for (i = 1; i < csc->ss_cnt; i++) {
+        previous = current;
+        current = csc->sub_scorers[i];
+        if (previous->doc > current->doc) {
+            if (!current->skip_to(current, previous->doc)) {
+                csc->more = false;
+                return;
+            }
+        }
+    }
+    /*qsort(csc->sub_scorers, csc->ss_cnt, sizeof(Scorer *), &scorer_doc_cmp);*/
     csc->first_idx = 0;
 }
 
@@ -371,7 +384,7 @@ static bool csc_skip_to(Scorer *self, int doc_num)
     bool more = csc->more;
 
     if (csc->first_time) {
-        csc_init(self, true);
+        csc_init(self, false);
     }
 
     for (i = 0; i < sub_sc_cnt; i++) {
@@ -1255,7 +1268,7 @@ static Weight *bw_new(Query *query, Searcher *searcher)
  *
  ***************************************************************************/
 
-void bc_set_occur(BooleanClause *self, enum BC_TYPE occur)
+void bc_set_occur(BooleanClause *self, BCType occur)
 {
     self->occur = occur;
     switch (occur) {
@@ -1295,7 +1308,7 @@ static int  bc_eq(BooleanClause *self, BooleanClause *o)
     return ((self->occur == o->occur) && q_eq(self->query, o->query)); 
 }
 
-BooleanClause *bc_new(Query *query, enum BC_TYPE occur)
+BooleanClause *bc_new(Query *query, BCType occur)
 {
     BooleanClause *self = ALLOC(BooleanClause);
     self->ref_cnt = 1;
@@ -1402,7 +1415,7 @@ static void bq_extract_terms(Query *self, HashSet *terms)
     }
 }
 
-static char *bq_to_s(Query *self, const char *field)
+static char *bq_to_s(Query *self, Symbol field)
 {
     int i;
     BooleanClause *clause;
@@ -1585,7 +1598,7 @@ BooleanClause *bq_add_clause(Query *self, BooleanClause *bc)
     return bq_add_clause_nr(self, bc);
 }
 
-BooleanClause *bq_add_query_nr(Query *self, Query *sub_query, enum BC_TYPE occur)
+BooleanClause *bq_add_query_nr(Query *self, Query *sub_query, BCType occur)
 {
     BooleanClause *bc;
     if (BQ(self)->clause_cnt >= BQ(self)->max_clause_cnt) {
@@ -1600,7 +1613,7 @@ BooleanClause *bq_add_query_nr(Query *self, Query *sub_query, enum BC_TYPE occur
     return bc;
 }
 
-BooleanClause *bq_add_query(Query *self, Query *sub_query, enum BC_TYPE occur)
+BooleanClause *bq_add_query(Query *self, Query *sub_query, BCType occur)
 {
     REF(sub_query);
     return bq_add_query_nr(self, sub_query, occur);

data/ext/q_const_score.c

@@ -1,5 +1,6 @@
 #include "search.h"
 #include <string.h>
+#include "internal.h"
 
 /***************************************************************************
  *
@@ -107,12 +108,12 @@ static Weight *csw_new(Query *query, Searcher *searcher)
  *
  ***************************************************************************/
 
-static char *csq_to_s(Query *self, const char *field)
+static char *csq_to_s(Query *self, Symbol default_field)
 {
     Filter *filter = CScQ(self)->filter;
     char *filter_str = filter->to_s(filter);
     char *buffer;
-    (void)field;
+    (void)default_field;
     if (self->boost == 1.0) {
         buffer = strfmt("ConstantScore(%s)", filter_str);
     }

data/ext/q_filtered_query.c

@@ -1,5 +1,6 @@
 #include "search.h"
 #include <string.h>
+#include "internal.h"
 
 /***************************************************************************
  *
@@ -17,13 +18,13 @@ typedef struct FilteredQueryScorer
     BitVector  *bv;
 } FilteredQueryScorer;
 
-float fqsc_score(Scorer *self)
+static float fqsc_score(Scorer *self)
 {
     Scorer *sub_sc = FQSc(self)->sub_scorer;
     return sub_sc->score(sub_sc);
 }
 
-bool fqsc_next(Scorer *self)
+static bool fqsc_next(Scorer *self)
 {
     Scorer *sub_sc = FQSc(self)->sub_scorer;
     BitVector *bv = FQSc(self)->bv;
@@ -34,33 +35,35 @@ bool fqsc_next(Scorer *self)
     return false;
 }
 
-bool fqsc_skip_to(Scorer *self, int doc_num)
+static bool fqsc_skip_to(Scorer *self, int doc_num)
 {
     Scorer *sub_sc = FQSc(self)->sub_scorer;
     BitVector *bv = FQSc(self)->bv;
     if (sub_sc->skip_to(sub_sc, doc_num)) {
-        self->doc = sub_sc->doc;
         do {
-            if (bv_get(bv, self->doc)) return true;
+            self->doc = sub_sc->doc;
+            if (bv_get(bv, self->doc)) {
+                return true;
+            }
         } while (sub_sc->next(sub_sc));
     }
     return false;
 }
 
-Explanation *fqsc_explain(Scorer *self, int doc_num)
+static Explanation *fqsc_explain(Scorer *self, int doc_num)
 {
     Scorer *sub_sc = FQSc(self)->sub_scorer;
     return sub_sc->explain(sub_sc, doc_num);
 }
 
-void fqsc_destroy(Scorer *self)
+static void fqsc_destroy(Scorer *self)
 {
     FilteredQueryScorer *fqsc = FQSc(self);
     fqsc->sub_scorer->destroy(fqsc->sub_scorer);
     scorer_destroy_i(self);
 }
 
-Scorer *fqsc_new(Scorer *scorer, BitVector *bv, Similarity *sim)
+static Scorer *fqsc_new(Scorer *scorer, BitVector *bv, Similarity *sim)
 {
     Scorer *self            = scorer_new(FilteredQueryScorer, sim);
 
@@ -161,11 +164,11 @@ static Weight *fqw_new(Query *query, Weight *sub_weight, Similarity *sim)
  *
  ***************************************************************************/
 
-static char *fq_to_s(Query *self, const char *field)
+static char *fq_to_s(Query *self, Symbol default_field)
 {
     FilteredQuery *fq = FQQ(self);
     char *filter_str = fq->filter->to_s(fq->filter);
-    char *query_str = fq->query->to_s(fq->query, field);
+    char *query_str = fq->query->to_s(fq->query, default_field);
     char *buffer;
     if (self->boost == 1.0) {
         buffer = strfmt("FilteredQuery(query:%s, filter:%s)",
@@ -179,14 +182,14 @@ static char *fq_to_s(Query *self, const char *field)
     return buffer;;
 }
 
-void fq_destroy(Query *self)
+static void fq_destroy(Query *self)
 {
     filt_deref(FQQ(self)->filter);
     q_deref(FQQ(self)->query);
     q_destroy_i(self);
 }
 
-Weight *fq_new_weight(Query *self, Searcher *searcher)
+static Weight *fq_new_weight(Query *self, Searcher *searcher)
 {
     Query *sub_query = FQQ(self)->query;
     return fqw_new(self, q_weight(sub_query, searcher),