ferret 0.9.6 → 0.10.0

data/ext/filter.c

@@ -7,66 +7,76 @@
  *
  ***************************************************************************/
 
-void filt_destroy(Filter *self)
+void filt_destroy_i(Filter *filt)
 {
-  h_destroy(self->cache);
-  free(self->name);
-  free(self);
+    h_destroy(filt->cache);
+    free(filt->name);
+    free(filt);
+}
+void filt_deref(Filter *filt)
+{
+    if (--(filt->ref_cnt) == 0) {
+        filt->destroy_i(filt);
+    }
 }
 
-BitVector *filt_get_bv(Filter *self, IndexReader *ir)
+BitVector *filt_get_bv(Filter *filt, IndexReader *ir)
 {
-  CacheObject *co = h_get(self->cache, ir);
-  if (!co) {
-    BitVector *bv;
-    if (!ir->cache) {
-      ir_add_cache(ir);
+    CacheObject *co = h_get(filt->cache, ir);
+
+    if (!co) {
+        BitVector *bv;
+        if (!ir->cache) {
+            ir_add_cache(ir);
+        }
+        bv = filt->get_bv_i(filt, ir);
+        co = co_create(filt->cache, ir->cache, filt, ir,
+                       (free_ft)&bv_destroy, (void *)bv);
     }
-    bv = self->get_bv(self, ir);
-    co = co_create(self->cache, ir->cache, self, ir,
-        (free_ft)&bv_destroy, (void *)bv);
-  }
-  return (BitVector *)co->obj;
+    return (BitVector *)co->obj;
 }
 
-char *filt_to_s_i(Filter *self)
+static char *filt_to_s_i(Filter *filt)
 {
-  return estrdup(self->name);
+    return estrdup(filt->name);
 }
 
-uint filt_hash_dflt(Filter *self)
+ulong filt_hash_default(Filter *filt)
 {
-  return 0;
+    (void)filt;
+    return 0;
 }
 
-int filt_eq_dflt(Filter *self, Filter *o)
+int filt_eq_default(Filter *filt, Filter *o)
 {
-  return false;
+    (void)filt; (void)o;
+    return false;
 }
 
-Filter *filt_create(char *name)
+Filter *filt_create(size_t size, const char *name)
 {
-  Filter *self = ALLOC(Filter);
-  self->cache = co_hsh_create();
-  self->name = estrdup(name);
-  self->to_s = &filt_to_s_i;
-  self->hash = &filt_hash_dflt;
-  self->eq = &filt_eq_dflt;
-  self->destroy = &filt_destroy;
-  return self;
+    Filter *filt    = (Filter *)emalloc(size);
+    filt->cache     = co_hash_create();
+    filt->name      = estrdup(name);
+    filt->to_s      = &filt_to_s_i;
+    filt->hash      = &filt_hash_default;
+    filt->eq        = &filt_eq_default;
+    filt->destroy_i = &filt_destroy_i;
+    filt->ref_cnt   = 1;
+    return filt;
 }
 
-uint filt_hash(Filter *self)
+ulong filt_hash(Filter *filt)
 {
-  return str_hash(self->name) ^ self->hash(self);
+    return str_hash(filt->name) ^ filt->hash(filt);
 }
 
-int filt_eq(Filter *self, Filter *o)
+int filt_eq(Filter *filt, Filter *o)
 {
-  return ((self == o) ||
-      ((strcmp(self->name, o->name) == 0) &&
-       (self->eq == o->eq) &&
-       (self->eq(self, o))));
+    return ((filt == o)
+            || ((strcmp(filt->name, o->name) == 0)
+                && (filt->eq == o->eq)
+                && (filt->eq(filt, o))));
 }
 
 /***************************************************************************
@@ -75,67 +85,72 @@ int filt_eq(Filter *self, Filter *o)
  *
  ***************************************************************************/
 
-char *qfilt_to_s(Filter *self)
+#define QF(filt) ((QueryFilter *)(filt))
+typedef struct QueryFilter
+{
+    Filter super;
+    Query *query;
+} QueryFilter;
+
+static char *qfilt_to_s(Filter *filt)
 {
-  QueryFilter *qf = (QueryFilter *)self->data;
-  Query *query = (Query *)qf->query;
-  char *query_str = query->to_s(query, "");
-  char *filter_str = strfmt("QueryFilter< %s >", query_str);
-  free(query_str);
-  return filter_str;
+    Query *query = QF(filt)->query;
+    char *query_str = query->to_s(query, "");
+    char *filter_str = strfmt("QueryFilter< %s >", query_str);
+    free(query_str);
+    return filter_str;
 }
 
-BitVector *qfilt_get_bv(Filter *filt, IndexReader *ir)
+static BitVector *qfilt_get_bv_i(Filter *filt, IndexReader *ir)
 {
-  BitVector *bv = bv_create_size(ir->max_doc(ir));
-  QueryFilter *qfilt = (QueryFilter *)filt->data;
-  Searcher *sea = sea_create(ir);
-  Weight *weight = q_weight(qfilt->query, sea);
-  Scorer *scorer = weight->scorer(weight, ir);
-  if (scorer) {
-    while (scorer->next(scorer)) {
-      bv_set(bv, scorer->doc);
+    BitVector *bv = bv_new_capa(ir->max_doc(ir));
+    Searcher *sea = isea_new(ir);
+    Weight *weight = q_weight(QF(filt)->query, sea);
+    Scorer *scorer = weight->scorer(weight, ir);
+    if (scorer) {
+        while (scorer->next(scorer)) {
+            bv_set(bv, scorer->doc);
+        }
+        scorer->destroy(scorer);
     }
-    scorer->destroy(scorer);
-  }
-  weight->destroy(weight);
-  free(sea);
-  return bv;
+    weight->destroy(weight);
+    free(sea);
+    return bv;
 }
 
-uint qfilt_hash(Filter *self)
+static ulong qfilt_hash(Filter *filt)
 {
-  Query *query = (Query *)((QueryFilter *)self->data)->query;
-  return q_hash(query);
+    return q_hash(QF(filt)->query);
 }
 
-int qfilt_eq(Filter *self, Filter *o)
+static int qfilt_eq(Filter *filt, Filter *o)
 {
-  Query *query1 = (Query *)((QueryFilter *)self->data)->query;
-  Query *query2 = (Query *)((QueryFilter *)o->data)->query;
-  return q_eq(query1, query2);
+    return q_eq(QF(filt)->query, QF(o)->query);
 }
 
-void qfilt_destroy(Filter *self)
+static void qfilt_destroy_i(Filter *filt)
 {
-  Query *query = (Query *)((QueryFilter *)self->data)->query;
-  q_deref(query);
-  free(self->data);
-  filt_destroy(self);
+    Query *query = QF(filt)->query;
+    q_deref(query);
+    filt_destroy_i(filt);
 }
 
-Filter *qfilt_create(Query *query)
+Filter *qfilt_new_nr(Query *query)
 {
-  Filter *self;
-  QueryFilter *qfilt = ALLOC(QueryFilter);
-  qfilt->query = query;
+    Filter *filt = filt_new(QueryFilter);
 
-  self = filt_create("QueryFilter");
-  self->data = qfilt;
-  self->get_bv = &qfilt_get_bv;
-  self->hash = &qfilt_hash;
-  self->eq = &qfilt_eq;
-  self->to_s = &qfilt_to_s;
-  self->destroy = &qfilt_destroy;
-  return self;
+    QF(filt)->query = query;
+
+    filt->get_bv_i  = &qfilt_get_bv_i;
+    filt->hash      = &qfilt_hash;
+    filt->eq        = &qfilt_eq;
+    filt->to_s      = &qfilt_to_s;
+    filt->destroy_i = &qfilt_destroy_i;
+    return filt;
+}
+
+Filter *qfilt_new(Query *query)
+{
+    REF(query);
+    return qfilt_new_nr(query);
 }

data/ext/fs_store.c

@@ -1,478 +1,459 @@
 #include "store.h"
-#include "frtio.h"
-#ifdef WIN32
-# ifndef S_IRUSR
-#  define S_IRUSR _S_IREAD
-# endif
-# ifndef S_IWUSR
-# define S_IWUSR _S_IWRITE
-# endif
-# include <io.h>
-#else
-#include <unistd.h>
-# define _close close
-# define _open open
-# define _creat creat
-# define _lseek lseek
-# define _read read
-# define _stat stat
-# define _fstat fstat
-#endif
 #include <sys/types.h>
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <errno.h>
 #include <string.h>
 #include <stdio.h>
+#ifdef POSH_OS_WIN32
+# include <io.h>
+# include "win32.h"
+# ifndef sleep
+#   define sleep _sleep
+# endif
+# ifndef DIR_SEPARATOR
+#   define DIR_SEPARATOR "\\"
+# endif
+# ifndef S_IRUSR
+#   define S_IRUSR _S_IREAD
+# endif
+# ifndef S_IWUSR
+#   define S_IWUSR _S_IWRITE
+# endif
+#else
+# define DIR_SEPARATOR "/"
+# include <unistd.h>
+# include <dirent.h>
+#endif
+#ifndef O_BINARY
+# define O_BINARY 0
+#endif
 
-
-static char * const FILE_OPEN_ERROR_MSG = "Couldn't open the file to read";
-static char * const SEEK_ERROR_MSG = "Seek error message";
-static char * const WRITE_ERROR_MSG = "Write error message";
-
+extern Store *store_new();
 extern void store_destroy(Store *store);
+extern OutStream *os_new();
+extern InStream *is_new();
+extern int file_is_lock(char *filename);
 
 /**
- * Create the file +filename+ in the +store+.
- *
- * @param store the store to create the file in
- * @param filename the name of the file to create
- * @throws IO_ERROR if the file cannot be created
+ * Create a filepath for a file in the store using the operating systems
+ * default file seperator.
  */
+static char *join_path(char *buf, const char *base, const char *filename)
+{
+  sprintf(buf, "%s"DIR_SEPARATOR"%s", base, filename);
+  return buf;
+}
+
 static void fs_touch(Store *store, char *filename)
 {
-  int f;
-  char path[MAX_FILE_PATH];
-  join_path(path, store->dir.path, filename);
-  if ((f = _creat(path, S_IRUSR|S_IWUSR)) == 0) {
-    RAISE(IO_ERROR, strerror(errno));
-  }
-  _close(f);
+    int f;
+    char path[MAX_FILE_PATH];
+    join_path(path, store->dir.path, filename);
+    if ((f = creat(path, S_IRUSR | S_IWUSR)) == 0) {
+        RAISE(IO_ERROR, "couldn't create file %s: <%s>", path,
+              strerror(errno));
+    }
+    close(f);
 }
 
-/**
- * Return true if a file of name +filename+ exists in +store+.
- *
- * @param store the store to check in
- * @param filename the name of the file to check for
- * @returns true if the file exists
- * @throws IO_ERROR if there is an error checking for the files existance
- */
-int fs_exists(Store *store, char *filename)
+static int fs_exists(Store *store, char *filename)
 {
-  char buf[MAX_FILE_PATH];
-  return exists(join_path(buf, store->dir.path, filename));
+    int fd;
+    char path[MAX_FILE_PATH];
+    join_path(path, store->dir.path, filename);
+    fd = open(path, 0);
+    if (fd < 0) {
+        if (errno != ENOENT) {
+            RAISE(IO_ERROR, "checking existance of %s: <%s>", path,
+                  strerror(errno));
+        }
+        return false;
+    }
+    close(fd);
+    return true;
 }
 
-/**
- * Remove the file +filename+ from the +store+
- *
- * @param store the store to remove from
- * @param filename the name of the file to remove
- * @returns On success, zero is returned.  On error, -1 is returned, and errno
- *          is set appropriately.
- */
-int fs_remove(Store *store, char *filename)
+static int fs_remove(Store *store, char *filename)
 {
-  char buf[MAX_FILE_PATH];
-  return remove(join_path(buf, store->dir.path, filename));
+    char path[MAX_FILE_PATH];
+    return remove(join_path(path, store->dir.path, filename));
 }
 
-/**
- * Rename the file in the +store+ from the name +from+ to the name +to+.
- *
- * @param store the store to rename the file in
- * @param from the name of the file to rename
- * @param to the new name of the file
- * @returns On success, zero is returned.  On error, -1 is returned, and errno
- *          is set appropriately.
- */
-int fs_rename(Store *store, char *from, char *to)
+static void fs_rename(Store *store, char *from, char *to)
 {
-  char buf1[MAX_FILE_PATH], buf2[MAX_FILE_PATH];
+    char path1[MAX_FILE_PATH], path2[MAX_FILE_PATH];
 
-#ifdef WIN32
-  remove(join_path(buf1, store->dir.path, to));
+#ifdef POSH_OS_WIN32
+    remove(join_path(path1, store->dir.path, to));
 #endif
 
-  if (rename(join_path(buf1, store->dir.path, from),
-    join_path(buf2, store->dir.path, to)) < 0) {
-    RAISE(IO_ERROR, strerror(errno));
-  }
-  return true;
+    if (rename(join_path(path1, store->dir.path, from),
+               join_path(path2, store->dir.path, to)) < 0) {
+        RAISE(IO_ERROR, "couldn't rename file \"%s\" to \"%s\": <%s>",
+              path1, path2, strerror(errno));
+    }
 }
 
-/**
- * Returns the number of files in the store.
- *
- * @param store the store to count the files in
- * @return the number of files in the store
- * @throws IO_ERROR if there is an error opening the directory
- */
-int fs_count(Store *store)
+static int fs_count(Store *store)
 {
-  return fcount(store->dir.path);
+    int cnt = 0;
+    struct dirent *de;
+    DIR *d = opendir(store->dir.path);
+
+    if (!d) {
+        RAISE(IO_ERROR, "counting files in %s: <%s>",
+              store->dir.path, strerror(errno));
+    }
+
+    while ((de = readdir(d)) != NULL) {
+        if (de->d_name[0] > '/') { /* skip ., .., / and '\0'*/
+            cnt++;
+        }
+    }
+    closedir(d);
+
+    return cnt;
 }
 
-/**
- * Call the function +func+ with each filename in the store and the arg that
- * you passed. If you need to open the file you should pass the store as the
- * argument. If you need to pass more than one argument, you should pass a
- * struct.
- *
- * @param store the store to grab the files from
- * @param func the function to call with each files name and the +arg+ passed
- * @param arg the argument to pass to the function
- * @throws IO_ERROR if there is an error opening the directory
- */
-void fs_each(Store *store, void (*func)(char *fname, void *arg), void *arg)
+static void fs_each(Store *store, void (*func)(char *fname, void *arg), void *arg)
+{
+    struct dirent *de;
+    DIR *d = opendir(store->dir.path);
+
+    if (!d) {
+        RAISE(IO_ERROR, "doing 'each' in %s: <%s>",
+              store->dir.path, strerror(errno));
+    }
+
+    while ((de = readdir(d)) != NULL) {
+        if (de->d_name[0] > '/' /* skip ., .., / and '\0'*/
+                && !file_is_lock(de->d_name)) {
+            func(de->d_name, arg);
+        }
+    }
+    closedir(d);
+}
+
+static void fs_clear_locks(Store *store)
 {
-  dir_each(store->dir.path, func, arg);
+    struct dirent *de;
+    DIR *d = opendir(store->dir.path);
+
+    if (!d) {
+        RAISE(IO_ERROR, "clearing locks in %s: <%s>",
+              store->dir.path, strerror(errno));
+    }
+
+    while ((de = readdir(d)) != NULL) {
+        if (file_is_lock(de->d_name)) {
+            char path[MAX_FILE_PATH];
+            remove(join_path(path, store->dir.path, de->d_name));
+        }
+    }
+    closedir(d);
+}
+
+static void fs_clear(Store *store)
+{
+    struct dirent *de;
+    DIR *d = opendir(store->dir.path);
+
+    if (!d) {
+        RAISE(IO_ERROR, "clearing files in %s: <%s>",
+              store->dir.path, strerror(errno));
+    }
+
+    while ((de = readdir(d)) != NULL) {
+        if (de->d_name[0] > '/' /* skip ., .., / and '\0'*/
+                && !file_is_lock(de->d_name)) {
+            char path[MAX_FILE_PATH];
+            remove(join_path(path, store->dir.path, de->d_name));
+        }
+    }
+    closedir(d);
+}
+
+static void fs_clear_all(Store *store)
+{
+    struct dirent *de;
+    DIR *d = opendir(store->dir.path);
+
+    if (!d) {
+        RAISE(IO_ERROR, "clearing all files in %s: <%s>",
+              store->dir.path, strerror(errno));
+    }
+
+    while ((de = readdir(d)) != NULL) {
+        if (de->d_name[0] > '/') { /* skip ., .., / and '\0'*/
+            char path[MAX_FILE_PATH];
+            remove(join_path(path, store->dir.path, de->d_name));
+        }
+    }
+    closedir(d);
 }
 
 /**
  * Destroy the store.
  *
  * @param p the store to destroy
- * @throws IO_ERROR if there is an error deleting the locks
+ * @raise IO_ERROR if there is an error deleting the locks
  */
-void fs_destroy(Store *store)
+static void fs_destroy(Store *store)
 {
-  fs_clear_locks(store);
-  free(store->dir.path);
-  store_destroy(store);
+    fs_clear_locks(store);
+    free(store->dir.path);
+    store_destroy(store);
 }
 
-/**
- * Return the length of the file +filename+ in +store+
- *
- * @param store the store to use
- * @param the name of the file to check the length of
- * @return the length of the file in bytes
- * @throws IO_ERROR if there is an error checking the file length
- */
-int fs_length(Store *store, char *filename)
+static off_t fs_length(Store *store, char *filename)
 {
-  char buf[MAX_FILE_PATH];
-  struct stat stt;
+    char path[MAX_FILE_PATH];
+    struct stat stt;
 
-  if (stat(join_path(buf, store->dir.path, filename), &stt))
-    RAISE(IO_ERROR, strerror(errno));
+    if (stat(join_path(path, store->dir.path, filename), &stt)) {
+        RAISE(IO_ERROR, "getting lenth of %s: <%s>", path,
+              strerror(errno));
+    }
 
-  return stt.st_size;
+    return stt.st_size;
 }
 
-/**
- * Flush +len+ characters from +src+ to the output stream +os+
- *
- * @param os the output stream to write to
- * @param src the characters to write to the output stream
- * @param len the number of characters to write
- * @throws IO_ERROR if there is an error writing the characters
- */
-void fso_flush_internal(OutStream *os, uchar *src, int len)
+static void fso_flush_i(OutStream *os, uchar *src, int len)
 {
-  if (len != fwrite(src, sizeof(uchar), len, (FILE *)os->file))
-    RAISE(IO_ERROR, WRITE_ERROR_MSG);
+    if (len != write(os->file.fd, src, len)) {
+        RAISE(IO_ERROR, "flushing src of length %d", len);
+    }
 }
 
-/**
- * Seek +pos+ in the output stream
- *
- * @param os the output stream to seek in
- * @param pos the position to seek in the stream
- * @throws IO_ERROR if there is an error seeking in the output stream
- */
-void fso_seek_internal(OutStream *os, int pos)
+static void fso_seek_i(OutStream *os, off_t pos)
 {
-  if (fseek((FILE *)os->file, pos, SEEK_SET))
-    RAISE(IO_ERROR, strerror(errno));
+    if (lseek(os->file.fd, pos, SEEK_SET) < 0) {
+        RAISE(IO_ERROR, "seeking position %"F_OFF_T_PFX"d: <%s>",
+              pos, strerror(errno));
+    }
 }
 
-/**
- * Close any resources used by the output stream +os+
- *
- * @param os the output stream to seek in
- * @throws IO_ERROR if there is an closing the file
- */
-void fso_close_internal(OutStream *os)
+static void fso_close_i(OutStream *os)
 {
-  if (fclose((FILE *)os->file))
-    RAISE(IO_ERROR, strerror(errno));
+    if (close(os->file.fd)) {
+        RAISE(IO_ERROR, "closing file: <%s>", strerror(errno));
+    }
 }
 
-/**
- * Allocate the resources needed for the output stream in the +store+ with the
- * name +filename+
- *
- * @param store the store to create the output stream in.
- * @param filename the name of the output stream
- * @return a newly allocated filestream
- * @throws IO_ERROR if there is an error opening the output stream resources
- */
-OutStream *fs_create_output(Store *store, const char *filename)
+const struct OutStreamMethods FS_OUT_STREAM_METHODS = {
+    fso_flush_i,
+    fso_seek_i,
+    fso_close_i
+};
+
+static OutStream *fs_new_output(Store *store, const char *filename)
 {
-  char buf[MAX_FILE_PATH];
-  FILE *f = fopen(join_path(buf, store->dir.path, filename), "wb");
-  OutStream *os;
-  if (!f) RAISE(IO_ERROR, strerror(errno));
-
-  os = os_create();
-  os->file = f;
-  os->flush_internal = &fso_flush_internal;
-  os->seek_internal  = &fso_seek_internal;
-  os->close_internal = &fso_close_internal;
-  return os;
+    char path[MAX_FILE_PATH];
+    int fd = open(join_path(path, store->dir.path, filename),
+                  O_WRONLY | O_CREAT | O_BINARY, S_IRUSR | S_IWUSR);
+    OutStream *os;
+    if (fd < 0) {
+        RAISE(IO_ERROR, "couldn't create OutStream %s: <%s>",
+              path, strerror(errno));
+    }
+
+    os = os_new();
+    os->file.fd = fd;
+    os->m = &FS_OUT_STREAM_METHODS;
+    return os;
 }
 
-/**
- * Read +len+ characters from the input stream into the +offset+ position in
- * +b+, an array of unsigned characters.
- *
- * @param is the input stream to read from
- * @param b an array of characters which must be allocated with  at least
- *          +offset+ + +len+ bytes
- * @param offset the position in +b+ to start writing the bytes read
- * @param len the number of bytes to read
- * @throws IO_ERROR if there is an error reading from the input stream
- */
-void fsi_read_internal(InStream *is, uchar *b, int offset, int len)
+static void fsi_read_i(InStream *is, uchar *path, int len)
 {
-  int fd = (int)is->file;
-  int pos = is_pos(is);
-  if (pos != _lseek(fd, 0, SEEK_CUR)) {
-    _lseek(fd, pos, SEEK_SET);
-  }
-  if (_read(fd, b, len) != len) {
-    /* win: the wrong value can be returned for some reason so double check */
-    if (_lseek(fd, 0, SEEK_CUR) != (pos + len)) {
-      RAISE(EOF_ERROR, strerror(errno));
+    int fd = is->file.fd;
+    int pos = is_pos(is);
+    if (pos != lseek(fd, 0, SEEK_CUR)) {
+        lseek(fd, pos, SEEK_SET);
+    }
+    if (read(fd, path, len) != len) {
+        /* win: the wrong value can be returned for some reason so double check */
+        if (lseek(fd, 0, SEEK_CUR) != (pos + len)) {
+            RAISE(IO_ERROR, "couldn't read %d chars from %s: <%s>",
+                  len, path, strerror(errno));
+        }
     }
-  }
 }
 
-/**
- * Seek position +pos+ in input stream +is+
- *
- * @param is the input stream to seek in
- * @param pos the position to seek
- * @throws IO_ERROR if the seek fails
- */
-void fsi_seek_internal(InStream *is, int pos)
+static void fsi_seek_i(InStream *is, off_t pos)
 {
-  if (_lseek((int)is->file, pos, SEEK_SET) < 0) {
-    RAISE(IO_ERROR, strerror(errno));
-  }
+    if (lseek(is->file.fd, pos, SEEK_SET) < 0) {
+        RAISE(IO_ERROR, "seeking pos %"F_OFF_T_PFX"d: <%s>",
+              pos, strerror(errno));
+    }
 }
 
-/**
- * Close the resources allocated to the inputstream +is+
- *
- * @param is the input stream to close
- * @throws IO_ERROR if the close fails
- */
-void fsi_close_internal(InStream *is)
+static void fsi_close_i(InStream *is)
 {
-  if (!is->is_clone) {
-    if (_close((int)is->file)) {
-      RAISE(IO_ERROR, strerror(errno));
+    if (close(is->file.fd)) {
+        RAISE(IO_ERROR, strerror(errno));
     }
     free(is->d.path);
-  }
 }
 
-/**
- * Returns the length of the input stream +is+
- *
- * @param is the input stream to get the length of
- * @throws IO_ERROR if there is an error getting the file length
- */
-int fsi_length(InStream *is)
+static off_t fsi_length_i(InStream *is)
 {
-  struct _stat stt;
-  if (_fstat((int)is->file, &stt)) {
-    RAISE(IO_ERROR, strerror(errno));
-  }
-  return stt.st_size;
+    struct stat stt;
+    if (fstat(is->file.fd, &stt)) {
+        RAISE(IO_ERROR, "fstat failed: <%s>", strerror(errno));
+    }
+    return stt.st_size;
 }
 
-/**
- * Clone the input stream. Nothing to do for a file system input stream
- */
-void fsi_clone_internal(InStream *is, InStream *new_is)
-{ }
+static const struct InStreamMethods FS_IN_STREAM_METHODS = {
+    fsi_read_i,
+    fsi_seek_i,
+    fsi_length_i,
+    fsi_close_i
+};
 
-/**
- * Open an input stream in the +store+ with the name +filename+
- *
- * @param store the store to create the input stream in
- * @param filename the name of the input stream
- * @throws IO_ERROR if the input stream cannot be opened
- */
-InStream *fs_open_input(Store *store, const char *filename)
+static InStream *fs_open_input(Store *store, const char *filename)
 {
-  InStream *is;
-  char buf[MAX_FILE_PATH];
-  int fd = _open(join_path(buf, store->dir.path, filename), O_RDONLY);
-  if (fd < 0) {
-    RAISE(IO_ERROR, FILE_OPEN_ERROR_MSG);
-  }
-  
-  is = is_create();
-  is->file = (void *)fd;
-  is->d.path = estrdup(buf);
-  is->is_clone = false;
-  is->read_internal  = &fsi_read_internal;
-  is->seek_internal  = &fsi_seek_internal;
-  is->close_internal = &fsi_close_internal;
-  is->clone_internal = &fsi_clone_internal;
-  is->length_internal= &fsi_length;
-  return is;
+    InStream *is;
+    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>",
+              path, strerror(errno));
+    }
+    is = is_new();
+    is->file.fd = fd;
+    is->d.path = estrdup(path);
+    is->m = &FS_IN_STREAM_METHODS;
+    return is;
 }
 
 #define LOCK_OBTAIN_TIMEOUT 5
 
-/**
- * Obtain a lock on the lock +lock+
- *
- * @param lock the lock to obtain
- */
-int fs_lock_obtain(Lock *lock)
+static int fs_lock_obtain(Lock *lock)
 {
-  int f;
-  int trys = LOCK_OBTAIN_TIMEOUT;
-  while (((f = _open(lock->name, O_CREAT|O_EXCL|O_WRONLY, S_IRUSR|S_IWUSR)) < 0) &&
-    (trys > 0)) {
-    trys--;
-  }
-  if (f >= 0) {
-    _close(f);
-    return true;
-  } else {
-    return false;
-  }
+    int f;
+    int trys = LOCK_OBTAIN_TIMEOUT;
+    while (((f =
+             open(lock->name, O_CREAT | O_EXCL | O_RDWR,
+                   S_IRUSR | S_IWUSR)) < 0) && (trys > 0)) {
+        trys--;
+        /* FIXME:: implement sleep properly to sleep in milliseconds
+         * sleep(1); */
+    }
+    if (f >= 0) {
+        close(f);
+        return true;
+    }
+    else {
+        return false;
+    }
 }
 
-/**
- * Returns true if +lock+ is locked. To test if the file is locked:wq
- *
- * @param lock the lock to test
- * @throws 
- */
-int fs_lock_is_locked(Lock *lock)
+static int fs_lock_is_locked(Lock *lock)
 {
-  int f = _open(lock->name, O_CREAT|O_EXCL|O_WRONLY, S_IRUSR|S_IWUSR);
-  if (f >= 0) {
-    if (_close(f) || remove(lock->name)) {
-      RAISE(IO_ERROR, strerror(errno));
+    int f = open(lock->name, O_CREAT | O_EXCL | O_WRONLY, S_IRUSR | S_IWUSR);
+    if (f >= 0) {
+        if (close(f) || remove(lock->name)) {
+            RAISE(IO_ERROR, "couldn't close lock \"%s\": <%s>", lock->name,
+                  strerror(errno));
+        }
+        return false;
+    }
+    else {
+        return true;
     }
-    return false;
-  } else {
-    return true;
-  }
 }
 
 void fs_lock_release(Lock *lock)
 {
-  remove(lock->name);
+    remove(lock->name);
 }
 
-Lock *fs_open_lock(Store *store, char *lockname)
+static Lock *fs_open_lock(Store *store, char *lockname)
 {
-  Lock *lock = ALLOC(Lock);
-  char lname[100];
-  char buf[MAX_FILE_PATH];
-  sprintf(lname, "%s%s.lck", LOCK_PREFIX, lockname);
-  lock->name = estrdup(join_path(buf, store->dir.path, lname));
-  lock->obtain = &fs_lock_obtain;
-  lock->release = &fs_lock_release;
-  lock->is_locked = &fs_lock_is_locked;
-  return lock;
+    Lock *lock = ALLOC(Lock);
+    char lname[100];
+    char path[MAX_FILE_PATH];
+    sprintf(lname, "%s%s.lck", LOCK_PREFIX, lockname);
+    lock->name = estrdup(join_path(path, store->dir.path, lname));
+    lock->store = store;
+    lock->obtain = &fs_lock_obtain;
+    lock->release = &fs_lock_release;
+    lock->is_locked = &fs_lock_is_locked;
+    return lock;
 }
 
-void fs_close_lock(Lock *lock)
+static void fs_close_lock(Lock *lock)
 {
-  remove(lock->name);
-  free(lock->name);
-  free(lock);
+    remove(lock->name);
+    free(lock->name);
+    free(lock);
 }
 
-#ifdef WIN32
-static HshTable stores = {
-  /* fill */0,
-  /* used */0,
-  /* mask */Hsh_MINSIZE - 1,
-  /* table */stores.smalltable,
-  /* smalltable */{0},
-  /* lookup */&h_lookup_str,
-  /* hash */NULL,
-  /* eq */NULL,
-  /* free_key */(free_ft)&dummy_free,
-  /* free_value */(free_ft)&fs_destroy
-};
-#else
-static HshTable stores = {
-  fill:0,
-  used:0,
-  mask:Hsh_MINSIZE - 1,
-  table:stores.smalltable,
-  lookup:&h_lookup_str,
-  hash:NULL,
-  eq:NULL,
-  free_key:(free_ft)&dummy_free,
-  free_value:(free_ft)&fs_destroy
+static HashTable stores = {
+    /* fill */       0,
+    /* used */       0,
+    /* mask */       HASH_MINSIZE - 1,
+    /* table */      stores.smalltable,
+    /* smalltable */ {{0, NULL, NULL}},
+    /* lookup */     (h_lookup_ft)&h_lookup_str,
+    /* hash */       NULL,
+    /* eq */         NULL,
+    /* free_key */   (free_ft)&dummy_free,
+    /* free_value */ (free_ft)&fs_destroy
 };
-#endif
 
-#ifndef FERRET_EXT
+#ifndef UNTHREADED
 static mutex_t stores_mutex = MUTEX_INITIALIZER;
 #endif
 
-void fs_close_i(Store *store)
+static void fs_close_i(Store *store)
 {
-  mutex_lock(&stores_mutex);
-  h_del(&stores, store->dir.path);
-  mutex_unlock(&stores_mutex);
+    mutex_lock(&stores_mutex);
+    h_del(&stores, store->dir.path);
+    mutex_unlock(&stores_mutex);
 }
 
-Store *fs_store_create(const char *pathname)
+static Store *fs_store_new(const char *pathname)
 {
-  Store *new_store = store_create();
-  
-  new_store->dir.path      = estrdup(pathname);
-  new_store->touch         = &fs_touch;
-  new_store->exists        = &fs_exists;
-  new_store->remove        = &fs_remove;
-  new_store->rename        = &fs_rename;
-  new_store->count         = &fs_count;
-  new_store->close_i       = &fs_close_i;
-  new_store->clear         = &fs_clear;
-  new_store->clear_all     = &fs_clear_all;
-  new_store->clear_locks   = &fs_clear_locks;
-  new_store->length        = &fs_length;
-  new_store->each          = &fs_each;
-  new_store->create_output = &fs_create_output;
-  new_store->open_input    = &fs_open_input;
-  new_store->open_lock     = &fs_open_lock;
-  new_store->close_lock    = &fs_close_lock;
-  return new_store;
+    Store *new_store = store_new();
+
+    new_store->dir.path      = estrdup(pathname);
+    new_store->touch         = &fs_touch;
+    new_store->exists        = &fs_exists;
+    new_store->remove        = &fs_remove;
+    new_store->rename        = &fs_rename;
+    new_store->count         = &fs_count;
+    new_store->close_i       = &fs_close_i;
+    new_store->clear         = &fs_clear;
+    new_store->clear_all     = &fs_clear_all;
+    new_store->clear_locks   = &fs_clear_locks;
+    new_store->length        = &fs_length;
+    new_store->each          = &fs_each;
+    new_store->new_output    = &fs_new_output;
+    new_store->open_input    = &fs_open_input;
+    new_store->open_lock     = &fs_open_lock;
+    new_store->close_lock    = &fs_close_lock;
+    return new_store;
 }
 
 Store *open_fs_store(const char *pathname)
 {
-  Store *store = NULL;
-  
-  mutex_lock(&stores_mutex);
-  store = h_get(&stores, pathname);
-  if (store) {
-    mutex_lock(&store->mutex);
-    store->ref_cnt++;
-    mutex_unlock(&store->mutex);
-  } else {
-    store = fs_store_create(pathname);
-    h_set(&stores, store->dir.path, store);
-  }
-  mutex_unlock(&stores_mutex);
-
-  return store;
+    Store *store = NULL;
+
+    mutex_lock(&stores_mutex);
+    store = h_get(&stores, pathname);
+    if (store) {
+        mutex_lock(&store->mutex);
+        store->ref_cnt++;
+        mutex_unlock(&store->mutex);
+    }
+    else {
+        store = fs_store_new(pathname);
+        h_set(&stores, store->dir.path, store);
+    }
+    mutex_unlock(&stores_mutex);
+
+    return store;
 }