ferret 0.11.6 → 0.11.8.4

data/ext/global.c

@@ -1,4 +1,6 @@
 #include "global.h"
+#include "symbol.h"
+#include "hash.h"
 #include <stdarg.h>
 #include <stdio.h>
 #include <string.h>
@@ -6,10 +8,17 @@
 #include <assert.h>
 #include <math.h>
 #include <ctype.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <signal.h>
+#include "internal.h"
 
 const char *EMPTY_STRING = "";
 
-bool x_do_logging = false;
+bool  x_do_logging = false;
+bool  x_abort_on_exception = true;
+bool  x_has_aborted = false;
+FILE *x_exception_stream = NULL;
 
 INLINE int min3(int a, int b, int c)
 {
@@ -36,6 +45,11 @@ int scmp(const void *p1, const void *p2)
     return strcmp(*(char **) p1, *(char **) p2);
 }
 
+void frt_strsort(char **str_array, int size)
+{
+    qsort(str_array, size, sizeof(char *), &scmp);
+}
+
 int icmp(const void *p1, const void *p2)
 {
     int i1 = *(int *) p1;
@@ -69,104 +83,20 @@ unsigned long *lmalloc(unsigned long value)
   return p;
 }
 
-f_u32 *u32malloc(f_u32 value)
+u32 *u32malloc(u32 value)
 {
-  f_u32 *p = ALLOC(f_u32);
+  u32 *p = ALLOC(u32);
   *p = value;
   return p;
 }
 
-f_u64 *u64malloc(f_u64 value)
+u64 *u64malloc(u64 value)
 {
-  f_u64 *p = ALLOC(f_u64);
+  u64 *p = ALLOC(u64);
   *p = value;
   return p;
 }
 
-
-#ifndef RUBY_BINDINGS
-/* frt_exit: print error message and exit */
-# ifdef FRT_HAS_VARARGS
-void vfrt_exit(const char *file, int line_num, const char *func,
-               const char *err_type, const char *fmt, va_list args)
-# else
-void V_FRT_EXIT(const char *err_type, const char *fmt, va_list args)
-# endif
-{
-    fflush(stdout);
-    fprintf(stderr, "\n");
-    if (progname() != NULL) {
-        fprintf(stderr, "%s: ", progname());
-    }
-
-# ifdef FRT_HAS_VARARGS
-    fprintf(stderr, "%s occured at <%s>:%d in %s\n",
-            err_type, file, line_num, func);
-# else
-    fprintf(stderr, "%s occured:\n", err_type);
-# endif
-    vfprintf(stderr, fmt, args);
-
-    if (fmt[0] != '\0' && fmt[strlen(fmt) - 1] == ':') {
-        fprintf(stderr, " %s", strerror(errno));
-    }
-
-    fprintf(stderr, "\n");
-    exit(2);                    /* conventional value for failed execution */
-}
-
-
-# ifdef FRT_HAS_VARARGS
-void frt_exit(const char *file, int line_num, const char *func,
-              const char *err_type, const char *fmt, ...)
-# else
-void FRT_EXIT(const char *err_type, const char *fmt, ...)
-# endif
-{
-    va_list args;
-    va_start(args, fmt);
-# ifdef FRT_HAS_VARARGS
-    vfrt_exit(file, line_num, func, err_type, fmt, args);
-# else
-    V_FRT_EXIT(err_type, fmt, args);
-# endif
-    va_end(args);
-}
-#endif
-
-
-/* weprintf: print error message and don't exit */
-void weprintf(const char *fmt, ...)
-{
-    va_list args;
-
-    fflush(stdout);
-    if (progname() != NULL)
-        fprintf(stderr, "%s: ", progname());
-
-    va_start(args, fmt);
-    vfprintf(stderr, fmt, args);
-    va_end(args);
-
-    if (fmt[0] != '\0' && fmt[strlen(fmt) - 1] == ':')
-        fprintf(stderr, " %s", strerror(errno));
-    fprintf(stderr, "\n");
-}
-
-#define MAX_PROG_NAME 200
-static char name[MAX_PROG_NAME]; /* program name for error msgs */
-
-/* setprogname: set stored name of program */
-void setprogname(const char *str)
-{
-    strncpy(name, str, MAX_PROG_NAME - 1);
-}
-
-char *progname()
-{
-    return name;
-}
-
 /* concatenate two strings freeing the second */
 char *estrcat(char *str1, char *str2)
 {
@@ -196,52 +126,11 @@ char *epstrdup(const char *fmt, int len, ...)
 /* estrdup: duplicate a string, report if error */
 char *estrdup(const char *s)
 {
-    char *t = (char *)malloc(strlen(s) + 1);
-
-    if (t == NULL) {
-        RAISE(MEM_ERROR, "failed to allocate %d bytes", (int)strlen(s) + 1);
-    }
-
+    char *t = ALLOC_N(char, strlen(s) + 1);
     strcpy(t, s);
     return t;
 }
 
-/* emalloc: malloc and report if error */
-void *emalloc(size_t size)
-{
-    void *p = malloc(size);
-
-    if (p == NULL) {
-        RAISE(MEM_ERROR, "failed to allocate %d bytes", (int)size);
-    }
-
-    return p;
-}
-
-/* ecalloc: malloc, zeroset and report if error */
-void *ecalloc(size_t size)
-{
-    void *p = calloc(1, size);
-
-    if (p == NULL) {
-        RAISE(MEM_ERROR, "failed to allocate %d bytes", (int)size);
-    }
-
-    return p;
-}
-
-/* erealloc: realloc and report if error */
-void *erealloc(void *ptr, size_t size)
-{
-    void *p = realloc(ptr, size);
-
-    if (p == NULL) {
-        RAISE(MEM_ERROR, "failed to reallocate %d bytes", (int)size);
-    }
-
-    return p;
-}
-
 /* Pretty print a float to the buffer. The buffer should have at least 32
  * bytes available.
  */
@@ -258,16 +147,14 @@ char *dbl_to_s(char *buf, double num)
     }
 #endif
 
