ferret 0.9.6 → 0.10.0

data/ext/defines.h

@@ -0,0 +1,49 @@
+#ifndef FRT_DEFINES_H
+#define FRT_DEFINES_H
+
+#include <sys/types.h>
+#include "posh.h"
+
+#ifndef false
+#define false 0
+#endif
+#ifndef true
+#define true  1
+#endif
+
+typedef unsigned int        bool;
+typedef unsigned char       uchar;
+typedef unsigned int        uint;
+typedef unsigned long int   ulong;
+
+typedef posh_u16_t f_u16;
+typedef posh_i16_t f_i16;
+typedef posh_u32_t f_u32;
+typedef posh_i32_t f_i32;
+typedef posh_u64_t f_u64;
+typedef posh_i64_t f_i64;
+
+#if defined(_FILE_OFFSET_BITS) && (_FILE_OFFSET_BITS == 64)
+#define F_OFF_T_PFX "ll"
+#else
+#define F_OFF_T_PFX "l"
+#endif
+
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
+#define FRT_HAS_INLINE
+#define FRT_IS_C99
+#define FRT_HAS_ISO_VARARGS
+#define FRT_HAS_VARARGS
+#endif
+
+#if defined(__GNUC__) && !defined(__STRICT_ANSI__)
+#define FRT_HAS_INLINE
+#define FRT_HAS_GNUC_VARARGS
+#define FRT_HAS_VARARGS
+#endif
+
+#ifndef FRT_HAS_INLINE
+# define inline
+#endif
+
+#endif

data/ext/document.c

@@ -7,192 +7,86 @@
  *
  ****************************************************************************/
 
-static char * const INDEX_NO_STORE_NO_MSG = "it doesn't make sense to have a field that is neither indexed nor stored";
-static char * const INDEX_NO_TV_YES_MSG = "cannot store term vector information for a field that is not indexed";
-static char * const INVALID_STORE_VAL_MSG = "Invalid value for store in document field";
-static char * const INVALID_INDEX_VAL_MSG = "Invalid value for index in document field";
-static char * const INVALID_TV_VAL_MSG = "Invalid value for term_vector in document field";
-static char * const BIN_FIELD_STORE_NO_MSG = "It doesn't make sense not to store binary data";
-
-/**
- * @throws ARG_ERROR
- */
-inline void df_set(DocField *df, const char *name,
-    char *data, int store, int index, int tv)
+DocField *df_new(const char *name)
 {
-  if ((index == DF_INDEX_NO) && (store == DF_STORE_NO))
-    RAISE(ARG_ERROR, INDEX_NO_STORE_NO_MSG);
-  if ((index == DF_INDEX_NO) && (tv != DF_TERM_VECTOR_NO))
-    RAISE(ARG_ERROR, INDEX_NO_TV_YES_MSG);
-  df->name = estrdup(name);
-  df->data = data;
-  df->blen = (int)strlen(data);
-  df_set_store(df, store);
-  df_set_index(df, index);
-  df_set_term_vector(df, tv);
-  df->is_binary = false;
-  df->boost = 1.0;
+    DocField *df = ALLOC(DocField);
+    df->name = estrdup(name);
+    df->size = 0;
+    df->capa = DF_INIT_CAPA;
+    df->data = ALLOC_N(char *, df->capa);
+    df->lengths = ALLOC_N(int, df->capa);
+    df->destroy_data = false;
+    df->boost = 1.0;
+    return df;
 }
 
-/*
- * @throws ARG_ERROR
- */
-DocField *df_create(const char *name, char *data, int store, int index, int tv)
+DocField *df_add_data_len(DocField *df, char *data, int len)
 {
-  DocField *df = ALLOC(DocField);
-  df_set(df, name, data, store, index, tv);
-  return df;
+    if (df->size >= df->capa) {
+        df->capa <<= 2;
+        REALLOC_N(df->data, char *, df->capa);
+        REALLOC_N(df->lengths, int, df->capa);
+    }
+    df->data[df->size] = data;
+    df->lengths[df->size] = len;
+    df->size++;
+    return df;
 }
 
