sdsykes-ferret 0.11.6.19

data/ext/config.h

@@ -0,0 +1,42 @@
+#ifndef FRT_DEFINES_H
+#define FRT_DEFINES_H
+
+#include <sys/types.h>
+#include <limits.h>
+#include "posh.h"
+
+#ifndef false
+#define false 0
+#endif
+#ifndef true
+#define true  1
+#endif
+
+typedef unsigned int        bool;
+typedef unsigned char       uchar;
+
+typedef posh_u16_t f_u16;
+typedef posh_i16_t f_i16;
+typedef posh_u32_t f_u32;
+typedef posh_i32_t f_i32;
+typedef posh_u64_t f_u64;
+typedef posh_i64_t f_i64;
+
+#if ( LONG_MAX == 2147483647 ) && defined(_FILE_OFFSET_BITS) && (_FILE_OFFSET_BITS == 64)
+#define F_OFF_T_PFX "ll"
+#else
+#define F_OFF_T_PFX "l"
+#endif
+
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
+#define FRT_IS_C99
+#define FRT_HAS_ISO_VARARGS
+#define FRT_HAS_VARARGS
+#endif
+
+#if defined(__GNUC__) && !defined(__STRICT_ANSI__)
+#define FRT_HAS_GNUC_VARARGS
+#define FRT_HAS_VARARGS
+#endif
+
+#endif

data/ext/document.c

@@ -0,0 +1,156 @@
+#include "document.h"
+#include <string.h>
+
+/****************************************************************************
+ *
+ * DocField
+ *
+ ****************************************************************************/
+
+DocField *df_new(const char *name)
+{
+    DocField *df = ALLOC(DocField);
+    df->name = estrdup(name);
+    df->size = 0;
+    df->capa = DF_INIT_CAPA;
+    df->data = ALLOC_N(char *, df->capa);
+    df->lengths = ALLOC_N(int, df->capa);
+    df->destroy_data = false;
+    df->boost = 1.0;
+    return df;
+}
+
+DocField *df_add_data_len(DocField *df, char *data, int len)
+{
+    if (df->size >= df->capa) {
+        df->capa <<= 2;
+        REALLOC_N(df->data, char *, df->capa);
+        REALLOC_N(df->lengths, int, df->capa);
+    }
+    df->data[df->size] = data;
+    df->lengths[df->size] = len;
+    df->size++;
+    return df;
+}
+
+DocField *df_add_data(DocField *df, char *data)
+{
+    return df_add_data_len(df, data, strlen(data));
+}
+
+void df_destroy(DocField *df)
+{
+    if (df->destroy_data) {
+        int i;
+        for (i = 0; i < df->size; i++) {
+            free(df->data[i]);
+        }
+    }
+    free(df->data);
+    free(df->lengths);
+    free(df->name);
+    free(df);
+}
+
+char *df_to_s(DocField *df)
+{
+    int i;
+    int len = strlen(df->name) + 10;
+    char *str, *s;
+    for (i = 0; i < df->size; i++) {
+        len += df->lengths[i] + 5;
+    }
+    s = str = ALLOC_N(char, len);
+    sprintf(str, "%s: ", df->name);
+    s += strlen(str);
+    if (df->size == 1) {
+        *(s++) = '"';
+        strncpy(s, df->data[0], df->lengths[0]);
+        s += df->lengths[0];
+        *(s++) = '"';
+        *(s++) = '\0';
+    }
+    else {
+        *(s++) = '[';
+        *(s++) = '"';
+        strncpy(s, df->data[0], df->lengths[0]);
+        s += df->lengths[0];
+        *(s++) = '"';
+        for (i = 1; i < df->size; i++) {
+            *(s++) = ',';
+            *(s++) = ' ';
+            *(s++) = '"';
+            strncpy(s, df->data[i], df->lengths[i]);
+            s += df->lengths[i];
+            *(s++) = '"';
+        }
+        sprintf(s, "]");
+    }
+    return str;
+}
+
+/****************************************************************************
+ *
+ * Document
+ *
+ ****************************************************************************/
+
+Document *doc_new()
+{
+    Document *doc = ALLOC(Document);
+    doc->field_dict = h_new_str(NULL, (free_ft)&df_destroy);
+    doc->size = 0;
+    doc->capa = DOC_INIT_CAPA;
+    doc->fields = ALLOC_N(DocField *, doc->capa);
+    doc->boost = 1.0;
+    return doc;
+}
+
+DocField *doc_add_field(Document *doc, DocField *df)
+{
+    if (!h_set_safe(doc->field_dict, df->name, df)) {
+        RAISE(EXCEPTION, "tried to add %s field which alread existed\n",
+              df->name);
+    }
+    if (doc->size >= doc->capa) {
+        doc->capa <<= 1;
+        REALLOC_N(doc->fields, DocField *, doc->capa);
+    }
+    doc->fields[doc->size] = df;
+    doc->size++;
+    return df;
+}
+
+DocField *doc_get_field(Document *doc, const char *name)
+{
+    return h_get(doc->field_dict, name);
+}
+
+char *doc_to_s(Document *doc)
+{
+    int i;
+    int len = 100;
+    char **fields = ALLOC_N(char *, doc->size);
+    char *buf, *s;
+    for (i = 0; i < doc->size; i++) {
+        fields[i] = df_to_s(doc->fields[i]);
+        len += strlen(fields[i]) + 10;
+    }
+    s = buf = ALLOC_N(char, len);
+    sprintf(buf, "Document [\n");
+    s += strlen(buf);
+    for (i = 0; i < doc->size; i++) {
+        sprintf(s, "  =>%s\n", fields[i]);
+        free(fields[i]);
+        s += strlen(s);
+    }
+    return buf;
+}
+
+void doc_destroy(Document *doc)
+{
+    h_destroy(doc->field_dict);
+    free(doc->fields);
+    free(doc);
+}
+

