ferret 0.9.0 → 0.9.1

data/ext/field.c

@@ -47,8 +47,11 @@ FieldInfos *fis_open(Store *store, char *filename)
 {
   FieldInfos *fis = fis_create();
   InStream *is = store->open_input(store, filename);
-  fis_read(fis, is);
-  is_close(is);
+  TRY
+    fis_read(fis, is);
+  XFINALLY
+    is_close(is);
+  XENDTRY
   return fis;
 }
 
@@ -166,13 +169,16 @@ void fis_write(FieldInfos *fis, Store *store, char *segment, char *ext)
   strcpy(fname, segment);
   strcat(fname, ext);
   OutStream *os = store->create_output(store, fname);
-  os_write_vint(os, fis->fcnt);
-  for (i = 0; i < fis->fcnt; i++) {
-    fi = fis->by_number[i];
-    os_write_string(os, fi->name);
-    os_write_vint(os, fi_field_info_byte(fi));
-  }
-  os_close(os);
+  TRY
+    os_write_vint(os, fis->fcnt);
+    for (i = 0; i < fis->fcnt; i++) {
+      fi = fis->by_number[i];
+      os_write_string(os, fi->name);
+      os_write_vint(os, fi_field_info_byte(fi));
+    }
+  XFINALLY
+    os_close(os);
+  XENDTRY
 }
 
 FieldInfos *fis_read(FieldInfos *fis, InStream *is)

data/ext/filter.c

@@ -56,7 +56,7 @@ char *qfilt_to_s(Filter *self)
   QueryFilter *qf = (QueryFilter *)self->data;
   Query *query = (Query *)qf->query;
   char *query_str = query->to_s(query, "");
-  char *filter_str = epstrdup("QueryFilter(%s)", strlen(query_str), query_str);
+  char *filter_str = strfmt("QueryFilter(%s)", query_str);
   free(query_str);
   return filter_str;
 }

data/ext/fs_store.c

@@ -10,55 +10,102 @@
 #include <stdio.h>
 #include "store.h"
 
+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";
+
+/**
+ * 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)
 {
-  strcpy(buf, base);
-  strcat(buf, "/");
-  strcat(buf, filename);
+  sprintf(buf, "%s/%s", base, filename);
   return buf;
 }
 
+/**
+ * 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
+ */
 void fs_touch(Store *store, char *filename)
 {
   char buf[MAX_PATH];
   int fd = creat(join_path(buf, store->dir.path, filename), S_IRUSR|S_IWUSR);
+  if (fd == -1)
+    RAISE(IO_ERROR, strerror(errno));
   close(fd);
 }
 