-DocField *df_clone(DocField *self)
+DocField *df_add_data(DocField *df, char *data)
 {
-  DocField *clone = ALLOC(DocField);
-  memcpy(clone, self, sizeof(DocField));
-  clone->name = estrdup(self->name);
-  clone->data = estrdup(self->data);
-  return clone;
+    return df_add_data_len(df, data, strlen(data));
 }
 
 void df_destroy(DocField *df)
 {
-  free(df->name);
-  free(df);
-}
-
-void df_destroy_data(DocField *df)
-{
-  free(df->data);
-  free(df->name);
-  free(df);
-}
-
-/*
- * @throws ARG_ERROR
- */
-void df_set_store(DocField *df, int store)
-{
-  switch (store) {
-    case DF_STORE_YES:
-      df->is_stored = true;
-      df->is_compressed = false;
-      break;
-    case DF_STORE_NO:
-      df->is_stored = false;
-      df->is_compressed = false;
-      break;
-    case DF_STORE_COMPRESS:
-      df->is_stored = true;
-      df->is_compressed = true;
-      break;
-    default:
-      RAISE(ARG_ERROR, INVALID_STORE_VAL_MSG);
-  }
-}
-
-/*
- * @throws ARG_ERROR
- */
-void df_set_index(DocField *df, int index)
-{
-  df->omit_norms = false;
-  switch (index) {
-    case DF_INDEX_NO:
-      df->is_indexed = false;
-      df->is_tokenized = false;
-      break;
-    case DF_INDEX_TOKENIZED:
-      df->is_indexed = true;
-      df->is_tokenized = true;
-      break;
-    case DF_INDEX_UNTOKENIZED:
-      df->is_indexed = true;
-      df->is_tokenized = false;
-      break;
-    case DF_INDEX_NO_NORMS:
-      df->is_indexed = true;
-      df->is_tokenized = false;
-      df->omit_norms = true;
-      break;
-    default:
-      RAISE(ARG_ERROR, INVALID_INDEX_VAL_MSG);
-  }
-}
-
-/*
- * @throws ARG_ERROR
- */
-void df_set_term_vector(DocField *df, int tv)
-{
-  switch (tv) {
-    case DF_TERM_VECTOR_NO:
-      df->store_tv = false;
-      df->store_offset = false;
-      df->store_pos = false;
-      break;
-    case DF_TERM_VECTOR_YES:
-      df->store_tv = true;
-      df->store_offset = false;
-      df->store_pos = false;
-      break;
-    case DF_TERM_VECTOR_WITH_OFFSETS:
-      df->store_tv = true;
-      df->store_offset = true;
-      df->store_pos = false;
-      break;
-    case DF_TERM_VECTOR_WITH_POSITIONS:
-      df->store_tv = true;
-      df->store_offset = false;
-      df->store_pos = true;
-      break;
-    case DF_TERM_VECTOR_WITH_POSITIONS_OFFSETS:
-      df->store_tv = true;
-      df->store_offset = true;
-      df->store_pos = true;
-      break;
-    default:
-      RAISE(ARG_ERROR, INVALID_TV_VAL_MSG);
-  }
-}
-
-/*
- * @throws ARG_ERROR
- */
-DocField *df_create_binary(char *name, char *data, int blen, int store)
-{
-  DocField *df;
-  
-  if (store == DF_STORE_NO) {
-    RAISE(ARG_ERROR, BIN_FIELD_STORE_NO_MSG);
-  }
-  
-  df = df_create(name, data, store, DF_INDEX_NO, DF_TERM_VECTOR_NO);
-  df->is_binary = true;
-  df->blen = blen;
-  return df;
+    if (df->destroy_data) {
+        int i;
+        for (i = 0; i < df->size; i++) {
+            free(df->data[i]);
+        }
+    }
+    free(df->data);
+    free(df->lengths);
+    free(df->name);
+    free(df);
 }
 