data/ext/document.h

@@ -0,0 +1,53 @@
+#ifndef FRT_DOCUMENT_H
+#define FRT_DOCUMENT_H
+
+#include "global.h"
+#include "hash.h"
+
+/****************************************************************************
+ *
+ * DocField
+ *
+ ****************************************************************************/
+
+#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;
+
+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);
+
+/****************************************************************************
+ *
+ * Document
+ *
+ ****************************************************************************/
+
+#define DOC_INIT_CAPA 8
+typedef struct Document
+{
+    HashTable *field_dict;
+    int size;
+    int capa;
+    DocField **fields;
+    float boost;
+} Document;
+
+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

@@ -0,0 +1,120 @@
+#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;
+
+const char *const FRT_ERROR_TYPES[] = {
+  "Body",
+  "Finally",
+  "Exception",
+  "IO Error",
+  "File Not Found 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[XMSG_BUFFER_SIZE];
+char xmsg_buffer_final[XMSG_BUFFER_SIZE];
+
+static thread_key_t exception_stack_key;
+static thread_once_t exception_stack_key_once = THREAD_ONCE_INIT;
+
+static void exception_stack_alloc(void)
+{
+    thread_key_create(&exception_stack_key, NULL);
+}
+
+/*
+static void put_stack(char *inst, xcontext_t *top)
+{
+    int x = 10;
+    fprintf(stderr, "( %s )", inst);
+    while (top && x--) {
+        fprintf(stderr, "=> %x ", top);
+        top = top->next;
+    }
+    fprintf(stderr, "\n");
+}
+*/
+
+void xpush_context(xcontext_t *context)
+{
+    xcontext_t *top_context;
+    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,
+                                    volatile int excode,
+                                    const char *const msg)
+{
+    context->msg = msg;
+    context->excode = excode;
+    context->handled = false;
+    longjmp(context->jbuf, excode);
+}
+
+#ifndef FRT_HAS_VARARGS
+void RAISE(int excode, const char *fmt, ...)
+{
+    va_list args;
+    va_start(args, fmt);
+    vsnprintf(xmsg_buffer, XMSG_BUFFER_SIZE, 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_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

@@ -0,0 +1,168 @@
+/**
+ * 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);
+ *       }
+ *   XENDTRY
+ * </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.
+ *
+ * ENDTRY
+ *   Must be placed at the end of all exception handling code.
+ *
+ * XFINALLY
+ *   Similar to case FINALLY: except that it uses a fall through (ie, you must
+ *   not use a break before it) instead of a jump to get to it. This saves a
+ *   jump. It must be used in combination with XENDTRY and must not have any
+ *   other catches. This is an optimization so should probably be not be used
+ *   in most cases.
+ *
+ * XCATCHALL
+ *   Like XFINALLY but the block is only called when an exception is raised.
+ *   Must use in combination with XENDTRY and do not have any other FINALLY or
+ *   catch block.
+ *
+ * XENDTRY
+ *   Must use in combination with XFINALLY or XCATCHALL. Simply, it doesn't
+ *   jump to FINALLY, making it more efficient.
+ */
+#ifndef FRT_EXCEPT_H
+#define FRT_EXCEPT_H
+
+#include <setjmp.h>
+#include "config.h"
+
+#define BODY 0
+#define FINALLY 1
+#define EXCEPTION 2
+#define FERRET_ERROR 2
+#define IO_ERROR 3
+#define FILE_NOT_FOUND_ERROR 4
+#define ARG_ERROR 5
+#define EOF_ERROR 6
+#define UNSUPPORTED_ERROR 7
+#define STATE_ERROR 8
+#define PARSE_ERROR 9
+#define MEM_ERROR 10
+#define INDEX_ERROR 11
+#define LOCK_ERROR 12
+
+extern char *const UNSUPPORTED_ERROR_MSG;
+extern char *const EOF_ERROR_MSG;
+extern bool except_show_pos;
+
+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;\
+    xpush_context(&xcontext);\
+    switch (setjmp(xcontext.jbuf)) {\
+      case BODY:
+
+
+#define XENDTRY\
+    }\
+    xpop_context();\
+  } while (0);
+
+#define ENDTRY\
+    }\
+    if (!xcontext.in_finally) {\
+      xpop_context();\
+      xcontext.in_finally = 1;\
+      longjmp(xcontext.jbuf, FINALLY);\
+    }\
+  } while (0);
+
+#define RETURN_EARLY() xpop_context()
+
+
+#define XFINALLY default: xcontext.in_finally = 1;
+
+#define XCATCHALL break; default: xcontext.in_finally = 1;
+
+#define HANDLED() xcontext.handled = 1; /* true */
+
+#define XMSG_BUFFER_SIZE 2048
+
+#ifdef FRT_HAS_ISO_VARARGS
+# define RAISE(excode, ...) do {\
+  snprintf(xmsg_buffer, XMSG_BUFFER_SIZE, __VA_ARGS__);\
+  snprintf(xmsg_buffer_final, XMSG_BUFFER_SIZE,\
+          "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 {\
+  snprintf(xmsg_buffer, XMSG_BUFFER_SIZE, ##args);\
+  snprintf(xmsg_buffer_final, XMSG_BUFFER_SIZE,\
+          "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(FERRET_ERROR, "Hell")
+
+
+extern void xraise(int excode, const char *const msg);
+extern void xpush_context(xcontext_t *context);
+extern void xpop_context();
+
+extern char xmsg_buffer[XMSG_BUFFER_SIZE];
+extern char xmsg_buffer_final[XMSG_BUFFER_SIZE];
+
+#endif