+/**
+ * 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)
 {
   char buf[MAX_PATH];
   int fd = open(join_path(buf, store->dir.path, filename), 0);
   if (fd < 0) {
-    assert(errno == ENOENT);
+    if (errno != ENOENT)
+      RAISE(IO_ERROR, 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)
 {
   char buf[MAX_PATH];
   return remove(join_path(buf, 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)
 {
   char buf1[MAX_PATH], buf2[MAX_PATH];
-  int ret;
 
-  ret = rename(join_path(buf1, store->dir.path, from),
+  return rename(join_path(buf1, store->dir.path, from),
       join_path(buf2, store->dir.path, to));
-
-  return ret;
 }
 
+/**
+ * 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)
 {
   int cnt = 0;
-  DIR *d = opendir(store->dir.path);
   struct dirent *de;
+  DIR *d = opendir(store->dir.path);
+
+  if (!d) RAISE(IO_ERROR, strerror(errno));
 
   while ((de = readdir(d)) != NULL) {
     if (de->d_name[0] != '.') {
@@ -70,12 +117,24 @@ int fs_count(Store *store)
   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)
 {
-  DIR *d;
   struct dirent *de;
+  DIR *d = opendir(store->dir.path);
+
+  if (!d) RAISE(IO_ERROR, strerror(errno));
 
-  d = opendir(store->dir.path);
   while ((de = readdir(d)) != NULL) {
     if ((strncmp(de->d_name, LOCK_PREFIX, strlen(LOCK_PREFIX)) == 0) ||
         (de->d_name[0] == '.'))
@@ -85,12 +144,19 @@ void fs_each(Store *store, void (*func)(char *fname, void *arg), void *arg)
   closedir(d);
 }
 
+/**
+ * Clear all the locks in the store.
+ *
+ * @param store the store to clear the locks from
+ * @throws IO_ERROR if there is an error opening the directory
+ */
 void fs_clear_locks(Store *store)
 {
-  DIR *d;
   struct dirent *de;
+  DIR *d = opendir(store->dir.path);
+
+  if (!d) RAISE(IO_ERROR, strerror(errno));
 
-  d = opendir(store->dir.path);
   while ((de = readdir(d)) != NULL) {
     if (file_is_lock(de->d_name)) {
       fs_remove(store, de->d_name);
@@ -99,6 +165,12 @@ void fs_clear_locks(Store *store)
   closedir(d);
 }
 
+/**
+ * Destroy the store.
+ *
+ * @param p the store to destroy
+ * @throws IO_ERROR if there is an error deleting the locks
+ */
 void fs_destroy(void *p)
 {
   Store *store = (Store *)p;
@@ -107,12 +179,19 @@ void fs_destroy(void *p)
   store_destroy(store);
 }
 
+/**
+ * Clear all files from the store except the lock files.
+ *
+ * @param store the store to clear all the files from
+ * @throws IO_ERROR if there is an error deleting the files
+ */
 void fs_clear(Store *store)
 {
-  DIR *d;
   struct dirent *de;
+  DIR *d = opendir(store->dir.path);
+
+  if (!d) RAISE(IO_ERROR, strerror(errno));
 
-  d = opendir(store->dir.path);
   while ((de = readdir(d)) != NULL) {
     if (de->d_name[0] != '.' && !file_is_lock(de->d_name)) {
       fs_remove(store, de->d_name);
@@ -121,12 +200,17 @@ void fs_clear(Store *store)
   closedir(d);
 }
 
+/**
+ * Clear all files from the store including the lock files.
+ *
+ * @param store the store to clear all the files from
+ * @throws IO_ERROR if there is an error deleting the files
+ */
 void fs_clear_all(Store *store)
 {
-  DIR *d;
   struct dirent *de;
+  DIR *d = opendir(store->dir.path);
 
-  d = opendir(store->dir.path);
   while ((de = readdir(d)) != NULL) {
     if (de->d_name[0] != '.') {
       fs_remove(store, de->d_name);
@@ -135,37 +219,79 @@ void fs_clear_all(Store *store)
   closedir(d);
 }
 
+/**
+ * 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)
 {
   char buf[MAX_PATH];
   struct stat stt;
-  stat(join_path(buf, store->dir.path, filename), &stt);
+
+  if (stat(join_path(buf, store->dir.path, filename), &stt))
+    RAISE(IO_ERROR, strerror(errno));
+
   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)
 {
-  fwrite(src, sizeof(uchar), len, (FILE *)os->file);
+  if (len != fwrite(src, sizeof(uchar), len, (FILE *)os->file))
+    RAISE(IO_ERROR, WRITE_ERROR_MSG);
 }
 
+/**
+ * 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)
 {
-  fseek((FILE *)os->file, pos, SEEK_SET);
+  if (fseek((FILE *)os->file, pos, SEEK_SET))
+    RAISE(IO_ERROR, 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)
 {
-  fclose((FILE *)os->file);
+  if (fclose((FILE *)os->file))
+    RAISE(IO_ERROR, 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)
 {
   char buf[MAX_PATH];
   FILE *f = fopen(join_path(buf, store->dir.path, filename), "wb");
-  if (!f) {
-    eprintf(IO_ERROR, "Couldn't open the file %s to write. Error was %s",
-        buf, strerror(errno));
-  }
+  if (!f) RAISE(IO_ERROR, strerror(errno));
+
   OutStream *os = os_create();
   os->file = f;
   os->flush_internal = &fso_flush_internal;
@@ -174,6 +300,17 @@ OutStream *fs_create_output(Store *store, const char *filename)
   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)
 {
   int fd = (int)is->file;
@@ -181,39 +318,72 @@ void fsi_read_internal(InStream *is, uchar *b, int offset, int len)
   if (pos != lseek(fd, 0, SEEK_CUR)) {
     lseek(fd, pos, SEEK_SET);
   }
-  read(fd, b, len);
+  if (read(fd, b, len) != len) {
+    RAISE(EOF_ERROR, 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)
 {
-  lseek((int)is->file, pos, SEEK_SET);
+  if (lseek((int)is->file, pos, SEEK_SET) < 0)
+    RAISE(IO_ERROR, 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)
 {
   if (!is->is_clone) {
-    close((int)is->file);
+    if (close((int)is->file))
+      RAISE(IO_ERROR, strerror(errno));
     free(is->d.path);
   }
 }
 
+/**
+ * Clone the input stream. Nothing to do for a file system input stream
+ */
 void fsi_clone_internal(InStream *is, InStream *new_is)
 { }
 
+/**
+ * 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)
 {
   struct stat stt;
-  fstat((int)is->file, &stt);
+  if (fstat((int)is->file, &stt))
+    RAISE(IO_ERROR, strerror(errno));
   return stt.st_size;
 }
 
+/**
+ * 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)
 {
   char buf[MAX_PATH];
   int fd = open(join_path(buf, store->dir.path, filename), O_RDONLY);
-  if (fd < 0) {
-    eprintf(IO_ERROR, "Couldn't open the file %s to read", buf);
-  }
+  if (fd < 0) RAISE(IO_ERROR, FILE_OPEN_ERROR_MSG);
+
   InStream *is = is_create();
   is->file = (void *)fd;
   is->d.path = estrdup(buf);
@@ -228,6 +398,11 @@ InStream *fs_open_input(Store *store, const char *filename)
 
 #define LOCK_OBTAIN_TIMEOUT 5
 
+/**
+ * Obtain a lock on the lock +lock+
+ *
+ * @param lock the lock to obtain
+ */
 int fs_lock_obtain(Lock *lock)
 {
   int f;
@@ -243,12 +418,18 @@ int fs_lock_obtain(Lock *lock)
   }
 }
 
+/**
+ * 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)
 {
   int f = open(lock->name, O_CREAT|O_EXCL|O_WRONLY, S_IRUSR|S_IWUSR);
   if (f >= 0) {
-    close(f);
-    remove(lock->name);
+    if (close(f) || remove(lock->name))
+      RAISE(IO_ERROR, strerror(errno));
     return false;
   } else {
     return true;