ferret 0.10.14 → 0.11.0

data/TODO

@@ -5,6 +5,9 @@
 * Fix highlighting to work for compressed fields
 * Fix highlighting to work for external fields
 * Add Ferret::Index::Index
+* Fix:
+> Working Query:  field1:value1 AND NOT field2:value2
+> Failing Query:    field1:value1 AND ( NOT field2:value2 )
 
 = Done
 * Add string Sort descripter

data/ext/analysis.c

@@ -876,6 +876,11 @@ static Token *std_next(TokenStream *ts)
             tk_set_ts(&(CTS(ts)->token), start, t, ts->text, 1);
             CTS(ts)->token.end += 2;
         }
+        else if (t[-1] == '\'') {
+            t -= 1;
+            tk_set_ts(&(CTS(ts)->token), start, t, ts->text, 1);
+            CTS(ts)->token.end += 1;
+        }
         else {
             tk_set_ts(&(CTS(ts)->token), start, t, ts->text, 1);
         }

data/ext/compound_io.c

@@ -58,6 +58,20 @@ static int cmpd_count(Store *store)
     return store->dir.cmpd->entries->size;
 }
 
+static void cmpd_each(Store *store,
+                     void (*func)(char *fname, void *arg), void *arg)
+{
+    HashTable *ht = store->dir.cmpd->entries;
+    int i;
+    for (i = 0; i <= ht->mask; i++) {
+        char *fn = (char *)ht->table[i].key;
+        if (fn) {
+            func(fn, arg);
+        }
+    }
+}
+
+
 /**
  * @throws UNSUPPORTED_ERROR
  */
@@ -200,35 +214,42 @@ Store *open_cmpd_store(Store *store, const char *name)
     int count, i;
     off_t offset;
     char *fname;
-    FileEntry *entry;
+    FileEntry *entry = NULL;
     Store *new_store = NULL;
     CompoundStore *cmpd = NULL;
     InStream *is = NULL;
 
