ferret 0.11.6 → 0.11.8.4

data/ext/store.c

@@ -1,5 +1,6 @@
 #include "store.h"
 #include <string.h>
+#include "internal.h"
 
 #define VINT_MAX_LEN 10
 #define VINT_END BUFFER_SIZE - VINT_MAX_LEN
@@ -10,7 +11,7 @@
 void with_lock(Lock *lock, void (*func)(void *arg), void *arg)
 {
     if (!lock->obtain(lock)) {
-        RAISE(IO_ERROR, "couldn't obtain lock \"%s\"", lock->name);
+        RAISE(LOCK_ERROR, "couldn't obtain lock \"%s\"", lock->name);
     }
     func(arg);
     lock->release(lock);
@@ -19,7 +20,7 @@ void with_lock(Lock *lock, void (*func)(void *arg), void *arg)
 /*
  * TODO: add try finally
  */
-void with_lock_name(Store *store, char *lock_name,
+void with_lock_name(Store *store, const char *lock_name,
                     void (*func)(void *arg), void *arg)
 {
     Lock *lock = store->open_lock_i(store, lock_name);
@@ -42,7 +43,7 @@ void store_deref(Store *store)
     }
 }
 
-Lock *open_lock(Store *store, char *lockname)
+Lock *open_lock(Store *store, const char *lockname)
 {
     Lock *lock = store->open_lock_i(store, lockname);
     hs_add(store->locks, lock);
@@ -54,7 +55,7 @@ void close_lock(Lock *lock)
     hs_del(lock->store->locks, lock);
 }
 
-void close_lock_i(Lock *lock)
+static void close_lock_i(Lock *lock)
 {
     lock->store->close_lock_i(lock);
 }
@@ -68,7 +69,7 @@ Store *store_new()
     store->ref_cnt = 1;
     mutex_init(&store->mutex_i, NULL);
     mutex_init(&store->mutex, NULL);
-    store->locks = hs_new(ptr_hash, ptr_eq, (free_ft)&close_lock_i);
+    store->locks = hs_new_ptr((free_ft)&close_lock_i);
     return store;
 }
 
@@ -151,7 +152,7 @@ INLINE void os_write_byte(OutStream *os, uchar b)
     write_byte(os, b);
 }
 