-char *df_to_s(DocField *self)
+char *df_to_s(DocField *df)
 {
-  /* the length of the str is name.len + data.len + 119, add safety 10 */
-  char *str = ALLOC_N(char, strlen(self->name) + strlen(self->data) + 129);
-  char *str_ptr = str;
-
-  if (self->is_stored) {
-    sprintf(str, "stored/%s,", self->is_compressed ?  "compressed" : "uncompressed");
-    str_ptr = str + strlen(str);
-  }
-  sprintf(str_ptr, "%s%s%s%s%s%s%s<%s:%s>",
-      self->is_indexed ? "indexed," : "",
-      self->is_tokenized ? "tokenized," : "",
-      self->store_tv ? "store_term_vector," : "",
-      self->store_offset ? "store_offsets," : "",
-      self->store_pos ? "store_positions," : "",
-      self->omit_norms ? "omit_norms," : "",
-      self->is_binary ? "binary," : "",
-      self->name,
-      self->is_binary ? "=bin_data=" : self->data);
-
-  return str;
+    int i;
+    int len = strlen(df->name) + 10;
+    char *str, *s;
+    for (i = 0; i < df->size; i++) {
+        len += df->lengths[i] + 5;
+    }
+    s = str = ALLOC_N(char, len);
+    sprintf(str, "%s: ", df->name);
+    s += strlen(str);
+    if (df->size == 1) {
+        *(s++) = '"';
+        strncpy(s, df->data[0], df->lengths[0]);
+        s += df->lengths[0];
+        *(s++) = '"';
+        *(s++) = '\0';
+    }
+    else {
+        *(s++) = '[';
+        *(s++) = '"';
+        strncpy(s, df->data[0], df->lengths[0]);
+        s += df->lengths[0];
+        *(s++) = '"';
+        for (i = 1; i < df->size; i++) {
+            *(s++) = ',';
+            *(s++) = ' ';
+            *(s++) = '"';
+            strncpy(s, df->data[i], df->lengths[i]);
+            s += df->lengths[i];
+            *(s++) = '"';
+        }
+        sprintf(s, "]");
+    }
+    return str;
 }
 
 /****************************************************************************
@@ -201,166 +95,62 @@ char *df_to_s(DocField *self)
  *
  ****************************************************************************/
 
-Document *doc_create()
-{
-  Document *doc = ALLOC(Document);
-  doc->fields = h_new_str(&free, (free_ft)&ary_destroy);
-  doc->fcnt = 0;
-  doc->dfcnt = 0;
-  doc->field_arr = NULL;
-  doc->df_arr = NULL;
-  doc->boost = 1.0;
-  doc->free_data = (free_ft)&df_destroy_data;
-  return doc;
-}
-
-Document *doc_create_keep_data()
+Document *doc_new()
 {
-  Document *doc = doc_create();
-  doc->free_data = (free_ft)&df_destroy;
-  return doc;
+    Document *doc = ALLOC(Document);
+    doc->field_dict = h_new_str(NULL, (free_ft)&df_destroy);
+    doc->size = 0;
+    doc->capa = DOC_INIT_CAPA;
+    doc->fields = ALLOC_N(DocField *, doc->capa);
+    doc->boost = 1.0;
+    return doc;
 }
 