-    new_store = store_new();
-    cmpd = ALLOC(CompoundStore);
-
-    cmpd->store       = store;
-    cmpd->name        = name;
-    cmpd->entries     = h_new_str(&free, &free);
-    is = cmpd->stream = store->open_input(store, cmpd->name);
-
-    /* read the directory and init files */
-    count = is_read_vint(is);
-    entry = NULL;
-    for (i = 0; i < count; i++) {
-        offset = (off_t)is_read_i64(is);
-        fname = is_read_string(is);
-
-        if (entry != NULL) {
-            /* set length of the previous entry */
-            entry->length = offset - entry->offset;
+    TRY
+        new_store = store_new();
+        cmpd = ALLOC_AND_ZERO(CompoundStore);
+
+        cmpd->store       = store;
+        cmpd->name        = name;
+        cmpd->entries     = h_new_str(&free, &free);
+        is = cmpd->stream = store->open_input(store, cmpd->name);
+
+        /* read the directory and init files */
+        count = is_read_vint(is);
+        entry = NULL;
+        for (i = 0; i < count; i++) {
+            offset = (off_t)is_read_i64(is);
+            fname = is_read_string(is);
+
+            if (entry != NULL) {
+                /* set length of the previous entry */
+                entry->length = offset - entry->offset;
+            }
+
+            entry = ALLOC(FileEntry);
+            entry->offset = offset;
+            h_set(cmpd->entries, fname, entry);
         }
-
-        entry = ALLOC(FileEntry);
-        entry->offset = offset;
-        h_set(cmpd->entries, fname, entry);
-    }
+    XCATCHALL
+        store_destroy(new_store);
+        if (is) is_close(is);
+        if (cmpd->entries) h_destroy(cmpd->entries);
+        free(cmpd);
+    XENDTRY
 
     /* set the length of the final entry */
     if (entry != NULL) {
@@ -243,6 +264,7 @@ Store *open_cmpd_store(Store *store, const char *name)
     new_store->count        = &cmpd_count;
     new_store->clear        = &cmpd_clear;
     new_store->length       = &cmpd_length;
+    new_store->each         = &cmpd_each;
     new_store->close_i      = &cmpd_close_i;
     new_store->new_output   = &cmpd_new_output;
     new_store->open_input   = &cmpd_open_input;

data/ext/except.c

@@ -14,6 +14,7 @@ const char *const FRT_ERROR_TYPES[] = {
   "Finally",
   "Exception",
   "IO Error",
+  "File Not Found Error",
   "Argument Error",
   "End-of-File Error",
   "Unsupported Function Error",
@@ -37,6 +38,19 @@ static void exception_stack_alloc(void)
     thread_key_create(&exception_stack_key, NULL);
 }
 
+/*
+static void put_stack(char *inst, xcontext_t *top)
+{
+    int x = 10;
+    fprintf(stderr, "( %s )", inst);
+    while (top && x--) {
+        fprintf(stderr, "=> %x ", top);
+        top = top->next;
+    }
+    fprintf(stderr, "\n");
+}
+*/
+
 void xpush_context(xcontext_t *context)
 {
     xcontext_t *top_context;

data/ext/except.h

@@ -25,7 +25,7 @@
  *       if (close_widget_two(arg) == 0) {
  *           RAISE(EXCEPTION_CODE, msg);
  *       }
- *   ENDTRY
+ *   XENDTRY
  * </pre>
  *
  * Basically exception handling uses the following macros;
@@ -48,17 +48,25 @@
  *   Code in this block is always called. Use this block to close any
  *   resources opened in the Exception handling body.
  *
- * XFINALLY
- *   Similar to case FINALLY: except that any exceptions thrown in this block
- *   are ignored until the end of the block is reached at which time the first
- *   exception which was raise will be re-raised. This is useful for closing a
- *   number of resources that all might raise exceptions so as much as
- *   possible will be successfully closed.
- *
  * ENDTRY
  *   Must be placed at the end of all exception handling code.
+ *
+ * XFINALLY
+ *   Similar to case FINALLY: except that it uses a fall through (ie, you must
+ *   not use a break before it) instead of a jump to get to it. This saves a
+ *   jump. It must be used in combination with XENDTRY and must not have any
+ *   other catches. This is an optimization so should probably be not be used
+ *   in most cases.
+ *
+ * XCATCHALL
+ *   Like XFINALLY but the block is only called when an exception is raised.
+ *   Must use in combination with XENDTRY and do not have any other FINALLY or
+ *   catch block.
+ *
+ * XENDTRY
+ *   Must use in combination with XFINALLY or XCATCHALL. Simply, it doesn't
+ *   jump to FINALLY, making it more efficient.
  */
-
 #ifndef FRT_EXCEPT_H
 #define FRT_EXCEPT_H
 
@@ -70,14 +78,15 @@
 #define EXCEPTION 2
 #define FERRET_ERROR 2
 #define IO_ERROR 3
-#define ARG_ERROR 4
-#define EOF_ERROR 5
-#define UNSUPPORTED_ERROR 6
-#define STATE_ERROR 7
-#define PARSE_ERROR 8
-#define MEM_ERROR 9
-#define INDEX_ERROR 10
-#define LOCK_ERROR 11
+#define FILE_NOT_FOUND_ERROR 4
+#define ARG_ERROR 5
+#define EOF_ERROR 6
+#define UNSUPPORTED_ERROR 7
+#define STATE_ERROR 8
+#define PARSE_ERROR 9
+#define MEM_ERROR 10
+#define INDEX_ERROR 11
+#define LOCK_ERROR 12
 
 extern char *const UNSUPPORTED_ERROR_MSG;
 extern char *const EOF_ERROR_MSG;
@@ -115,6 +124,9 @@ typedef struct xcontext_t
     }\
   } while (0);
 
+#define RETURN_EARLY() xpop_context()
+
+
 #define XFINALLY default: xcontext.in_finally = 1;
 
 #define XCATCHALL break; default: xcontext.in_finally = 1;

data/ext/ferret.c

@@ -158,6 +158,22 @@ void *frt_rb_data_ptr(VALUE val)
     return DATA_PTR(val);
 }
 
