ferret 0.9.6 → 0.10.0

data/ext/document.h

@@ -1,62 +1,32 @@
 #ifndef FRT_DOCUMENT_H
 #define FRT_DOCUMENT_H
 
-#include <global.h>
-#include <hash.h>
-#include <array.h>
+#include "global.h"
+#include "hash.h"
 
 /****************************************************************************
  *
  * DocField
  *
  ****************************************************************************/
-enum {
-  DF_STORE_YES = 0,
-  DF_STORE_NO = 1,
-  DF_STORE_COMPRESS = 2
-};
 
-enum {
-  DF_INDEX_UNTOKENIZED = 0,
-  DF_INDEX_TOKENIZED = 1,
-  DF_INDEX_NO = 2,
-  DF_INDEX_NO_NORMS = 3
-};
-
-enum {
-  DF_TERM_VECTOR_NO = 0,
-  DF_TERM_VECTOR_YES = 1,
-  DF_TERM_VECTOR_WITH_POSITIONS = 2,
-  DF_TERM_VECTOR_WITH_OFFSETS = 3,
-  DF_TERM_VECTOR_WITH_POSITIONS_OFFSETS = 4
-};
-
-typedef struct DocField {
-  char  *name;
-  char  *data;
-  int blen; /* used for binary fields to store data length */
-  float boost;
-  bool is_stored : 1;
-  bool is_compressed : 1;
-  bool is_indexed : 1;
-  bool is_tokenized : 1;
-  bool store_tv : 1;
-  bool store_pos : 1;
-  bool store_offset : 1;
-  bool omit_norms : 1;
-  bool is_binary : 1;
+#define DF_INIT_CAPA 1
+typedef struct DocField
+{
+    char *name;
+    int size;
+    int capa;
+    int *lengths;
+    char **data;
+    float boost;
+    bool destroy_data : 1;
 } DocField;
 
-DocField *df_create(const char *name, char *data, int store, int index, int tv);
-DocField *df_clone(DocField *self);
-void df_set(DocField *df, const char *name, char *data, int store, int index, int tv);
-void df_destroy(DocField *df);
-void df_destroy_data(DocField *df);
-void df_set_store(DocField *df, int store);
-void df_set_index(DocField *df, int index);
-void df_set_term_vector(DocField *df, int tv);
-char *df_to_s(DocField *df);
-DocField *df_create_binary(char *name, char *data, int blen, int store);
+extern DocField *df_new(const char *name);
+extern DocField *df_add_data(DocField *df, char *data);
+extern DocField *df_add_data_len(DocField *df, char *data, int len);
+extern void df_destroy(DocField *df);
+extern char *df_to_s(DocField *df);
 
 /****************************************************************************
  *
@@ -64,24 +34,20 @@ DocField *df_create_binary(char *name, char *data, int blen, int store);
  *
  ****************************************************************************/
 
-typedef struct Document {
-  HshTable *fields;
-  Array **field_arr;
-  int fcnt;
-  DocField **df_arr;
-  int dfcnt;
-  float boost;
-  free_ft free_data;
+#define DOC_INIT_CAPA 8
+typedef struct Document
+{
+    HashTable *field_dict;
+    int size;
+    int capa;
+    DocField **fields;
+    float boost;
 } Document;
 
-Document *doc_create();
-Document *doc_create_keep_data();
-void doc_destroy(Document *doc);
-void doc_add_field(Document *doc, DocField *df);
-DocField *doc_get_field(Document *doc, const char *fname);
-Array *doc_get_fields(Document *doc, const char *fname);
-Array *doc_remove_fields(Document *doc, const char *fname);
-DocField *doc_remove_field(Document *doc, const char *fname);
-bool doc_delete_fields(Document *doc, const char *fname);
-char *doc_to_s(Document *doc);
+extern Document *doc_new();
+extern DocField *doc_add_field(Document *doc, DocField *df);
+extern DocField *doc_get_field(Document *doc, const char *fname);
+extern char *doc_to_s(Document *doc);
+extern void doc_destroy(Document *doc);
+
 #endif

data/ext/except.c

@@ -1,61 +1,106 @@
+#include <stdarg.h>
 #include "global.h"
 #include "except.h"
+#include "threading.h"
 
+/**
+ * Set this to false if you don't want to print the error location when an
+ * exception occurs.
+ */
 bool except_show_pos = true;
 
-char * const UNSUPPORTED_ERROR_MSG = "Unsupported operation";
-char * const EOF_ERROR_MSG = "Read past end of file";
+const char *const FRT_ERROR_TYPES[] = {
+  "Body",
+  "Finally",
+  "Exception",
+  "IO Error",
+  "Argument Error",
+  "End-of-File Error",
+  "Unsupported Function Error",
+  "State Error",
+  "Parse Error",
+  "Memory Error",
+  "Index Error",
+  "Lock Error"
+};
+
+char *const UNSUPPORTED_ERROR_MSG = "Unsupported operation";
+char *const EOF_ERROR_MSG = "Read past end of file";
+char xmsg_buffer[2048];
+char xmsg_buffer_final[2048];
 
 static thread_key_t exception_stack_key;
 static thread_once_t exception_stack_key_once = THREAD_ONCE_INIT;
 
-void exception_stack_alloc()
+static void exception_stack_alloc(void)
 {
-  thread_key_create(&exception_stack_key, NULL);
+    thread_key_create(&exception_stack_key, NULL);
 }
 
 void xpush_context(xcontext_t *context)
 {
-  xcontext_t *top_context;
-  thread_once(&exception_stack_key_once, *exception_stack_alloc);
-  top_context = thread_getspecific(exception_stack_key); 
-  context->next = top_context;
-  thread_setspecific(exception_stack_key, context);
-  context->handled = true;
-  context->in_finally = false;
+    xcontext_t *top_context;
+    thread_once(&exception_stack_key_once, *exception_stack_alloc);
+    top_context = thread_getspecific(exception_stack_key);
+    context->next = top_context;
+    thread_setspecific(exception_stack_key, context);
+    context->handled = true;
+    context->in_finally = false;
 }
 
-static inline void xraise_context(xcontext_t *context, int excode, char *msg)
+static inline void xraise_context(xcontext_t *context,
+                                  volatile int excode,
+                                  const char *const msg)
 {
-  context->msg = msg;
-  context->excode = excode;
-  context->handled = false;
-  longjmp(context->jbuf, excode);
+    context->msg = msg;
+    context->excode = excode;
+    context->handled = false;
+    longjmp(context->jbuf, excode);
 }
 
-void xraise(int excode, char *msg)
+#ifndef FRT_HAS_VARARGS
+void RAISE(int excode, const char *fmt, ...)
 {
-  xcontext_t *top_context;
-  top_context = thread_getspecific(exception_stack_key); 
-  if (!top_context) {
-    eprintf(EXCEPTION_CODE, "Error: exception %d not handled: %s", excode, msg);
-  } else if (!top_context->in_finally) {
-    xraise_context(top_context, excode, msg);
-  } else if (top_context->handled) {
-    top_context->msg = msg;
-    top_context->excode = excode;
-    top_context->handled = false;
-  }
+    va_list args;
+    va_start(args, fmt);
+    vsprintf(xmsg_buffer, fmt, args);
+    xraise(excode, xmsg_buffer);
+    va_end(args);
+}
+#endif
+
+void xraise(int excode, const char *const msg)
+{
+    xcontext_t *top_context;
+    thread_once(&exception_stack_key_once, *exception_stack_alloc);
+    top_context = thread_getspecific(exception_stack_key);
+
+    if (!top_context) {
+        FRT_EXIT(FRT_ERROR_TYPES[excode], msg);
+    }
+    else if (!top_context->in_finally) {
+        xraise_context(top_context, excode, msg);
+    }
+    else if (top_context->handled) {
+        top_context->msg = msg;
+        top_context->excode = excode;
+        top_context->handled = false;
+    }
 }
 
 void xpop_context()
 {
-  xcontext_t *top_context, *context;
-  thread_once(&exception_stack_key_once, *exception_stack_alloc);
-  top_context = thread_getspecific(exception_stack_key); 
-  context = top_context->next;
-  thread_setspecific(exception_stack_key, context);
-  if (!top_context->handled) {
-    xraise_context(context, top_context->excode, top_context->msg);
-  }
+    xcontext_t *top_cxt, *context;
+    thread_once(&exception_stack_key_once, *exception_stack_alloc);
+    top_cxt = thread_getspecific(exception_stack_key);
+    context = top_cxt->next;
+    thread_setspecific(exception_stack_key, context);
+    if (!top_cxt->handled) {
+        if (context) {
+            xraise_context(context, top_cxt->excode, top_cxt->msg);
+        }
+        else {
+            FRT_EXIT(FRT_ERROR_TYPES[top_cxt->excode], top_cxt->msg);
+        }
+    }
 }

data/ext/except.h

@@ -1,90 +1,152 @@
+/**
+ * Exception Handling Framework
+ *
+ * Exception Handling looks something like this;
+ *
+ * <pre>
+ *   TRY
+ *       RAISE(EXCEPTION, msg1);
+ *       break;
+ *   case EXCEPTION:
+ *       // This should be called
+ *       exception_handled = true;
+ *       HANDLED();
+ *       break;
+ *   default:
+ *       // shouldn't enter here
+ *       break;
+ *   XFINALLY
+ *       // this code will always be run
+ *       if (close_widget_one(arg) == 0) {
+ *           RAISE(EXCEPTION_CODE, msg);
+ *       }
+ *       // this code will also always run, even if the above exception is
+ *       // raised
+ *       if (close_widget_two(arg) == 0) {
+ *           RAISE(EXCEPTION_CODE, msg);
+ *       }
+ *   ENDTRY
+ * </pre>
+ *
+ * Basically exception handling uses the following macros;
+ *
+ * TRY 
+ *   Sets up the exception handler and need be placed before any expected
+ *   exceptions would be raised.
+ *
+ * case <EXCEPTION_CODE>:
+ *   Internally the exception handling uses a switch statement so use the case
+ *   statement with the appropriate error code to catch Exceptions. Hence, if
+ *   you want to catch all exceptions, use the default keyword.
+ *
+ * HANDLED
+ *   If you catch and handle an exception you need to explicitely call
+ *   HANDLED(); or the exeption will be re-raised once the current exception
+ *   handling context is left.
+ *
+ * case FINALLY:
+ *   Code in this block is always called. Use this block to close any
+ *   resources opened in the Exception handling body.
+ *
+ * XFINALLY
+ *   Similar to case FINALLY: except that any exceptions thrown in this block
+ *   are ignored until the end of the block is reached at which time the first
+ *   exception which was raise will be re-raised. This is useful for closing a
+ *   number of resources that all might raise exceptions so as much as
+ *   possible will be successfully closed.
+ *
+ * ENDTRY
+ *   Must be placed at the end of all exception handling code.
+ */
+
 #ifndef FRT_EXCEPT_H
 #define FRT_EXCEPT_H
 
 #include <setjmp.h>
-#include <ruby.h>
+#include "defines.h"
 
 #define BODY 0
-#define FINALLY -1
-#define EXCEPTION 1
-#define IO_ERROR 2
-#define ARG_ERROR 3
-#define EOF_ERROR 4
-#define UNSUPPORTED_ERROR 5
-#define STATE_ERROR 6
-#define PARSE_ERROR 7
-#define MEM_ERROR 8
-
-typedef struct xcontext_t {
-  jmp_buf jbuf;
-  struct xcontext_t *next;
-  char *msg;
-  volatile int excode;
-  int handled : 1;
-  int in_finally : 1;
-} xcontext_t;
+#define FINALLY 1
+#define EXCEPTION 2
+#define ERROR 2
+#define IO_ERROR 3
+#define ARG_ERROR 4
+#define EOF_ERROR 5
+#define UNSUPPORTED_ERROR 6
+#define STATE_ERROR 7
+#define PARSE_ERROR 8
+#define MEM_ERROR 9
+#define INDEX_ERROR 10
+#define LOCK_ERROR 11
+
+extern char *const UNSUPPORTED_ERROR_MSG;
+extern char *const EOF_ERROR_MSG;
+extern bool except_show_pos;
 
-RUBY_EXTERN int rb_thread_critical;
-extern xcontext_t *xtop_context;
+typedef struct xcontext_t
+{
+    jmp_buf jbuf;
+    struct xcontext_t *next;
+    const char *msg;
+    volatile int excode;
+    unsigned int handled : 1;
+    unsigned int in_finally : 1;
+} xcontext_t;
 
 #define TRY\
   do {\
     xcontext_t xcontext;\
-    rb_thread_critical = Qtrue;\
-    xcontext.next = xtop_context;\
-    xtop_context = &xcontext;\
-    xcontext.handled = true;\
-    xcontext.in_finally = false;\
+    xpush_context(&xcontext);\
     switch (setjmp(xcontext.jbuf)) {\
       case BODY:
 
 
 #define XENDTRY\
     }\
-    xtop_context = xcontext.next;\
-    if (!xcontext.handled) {\
-      RAISE(xcontext.excode, xcontext.msg);\
-    }\
-    rb_thread_critical = 0;\
+    xpop_context();\
   } while (0);
 
 #define ENDTRY\
     }\
     if (!xcontext.in_finally) {\
-      xtop_context = xcontext.next;\
-      if (!xcontext.handled) {\
-        RAISE(xcontext.excode, xcontext.msg);\
-      }\
+      xpop_context();\
       xcontext.in_finally = 1;\
       longjmp(xcontext.jbuf, FINALLY);\
     }\
-    rb_thread_critical = 0;\
   } while (0);
 
 #define XFINALLY default: xcontext.in_finally = 1;
 
 #define XCATCHALL break; default: xcontext.in_finally = 1;
 
