ferret 0.9.6 → 0.10.0

data/ext/global.c

@@ -7,283 +7,321 @@
 #include <math.h>
 #include <ctype.h>
 
-static char * const ESTRDUP_MEM_ERROR_MSG = "estrdup failed";
-static char * const MEM_ERROR_MSG = "malloc failed";
-
 const char *EMPTY_STRING = "";
 
-int min3(int a, int b, int c)
+bool x_do_logging = false;
+
+inline int min3(int a, int b, int c)
 {
-  return MIN3(a, b, c);
+    return MIN3(a, b, c);
 }
 
-int min2(int a, int b)
+inline int min2(int a, int b)
 {
-  return MIN(a, b);
+    return MIN(a, b);
 }
 
-int max3(int a, int b, int c)
+inline int max3(int a, int b, int c)
 {
-  return MAX3(a, b, c);
+    return MAX3(a, b, c);
 }
 
-int max2(int a, int b)
+inline int max2(int a, int b)
 {
-  return MAX(a, b);
+    return MAX(a, b);
 }
 
 int scmp(const void *p1, const void *p2)
 {
-  return strcmp(*(char **)p1, *(char **)p2);
+    return strcmp(*(char **) p1, *(char **) p2);
 }
 
-int icmp_risky(const void *p1, const void *p2)
+int icmp(const void *p1, const void *p2)
 {
-  return (*(int *)p1) - *((int *)p2);
+    int i1 = *(int *) p1;
+    int i2 = *(int *) p2;
+
+    if (i1 > i2) {
+        return 1;
+    }
+    else if (i1 < i2) {
+        return -1;
+    }
+    return 0;
 }
 
-int icmp(const void *p1, const void *p2)
+int icmp_risky(const void *p1, const void *p2)
 {
-  int i1 = *(int *)p1;
-  int i2 = *(int *)p2;
-
-  if (i1 > i2) return 1;
-  else if (i1 < i2) return -1;
-  return 0;
+  return (*(int *)p1) - *((int *)p2);
 }
 
 
-/* eprintf: print error message and exit */
-void eprintf_old(const char *fmt, ...)
+/* 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
 {
-  va_list args;
+    fflush(stdout);
+    fprintf(stderr, "\n");
+    if (progname() != NULL) {
+        fprintf(stderr, "%s: ", progname());
+    }
 
-  fflush(stdout);
-  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);
 
-  va_start(args, fmt);
-  vfprintf(stderr, fmt, args);
-  va_end(args);
+    if (fmt[0] != '\0' && fmt[strlen(fmt) - 1] == ':') {
+        fprintf(stderr, " %s", strerror(errno));
+    }
 
-  if (fmt[0] != '\0' && fmt[strlen(fmt)-1] == ':')
-    fprintf(stderr, " %s", strerror(errno));
-  fprintf(stderr, "\n");
-  exit(2); /* conventional value for failed execution */
+    fprintf(stderr, "\n");
+    exit(2);                    /* conventional value for failed execution */
 }
 
-/* eprintf: print error message and exit */
-void eprintf_inner(char *file, int line_num, const char *etype, const char *fmt, ...)
+
+#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;
-
-  fflush(stdout);
-  fprintf(stderr, "\n");
-  if (progname() != NULL)
-    fprintf(stderr, "%s: ", progname());
-
-  fprintf(stderr, "%s occured at <%s>:%d\n", etype, file, line_num);
-  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");
-  exit(2); /* conventional value for failed execution */
+    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);
 }
 
+
 /* weprintf: print error message and don't exit */
 void weprintf(const char *fmt, ...)
 {
-  va_list args;
+    va_list args;
 
-  fflush(stdout);
-  if (progname() != NULL)
-    fprintf(stderr, "%s: ", progname());
+    fflush(stdout);
+    if (progname() != NULL)
+        fprintf(stderr, "%s: ", progname());
 
-  va_start(args, fmt);
-  vfprintf(stderr, fmt, args);
-  va_end(args);
+    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");
+    if (fmt[0] != '\0' && fmt[strlen(fmt) - 1] == ':')
+        fprintf(stderr, " %s", strerror(errno));
+    fprintf(stderr, "\n");
 }
 
-static char name[200]; /* program name for error msgs */
+#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)
 {
-  strcpy(name, str);
+    strncpy(name, str, MAX_PROG_NAME - 1);
 }
 