-void os_write_bytes(OutStream *os, uchar *buf, int len)
+void os_write_bytes(OutStream *os, const uchar *buf, int len)
 {
     if (os->buf.pos > 0) {      /* flush buffer */
         os_flush(os);
@@ -200,7 +201,7 @@ InStream *is_new()
  * @raise IO_ERROR if there is a error reading from the filesystem
  * @raise EOF_ERROR if there is an attempt to read past the end of the file
  */
-void is_refill(InStream *is)
+static void is_refill(InStream *is)
 {
     off_t start = is->buf.start + is->buf.pos;
     off_t last = start + BUFFER_SIZE;
@@ -212,8 +213,8 @@ void is_refill(InStream *is)
 
     is->buf.len = last - start;
     if (is->buf.len <= 0) {
-        RAISE(EOF_ERROR, "current pos = %"F_OFF_T_PFX"d, "
-              "file length = %"F_OFF_T_PFX"d", start, flen);
+        RAISE(EOF_ERROR, "current pos = %"OFF_T_PFX"d, "
+              "file length = %"OFF_T_PFX"d", start, flen);
     }
 
     is->m->read_i(is, is->buf.buf, is->buf.len);
@@ -303,44 +304,44 @@ InStream *is_clone(InStream *is)
     return new_index_i;
 }
 
-f_i32 is_read_i32(InStream *is)
+i32 is_read_i32(InStream *is)
 {
-    return ((f_i32)is_read_byte(is) << 24) |
-        ((f_i32)is_read_byte(is) << 16) |
-        ((f_i32)is_read_byte(is) << 8) |
-        ((f_i32)is_read_byte(is));
+    return ((i32)is_read_byte(is) << 24) |
+        ((i32)is_read_byte(is) << 16) |
+        ((i32)is_read_byte(is) << 8) |
+        ((i32)is_read_byte(is));
 }
 
-f_i64 is_read_i64(InStream *is)
+i64 is_read_i64(InStream *is)
 {
-    return ((f_i64)is_read_byte(is) << 56) |
-        ((f_i64)is_read_byte(is) << 48) |
-        ((f_i64)is_read_byte(is) << 40) |
-        ((f_i64)is_read_byte(is) << 32) |
-        ((f_i64)is_read_byte(is) << 24) |
-        ((f_i64)is_read_byte(is) << 16) |
-        ((f_i64)is_read_byte(is) << 8) |
-        ((f_i64)is_read_byte(is));
+    return ((i64)is_read_byte(is) << 56) |
+        ((i64)is_read_byte(is) << 48) |
+        ((i64)is_read_byte(is) << 40) |
+        ((i64)is_read_byte(is) << 32) |
+        ((i64)is_read_byte(is) << 24) |
+        ((i64)is_read_byte(is) << 16) |
+        ((i64)is_read_byte(is) << 8) |
+        ((i64)is_read_byte(is));
 }
 
-f_u32 is_read_u32(InStream *is)
+u32 is_read_u32(InStream *is)
 {
-    return ((f_u32)is_read_byte(is) << 24) |
-        ((f_u32)is_read_byte(is) << 16) |
-        ((f_u32)is_read_byte(is) << 8) |
-        ((f_u32)is_read_byte(is));
+    return ((u32)is_read_byte(is) << 24) |
+        ((u32)is_read_byte(is) << 16) |
+        ((u32)is_read_byte(is) << 8) |
+        ((u32)is_read_byte(is));
 }
 
-f_u64 is_read_u64(InStream *is)
+u64 is_read_u64(InStream *is)
 {
-    return ((f_u64)is_read_byte(is) << 56) |
-        ((f_u64)is_read_byte(is) << 48) |
-        ((f_u64)is_read_byte(is) << 40) |
-        ((f_u64)is_read_byte(is) << 32) |
-        ((f_u64)is_read_byte(is) << 24) |
-        ((f_u64)is_read_byte(is) << 16) |
-        ((f_u64)is_read_byte(is) << 8) |
-        ((f_u64)is_read_byte(is));
+    return ((u64)is_read_byte(is) << 56) |
+        ((u64)is_read_byte(is) << 48) |
+        ((u64)is_read_byte(is) << 40) |
+        ((u64)is_read_byte(is) << 32) |
+        ((u64)is_read_byte(is) << 24) |
+        ((u64)is_read_byte(is) << 16) |
+        ((u64)is_read_byte(is) << 8) |
+        ((u64)is_read_byte(is));
 }
 
 /* optimized to use unchecked read_byte if there is definitely space */
@@ -404,9 +405,9 @@ INLINE off_t is_read_voff_t(InStream *is)
 }
 
 /* optimized to use unchecked read_byte if there is definitely space */
-INLINE unsigned long long is_read_vll(InStream *is)
+INLINE u64 is_read_vll(InStream *is)
 {
-    register unsigned long long res, b;
+    register u64 res, b;
     register int shift = 7;
 
     if (is->buf.pos > (is->buf.len - VINT_MAX_LEN)) {
@@ -441,8 +442,10 @@ INLINE void is_skip_vints(InStream *is, register int cnt)
     }
 }
 
-INLINE void is_read_chars(InStream *is, char *buffer,
-                                  int off, int len)
+/*
+ * FIXME: Not used. Do we need/want this?
+static INLINE void is_read_chars(InStream *is, char *buffer,
+                          int off, int len)
 {
     int end, i;
 
@@ -452,6 +455,7 @@ INLINE void is_read_chars(InStream *is, char *buffer,
         buffer[i] = is_read_byte(is);
     }
 }
+*/
 
 char *is_read_string(InStream *is)
 {
@@ -497,7 +501,7 @@ char *is_read_string_safe(InStream *is)
     return str;
 }
 
-void os_write_i32(OutStream *os, f_i32 num)
+void os_write_i32(OutStream *os, i32 num)
 {
     os_write_byte(os, (uchar)((num >> 24) & 0xFF));
     os_write_byte(os, (uchar)((num >> 16) & 0xFF));
@@ -505,7 +509,7 @@ void os_write_i32(OutStream *os, f_i32 num)
     os_write_byte(os, (uchar)(num & 0xFF));
 }
 
-void os_write_i64(OutStream *os, f_i64 num)
+void os_write_i64(OutStream *os, i64 num)
 {
     os_write_byte(os, (uchar)((num >> 56) & 0xFF));
     os_write_byte(os, (uchar)((num >> 48) & 0xFF));
@@ -517,7 +521,7 @@ void os_write_i64(OutStream *os, f_i64 num)
     os_write_byte(os, (uchar)(num & 0xFF));
 }
 
-void os_write_u32(OutStream *os, f_u32 num)
+void os_write_u32(OutStream *os, u32 num)
 {
     os_write_byte(os, (uchar)((num >> 24) & 0xFF));
     os_write_byte(os, (uchar)((num >> 16) & 0xFF));
@@ -525,7 +529,7 @@ void os_write_u32(OutStream *os, f_u32 num)
     os_write_byte(os, (uchar)(num & 0xFF));
 }
 
-void os_write_u64(OutStream *os, f_u64 num)
+void os_write_u64(OutStream *os, u64 num)
 {
     os_write_byte(os, (uchar)((num >> 56) & 0xFF));
     os_write_byte(os, (uchar)((num >> 48) & 0xFF));
@@ -576,7 +580,7 @@ INLINE void os_write_voff_t(OutStream *os, register off_t num)
 }
 
 /* optimized to use an unchecked write if there is space */
-INLINE void os_write_vll(OutStream *os, register unsigned long long num)
+INLINE void os_write_vll(OutStream *os, register u64 num)
 {
     if (os->buf.pos > VINT_END) {
         while (num > 127) {
@@ -594,13 +598,15 @@ INLINE void os_write_vll(OutStream *os, register unsigned long long num)
     }
 }
 
-void os_write_string(OutStream *os, char *str)
+INLINE void os_write_string_len(OutStream *os, const char *str, int len)
 {
-    int len = (int)strlen(str);
     os_write_vint(os, len);
-
     os_write_bytes(os, (uchar *)str, len);
 }
+void os_write_string(OutStream *os, const char *str)
+{
+    os_write_string_len(os, str, (int)strlen(str));
+}
 
 /**
  * Determine if the filename is the name of a lock file. Return 1 if it is, 0
@@ -609,7 +615,7 @@ void os_write_string(OutStream *os, char *str)
  * @param filename the name of the file to check
  * @return 1 (true) if the file is a lock file, 0 (false) otherwise
  */
-int file_is_lock(char *filename)
+int file_is_lock(const char *filename)
 {
     int start = (int) strlen(filename) - 4;
     return ((start > 0) && (strcmp(LOCK_EXT, &filename[start]) == 0));
@@ -652,7 +658,7 @@ struct FileNameListArg
 /**
  * Test function used to test store->each function
  */
-static void add_file_name(char *fname, void *arg)
+static void add_file_name(const char *fname, void *arg)
 {
     struct FileNameListArg *fnl = (struct FileNameListArg *)arg;
     if (fnl->count >= fnl->size) {

data/ext/store.h

@@ -7,78 +7,74 @@
 #include "hashset.h"
 #include "threading.h"
 
-#define BUFFER_SIZE 1024
-#define LOCK_PREFIX "ferret-"
-#define LOCK_EXT ".lck"
+#define FRT_LOCK_PREFIX "ferret-"
+#define FRT_LOCK_EXT ".lck"
 
-#define VINT_MAX_LEN 10
-#define VINT_END BUFFER_SIZE - VINT_MAX_LEN
-
-typedef struct Buffer
+typedef struct FrtBuffer
 {
-    uchar buf[BUFFER_SIZE];
+    frt_uchar buf[FRT_BUFFER_SIZE];
     off_t start;
     off_t pos;
     off_t len;
-} Buffer;
+} FrtBuffer;
 
-typedef struct OutStream OutStream;
-struct OutStreamMethods {
-    /* internal functions for the InStream */
+typedef struct FrtOutStream FrtOutStream;
+struct FrtOutStreamMethods {
+    /* internal functions for the FrtInStream */
     /**
      * Flush +len+ characters from +src+ to the output stream +os+
      *
      * @param os self
      * @param src the characters to write to the output stream
      * @param len the number of characters to write
-     * @raise IO_ERROR if there is an error writing the characters
+     * @raise FRT_IO_ERROR if there is an error writing the characters
      */
-    void (*flush_i)(struct OutStream *os, uchar *buf, int len);
+    void (*flush_i)(struct FrtOutStream *os, const frt_uchar *buf, int len);
 
     /**
      * Seek +pos+ in the output stream
      *
      * @param os self
      * @param pos the position to seek in the stream
-     * @raise IO_ERROR if there is an error seeking in the output stream
+     * @raise FRT_IO_ERROR if there is an error seeking in the output stream
      */
-    void (*seek_i)(struct OutStream *os, off_t pos);
+    void (*seek_i)(struct FrtOutStream *os, off_t pos);
 
     /**
      * Close any resources used by the output stream +os+
      *
      * @param os self
-     * @raise IO_ERROR if there is an closing the file
+     * @raise FRT_IO_ERROR if there is an closing the file
      */
-    void (*close_i)(struct OutStream *os);
+    void (*close_i)(struct FrtOutStream *os);
 };
 
-typedef struct RAMFile
+typedef struct FrtRAMFile
 {
     char   *name;
-    uchar **buffers;
+    frt_uchar **buffers;
     int     bufcnt;
     off_t   len;
     int     ref_cnt;
-} RAMFile;
+} FrtRAMFile;
 
-struct OutStream
+struct FrtOutStream
 {
-    Buffer buf;
+    FrtBuffer buf;
     union
     {
         int fd;
-        RAMFile *rf;
+        FrtRAMFile *rf;
     } file;
     off_t  pointer;             /* only used by RAMOut */
-    const struct OutStreamMethods *m;
+    const struct FrtOutStreamMethods *m;
 };
 
-typedef struct CompoundInStream CompoundInStream;
+typedef struct FrtCompoundInStream FrtCompoundInStream;
 
-typedef struct InStream InStream;
+typedef struct FrtInStream FrtInStream;
 
-struct InStreamMethods
+struct FrtInStreamMethods
 {
     /**
      * Read +len+ characters from the input stream into the +offset+ position in
@@ -88,92 +84,92 @@ struct InStreamMethods
      * @param buf an array of characters which must be allocated with  at least
      *          +offset+ + +len+ bytes
      * @param len the number of bytes to read
-     * @raise IO_ERROR if there is an error reading from the input stream
+     * @raise FRT_IO_ERROR if there is an error reading from the input stream
      */
-    void (*read_i)(struct InStream *is, uchar *buf, int len);
+    void (*read_i)(struct FrtInStream *is, frt_uchar *buf, int len);
 
     /**
      * Seek position +pos+ in input stream +is+
      *
      * @param is self
      * @param pos the position to seek
-     * @raise IO_ERROR if the seek fails
+     * @raise FRT_IO_ERROR if the seek fails
      */
-    void (*seek_i)(struct InStream *is, off_t pos);
+    void (*seek_i)(struct FrtInStream *is, off_t pos);
 
     /**
      * Returns the length of the input stream +is+
      *
      * @param is self
-     * @raise IO_ERROR if there is an error getting the file length
+     * @raise FRT_IO_ERROR if there is an error getting the file length
      */
-    off_t (*length_i)(struct InStream *is);
-    
+    off_t (*length_i)(struct FrtInStream *is);
+
     /**
      * Close the resources allocated to the inputstream +is+
      *
      * @param is self
-     * @raise IO_ERROR if the close fails
+     * @raise FRT_IO_ERROR if the close fails
      */
-    void (*close_i)(struct InStream *is);
+    void (*close_i)(struct FrtInStream *is);
 };
 
-struct InStream
+struct FrtInStream
 {
-    Buffer buf;
+    FrtBuffer buf;
     union
     {
         int fd;
-        RAMFile *rf;
+        FrtRAMFile *rf;
     } file;
     union
     {
-        off_t pointer;           /* only used by RAMIn */
+        off_t pointer;          /* only used by RAMIn */
         char *path;             /* only used by FSIn */
-        CompoundInStream *cis;
+        FrtCompoundInStream *cis;
     } d;
     int *ref_cnt_ptr;
-    const struct InStreamMethods *m;
+    const struct FrtInStreamMethods *m;
 };
 
-struct CompoundInStream
+struct FrtCompoundInStream
 {
-    InStream *sub;
+    FrtInStream *sub;
     off_t offset;
     off_t length;
 };
 
 #define is_length(mis) mis->m->length_i(mis)
 
-typedef struct Store Store;
-typedef struct Lock Lock;
-struct Lock
+typedef struct FrtStore FrtStore;
+typedef struct FrtLock FrtLock;
+struct FrtLock
 {
     char *name;
-    Store *store;
-    int (*obtain)(Lock *lock);
-    int (*is_locked)(Lock *lock);
-    void (*release)(Lock *lock);
+    FrtStore *store;
+    int (*obtain)(FrtLock *lock);
+    int (*is_locked)(FrtLock *lock);
+    void (*release)(FrtLock *lock);
 };
 
-typedef struct CompoundStore
+typedef struct FrtCompoundStore
 {
-    Store *store;
+    FrtStore *store;
     const char *name;
-    HashTable *entries;
-    InStream *stream;
-} CompoundStore;
+    FrtHash *entries;
+    FrtInStream *stream;
+} FrtCompoundStore;
 
-struct Store
+struct FrtStore
 {
     int ref_cnt;                /* for fs_store only */
-    mutex_t mutex_i;            /* for internal use only */
-    mutex_t mutex;              /* external mutex for use outside */
+    frt_mutex_t mutex_i;        /* for internal use only */
+    frt_mutex_t mutex;          /* external mutex for use outside */
     union
     {
         char *path;             /* for fs_store only */
-        HashTable *ht;          /* for ram_store only */
-        CompoundStore *cmpd;    /* for compound_store only */
+        FrtHash *ht;            /* for ram_store only */
+        FrtCompoundStore *cmpd; /* for compound_store only */
     } dir;
 
 #ifdef POSH_OS_WIN32
@@ -181,16 +177,16 @@ struct Store
 #else
     mode_t file_mode;
 #endif
-    HashSet *locks;
+    FrtHashSet *locks;
 
     /**
      * Create the file +filename+ in the +store+.
      *
      * @param store self
      * @param filename the name of the file to create
-     * @raise IO_ERROR if the file cannot be created
+     * @raise FRT_IO_ERROR if the file cannot be created
      */
-    void (*touch)(Store *store, char *filename);
+    void (*touch)(FrtStore *store, const char *filename);
 
     /**
      * Return true if a file of name +filename+ exists in +store+.
@@ -198,9 +194,9 @@ struct Store
      * @param store self
      * @param filename the name of the file to check for
      * @returns true if the file exists
-     * @raise IO_ERROR if there is an error checking for the files existance
+     * @raise FRT_IO_ERROR if there is an error checking for the files existance
      */
-    int (*exists)(Store *store, char *filename);
+    int (*exists)(FrtStore *store, const char *filename);
 
     /**
      * Remove the file +filename+ from the +store+
@@ -210,7 +206,7 @@ struct Store
      * @returns On success, zero is returned.  On error, -1 is returned, and errno
      *          is set appropriately.
      */
-    int (*remove)(Store *store, char *filename);
+    int (*remove)(FrtStore *store, const char *filename);
 
     /**
      * Rename the file in the +store+ from the name +from+ to the name +to+.
@@ -218,18 +214,18 @@ struct Store
      * @param store self
      * @param from the name of the file to rename
      * @param to the new name of the file
-     * @raise IO_ERROR if there is an error renaming the file
+     * @raise FRT_IO_ERROR if there is an error renaming the file
      */
-    void (*rename)(Store *store, char *from, char *to);
+    void (*rename)(FrtStore *store, const char *from, const char *to);
 
     /**
      * Returns the number of files in the store.
      *
      * @param store self
      * @return the number of files in the store
-     * @raise IO_ERROR if there is an error opening the directory
+     * @raise FRT_IO_ERROR if there is an error opening the directory
      */
-    int (*count)(Store *store);
+    int (*count)(FrtStore *store);
 
     /**
      * Call the function +func+ with each filename in the store and the arg
@@ -241,34 +237,34 @@ struct Store
      * @param func the function to call with each files name and the +arg+
      *   passed
      * @param arg the argument to pass to the function
-     * @raise IO_ERROR if there is an error opening the directory
+     * @raise FRT_IO_ERROR if there is an error opening the directory
      */
-    void (*each)(Store *store, void (*func)(char *fname, void *arg),
+    void (*each)(FrtStore *store, void (*func)(const char *fname, void *arg),
                   void *arg);
 
     /**
      * Clear all the locks in the store.
      *
      * @param store self
-     * @raise IO_ERROR if there is an error opening the directory
+     * @raise FRT_IO_ERROR if there is an error opening the directory
      */
-    void (*clear_locks)(Store *store);
+    void (*clear_locks)(FrtStore *store);
 
     /**
      * Clear all files from the store except the lock files.
      *
      * @param store self
-     * @raise IO_ERROR if there is an error deleting the files
+     * @raise FRT_IO_ERROR if there is an error deleting the files
      */
-    void (*clear)(Store *store);
+    void (*clear)(FrtStore *store);
 
     /**
      * Clear all files from the store including the lock files.
      *
      * @param store self
-     * @raise IO_ERROR if there is an error deleting the files
+     * @raise FRT_IO_ERROR if there is an error deleting the files
      */
-    void (*clear_all)(Store *store);
+    void (*clear_all)(FrtStore *store);
 
     /**
      * Return the length of the file +filename+ in +store+
@@ -276,9 +272,9 @@ struct Store
      * @param store self
      * @param the name of the file to check the length of
      * @return the length of the file in bytes
-     * @raise IO_ERROR if there is an error checking the file length
+     * @raise FRT_IO_ERROR if there is an error checking the file length
      */
-    off_t (*length)(Store *store, char *filename);
+    off_t (*length)(FrtStore *store, const char *filename);
 
     /**
      * Allocate the resources needed for the output stream in the +store+ with
@@ -287,19 +283,19 @@ struct Store
      * @param store self
      * @param filename the name of the output stream
      * @return a newly allocated filestream
-     * @raise IO_ERROR if there is an error opening the output stream
+     * @raise FRT_IO_ERROR if there is an error opening the output stream
      *   resources
      */
-    OutStream *(*new_output)(Store *store, const char *filename);
+    FrtOutStream *(*new_output)(FrtStore *store, const char *filename);
 
     /**
      * Open an input stream in the +store+ with the name +filename+
      *
      * @param store self
      * @param filename the name of the input stream
-     * @raise FILE_NOT_FOUND_ERROR if the input stream cannot be opened
+     * @raise FRT_FILE_NOT_FOUND_ERROR if the input stream cannot be opened
      */
-    InStream *(*open_input)(Store *store, const char *filename);
+    FrtInStream *(*open_input)(FrtStore *store, const char *filename);
 
     /**
      * Obtain a lock on the lock +lock+
@@ -307,15 +303,15 @@ struct Store
      * @param store self
      * @param lock the lock to obtain
      */
-    Lock *(*open_lock_i)(Store *store, char *lockname);
+    FrtLock *(*open_lock_i)(FrtStore *store, const char *lockname);
 
     /**
      * Returns true if +lock+ is locked. To test if the file is locked:wq
      *
      * @param lock the lock to test
-     * @raise IO_ERROR if there is an error detecting the lock status
+     * @raise FRT_IO_ERROR if there is an error detecting the lock status
      */
-    void (*close_lock_i)(Lock *lock);
+    void (*close_lock_i)(FrtLock *lock);
 
     /**
      * Internal function to close the store freeing implementation specific
@@ -323,27 +319,27 @@ struct Store
      *
      * @param store self
      */
-    void (*close_i)(Store *store);
+    void (*close_i)(FrtStore *store);
 };
 
 /**
- * Create a newly allocated file-system Store at the pathname designated. The
+ * Create a newly allocated file-system FrtStore at the pathname designated. The
  * pathname must be the name of an existing directory.
  *
  * @param pathname the pathname of the directory to be used by the index
- * @return a newly allocated file-system Store.
+ * @return a newly allocated file-system FrtStore.
  */
-extern Store *open_fs_store(const char *pathname);
+extern FrtStore *frt_open_fs_store(const char *pathname);
 
 /**
- * Create a newly allocated in-memory or RAM Store.
+ * Create a newly allocated in-memory or RAM FrtStore.
  *
- * @return a newly allocated RAM Store.
+ * @return a newly allocated RAM FrtStore.
  */
-extern Store *open_ram_store();
+extern FrtStore *frt_open_ram_store();
 
 /**
- * Create a newly allocated in-memory or RAM Store. Copy the contents of
+ * Create a newly allocated in-memory or RAM FrtStore. Copy the contents of
  * another store into this store. Then close the other store if required. This
  * method would be used for example to read an index into memory for faster
  * searching.
@@ -351,9 +347,9 @@ extern Store *open_ram_store();
  * @param store the whose contents will be copied into the newly allocated RAM
  *   store
  * @param close_store close the store whose contents where copied
- * @return a newly allocated RAM Store.
+ * @return a newly allocated RAM FrtStore.
  */
-extern Store *open_ram_store_and_copy(Store *store, bool close_store);
+extern FrtStore *frt_open_ram_store_and_copy(FrtStore *store, bool close_store);
 
 /**
  * Open a compound store. This is basically store which is stored within a
@@ -362,86 +358,86 @@ extern Store *open_ram_store_and_copy(Store *store, bool close_store);
  *
  * @param store the store within which this compound store will be stored
  * @param filename the name of the file in which to store the compound store
- * @return a newly allocated Compound Store.
+ * @return a newly allocated Compound FrtStore.
  */
-extern Store *open_cmpd_store(Store *store, const char *filename);
+extern FrtStore *frt_open_cmpd_store(FrtStore *store, const char *filename);
 
-/* 
+/*
  * == RamStore functions ==
  *
  * These functions or optimizations to be used when you know you are using a
- * Ram OutStream.
+ * Ram FrtOutStream.
  */
 
 /**
- * Return the length of the OutStream in bytes.
+ * Return the length of the FrtOutStream in bytes.
  *
- * @param os the OutStream who's length you want
+ * @param os the FrtOutStream who's length you want
  * @return the length of +os+ in bytes
  */
-extern off_t ramo_length(OutStream *os);
+extern off_t frt_ramo_length(FrtOutStream *os);
 
 /**
- * Reset the OutStream removing any data written to it. Since it is a RAM
+ * Reset the FrtOutStream removing any data written to it. Since it is a RAM
  * file, all that needs to be done is set the length to 0.
  *
- * @param os the OutStream to reset
+ * @param os the FrtOutStream to reset
  */
-extern void ramo_reset(OutStream *os);
+extern void frt_ramo_reset(FrtOutStream *os);
 
 /**
- * Write the contents of a RAM OutStream to another OutStream.
+ * Write the contents of a RAM FrtOutStream to another FrtOutStream.
  *
- * @param from_os the OutStream to write from
- * @param to_os the OutStream to write to
+ * @param from_os the FrtOutStream to write from
+ * @param to_os the FrtOutStream to write to
  */
-extern void ramo_write_to(OutStream *from_os, OutStream *to_os);
+extern void frt_ramo_write_to(FrtOutStream *from_os, FrtOutStream *to_os);
 
 /**
- * Create a buffer RAM OutStream which is unassociated with any RAM Store.
- * This OutStream can be used to write temporary data too. When the time
- * comes, this data can be written to another OutStream (which might possibly
- * be a file-system OutStream) using ramo_write_to.
+ * Create a buffer RAM FrtOutStream which is unassociated with any RAM FrtStore.
+ * This FrtOutStream can be used to write temporary data too. When the time
+ * comes, this data can be written to another FrtOutStream (which might possibly
+ * be a file-system FrtOutStream) using frt_ramo_write_to.
  *
- * @return A newly allocated RAM OutStream
+ * @return A newly allocated RAM FrtOutStream
  */
-extern OutStream *ram_new_buffer();
+extern FrtOutStream *frt_ram_new_buffer();
 
 /**
- * Destroy a RAM OutStream which is unassociated with any RAM Store, freeing
+ * Destroy a RAM FrtOutStream which is unassociated with any RAM FrtStore, freeing
  * all resources allocated to it.
  *
- * @param os the OutStream to destroy
+ * @param os the FrtOutStream to destroy
  */
-extern void ram_destroy_buffer(OutStream *os);
+extern void frt_ram_destroy_buffer(FrtOutStream *os);
 
 /**
  * Call the function +func+ with the +lock+ locked. The argument +arg+ will be
  * passed to +func+. If you need to pass more than one argument you should use
  * a struct. When the function is finished, release the lock.
- * 
+ *
  * @param lock     lock to be locked while func is called
  * @param func     function to call with the lock locked
  * @param arg      argument to pass to the function
- * @raise IO_ERROR if the lock is already locked
- * @see with_lock_name
+ * @raise FRT_IO_ERROR if the lock is already locked
+ * @see frt_with_lock_name
  */
-extern void with_lock(Lock *lock, void (*func)(void *arg), void *arg);
+extern void frt_with_lock(FrtLock *lock, void (*func)(void *arg), void *arg);
 
 /**
  * Create a lock in the +store+ with the name +lock_name+. Call the function
  * +func+ with the lock locked. The argument +arg+ will be passed to +func+.
  * If you need to pass more than one argument you should use a struct. When
  * the function is finished, release and destroy the lock.
- * 
+ *
  * @param store     store to open the lock in
  * @param lock_name name of the lock to open
  * @param func      function to call with the lock locked
  * @param arg       argument to pass to the function
- * @raise IO_ERROR  if the lock is already locked
- * @see with_lock
+ * @raise FRT_IO_ERROR  if the lock is already locked
+ * @see frt_with_lock
  */
-extern void with_lock_name(Store *store, char *lock_name,
+extern void frt_with_lock_name(FrtStore *store, const char *lock_name,
                            void (*func)(void *arg), void *arg);
 
 /**
@@ -450,328 +446,354 @@ extern void with_lock_name(Store *store, char *lock_name,
  *
  * @param store the store to be dereferenced
  */
-extern void store_deref(Store *store);
+extern void frt_store_deref(FrtStore *store);
 
 /**
- * Flush the buffered contents of the OutStream to the store.
+ * Flush the buffered contents of the FrtOutStream to the store.
  *
- * @param os the OutStream to flush
+ * @param os the FrtOutStream to flush
  */
-extern void os_flush(OutStream *os);
+extern void frt_os_flush(FrtOutStream *os);
 
 /**
- * Close the OutStream after flushing the buffers, also freeing all allocated
+ * Close the FrtOutStream after flushing the buffers, also freeing all allocated
  * resources.
  *
- * @param os the OutStream to close
+ * @param os the FrtOutStream to close
  */
-extern void os_close(OutStream *os);
+extern void frt_os_close(FrtOutStream *os);
 
 /**
- * Return the current position of OutStream +os+. 
+ * Return the current position of FrtOutStream +os+.
  *
- * @param os the OutStream to get the position from
- * @return the current position in OutStream +os+
+ * @param os the FrtOutStream to get the position from
+ * @return the current position in FrtOutStream +os+
  */
-extern off_t os_pos(OutStream *os);
+extern off_t frt_os_pos(FrtOutStream *os);
 
 /**
- * Set the current position in OutStream +os+.
+ * Set the current position in FrtOutStream +os+.
  *
- * @param os the OutStream to set the position in
- * @param pos the new position in the OutStream
- * @raise IO_ERROR if there is a file-system IO error seeking the file
+ * @param os the FrtOutStream to set the position in
+ * @param pos the new position in the FrtOutStream
+ * @raise FRT_IO_ERROR if there is a file-system IO error seeking the file
  */
-extern void os_seek(OutStream *os, off_t new_pos);
+extern void frt_os_seek(FrtOutStream *os, off_t new_pos);
 
 /**
- * Write a single byte +b+ to the OutStream +os+
+ * Write a single byte +b+ to the FrtOutStream +os+
  *
- * @param os the OutStream to write to @param b  the byte to write @raise
- * IO_ERROR if there is an IO error writing to the file-system
+ * @param os the FrtOutStream to write to @param b  the byte to write @raise
+ * FRT_IO_ERROR if there is an IO error writing to the file-system
  */
-extern void os_write_byte(OutStream *os, uchar b);
+extern void frt_os_write_byte(FrtOutStream *os, frt_uchar b);
 /**
- * Write +len+ bytes from buffer +buf+ to the OutStream +os+.
+ * Write +len+ bytes from buffer +buf+ to the FrtOutStream +os+.
  *
- * @param os  the OutStream to write to
+ * @param os  the FrtOutStream to write to
  * @param len the number of bytes to write
  * @param buf the buffer from which to get the bytes to write.
- * @raise IO_ERROR if there is an IO error writing to the file-system
+ * @raise FRT_IO_ERROR if there is an IO error writing to the file-system
  */
-extern void os_write_bytes(OutStream *os, uchar *buf, int len);
+extern void frt_os_write_bytes(FrtOutStream *os, const frt_uchar *buf, int len);
 
 /**
- * Write a 32-bit signed integer to the OutStream
+ * Write a 32-bit signed integer to the FrtOutStream
  *
- * @param os OutStream to write to
+ * @param os FrtOutStream to write to
  * @param num the 32-bit signed integer to write
- * @raise IO_ERROR if there is an error writing to the file-system
+ * @raise FRT_IO_ERROR if there is an error writing to the file-system
  */
-extern void os_write_i32(OutStream *os, f_i32 num);
+extern void frt_os_write_i32(FrtOutStream *os, frt_i32 num);
 
 /**
- * Write a 64-bit signed integer to the OutStream
+ * Write a 64-bit signed integer to the FrtOutStream
  *
  *
- * @param os OutStream to write to
+ * @param os FrtOutStream to write to
  * @param num the 64-bit signed integer to write
- * @raise IO_ERROR if there is an error writing to the file-system
+ * @raise FRT_IO_ERROR if there is an error writing to the file-system
  */
-extern void os_write_i64(OutStream *os, f_i64 num);
+extern void frt_os_write_i64(FrtOutStream *os, frt_i64 num);
 
 /**
- * Write a 32-bit unsigned integer to the OutStream
+ * Write a 32-bit unsigned integer to the FrtOutStream
  *
- * @param os OutStream to write to
+ * @param os FrtOutStream to write to
  * @param num the 32-bit unsigned integer to write
- * @raise IO_ERROR if there is an error writing to the file-system
+ * @raise FRT_IO_ERROR if there is an error writing to the file-system
  */
-extern void os_write_u32(OutStream *os, f_u32 num);
+extern void frt_os_write_u32(FrtOutStream *os, frt_u32 num);
 
 /**
- * Write a 64-bit unsigned integer to the OutStream
+ * Write a 64-bit unsigned integer to the FrtOutStream
  *
- * @param os OutStream to write to
+ * @param os FrtOutStream to write to
  * @param num the 64-bit unsigned integer to write
- * @raise IO_ERROR if there is an error writing to the file-system
+ * @raise FRT_IO_ERROR if there is an error writing to the file-system
  */
-extern void os_write_u64(OutStream *os, f_u64 num);
+extern void frt_os_write_u64(FrtOutStream *os, frt_u64 num);
 
 /**
- * Write an unsigned integer to OutStream in compressed VINT format.
+ * Write an unsigned integer to FrtOutStream in compressed VINT format.
  * TODO: describe VINT format
  *
- * @param os OutStream to write to
+ * @param os FrtOutStream to write to
  * @param num the integer to write
- * @raise IO_ERROR if there is an error writing to the file-system
+ * @raise FRT_IO_ERROR if there is an error writing to the file-system
  */
-extern void os_write_vint(OutStream *os, register unsigned int num);
+extern void frt_os_write_vint(FrtOutStream *os, register unsigned int num);
 
 /**
- * Write an unsigned off_t to OutStream in compressed VINT format.
+ * Write an unsigned off_t to FrtOutStream in compressed VINT format.
  * TODO: describe VINT format
  *
- * @param os OutStream to write to
+ * @param os FrtOutStream to write to
  * @param num the off_t to write
- * @raise IO_ERROR if there is an error writing to the file-system
+ * @raise FRT_IO_ERROR if there is an error writing to the file-system
  */
-extern void os_write_voff_t(OutStream *os, register off_t num);
+extern void frt_os_write_voff_t(FrtOutStream *os, register off_t num);
 
 /**
- * Write an unsigned long long to OutStream in compressed VINT format.
+ * Write an unsigned 64bit int to FrtOutStream in compressed VINT format.
  * TODO: describe VINT format
  *
- * @param os OutStream to write to
- * @param num the long long to write
- * @raise IO_ERROR if there is an error writing to the file-system
+ * @param os FrtOutStream to write to
+ * @param num the 64bit int to write
+ * @raise FRT_IO_ERROR if there is an error writing to the file-system
+ */
+extern void frt_os_write_vll(FrtOutStream *os, register frt_u64 num);
+
+/**
+ * Write a string with known length to the FrtOutStream. A string is an
+ * integer +length+ in VINT format (see frt_os_write_vint) followed by
+ * +length+ bytes. The string can then be read using frt_is_read_string.
+ *
+ * @param os FrtOutStream to write to
+ * @param str the string to write
+ * @param len the length of the string to write
+ * @raise FRT_IO_ERROR if there is an error writing to the file-system
  */
-extern void os_write_vll(OutStream *os, register unsigned long long num);
+extern FRT_INLINE void frt_os_write_string_len(FrtOutStream *os,
+                                               const char *str,
+                                               int len);
 
 /**
- * Write a string to the OutStream. A string is an integer +length+ in VINT
- * format (see os_write_vint) followed by +length+ bytes. The string can then
- * be read using is_read_string.
+ * Write a string to the FrtOutStream. A string is an integer +length+ in VINT
+ * format (see frt_os_write_vint) followed by +length+ bytes. The string can then
+ * be read using frt_is_read_string.
  *
- * @param os OutStream to write to
+ * @param os FrtOutStream to write to
  * @param str the string to write
- * @raise IO_ERROR if there is an error writing to the file-system
+ * @raise FRT_IO_ERROR if there is an error writing to the file-system
  */
-extern void os_write_string(OutStream *os, char *str);
+extern void frt_os_write_string(FrtOutStream *os, const char *str);
+
 /**
- * Get the current position within an InStream.
+ * Get the current position within an FrtInStream.
  *
- * @param is the InStream to get the current position from
- * @return the current position within the InStream +is+
+ * @param is the FrtInStream to get the current position from
+ * @return the current position within the FrtInStream +is+
  */
-extern off_t is_pos(InStream *is);
+extern off_t frt_is_pos(FrtInStream *is);
 
 /**
- * Set the current position in InStream +is+ to +pos+.
+ * Set the current position in FrtInStream +is+ to +pos+.
  *
- * @param is the InStream to set the current position in
- * @param pos the position in InStream to seek
- * @raise IO_ERROR if there is a error seeking from the file-system
- * @raise EOF_ERROR if there is an attempt to seek past the end of the file
+ * @param is the FrtInStream to set the current position in
+ * @param pos the position in FrtInStream to seek
+ * @raise FRT_IO_ERROR if there is a error seeking from the file-system
+ * @raise FRT_EOF_ERROR if there is an attempt to seek past the end of the file
  */
-extern void is_seek(InStream *is, off_t pos);
+extern void frt_is_seek(FrtInStream *is, off_t pos);
 
 /**
- * Close the InStream freeing all allocated resources.
+ * Close the FrtInStream freeing all allocated resources.
  *
- * @param is the InStream to close
- * @raise IO_ERROR if there is an error closing the associated file
+ * @param is the FrtInStream to close
+ * @raise FRT_IO_ERROR if there is an error closing the associated file
  */
-extern void is_close(InStream *is);
+extern void frt_is_close(FrtInStream *is);
 
 /**
- * Clone the InStream allocating a new InStream structure
+ * Clone the FrtInStream allocating a new FrtInStream structure
  *
- * @param is the InStream to clone
- * @return a newly allocated InStream which is a clone of +is+
+ * @param is the FrtInStream to clone
+ * @return a newly allocated FrtInStream which is a clone of +is+
  */
-extern InStream *is_clone(InStream *is);
+extern FrtInStream *frt_is_clone(FrtInStream *is);
 
 /**
- * Read a singly byte (unsigned char) from the InStream +is+.
+ * Read a singly byte (unsigned char) from the FrtInStream +is+.
  *
  * @param is the Instream to read from
- * @return a single unsigned char read from the InStream +is+
- * @raise IO_ERROR if there is a error reading from the file-system
- * @raise EOF_ERROR if there is an attempt to read past the end of the file
+ * @return a single unsigned char read from the FrtInStream +is+
+ * @raise FRT_IO_ERROR if there is a error reading from the file-system
+ * @raise FRT_EOF_ERROR if there is an attempt to read past the end of the file
  */
-extern INLINE uchar is_read_byte(InStream *is);
+extern FRT_INLINE frt_uchar frt_is_read_byte(FrtInStream *is);
 
 /**
- * Read +len+ bytes from InStream +is+ and write them to buffer +buf+
+ * Read +len+ bytes from FrtInStream +is+ and write them to buffer +buf+
  *
- * @param is     the InStream to read from
+ * @param is     the FrtInStream to read from
  * @param buf    the buffer to read into, that is copy the bytes read to
  * @param len    the number of bytes to read
  * @return       the resultant buffer +buf+
- * @raise IO_ERROR if there is a error reading from the file-system
- * @raise EOF_ERROR if there is an attempt to read past the end of the file
+ * @raise FRT_IO_ERROR if there is a error reading from the file-system
+ * @raise FRT_EOF_ERROR if there is an attempt to read past the end of the file
  */
-extern uchar *is_read_bytes(InStream *is, uchar *buf, int len);
+extern frt_uchar *frt_is_read_bytes(FrtInStream *is, frt_uchar *buf, int len);
 
 /**
- * Read a 32-bit unsigned integer from the InStream.
+ * Read a 32-bit unsigned integer from the FrtInStream.
  *
- * @param is the InStream to read from
+ * @param is the FrtInStream to read from
  * @return a 32-bit unsigned integer
- * @raise IO_ERROR if there is a error reading from the file-system
- * @raise EOF_ERROR if there is an attempt to read past the end of the file
+ * @raise FRT_IO_ERROR if there is a error reading from the file-system
+ * @raise FRT_EOF_ERROR if there is an attempt to read past the end of the file
  */
-extern f_i32 is_read_i32(InStream *is);
+extern frt_i32 frt_is_read_i32(FrtInStream *is);
 
 /**
- * Read a 64-bit unsigned integer from the InStream.
+ * Read a 64-bit unsigned integer from the FrtInStream.
  *
- * @param is the InStream to read from
+ * @param is the FrtInStream to read from
  * @return a 64-bit unsigned integer
- * @raise IO_ERROR if there is a error reading from the file-system
- * @raise EOF_ERROR if there is an attempt to read past the end of the file
+ * @raise FRT_IO_ERROR if there is a error reading from the file-system
+ * @raise FRT_EOF_ERROR if there is an attempt to read past the end of the file
  */
-extern f_i64 is_read_i64(InStream *is);
+extern frt_i64 frt_is_read_i64(FrtInStream *is);
 
 /**
- * Read a 32-bit signed integer from the InStream.
+ * Read a 32-bit signed integer from the FrtInStream.
  *
- * @param is the InStream to read from
+ * @param is the FrtInStream to read from
  * @return a 32-bit signed integer
- * @raise IO_ERROR if there is a error reading from the file-system
- * @raise EOF_ERROR if there is an attempt to read past the end of the file
+ * @raise FRT_IO_ERROR if there is a error reading from the file-system
+ * @raise FRT_EOF_ERROR if there is an attempt to read past the end of the file
  */
-extern f_u32 is_read_u32(InStream *is);
+extern frt_u32 frt_is_read_u32(FrtInStream *is);
 
 /**
- * Read a 64-bit signed integer from the InStream.
+ * Read a 64-bit signed integer from the FrtInStream.
  *
- * @param is the InStream to read from
+ * @param is the FrtInStream to read from
  * @return a 64-bit signed integer
- * @raise IO_ERROR if there is a error reading from the file-system
- * @raise EOF_ERROR if there is an attempt to read past the end of the file
+ * @raise FRT_IO_ERROR if there is a error reading from the file-system
+ * @raise FRT_EOF_ERROR if there is an attempt to read past the end of the file
  */
-extern f_u64 is_read_u64(InStream *is);
+extern frt_u64 frt_is_read_u64(FrtInStream *is);
 
 /**
- * Read a compressed (VINT) unsigned integer from the InStream.
+ * Read a compressed (VINT) unsigned integer from the FrtInStream.
  * TODO: describe VINT format
  *
- * @param is the InStream to read from
+ * @param is the FrtInStream to read from
  * @return an int
- * @raise IO_ERROR if there is a error reading from the file-system
- * @raise EOF_ERROR if there is an attempt to read past the end of the file
+ * @raise FRT_IO_ERROR if there is a error reading from the file-system
+ * @raise FRT_EOF_ERROR if there is an attempt to read past the end of the file
  */
-extern INLINE unsigned int is_read_vint(InStream *is);
+extern FRT_INLINE unsigned int frt_is_read_vint(FrtInStream *is);
 
 /**
  * Skip _cnt_ vints. This is a convenience method used for performance reasons
  * to skip large numbers of vints. It is mostly used by TermDocEnums. When
  * skipping positions os the proximity index file.
  *
- * @param is the InStream to read from
+ * @param is the FrtInStream to read from
  * @param cnt the number of vints to skip
- * @raise IO_ERROR if there is a error reading from the file-system
- * @raise EOF_ERROR if there is an attempt to read past the end of the file
+ * @raise FRT_IO_ERROR if there is a error reading from the file-system
+ * @raise FRT_EOF_ERROR if there is an attempt to read past the end of the file
  */
-extern INLINE void is_skip_vints(InStream *is, register int cnt);
+extern FRT_INLINE void frt_is_skip_vints(FrtInStream *is, register int cnt);
 
 /**
- * Read a compressed (VINT) unsigned off_t from the InStream.
+ * Read a compressed (VINT) unsigned off_t from the FrtInStream.
  * TODO: describe VINT format
  *
- * @param is the InStream to read from
+ * @param is the FrtInStream to read from
  * @return a off_t
- * @raise IO_ERROR if there is a error reading from the file-system
- * @raise EOF_ERROR if there is an attempt to read past the end of the file
+ * @raise FRT_IO_ERROR if there is a error reading from the file-system
+ * @raise FRT_EOF_ERROR if there is an attempt to read past the end of the file
  */
-extern INLINE off_t is_read_voff_t(InStream *is);
+extern FRT_INLINE off_t frt_is_read_voff_t(FrtInStream *is);
 
 /**
- * Read a compressed (VINT) unsigned long long from the InStream.
+ * Read a compressed (VINT) unsigned 64bit int from the FrtInStream.
  * TODO: describe VINT format
  *
- * @param is the InStream to read from
- * @return a long long
- * @raise IO_ERROR if there is a error reading from the file-system
- * @raise EOF_ERROR if there is an attempt to read past the end of the file
+ * @param is the FrtInStream to read from
+ * @return a 64bit int
+ * @raise FRT_IO_ERROR if there is a error reading from the file-system
+ * @raise FRT_EOF_ERROR if there is an attempt to read past the end of the file
  */
-extern INLINE unsigned long long is_read_vll(InStream *is);
+extern FRT_INLINE frt_u64 frt_is_read_vll(FrtInStream *is);
 
 /**
- * Read a string from the InStream. A string is an integer +length+ in vint
- * format (see is_read_vint) followed by +length+ bytes. This is the format
- * used by os_write_string.
+ * Read a string from the FrtInStream. A string is an integer +length+ in vint
+ * format (see frt_is_read_vint) followed by +length+ bytes. This is the format
+ * used by frt_os_write_string.
  *
- * @param is the InStream to read from
+ * @param is the FrtInStream to read from
  * @return a null byte delimited string
- * @raise IO_ERROR if there is a error reading from the file-system
- * @raise EOF_ERROR if there is an attempt to read past the end of the file
+ * @raise FRT_IO_ERROR if there is a error reading from the file-system
+ * @raise FRT_EOF_ERROR if there is an attempt to read past the end of the file
  */
-extern char *is_read_string(InStream *is);
+extern char *frt_is_read_string(FrtInStream *is);
 
 /**
- * Read a string from the InStream. A string is an integer +length+ in vint
- * format (see is_read_vint) followed by +length+ bytes. This is the format
- * used by os_write_string. This method is similar to +is_read_string+ except
+ * Read a string from the FrtInStream. A string is an integer +length+ in vint
+ * format (see frt_is_read_vint) followed by +length+ bytes. This is the format
+ * used by frt_os_write_string. This method is similar to +frt_is_read_string+ except
  * that it will safely free all memory if there is an error reading the
  * string.
  *
- * @param is the InStream to read from
+ * @param is the FrtInStream to read from
  * @return a null byte delimited string
- * @raise IO_ERROR if there is a error reading from the file-system
- * @raise EOF_ERROR if there is an attempt to read past the end of the file
+ * @raise FRT_IO_ERROR if there is a error reading from the file-system
+ * @raise FRT_EOF_ERROR if there is an attempt to read past the end of the file
  */
-extern char *is_read_string_safe(InStream *is);
+extern char *frt_is_read_string_safe(FrtInStream *is);
 
 /**
- * Copy cnt bytes from Instream _is_ to OutStream _os_.
+ * Copy cnt bytes from Instream _is_ to FrtOutStream _os_.
  *
- * @param is the InStream to read from
- * @param os the OutStream to write to
- * @raise IO_ERROR
- * @raise EOF_ERROR
+ * @param is the FrtInStream to read from
+ * @param os the FrtOutStream to write to
+ * @raise FRT_IO_ERROR
+ * @raise FRT_EOF_ERROR
  */
-extern void is2os_copy_bytes(InStream *is, OutStream *os, int cnt);
+extern void frt_is2os_copy_bytes(FrtInStream *is, FrtOutStream *os, int cnt);
 
 /**
- * Copy cnt vints from Instream _is_ to OutStream _os_.
+ * Copy cnt vints from Instream _is_ to FrtOutStream _os_.
  *
- * @param is the InStream to read from
- * @param os the OutStream to write to
- * @raise IO_ERROR
- * @raise EOF_ERROR
+ * @param is the FrtInStream to read from
+ * @param os the FrtOutStream to write to
+ * @raise FRT_IO_ERROR
+ * @raise FRT_EOF_ERROR
  */
-extern void is2os_copy_vints(InStream *is, OutStream *os, int cnt);
+extern void frt_is2os_copy_vints(FrtInStream *is, FrtOutStream *os, int cnt);
 
 /**
  * Print the filenames in a store to a buffer.
  *
  * @param store the store to get the filenames from
  */
-extern char *store_to_s(Store *store);
+extern char *frt_store_to_s(FrtStore *store);
+
+extern FrtLock *frt_open_lock(FrtStore *store, const char *lockname);
+extern void frt_close_lock(FrtLock *lock);
+
+/* required by submodules
+ * FIXME document. Perhaps include in different header?? */
+extern FrtStore *frt_store_new();
+extern void frt_store_destroy(FrtStore *store);
+extern FrtOutStream *frt_os_new();
+extern FrtInStream *frt_is_new();
+extern int frt_file_is_lock(const char *filename);
+extern bool frt_file_name_filter_is_index_file(const char *file_name,
+                                               bool include_locks);
 
-extern Lock *open_lock(Store *store, char *lockname);
-extern void close_lock(Lock *lock);
 #endif