+char *
+rs2s(VALUE rstr)
+{
+    return (char *)(RSTRING(rstr)->ptr ? RSTRING(rstr)->ptr : EMPTY_STRING);
+}
+
+char *
+nstrdup(VALUE rstr)
+{
+    char *old = rs2s(rstr);
+    int len = RSTRING(rstr)->len;
+    char *new = ALLOC_N(char, len + 1);
+    memcpy(new, old, len + 1);
+    return new;
+}
+
 char *
 frt_field(VALUE rfield)
 {
@@ -165,7 +181,7 @@ frt_field(VALUE rfield)
         case T_SYMBOL:
             return rb_id2name(SYM2ID(rfield));
         case T_STRING:
-            return RSTRING(rfield)->ptr;
+            return rs2s(rfield);
         default:
             rb_raise(rb_eArgError, "field name must be a symbol");
     }
@@ -292,6 +308,7 @@ void Init_ferret_ext(void)
 {
     VALUE cParseError;
     VALUE cStateError;
+    VALUE cFileNotFoundError;
 
     /* initialize object map */
     object_map = h_new(&value_hash, &value_eq, NULL, NULL);
@@ -336,10 +353,14 @@ void Init_ferret_ext(void)
         rb_define_class_under(mFerret, "ParseError", rb_eStandardError);
     cStateError =
         rb_define_class_under(mFerret, "StateError", rb_eStandardError);
+    cFileNotFoundError =
+        rb_define_class_under(rb_cObject, "FileNotFoundError", rb_eIOError);
 
     error_map = rb_hash_new();
     rb_hash_aset(error_map, rb_intern("Exception"),         rb_eStandardError);
     rb_hash_aset(error_map, rb_intern("IO Error"),          rb_eIOError);
+    rb_hash_aset(error_map, rb_intern("File Not Found Error"),
+                                                            cFileNotFoundError);
     rb_hash_aset(error_map, rb_intern("Argument Error"),    rb_eArgError);
     rb_hash_aset(error_map, rb_intern("End-of-File Error"), rb_eEOFError);
     rb_hash_aset(error_map, rb_intern("Unsupported Function Error"),

data/ext/ferret.h

@@ -65,7 +65,8 @@ extern VALUE frt_hs_to_rb_ary(HashSet *hs);
 extern void *frt_rb_data_ptr(VALUE val);
 extern char * frt_field(VALUE rfield);
 extern VALUE frt_get_term(const char *field, const char *term);
-
+extern char *rs2s(VALUE rstr);
+extern char *nstrdup(VALUE rstr);
 #define Frt_Make_Struct(klass)\
   rb_data_object_alloc(klass,NULL,(RUBY_DATA_FUNC)NULL,(RUBY_DATA_FUNC)NULL)
 

data/ext/fs_store.c

@@ -202,7 +202,11 @@ static void fs_clear_all(Store *store)
  */
 static void fs_destroy(Store *store)
 {
-    fs_clear_locks(store);
+    TRY
+        fs_clear_locks(store);
+    XCATCHALL
+        HANDLED();
+    XENDTRY
     free(store->dir.path);
     store_destroy(store);
 }
@@ -320,7 +324,8 @@ static InStream *fs_open_input(Store *store, const char *filename)
     char path[MAX_FILE_PATH];
     int fd = open(join_path(path, store->dir.path, filename), O_RDONLY | O_BINARY);
     if (fd < 0) {
-        RAISE(IO_ERROR, "couldn't create InStream %s: <%s>",
+        RAISE(FILE_NOT_FOUND_ERROR,
+              "tried to open \"%s\" but it doesn't exist: <%s>",
               path, strerror(errno));
     }
     is = is_new();
@@ -344,17 +349,9 @@ static int fs_lock_obtain(Lock *lock)
              open(lock->name, O_CREAT | O_EXCL | O_RDWR,
                    S_IRUSR | S_IWUSR)) < 0) && (trys > 0)) {
 
-#ifdef RUBY_BINDINGS
-        rb_thread_wait_for(rb_time_interval(rb_float_new(0.01)));
-#endif
-        trys--;
-        /* sleep for 10 milliseconds
-        clock_t start = clock();
+        /* sleep for 10 milliseconds */
+        micro_sleep(10000);
         trys--;
-
-        while (((double)(clock() - start) / CLOCKS_PER_SEC) < 0.01) {
-        }
-        */
     }
     if (f >= 0) {
         close(f);

data/ext/global.c

@@ -6,6 +6,7 @@
 #include <assert.h>
 #include <math.h>
 #include <ctype.h>
+#include <unistd.h>
 
 const char *EMPTY_STRING = "";
 
@@ -55,6 +56,34 @@ int icmp_risky(const void *p1, const void *p2)
   return (*(int *)p1) - *((int *)p2);
 }
 
