iodine 0.7.59 → 0.8.0

data/ext/iodine/fiobject.c

@@ -1,620 +0,0 @@
-/*
-Copyright: Boaz Segev, 2017-2019
-License: MIT
-*/
-
-/**
-This facil.io core library provides wrappers around complex and (or) dynamic
-types, abstracting some complexity and making dynamic type related tasks easier.
-*/
-
-#include <fiobject.h>
-
-#define FIO_ARY_NAME fiobj_stack
-#define FIO_ARY_TYPE FIOBJ
-#define FIO_ARY_INVALID FIOBJ_INVALID
-/* don't free or compare objects, this stack shouldn't have side-effects */
-#include <fio.h>
-
-#include <stdarg.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-/* *****************************************************************************
-Use the facil.io features when available, but override when missing.
-***************************************************************************** */
-#ifndef fd_data /* defined in fio.c */
-
-#pragma weak fio_malloc
-void *fio_malloc(size_t size) {
-  void *m = malloc(size);
-  if (m)
-    memset(m, 0, size);
-  return m;
-}
-
-#pragma weak fio_calloc
-void *__attribute__((weak)) fio_calloc(size_t size, size_t count) {
-  return calloc(size, count);
-}
-
-#pragma weak fio_free
-void __attribute__((weak)) fio_free(void *ptr) { free(ptr); }
-
-#pragma weak fio_realloc
-void *__attribute__((weak)) fio_realloc(void *ptr, size_t new_size) {
-  return realloc(ptr, new_size);
-}
-
-#pragma weak fio_realloc2
-void *__attribute__((weak))
-fio_realloc2(void *ptr, size_t new_size, size_t valid_len) {
-  return realloc(ptr, new_size);
-  (void)valid_len;
-}
-
-#pragma weak fio_mmap
-void *__attribute__((weak)) fio_mmap(size_t size) { return fio_malloc(size); }
-
-/** The logging level */
-#if DEBUG
-#pragma weak FIO_LOG_LEVEL
-int __attribute__((weak)) FIO_LOG_LEVEL = FIO_LOG_LEVEL_DEBUG;
-#else
-#pragma weak FIO_LOG_LEVEL
-int __attribute__((weak)) FIO_LOG_LEVEL = FIO_LOG_LEVEL_INFO;
-#endif
-
-/**
- * We include this in case the parser is used outside of facil.io.
- */
-int64_t __attribute__((weak)) fio_atol(char **pstr) {
-  return strtoll(*pstr, pstr, 0);
-}
-#pragma weak fio_atol
-
-/**
- * We include this in case the parser is used outside of facil.io.
- */
-double __attribute__((weak)) fio_atof(char **pstr) {
-  return strtod(*pstr, pstr);
-}
-#pragma weak fio_atof
-
-/**
- * A helper function that writes a signed int64_t to a string.
- *
- * No overflow guard is provided, make sure there's at least 68 bytes
- * available (for base 2).
- *
- * Offers special support for base 2 (binary), base 8 (octal), base 10 and base
- * 16 (hex). An unsupported base will silently default to base 10. Prefixes
- * are automatically added (i.e., "0x" for hex and "0b" for base 2).
- *
- * Returns the number of bytes actually written (excluding the NUL
- * terminator).
- */
-#pragma weak fio_ltoa
-size_t __attribute__((weak)) fio_ltoa(char *dest, int64_t num, uint8_t base) {
-  const char notation[] = {'0', '1', '2', '3', '4', '5', '6', '7',
-                           '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
-
-  size_t len = 0;
-  char buf[48] = {0}; /* we only need up to 20 for base 10, but base 3 needs 41... */
-
-  if (!num)
-    goto zero;
-
-  switch (base) {
-  case 1: /* fallthrough */
-  case 2:
-    /* Base 2 */
-    {
-      uint64_t n = num; /* avoid bit shifting inconsistencies with signed bit */
-      uint8_t i = 0;    /* counting bits */
-      dest[len++] = '0';
-      dest[len++] = 'b';
-
-      while ((i < 64) && (n & 0x8000000000000000) == 0) {
-        n = n << 1;
-        i++;
-      }
-      /* make sure the Binary representation doesn't appear signed. */
-      if (i) {
-        dest[len++] = '0';
-      }
-      /* write to dest. */
-      while (i < 64) {
-        dest[len++] = ((n & 0x8000000000000000) ? '1' : '0');
-        n = n << 1;
-        i++;
-      }
-      dest[len] = 0;
-      return len;
-    }
-  case 8:
-    /* Base 8 */
-    {
-      uint64_t l = 0;
-      if (num < 0) {
-        dest[len++] = '-';
-        num = 0 - num;
-      }
-      dest[len++] = '0';
-
-      while (num) {
-        buf[l++] = '0' + (num & 7);
-        num = num >> 3;
-      }
-      while (l) {
-        --l;
-        dest[len++] = buf[l];
-      }
-      dest[len] = 0;
-      return len;
-    }
-
-  case 16:
-    /* Base 16 */
-    {
-      uint64_t n = num; /* avoid bit shifting inconsistencies with signed bit */
-      uint8_t i = 0;    /* counting bits */
-      dest[len++] = '0';
-      dest[len++] = 'x';
-      while (i < 8 && (n & 0xFF00000000000000) == 0) {
-        n = n << 8;
-        i++;
-      }
-      /* make sure the Hex representation doesn't appear signed. */
-      if (i && (n & 0x8000000000000000)) {
-        dest[len++] = '0';
-        dest[len++] = '0';
-      }
-      /* write the damn thing */
-      while (i < 8) {
-        uint8_t tmp = (n & 0xF000000000000000) >> 60;
-        dest[len++] = notation[tmp];
-        tmp = (n & 0x0F00000000000000) >> 56;
-        dest[len++] = notation[tmp];
-        i++;
-        n = n << 8;
-      }
-      dest[len] = 0;
-      return len;
-    }
-  case 3: /* fallthrough */
-  case 4: /* fallthrough */
-  case 5: /* fallthrough */
-  case 6: /* fallthrough */
-  case 7: /* fallthrough */
-  case 9: /* fallthrough */
-    /* rare bases */
-    if (num < 0) {
-      dest[len++] = '-';
-      num = 0 - num;
-    }
-    uint64_t l = 0;
-    while (num) {
-      uint64_t t = num / base;
-      buf[l++] = '0' + (num - (t * base));
-      num = t;
-    }
-    while (l) {
-      --l;
-      dest[len++] = buf[l];
-    }
-    dest[len] = 0;
-    return len;
-
-  default:
-    break;
-  }
-  /* Base 10, the default base */
-
-  if (num < 0) {
-    dest[len++] = '-';
-    num = 0 - num;
-  }
-  uint64_t l = 0;
-  while (num) {
-    uint64_t t = num / 10;
-    buf[l++] = '0' + (num - (t * 10));
-    num = t;
-  }
-  while (l) {
-    --l;
-    dest[len++] = buf[l];
-  }
-  dest[len] = 0;
-  return len;
-
-zero:
-  switch (base) {
-  case 1: /* fallthrough */
-  case 2:
-    dest[len++] = '0';
-    dest[len++] = 'b';
-    /* fallthrough */
-  case 16:
-    dest[len++] = '0';
-    dest[len++] = 'x';
-    dest[len++] = '0';
-  }
-  dest[len++] = '0';
-  dest[len] = 0;
-  return len;
-}
-
-/**
- * A helper function that converts between a double to a string.
- *
- * No overflow guard is provided, make sure there's at least 130 bytes
- * available (for base 2).
- *
- * Supports base 2, base 10 and base 16. An unsupported base will silently
- * default to base 10. Prefixes aren't added (i.e., no "0x" or "0b" at the
- * beginning of the string).
- *
- * Returns the number of bytes actually written (excluding the NUL
- * terminator).
- */
-#pragma weak fio_ftoa
-size_t __attribute__((weak)) fio_ftoa(char *dest, double num, uint8_t base) {
-  if (base == 2 || base == 16) {
-    /* handle the binary / Hex representation the same as if it were an
-     * int64_t
-     */
-    int64_t *i = (void *)&num;
-    return fio_ltoa(dest, *i, base);
-  }
-
-  size_t written = sprintf(dest, "%g", num);
-  uint8_t need_zero = 1;
-  char *start = dest;
-  while (*start) {
-    if (*start == ',') // locale issues?
-      *start = '.';
-    if (*start == '.' || *start == 'e') {
-      need_zero = 0;
-      break;
-    }
-    start++;
-  }
-  if (need_zero) {
-    dest[written++] = '.';
-    dest[written++] = '0';
-  }
-  return written;
-}
-
-#endif
-/* *****************************************************************************
-the `fiobj_each2` function
-***************************************************************************** */
-
-struct task_packet_s {
-  int (*task)(FIOBJ obj, void *arg);
-  void *arg;
-  fiobj_stack_s *stack;
-  FIOBJ next;
-  uintptr_t counter;
-  uint8_t stop;
-  uint8_t incomplete;
-};
-
-static int fiobj_task_wrapper(FIOBJ o, void *p_) {
-  struct task_packet_s *p = p_;
-  ++p->counter;
-  int ret = p->task(o, p->arg);
-  if (ret == -1) {
-    p->stop = 1;
-    return -1;
-  }
-  if (FIOBJ_IS_ALLOCATED(o) && FIOBJECT2VTBL(o)->each) {
-    p->incomplete = 1;
-    p->next = o;
-    return -1;
-  }
-  return 0;
-}
-/**
- * Single layer iteration using a callback for each nested fio object.
- *
- * Accepts any `FIOBJ ` type but only collections (Arrays and Hashes) are
- * processed. The container itself (the Array or the Hash) is **not** processed
- * (unlike `fiobj_each2`).
- *
- * The callback task function must accept an object and an opaque user pointer.
- *
- * Hash objects pass along a `FIOBJ_T_COUPLET` object, containing
- * references for both the key and the object. Keys shouldn't be altered once
- * placed as a key (or the Hash will break). Collections (Arrays / Hashes) can't
- * be used as keeys.
- *
- * If the callback returns -1, the loop is broken. Any other value is ignored.
- *
- * Returns the "stop" position, i.e., the number of items processed + the
- * starting point.
- */
-size_t fiobj_each2(FIOBJ o, int (*task)(FIOBJ obj, void *arg), void *arg) {
-  if (!o || !FIOBJ_IS_ALLOCATED(o) || (FIOBJECT2VTBL(o)->each == NULL)) {
-    task(o, arg);
-    return 1;
-  }
-  /* run task for root object */
-  if (task(o, arg) == -1)
-    return 1;
-  uintptr_t pos = 0;
-  fiobj_stack_s stack = FIO_ARY_INIT;
-  struct task_packet_s packet = {
-      .task = task,
-      .arg = arg,
-      .stack = &stack,
-      .counter = 1,
-  };
-  do {
-    if (!pos)
-      packet.next = 0;
-    packet.incomplete = 0;
-    pos = FIOBJECT2VTBL(o)->each(o, pos, fiobj_task_wrapper, &packet);
-    if (packet.stop)
-      goto finish;
-    if (packet.incomplete) {
-      fiobj_stack_push(&stack, pos);
-      fiobj_stack_push(&stack, o);
-    }
-
-    if (packet.next) {
-      fiobj_stack_push(&stack, (FIOBJ)0);
-      fiobj_stack_push(&stack, packet.next);
-    }
-    o = FIOBJ_INVALID;
-    fiobj_stack_pop(&stack, &o);
-    fiobj_stack_pop(&stack, &pos);
-  } while (o);
-finish:
-  fiobj_stack_free(&stack);
-  return packet.counter;
-}
-
-/* *****************************************************************************
-Free complex objects (objects with nesting)
-***************************************************************************** */
-
-static void fiobj_dealloc_task(FIOBJ o, void *stack_) {
-  // if (!o)
-  //   fprintf(stderr, "* WARN: freeing a NULL no-object\n");
-  // else
-  //   fprintf(stderr, "* freeing object %s\n", fiobj_obj2cstr(o).data);
-  if (!o || !FIOBJ_IS_ALLOCATED(o))
-    return;
-  if (OBJREF_REM(o))
-    return;
-  if (!FIOBJECT2VTBL(o)->each || !FIOBJECT2VTBL(o)->count(o)) {
-    FIOBJECT2VTBL(o)->dealloc(o, NULL, NULL);
-    return;
-  }
-  fiobj_stack_s *s = stack_;
-  fiobj_stack_push(s, o);
-}
-/**
- * Decreases an object's reference count, releasing memory and
- * resources.
- *
- * This function affects nested objects, meaning that when an Array or
- * a Hash object is passed along, it's children (nested objects) are
- * also freed.
- */
-void fiobj_free_complex_object(FIOBJ o) {
-  fiobj_stack_s stack = FIO_ARY_INIT;
-  do {
-    FIOBJECT2VTBL(o)->dealloc(o, fiobj_dealloc_task, &stack);
-  } while (!fiobj_stack_pop(&stack, &o));
-  fiobj_stack_free(&stack);
-}
-
-/* *****************************************************************************
-Is Equal?
-***************************************************************************** */
-#include <fiobj_hash.h>
-
-static inline int fiobj_iseq_simple(const FIOBJ o, const FIOBJ o2) {
-  if (o == o2)
-    return 1;
-  if (!o || !o2)
-    return 0; /* they should have compared equal before. */
-  if (!FIOBJ_IS_ALLOCATED(o) || !FIOBJ_IS_ALLOCATED(o2))
-    return 0; /* they should have compared equal before. */
-  if (FIOBJECT2HEAD(o)->type != FIOBJECT2HEAD(o2)->type)
-    return 0; /* non-type equality is a barriar to equality. */
-  if (!FIOBJECT2VTBL(o)->is_eq(o, o2))
-    return 0;
-  return 1;
-}
-
-static int fiobj_iseq____internal_complex__task(FIOBJ o, void *ary_) {
-  fiobj_stack_s *ary = ary_;
-  fiobj_stack_push(ary, o);
-  if (fiobj_hash_key_in_loop())
-    fiobj_stack_push(ary, fiobj_hash_key_in_loop());
-  return 0;
-}
-
-/** used internally for complext nested tests (Array / Hash types) */
-int fiobj_iseq____internal_complex__(FIOBJ o, FIOBJ o2) {
-  // if (FIOBJECT2VTBL(o)->each && FIOBJECT2VTBL(o)->count(o))
-  //   return int fiobj_iseq____internal_complex__(const FIOBJ o, const FIOBJ
-  //   o2);
-  fiobj_stack_s left = FIO_ARY_INIT, right = FIO_ARY_INIT, queue = FIO_ARY_INIT;
-  do {
-    fiobj_each1(o, 0, fiobj_iseq____internal_complex__task, &left);
-    fiobj_each1(o2, 0, fiobj_iseq____internal_complex__task, &right);
-    while (fiobj_stack_count(&left)) {
-      o = FIOBJ_INVALID;
-      o2 = FIOBJ_INVALID;
-      fiobj_stack_pop(&left, &o);
-      fiobj_stack_pop(&right, &o2);
-      if (!fiobj_iseq_simple(o, o2))
-        goto unequal;
-      if (FIOBJ_IS_ALLOCATED(o) && FIOBJECT2VTBL(o)->each &&
-          FIOBJECT2VTBL(o)->count(o)) {
-        fiobj_stack_push(&queue, o);
-        fiobj_stack_push(&queue, o2);
-      }
-    }
-    o = FIOBJ_INVALID;
-    o2 = FIOBJ_INVALID;
-    fiobj_stack_pop(&queue, &o2);
-    fiobj_stack_pop(&queue, &o);
-    if (!fiobj_iseq_simple(o, o2))
-      goto unequal;
-  } while (o);
-  fiobj_stack_free(&left);
-  fiobj_stack_free(&right);
-  fiobj_stack_free(&queue);
-  return 1;
-unequal:
-  fiobj_stack_free(&left);
-  fiobj_stack_free(&right);
-  fiobj_stack_free(&queue);
-  return 0;
-}
-
-/* *****************************************************************************
-Defaults / NOOPs
-***************************************************************************** */
-
-void fiobject___noop_dealloc(FIOBJ o, void (*task)(FIOBJ, void *), void *arg) {
-  (void)o;
-  (void)task;
-  (void)arg;
-}
-void fiobject___simple_dealloc(FIOBJ o, void (*task)(FIOBJ, void *),
-                               void *arg) {
-  fio_free(FIOBJ2PTR(o));
-  (void)task;
-  (void)arg;
-}
-
-uintptr_t fiobject___noop_count(const FIOBJ o) {
-  (void)o;
-  return 0;
-}
-size_t fiobject___noop_is_eq(const FIOBJ o1, const FIOBJ o2) {
-  (void)o1;
-  (void)o2;
-  return 0;
-}
-
-fio_str_info_s fiobject___noop_to_str(const FIOBJ o) {
-  (void)o;
-  return (fio_str_info_s){.len = 0, .data = NULL};
-}
-intptr_t fiobject___noop_to_i(const FIOBJ o) {
-  (void)o;
-  return 0;
-}
-double fiobject___noop_to_f(const FIOBJ o) {
-  (void)o;
-  return 0;
-}
-
-#if DEBUG
-
-#include <fiobj_ary.h>
-#include <fiobj_numbers.h>
-
-static int fiobject_test_task(FIOBJ o, void *arg) {
-  ++((uintptr_t *)arg)[0];
-  if (!o)
-    fprintf(stderr, "* WARN: counting a NULL no-object\n");
-  // else
-  //   fprintf(stderr, "* counting object %s\n", fiobj_obj2cstr(o).data);
-  return 0;
-  (void)o;
-}
-
-void fiobj_test_core(void) {
-#define TEST_ASSERT(cond, ...)                                                 \
-  if (!(cond)) {                                                               \
-    fprintf(stderr, __VA_ARGS__);                                              \
-    fprintf(stderr, "Testing failed.\n");                                      \
-    exit(-1);                                                                  \
-  }
-  fprintf(stderr, "=== Testing Primitives\n");
-  FIOBJ o = fiobj_null();
-  TEST_ASSERT(o == (FIOBJ)FIOBJ_T_NULL, "fiobj_null isn't NULL!\n");
-  TEST_ASSERT(FIOBJ_TYPE(0) == FIOBJ_T_NULL, "NULL isn't NULL!\n");
-  TEST_ASSERT(FIOBJ_TYPE_IS(0, FIOBJ_T_NULL), "NULL isn't NULL! (2)\n");
-  TEST_ASSERT(!FIOBJ_IS_ALLOCATED(fiobj_null()),
-              "fiobj_null claims to be allocated!\n");
-  TEST_ASSERT(!FIOBJ_IS_ALLOCATED(fiobj_true()),
-              "fiobj_true claims to be allocated!\n");
-  TEST_ASSERT(!FIOBJ_IS_ALLOCATED(fiobj_false()),
-              "fiobj_false claims to be allocated!\n");
-  TEST_ASSERT(FIOBJ_TYPE(fiobj_true()) == FIOBJ_T_TRUE,
-              "fiobj_true isn't FIOBJ_T_TRUE!\n");
-  TEST_ASSERT(FIOBJ_TYPE_IS(fiobj_true(), FIOBJ_T_TRUE),
-              "fiobj_true isn't FIOBJ_T_TRUE! (2)\n");
-  TEST_ASSERT(FIOBJ_TYPE(fiobj_false()) == FIOBJ_T_FALSE,
-              "fiobj_false isn't FIOBJ_T_TRUE!\n");
-  TEST_ASSERT(FIOBJ_TYPE_IS(fiobj_false(), FIOBJ_T_FALSE),
-              "fiobj_false isn't FIOBJ_T_TRUE! (2)\n");
-  fiobj_free(o); /* testing for crash*/
-  fprintf(stderr, "* passed.\n");
-  fprintf(stderr, "=== Testing fioj_each2\n");
-  o = fiobj_ary_new2(4);
-  FIOBJ tmp = fiobj_ary_new();
-  fiobj_ary_push(o, tmp);
-  fiobj_ary_push(o, fiobj_true());
-  fiobj_ary_push(o, fiobj_null());
-  fiobj_ary_push(o, fiobj_num_new(10));
-  fiobj_ary_push(tmp, fiobj_num_new(13));
-  fiobj_ary_push(tmp, fiobj_hash_new());
-  FIOBJ key = fiobj_str_new("my key", 6);
-  fiobj_hash_set(fiobj_ary_entry(tmp, -1), key, fiobj_true());
-  fiobj_free(key);
-  /* we have root array + 4 children (w/ array) + 2 children (w/ hash) + 1 */
-  uintptr_t count = 0;
-  size_t each_ret = 0;
-  TEST_ASSERT(fiobj_each2(o, fiobject_test_task, (void *)&count) == 8,
-              "fiobj_each1 didn't count everything... (%d != %d)", (int)count,
-              (int)each_ret);
-  TEST_ASSERT(count == 8, "Something went wrong with the counter task... (%d)",
-              (int)count)
-  fprintf(stderr, "* passed.\n");
-  fprintf(stderr, "=== Testing fioj_iseq with nested items\n");
-  FIOBJ o2 = fiobj_ary_new2(4);
-  tmp = fiobj_ary_new();
-  fiobj_ary_push(o2, tmp);
-  fiobj_ary_push(o2, fiobj_true());
-  fiobj_ary_push(o2, fiobj_null());
-  fiobj_ary_push(o2, fiobj_num_new(10));
-  fiobj_ary_push(tmp, fiobj_num_new(13));
-  fiobj_ary_push(tmp, fiobj_hash_new());
-  key = fiobj_str_new("my key", 6);
-  fiobj_hash_set(fiobj_ary_entry(tmp, -1), key, fiobj_true());
-  fiobj_free(key);
-  TEST_ASSERT(!fiobj_iseq(o, FIOBJ_INVALID),
-              "Array and FIOBJ_INVALID can't be equal!");
-  TEST_ASSERT(!fiobj_iseq(o, fiobj_null()),
-              "Array and fiobj_null can't be equal!");
-  TEST_ASSERT(fiobj_iseq(o, o2), "Arrays aren't euqal!");
-  fiobj_free(o);
-  fiobj_free(o2);
-  TEST_ASSERT(fiobj_iseq(fiobj_null(), fiobj_null()),
-              "fiobj_null() not equal to self!");
-  TEST_ASSERT(fiobj_iseq(fiobj_false(), fiobj_false()),
-              "fiobj_false() not equal to self!");
-  TEST_ASSERT(fiobj_iseq(fiobj_true(), fiobj_true()),
-              "fiobj_true() not equal to self!");
-  TEST_ASSERT(!fiobj_iseq(fiobj_null(), fiobj_false()),
-              "fiobj_null eqal to fiobj_false!");
-  TEST_ASSERT(!fiobj_iseq(fiobj_null(), fiobj_true()),
-              "fiobj_null eqal to fiobj_true!");
-  fprintf(stderr, "* passed.\n");
-}
-
-#endif