-    sprintf(buf, "%#.7g", num);
+    sprintf(buf, DBL2S, num);
     if (!(e = strchr(buf, 'e'))) {
         e = buf + strlen(buf);
     }
     if (!isdigit(e[-1])) {
         /* reformat if ended with decimal point (ex 111111111111111.) */
         sprintf(buf, "%#.6e", num);
-        if (!(e = strchr(buf, 'e'))) {
-            e = buf + strlen(buf);
-        }
+        if (!(e = strchr(buf, 'e'))) { e = buf + strlen(buf); }
     }
     p = e;
     while (p[-1] == '0' && isdigit(p[-2])) {
@@ -284,9 +171,9 @@ char *vstrfmt(const char *fmt, va_list args)
     char *string;
     char *p = (char *) fmt, *q;
     int len = (int) strlen(fmt) + 1;
-    int slen;
+    int slen, curlen;
     char *s;
-    long i;
+    long l;
     double d;
 
     q = string = ALLOC_N(char, len);
@@ -298,15 +185,17 @@ char *vstrfmt(const char *fmt, va_list args)
             case 's':
                 p++;
                 s = va_arg(args, char *);
-                if (s) {
-                    slen = (int) strlen(s);
-                    len += slen;
-                    *q = 0;
-                    REALLOC_N(string, char, len);
-                    q = string + strlen(string);
-                    sprintf(q, s);
-                    q += slen;
+                /* to be consistent with printf print (null) for NULL */
+                if (!s) {
+                    s = "(null)";
                 }
+                slen = (int) strlen(s);
+                len += slen;
+                curlen = q - string;
+                REALLOC_N(string, char, len);
+                q = string + curlen;
+                memcpy(q, s, slen);
+                q += slen;
                 continue;
             case 'f':
                 p++;
@@ -324,9 +213,8 @@ char *vstrfmt(const char *fmt, va_list args)
                 *q = 0;
                 REALLOC_N(string, char, len);
                 q = string + strlen(string);
-                i = va_arg(args, long);
-                sprintf(q, "%ld", i);
-                q += strlen(q);
+                l = va_arg(args, long);
+                q += sprintf(q, "%ld", l);
                 continue;
             default:
                 break;
@@ -356,29 +244,95 @@ void dummy_free(void *p)
     (void)p; /* suppress unused argument warning */
 }
 
-#ifdef FRT_IS_C99
-extern void usleep(unsigned long usec);
-#else
-# ifdef RUBY_BINDINGS
-struct timeval rb_time_interval _((VALUE));
-# else
-#  include <unistd.h>
-# endif
+#ifdef HAVE_GDB
+#define CMD_BUF_SIZE (128 + FILENAME_MAX)
+/* need to declare this as it is masked by default in linux */
+
+static char *build_shell_command(const char *gdb_filename)
+{
+    int   pid = getpid();
+    char *buf = ALLOC_N(char, CMD_BUF_SIZE);
+    char *command =
+        "gdb -quiet -command=%s %s %d 2>/dev/null | grep '^[ #]'";
+
+    snprintf(buf, CMD_BUF_SIZE, command, gdb_filename, progname(), pid);
+    return buf;
+}
+
+/* Returns the fd to the tempfile */
+static int build_tempfile(char *name, size_t max_size)
+{
+    char *tmpdir = getenv("TMPDIR");
+
+    snprintf(name, max_size, "%s/frt.XXXXXXXXXX", tmpdir ? tmpdir : "/tmp");
+    return mkstemp(name);
+}
+
+static char *build_gdb_commandfile()
+{
+    const char *commands = "bt\nquit\n";
+    char *filename = ALLOC_N(char, FILENAME_MAX);
+    int fd = build_tempfile(filename, FILENAME_MAX);
+    if (fd < 0) { return NULL; }
+    write(fd, commands, strlen(commands));
+    close(fd);
+    return filename;
+}
 #endif
 
-extern void micro_sleep(const int micro_seconds)
+/**
+ * Call out to gdb to get our stacktrace.
+ */
+char *get_stacktrace()
 {
-#ifdef RUBY_BINDINGS
-    rb_thread_wait_for(rb_time_interval(rb_float_new((double)micro_seconds/1000000.0)));
+#ifdef HAVE_GDB
+    FILE *stream;
+    char *gdb_filename = NULL, *buf = NULL, *stack = NULL;
+    int   offset = -BUFFER_SIZE;
+
+    if ( !(gdb_filename = build_gdb_commandfile()) ) {
+        fprintf(EXCEPTION_STREAM,
+                "Unable to build gdb command file\n");
+        goto cleanup;
+    }
+    if ( !(buf = build_shell_command(gdb_filename)) ) {
+        fprintf(EXCEPTION_STREAM,
+                "Unable to build stacktrace shell command\n");
+        goto cleanup;
+    }
+
+    if ( !(stream = popen(buf, "r")) ) {
+        fprintf(EXCEPTION_STREAM,
+                "Unable to exec stacktrace shell command: '%s'\n", buf);
+        goto cleanup;
+    }
+
+    do {
+        offset += BUFFER_SIZE;
+        REALLOC_N(stack, char, offset + BUFFER_SIZE);
+        ZEROSET_N(stack + offset, char, BUFFER_SIZE);
+    } while(fread(stack + offset, 1, BUFFER_SIZE, stream) == BUFFER_SIZE);
+
+    pclose(stream);
+
+ cleanup:
+    if (gdb_filename) free(gdb_filename);
+    if (buf) free(buf);
+    return stack;
 #else
-# ifdef POSH_OS_WIN32
-    Sleep(micro_seconds / 1000);
-# else
-    usleep(micro_seconds);
-# endif
+    return NULL;
 #endif
 }
 
+void print_stacktrace()
+{
+    char *stack = get_stacktrace();
+
+    fprintf(EXCEPTION_STREAM, "Stack trace:\n%s",
+            stack ? stack : "Not available\n");
+    if (stack) free(stack);
+}
+
 typedef struct FreeMe
 {
     void *p;
@@ -405,7 +359,7 @@ void register_for_cleanup(void *p, free_ft free_func)
     free_me->free_func = free_func;
 }
 
-void do_clean_up()
+void clean_up()
 {
     int i;
     for (i = 0; i < free_mes_size; i++) {
@@ -416,3 +370,129 @@ void do_clean_up()
     free_mes = NULL;
     free_mes_size = free_mes_capa = 0;
 }
+
+/* weprintf: print error message and don't exit */
+void weprintf(const char *fmt, ...)
+{
+    va_list args;
+
+    fflush(stdout);
+    fprintf(stderr, "%s: ", progname());
+
+    va_start(args, fmt);
+    vfprintf(stderr, fmt, args);
+    va_end(args);
+
+    if (fmt[0] != '\0' && fmt[strlen(fmt) - 1] == ':')
+        fprintf(stderr, " %s", strerror(errno));
+    fprintf(stderr, "\n");
+}
+
+#define MAX_PROG_NAME 200
+static char name[MAX_PROG_NAME]; /* program name for error msgs */
+
+/* setprogname: set stored name of program */
+void setprogname(const char *str)
+{
+    strncpy(name, str, sizeof(name) - 1);
+}
+
+const char *progname()
+{
+    return name;
+}
+
+static const char *signal_to_string(int signum)
+{
+    switch (signum)
+    {
+        case SIGILL:  return "SIGILL";
+        case SIGABRT: return "SIGABRT";
+        case SIGFPE:  return "SIGFPE";
+        case SIGBUS:  return "SIGBUS";
+        case SIGSEGV: return "SIGSEGV";
+    }
+
+    return "Unknown Signal";
+}
+
+static void sighandler_crash(int signum)
+{
+    print_stacktrace();
+    XEXIT("Exiting on signal %s (%d)",
+             signal_to_string(signum), signum);
+}
+
+#define SETSIG_IF_UNSET(sig, new) do {  \
+    struct sigaction __old;             \
+    sigaction(sig, NULL, &__old);       \
+    if (__old.sa_handler != SIG_IGN) {  \
+        sigaction(sig, &new, NULL);     \
+    }                                   \
+} while(0)
+
+void init(int argc, const char *const argv[])
+{
+    struct sigaction action;
+
+    if (argc > 0) {
+        setprogname(argv[0]);
+    }
+
+    action.sa_handler = sighandler_crash;
+    sigemptyset(&action.sa_mask);
+    action.sa_flags = 0;
+
+    SETSIG_IF_UNSET(SIGILL , action);
+    SETSIG_IF_UNSET(SIGABRT, action);
+    SETSIG_IF_UNSET(SIGFPE , action);
+    SETSIG_IF_UNSET(SIGBUS , action);
+    SETSIG_IF_UNSET(SIGSEGV, action);
+
+    symbol_init();
+
+    atexit(&hash_finalize);
+}
+
+/**
+ * For general use when testing
+ *
+ * TODO wrap in #ifdef
+ */
+
+static bool p_switch = false;
+static bool p_switch_tmp = false;
+
+void p(const char *format, ...)
+{
+    va_list args;
+
+    if (!p_switch) return;
+
+    va_start(args, format);
+    vfprintf(stderr, format, args);
+    va_end(args);
+}
+
+void p_on()
+{
+    fprintf(stderr, "> > > > > STARTING PRINT\n");
+    p_switch = true;
+}
+
+void p_off()
+{
+    fprintf(stderr, "< < < < < STOPPING PRINT\n");
+    p_switch = false;
+}
+
+void p_pause()
+{
+    p_switch_tmp = p_switch;
+    p_switch = false;
+}
+
+void p_resume()
+{
+    p_switch = p_switch_tmp;
+}