-char *progname(void)
+char *progname()
 {
-  return name;
+    return name;
 }
 
 /* concatenate two strings freeing the second */
 char *estrcat(char *str1, char *str2)
 {
-  size_t len1 = strlen(str1);
-  size_t len2 = strlen(str2);
-  REALLOC_N(str1, char, len1 + len2 + 3); // leave room for <CR>
-  memcpy(str1 + len1, str2, len2 + 1); // make sure '\0' copied too
-  free(str2);
-  return str1;
+    size_t len1 = strlen(str1);
+    size_t len2 = strlen(str2);
+    REALLOC_N(str1, char, len1 + len2 + 3);     /* leave room for <CR> */
+    memcpy(str1 + len1, str2, len2 + 1);        /* make sure '\0' copied too */
+    free(str2);
+    return str1;
 }
 
 /* epstrdup: duplicate a string with a format, report if error */
 char *epstrdup(const char *fmt, int len, ...)
 {
-  char *string;
-  va_list args;
-  len += (int)strlen(fmt);
+    char *string;
+    va_list args;
+    len += (int) strlen(fmt);
 
-  string = ALLOC_N(char, len + 1);
-  va_start(args, len);
-  vsprintf(string, fmt, args);
-  va_end(args);
+    string = ALLOC_N(char, len + 1);
+    va_start(args, len);
+    vsprintf(string, fmt, args);
+    va_end(args);
 
-  return string;
+    return string;
 }
 
 /* estrdup: duplicate a string, report if error */
 char *estrdup(const char *s)
 {
-  char *t;
+    char *t = (char *)malloc(strlen(s) + 1);
 
-  t = (char *)malloc(strlen(s) + 1);
-  if (t == NULL)
-    RAISE(MEM_ERROR, ESTRDUP_MEM_ERROR_MSG);
+    if (t == NULL) {
+        RAISE(MEM_ERROR, "failed to allocate %d bytes", (int)strlen(s) + 1);
+    }
 
-  strcpy(t, s);
-  return t;
+    strcpy(t, s);
+    return t;
 }
 
 /* emalloc: malloc and report if error */
 void *emalloc(size_t size)
 {
-  void *p;
-  p = malloc(size);
-  if (p == NULL)
-    RAISE(MEM_ERROR, MEM_ERROR_MSG);
-  return p;
+    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;
-  p = realloc(ptr, size);
-  if (p == NULL)
-    RAISE(MEM_ERROR, MEM_ERROR_MSG);
-  return p;
+    void *p = realloc(ptr, size);
+
+    if (p == NULL) {
+        RAISE(MEM_ERROR, "failed to reallocate %d bytes", (int)size);
+    }
+
+    return p;
 }
 
-/*
- * The following method comes slightly modified from the ruby core flo_to_s in
- * numeric.c. We use it so that tests comparing floats as strings will pass.
+/* Pretty print a float to the buffer. The buffer should have at least 32
+ * bytes available.
  */
 char *dbl_to_s(char *buf, double num)
 {
-  char *p, *e;
-
-  if (isinf(num)) {
-    return estrdup(num < 0 ? "-Infinity" : "Infinity");
-  } else if(isnan(num)) {
-    return estrdup("NaN");
-  }
-
-  sprintf(buf, "%#.7g", 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);
+    char *p, *e;
+
+#ifdef FRT_IS_C99
+    if (isinf(num)) {
+        return estrdup(num < 0 ? "-Infinity" : "Infinity");
+    }
+    else if (isnan(num)) {
+        return estrdup("NaN");
+    }
+#endif
+
+    sprintf(buf, "%#.7g", num);
     if (!(e = strchr(buf, 'e'))) {
-      e = buf + strlen(buf);
+        e = buf + strlen(buf);
     }
-  }
-  p = e;
-  while (p[-1]=='0' && isdigit(p[-2]))
-    p--;
-  memmove(p, e, strlen(e)+1);
-  return 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);
+        }
+    }
+    p = e;
+    while (p[-1] == '0' && isdigit(p[-2])) {
+        p--;
+    }
+
+    memmove(p, e, strlen(e) + 1);
+    return buf;
 }
 
-void lower_str(char *str)
+/* strfmt: like sprintf except that it allocates memory for the string */
+char *vstrfmt(const char *fmt, va_list args)
 {
-  while (*str) {
-    *str = tolower(*str);
-    str++;
-  }
+    char *string;
+    char *p = (char *) fmt, *q;
+    int len = (int) strlen(fmt) + 1;
+    int slen;
+    char *s;
+    long i;
+    double d;
+
+    q = string = ALLOC_N(char, len);
+
+    while (*p) {
+        if (*p == '%') {
+            p++;
+            switch (*p) {
+            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;
+                }
+                continue;
+            case 'f':
+                p++;
+                len += 32;
+                *q = 0;
+                REALLOC_N(string, char, len);
+                q = string + strlen(string);
+                d = va_arg(args, double);
+                dbl_to_s(q, d);
+                q += strlen(q);
+                continue;
+            case 'd':
+                p++;
+                len += 20;
+                *q = 0;
+                REALLOC_N(string, char, len);
+                q = string + strlen(string);
+                i = va_arg(args, long);
+                sprintf(q, "%ld", i);
+                q += strlen(q);
+                continue;
+            default:
+                break;
+            }
+        }
+        *q = *p;
+        p++;
+        q++;
+    }
+    *q = 0;
+
+    return string;
 }
 
-/* strfmt: like sprintf except that it allocates memory for the string */
 char *strfmt(const char *fmt, ...)
 {
-  char *string;
-  char *p = (char *)fmt, *q;
-  va_list args;
-  int len = (int)strlen(fmt) + 1;
-  int slen;
-  char *s;
-  long i;
-  double d;
-
-  q = string = ALLOC_N(char, len);
-
-  va_start(args, fmt);
-  while (*p) {
-    if (*p == '%') {
-      p++;
-      switch (*p) {
-        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;
-          }
-          continue;
-        case 'f':
-          p++;
-          len += 32;
-          *q = 0;
-          REALLOC_N(string, char, len);
-          q = string + strlen(string);
-          d = va_arg(args, double);
-          dbl_to_s(q, d);
-          q += strlen(q);
-          continue;
-        case 'd':
-          p++;
-          len += 20;
-          *q = 0;
-          REALLOC_N(string, char, len);
-          q = string + strlen(string);
-          i = va_arg(args, long);
-          sprintf(q, "%ld", i);
-          q += strlen(q);
-          continue;
-        default:
-          break;
-      }
-    }
-    *q = *p;
-    p++;
-    q++;
-  }
-  va_end(args);
-  *q = 0;
-
-  return string;
+    va_list args;
+    char *str;
+    va_start(args, fmt);
+    str = vstrfmt(fmt, args);
+    va_end(args);
+    return str;
+}
+
+void dummy_free(void *p)
+{
+    (void)p; /* suppress unused argument warning */
 }