-void doc_destroy(Document *doc)
+DocField *doc_add_field(Document *doc, DocField *df)
 {
-  int i;
-  if (doc->free_data) {
-    for (i = 0; i < doc->dfcnt; i++) {
-      doc->free_data(doc->df_arr[i]);
+    if (!h_set_safe(doc->field_dict, df->name, df)) {
+        RAISE(EXCEPTION, "tried to add %s field which alread existed\n",
+              df->name);
     }
-  }
-  free(doc->field_arr);
-  free(doc->df_arr);
-  h_destroy(doc->fields);
-  free(doc);
-}
-
-void doc_add_field(Document *doc, DocField *df)
-{
-  Array *fields = (Array *)h_get(doc->fields, df->name);
-  if (fields == NULL) {
-    fields = ary_create(1, NULL);
-    h_set(doc->fields, estrdup(df->name), fields);
-    doc->fcnt++;
-    REALLOC_N(doc->field_arr, Array *, doc->fcnt);
-    doc->field_arr[doc->fcnt-1] = fields;
-  }
-  ary_append(fields, df);
-  doc->dfcnt++;
-  REALLOC_N(doc->df_arr, DocField *, doc->dfcnt);
-  doc->df_arr[doc->dfcnt-1] = df;
-}
-
-DocField *doc_get_field(Document *doc, const char *fname)
-{
-  Array *fields = (Array *)h_get(doc->fields, fname);
-  if (fields) {
-    return fields->elems[0];
-  } else {
-    return NULL;
-  }
+    if (doc->size >= doc->capa) {
+        doc->capa <<= 1;
+        REALLOC_N(doc->fields, DocField *, doc->capa);
+    }
+    doc->fields[doc->size] = df;
+    doc->size++;
+    return df;
 }
 
-Array *doc_get_fields(Document *doc, const char *fname)
+DocField *doc_get_field(Document *doc, const char *name)
 {
-  return (Array *)h_get(doc->fields, fname);
+    return h_get(doc->field_dict, name);
 }
 
-/**
- * TODO:
- * This is not exactly elegant or efficient but it works and is not going to
- * be a performance problem. Still, it would be nice to make the code a little
- * clearer.
- */
-Array *doc_remove_fields(Document *doc, const char *fname)
+char *doc_to_s(Document *doc)
 {
-  Array *fields = (Array *)h_rem(doc->fields, fname, true);
-  if (fields) {
-    int i, j;
-    doc->fcnt--;
-    for (i = 0; i < doc->fcnt; i++) {
-      if (fields == doc->field_arr[i]) {
-        memmove(&doc->field_arr[i],
-                &doc->field_arr[i+1],
-                sizeof(void *) * (doc->fcnt - i));
-        break;
-      }
-    }
-    for (i = 0, j = 0; i < doc->dfcnt && j < fields->size;) {
-      if (fields->elems[j] == doc->df_arr[i]) {
-        memmove(&doc->df_arr[i],
-                &doc->df_arr[i+1],
-                sizeof(void *) * (doc->dfcnt - i - 1));
-        j++;
-        doc->dfcnt--;
-      } else {
-        i++;
-      }
+    int i;
+    int len = 100;
+    char **fields = ALLOC_N(char *, doc->size);
+    char *buf, *s;
+    for (i = 0; i < doc->size; i++) {
+        fields[i] = df_to_s(doc->fields[i]);
+        len += strlen(fields[i]) + 10;
     }
-    fields->free_elem = doc->free_data;
-    return fields;
-  } else {
-    return NULL;
-  }
-}
-
-DocField *doc_remove_field(Document *doc, const char *fname)
-{
-  DocField *df = NULL;
-  Array *dfs = (Array *)h_get(doc->fields, fname);
-  if (dfs) {
-    df = ary_remove(dfs, 0);
-    if (dfs->size == 0) {
-      Array *fields = doc_remove_fields(doc, fname);
-      fields->free_elem = doc->free_data;
-      ary_destroy(fields);
-    } else {
-      int i;
-      for (i = 0; i < doc->dfcnt; i++) {
-        if (df == doc->df_arr[i]) {
-          memmove(&doc->df_arr[i],
-                  &doc->df_arr[i+1],
-                  sizeof(void *) * (doc->dfcnt - i - 1));
-          doc->dfcnt--;
-          break;
-        }
-      }
+    s = buf = ALLOC_N(char, len);
+    sprintf(buf, "Document [\n");
+    s += strlen(buf);
+    for (i = 0; i < doc->size; i++) {
+        sprintf(s, "  =>%s\n", fields[i]);
+        free(fields[i]);
+        s += strlen(s);
     }
-  }
-  return df;
+    return buf;
 }
 
-bool doc_delete_fields(Document *doc, const char *fname)
+void doc_destroy(Document *doc)
 {
-  Array *fields = doc_remove_fields(doc, fname);
-  if (fields) {
-    fields->free_elem = doc->free_data;
-    ary_destroy(fields);
-    return true;
-  } else {
-    return false;
-  }
+    h_destroy(doc->field_dict);
+    free(doc->fields);
+    free(doc);
 }
 
-char *doc_to_s(Document *doc)
-{
-  int i, len = 20;
-  char *str, *str_ptr;
-  char **df_strs = ALLOC_N(char *, doc->dfcnt);
-  for (i = 0; i < doc->dfcnt; i++) {
-    df_strs[i] = df_to_s(doc->df_arr[i]);
-    len += (int)strlen(df_strs[i]) + 3;
-  }
-  str_ptr = str = ALLOC_N(char, len);
-  sprintf(str_ptr, "Document {\n");
-  str_ptr += strlen(str_ptr);
-  for (i = 0; i < doc->dfcnt; i++) {
-    sprintf(str_ptr, "  %s\n", df_strs[i]);
-    free(df_strs[i]);
-    str_ptr += strlen(str_ptr);
-  }
-  sprintf(str_ptr, "}");
-  free(df_strs);
-
-  return str;
-}