-//fprintf(stderr,"Error occured in %s, %d: %s\n", __FILE__, __LINE__, __func__);
-#define RAISE(xexcode, xmsg) \
-  do {\
-    if (!xtop_context) {\
-      eprintf(EXCEPTION_CODE, "Error: exception %d not handled: %s", xexcode, xmsg);\
-    } else if (!xtop_context->in_finally) {\
-      xtop_context->msg = xmsg;\
-      xtop_context->excode = xexcode;\
-      xtop_context->handled = false;\
-      longjmp(xtop_context->jbuf, xexcode);\
-    } else if (xtop_context->handled) {\
-      xtop_context->msg = xmsg;\
-      xtop_context->excode = xexcode;\
-      xtop_context->handled = false;\
-    }\
-  } while (0)
+#define HANDLED() xcontext.handled = 1; /* true */
+
+#ifdef FRT_HAS_ISO_VARARGS
+# define RAISE(excode, ...) do {\
+  sprintf(xmsg_buffer, __VA_ARGS__);\
+  sprintf(xmsg_buffer_final, "Error occured in %s:%d - %s\n\t%s\n",\
+          __FILE__, __LINE__, __func__, xmsg_buffer);\
+  xraise(excode, xmsg_buffer_final);\
+} while (0)
+#elif defined(FRT_HAS_GNUC_VARARGS)
+# define RAISE(excode, args...) do {\
+  sprintf(xmsg_buffer, ##args);\
+  sprintf(xmsg_buffer_final, "Error occured in %s:%d - %s\n\t%s\n",\
+          __FILE__, __LINE__, __func__, xmsg_buffer);\
+  xraise(excode, xmsg_buffer_final);\
+} while (0)
+
+#else
+extern void RAISE(int excode, const char *fmt, ...);
+#endif
+#define RAISE_HELL() RAISE(ERROR, "Hell")
+
 
-#define HANDLED() xcontext.handled = 1 /* true */
+extern void xraise(int excode, const char *const msg);
+extern void xpush_context(xcontext_t *context);
+extern void xpop_context();
 
-extern char * const UNSUPPORTED_ERROR_MSG;
-extern char * const EOF_ERROR_MSG;
+extern char xmsg_buffer[2048];
+extern char xmsg_buffer_final[2048];
 
 #endif