+unsigned int *imalloc(unsigned int value)
+{
+  unsigned int *p = ALLOC(unsigned int);
+  *p = value;
+  return p;
+}
+
+unsigned long *lmalloc(unsigned long value)
+{
+  unsigned long *p = ALLOC(unsigned long);
+  *p = value;
+  return p;
+}
+
+f_u32 *u32malloc(f_u32 value)
+{
+  f_u32 *p = ALLOC(f_u32);
+  *p = value;
+  return p;
+}
+
+f_u64 *u64malloc(f_u64 value)
+{
+  f_u64 *p = ALLOC(f_u64);
+  *p = value;
+  return p;
+}
+
 
 #ifndef RUBY_BINDINGS
 /* frt_exit: print error message and exit */
@@ -327,3 +356,54 @@ void dummy_free(void *p)
 {
     (void)p; /* suppress unused argument warning */
 }
+
+#ifdef FRT_IS_C99
+extern void usleep(unsigned long usec);
+#endif
+
+extern void micro_sleep(const int micro_seconds)
+{
+#ifdef POSH_OS_WIN32
+    Sleep(micro_seconds / 1000);
+#else
+    usleep(micro_seconds);
+#endif
+}
+
+typedef struct FreeMe
+{
+    void *p;
+    free_ft free_func;
+} FreeMe;
+
+static FreeMe *free_mes = NULL;
+static int free_mes_size = 0;
+static int free_mes_capa = 0;
+
+void register_for_cleanup(void *p, free_ft free_func)
+{
+    FreeMe *free_me;
+    if (free_mes_capa == 0) {
+        free_mes_capa = 16;
+        free_mes = ALLOC_N(FreeMe, free_mes_capa);
+    }
+    else if (free_mes_capa <= free_mes_size) {
+        free_mes_capa *= 2;
+        REALLOC_N(free_mes, FreeMe, free_mes_capa);
+    }
+    free_me = free_mes + free_mes_size++;
+    free_me->p = p;
+    free_me->free_func = free_func;
+}
+
+void do_clean_up()
+{
+    int i;
+    for (i = 0; i < free_mes_size; i++) {
+        FreeMe *free_me = free_mes + i;
+        free_me->free_func(free_me->p);
+    }
+    free(free_mes);
+    free_mes = NULL;
+    free_mes_size = free_mes_capa = 0;
+}

data/ext/global.h

@@ -61,6 +61,11 @@ typedef void (*free_ft)(void *key);
 extern char *progname();
 extern void setprogname(const char *str);
 
+extern unsigned int *imalloc(unsigned int value);
+extern unsigned long *lmalloc(unsigned long value);
+extern f_u32 *u32malloc(f_u32 value);
+extern f_u64 *u64malloc(f_u64 value);
+
 extern void *emalloc(size_t n);
 extern void *ecalloc(size_t n);
 extern void *erealloc(void *ptr, size_t n);
@@ -82,6 +87,11 @@ extern char *dbl_to_s(char *buf, double num);
 extern char *strfmt(const char *fmt, ...);
 extern char *vstrfmt(const char *fmt, va_list args);
 
+extern void micro_sleep(const int micro_seconds);
+
+extern void register_for_cleanup(void *p, free_ft free_func);
+extern void do_clean_up();
+
 /**
  * A dummy function which can be passed to functions which expect a free
  * function such as h_new() if you don't want the free functions to do anything.