iodine 0.4.19 → 0.5.0

data/ext/iodine/fiobj_ary.h

@@ -1,6 +1,6 @@
 #ifndef FIOBJ_ARRAY_H
 /*
-Copyright: Boaz Segev, 2017
+Copyright: Boaz Segev, 2017-2018
 License: MIT
 */
 
@@ -15,28 +15,25 @@ A dynamic Array type for the fiobj_s dynamic type system.
 extern "C" {
 #endif
 
-/** The Array type indentifier. */
-extern const uintptr_t FIOBJ_T_ARRAY;
-
 /* *****************************************************************************
 Array creation API
 ***************************************************************************** */
 
 /** Creates a mutable empty Array object. Use `fiobj_free` when done. */
-fiobj_s *fiobj_ary_new(void);
+FIOBJ fiobj_ary_new(void);
 
 /** Creates a mutable empty Array object with the requested capacity. */
-fiobj_s *fiobj_ary_new2(size_t capa);
+FIOBJ fiobj_ary_new2(size_t capa);
 
 /* *****************************************************************************
 Array direct entry access API
 ***************************************************************************** */
 
 /** Returns the number of elements in the Array. */
-size_t fiobj_ary_count(fiobj_s *ary);
+size_t fiobj_ary_count(FIOBJ ary);
 
 /** Returns the current, temporary, array capacity (it's dynamic). */
-size_t fiobj_ary_capa(fiobj_s *ary);
+size_t fiobj_ary_capa(FIOBJ ary);
 
 /**
  * Returns a TEMPORARY pointer to the begining of the array.
@@ -44,7 +41,7 @@ size_t fiobj_ary_capa(fiobj_s *ary);
  * This pointer can be used for sorting and other direct access operations as
  * long as no other actions (insertion/deletion) are performed on the array.
  */
-fiobj_s **fiobj_ary2prt(fiobj_s *ary);
+FIOBJ *fiobj_ary2ptr(FIOBJ ary);
 
 /**
  * Returns a temporary object owned by the Array.
@@ -56,14 +53,14 @@ fiobj_s **fiobj_ary2prt(fiobj_s *ary);
  * Negative values are retrived from the end of the array. i.e., `-1`
  * is the last item.
  */
-fiobj_s *fiobj_ary_index(fiobj_s *ary, int64_t pos);
+FIOBJ fiobj_ary_index(FIOBJ ary, int64_t pos);
 /** alias for `fiobj_ary_index` */
 #define fiobj_ary_entry(a, p) fiobj_ary_index((a), (p))
 
 /**
  * Sets an object at the requested position.
  */
-void fiobj_ary_set(fiobj_s *ary, fiobj_s *obj, int64_t pos);
+void fiobj_ary_set(FIOBJ ary, FIOBJ obj, int64_t pos);
 
 /* *****************************************************************************
 Array push / shift API
@@ -72,19 +69,19 @@ Array push / shift API
 /**
  * Pushes an object to the end of the Array.
  */
-void fiobj_ary_push(fiobj_s *ary, fiobj_s *obj);
+void fiobj_ary_push(FIOBJ ary, FIOBJ obj);
 
 /** Pops an object from the end of the Array. */
-fiobj_s *fiobj_ary_pop(fiobj_s *ary);
+FIOBJ fiobj_ary_pop(FIOBJ ary);
 
 /**
  * Unshifts an object to the begining of the Array. This could be
  * expensive.
  */
-void fiobj_ary_unshift(fiobj_s *ary, fiobj_s *obj);
+void fiobj_ary_unshift(FIOBJ ary, FIOBJ obj);
 
 /** Shifts an object from the beginning of the Array. */
-fiobj_s *fiobj_ary_shift(fiobj_s *ary);
+FIOBJ fiobj_ary_shift(FIOBJ ary);
 
 /* *****************************************************************************
 Array compacting (untested)
@@ -97,7 +94,11 @@ Array compacting (untested)
  * This action is O(n) where n in the length of the array.
  * It could get expensive.
  */
-void fiobj_ary_compact(fiobj_s *ary);
+void fiobj_ary_compact(FIOBJ ary);
+
+#if DEBUG
+void fiobj_test_array(void);
+#endif
 
 #ifdef __cplusplus
 } /* extern "C" */

data/ext/iodine/fiobj_data.c

@@ -0,0 +1,1160 @@
+#if defined(__unix__) || defined(__APPLE__) || defined(__linux__) ||           \
+    defined(__CYGWIN__) /* require POSIX */
+/*
+Copyright: Boaz Segev, 2017-2018
+License: MIT
+*/
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+/**
+ * A dynamic type for reading / writing to a local file,  a temporary file or an
+ * in-memory string.
+ *
+ * Supports basic reak, write, seek, puts and gets operations.
+ *
+ * Writing is always performed at the end of the stream / memory buffer,
+ * ignoring the current seek position.
+ */
+#include "fiobj_data.h"
+#include "fio_tmpfile.h"
+#include "fiobj_str.h"
+
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#define FIO_OVERRIDE_MALLOC 1
+#include "fio_mem.h"
+
+/* *****************************************************************************
+Numbers Type
+***************************************************************************** */
+
+typedef struct {
+  fiobj_object_header_s head;
+  uint8_t *buffer; /* reader buffer */
+  union {
+    FIOBJ parent;
+    void (*dealloc)(void *); /* buffer deallocation function */
+    size_t fpos;             /* the file reader's position */
+  };
+  size_t capa; /* total buffer capacity / slice offset */
+  size_t len;  /* length of valid data in buffer */
+  size_t pos;  /* position of reader */
+  int fd;      /* file descriptor (-1 if invalid). */
+} fiobj_data_s;
+
+#define obj2io(o) ((fiobj_data_s *)(o))
+
+/* *****************************************************************************
+Object required VTable and functions
+***************************************************************************** */
+
+#define REQUIRE_MEM(mem)                                                       \
+  do {                                                                         \
+    if ((mem) == NULL) {                                                       \
+      perror("FATAL ERROR: fiobj IO couldn't allocate memory");                \
+      exit(errno);                                                             \
+    }                                                                          \
+  } while (0)
+
+static void fiobj_data_copy_buffer(FIOBJ o) {
+  obj2io(o)->capa = (((obj2io(o)->len) >> 12) + 1) << 12;
+  void *tmp = malloc(obj2io(o)->capa);
+  REQUIRE_MEM(tmp);
+  memcpy(tmp, obj2io(o)->buffer, obj2io(o)->len);
+  if (obj2io(o)->dealloc)
+    obj2io(o)->dealloc(obj2io(o)->buffer);
+  obj2io(o)->dealloc = free;
+  obj2io(o)->buffer = tmp;
+}
+
+static void fiobj_data_copy_parent(FIOBJ o) {
+  switch (obj2io(obj2io(o)->parent)->fd) {
+  case -1:
+    obj2io(o)->buffer = malloc(obj2io(o)->len + 1);
+    memcpy(obj2io(o)->buffer,
+           obj2io(obj2io(o)->parent)->buffer + obj2io(o)->capa, obj2io(o)->len);
+    obj2io(o)->buffer[obj2io(o)->len] = 0;
+    obj2io(o)->capa = obj2io(o)->len;
+    obj2io(o)->fd = -1;
+    fiobj_free(obj2io(o)->parent);
+    obj2io(o)->dealloc = free;
+    return;
+  default:
+    obj2io(o)->fd = fio_tmpfile();
+    if (obj2io(o)->fd < 0) {
+      perror("FATAL ERROR: (fiobj_data) can't create temporary file");
+      exit(errno);
+    }
+    fio_cstr_s data;
+    size_t pos = 0;
+    do {
+      ssize_t written;
+      data = fiobj_data_pread(obj2io(o)->parent, pos + obj2io(o)->capa, 4096);
+      if (data.len + pos > obj2io(o)->len)
+        data.len = obj2io(o)->len - pos;
+    retry_int:
+      written = write(obj2io(o)->fd, data.buffer, data.len);
+      if (written < 0) {
+        if (errno == EINTR)
+          goto retry_int;
+        perror("FATAL ERROR: (fiobj_data) can't write to temporary file");
+        exit(errno);
+      }
+      pos += written;
+    } while (data.len == 4096);
+    fiobj_free(obj2io(o)->parent);
+    obj2io(o)->capa = 0;
+    obj2io(o)->len = pos;
+    obj2io(o)->fpos = obj2io(o)->pos;
+    obj2io(o)->pos = 0;
+    obj2io(o)->buffer = NULL;
+    break;
+  }
+}
+
+static inline void fiobj_data_pre_write(FIOBJ o, uintptr_t length) {
+  switch (obj2io(o)->fd) {
+  case -1:
+    if (obj2io(o)->dealloc != free) {
+      fiobj_data_copy_buffer(o);
+    }
+    break;
+  case -2:
+    fiobj_data_copy_parent(o);
+    break;
+  }
+  if (obj2io(o)->capa >= obj2io(o)->len + length)
+    return;
+  /* add rounded pages (4096) to capacity */
+  obj2io(o)->capa = (((obj2io(o)->len + length) >> 12) + 1) << 12;
+  obj2io(o)->buffer = realloc(obj2io(o)->buffer, obj2io(o)->capa);
+  REQUIRE_MEM(obj2io(o)->buffer);
+}
+
+static inline int64_t fiobj_data_get_fd_size(const FIOBJ o) {
+  struct stat stat;
+retry:
+  if (fstat(obj2io(o)->fd, &stat)) {
+    if (errno == EINTR)
+      goto retry;
+    return -1;
+  }
+  return stat.st_size;
+}
+
+static FIOBJ fiobj_data_alloc(void *buffer, int fd) {
+  fiobj_data_s *io = malloc(sizeof(*io));
+  REQUIRE_MEM(io);
+  *io = (fiobj_data_s){
+      .head = {.ref = 1, .type = FIOBJ_T_DATA}, .buffer = buffer, .fd = fd,
+  };
+  return (FIOBJ)io;
+}
+
+static void fiobj_data_dealloc(FIOBJ o, void (*task)(FIOBJ, void *),
+                               void *arg) {
+  switch (obj2io(o)->fd) {
+  case -1:
+    if (obj2io(o)->dealloc && obj2io(o)->buffer)
+      obj2io(o)->dealloc(obj2io(o)->buffer);
+    break;
+  case -2:
+    fiobj_free(obj2io(o)->parent);
+    break;
+  default:
+    close(obj2io(o)->fd);
+    free(obj2io(o)->buffer);
+    break;
+  }
+  free((void *)o);
+  (void)task;
+  (void)arg;
+}
+
+static intptr_t fiobj_data_i(const FIOBJ o) {
+  switch (obj2io(o)->fd) {
+  case -1:
+  case -2:
+    return obj2io(o)->len;
+    break;
+  default:
+    return fiobj_data_get_fd_size(o);
+  }
+}
+
+static size_t fiobj_data_is_true(const FIOBJ o) { return fiobj_data_i(o) > 0; }
+
+static fio_cstr_s fio_io2str(const FIOBJ o) {
+  switch (obj2io(o)->fd) {
+  case -1:
+    return (fio_cstr_s){.buffer = obj2io(o)->buffer, .len = obj2io(o)->len};
+    break;
+  case -2:
+    return fiobj_data_pread(obj2io(o)->parent, obj2io(o)->capa, obj2io(o)->len);
+    break;
+  }
+  int64_t i = fiobj_data_get_fd_size(o);
+  if (i <= 0)
+    return (fio_cstr_s){.buffer = obj2io(o)->buffer, .len = obj2io(o)->len};
+  obj2io(o)->len = 0;
+  obj2io(o)->pos = 0;
+  fiobj_data_pre_write((FIOBJ)o, i + 1);
+  if (pread(obj2io(o)->fd, obj2io(o)->buffer, i, 0) != i)
+    return (fio_cstr_s){.buffer = NULL, .len = 0};
+  obj2io(o)->buffer[i] = 0;
+  return (fio_cstr_s){.buffer = obj2io(o)->buffer, .len = i};
+}
+
+static size_t fiobj_data_iseq(const FIOBJ self, const FIOBJ other) {
+  int64_t len;
+  return (
+      (len = fiobj_data_i(self)) == fiobj_data_i(other) &&
+      !memcmp(fio_io2str(self).buffer, fio_io2str(other).buffer, (size_t)len));
+}
+
+uintptr_t fiobject___noop_count(FIOBJ o);
+double fiobject___noop_to_f(FIOBJ o);
+
+const fiobj_object_vtable_s FIOBJECT_VTABLE_DATA = {
+    .class_name = "IO",
+    .dealloc = fiobj_data_dealloc,
+    .to_i = fiobj_data_i,
+    .to_str = fio_io2str,
+    .is_eq = fiobj_data_iseq,
+    .is_true = fiobj_data_is_true,
+    .to_f = fiobject___noop_to_f,
+    .count = fiobject___noop_count,
+};
+
+/* *****************************************************************************
+Seeking for characters in a string
+***************************************************************************** */
+
+#if FIO_MEMCHAR
+
+/**
+ * This seems to be faster on some systems, especially for smaller distances.
+ *
+ * On newer systems, `memchr` should be faster.
+ */
+static inline int swallow_ch(uint8_t **buffer, register uint8_t *const limit,
+                             const uint8_t c) {
+  if (**buffer == c)
+    return 1;
+
+#if !ALLOW_UNALIGNED_MEMORY_ACCESS || !defined(__x86_64__)
+  /* too short for this mess */
+  if ((uintptr_t)limit <= 16 + ((uintptr_t)*buffer & (~(uintptr_t)7)))
+    goto finish;
+
+  /* align memory */
+  {
+    const uint8_t *alignment =
+        (uint8_t *)(((uintptr_t)(*buffer) & (~(uintptr_t)7)) + 8);
+    if (limit >= alignment) {
+      while (*buffer < alignment) {
+        if (**buffer == c) {
+          (*buffer)++;
+          return 1;
+        }
+        *buffer += 1;
+      }
+    }
+  }
+  const uint8_t *limit64 = (uint8_t *)((uintptr_t)limit & (~(uintptr_t)7));
+#else
+  const uint8_t *limit64 = (uint8_t *)limit - 7;
+#endif
+  uint64_t wanted1 = 0x0101010101010101ULL * c;
+  for (; *buffer < limit64; *buffer += 8) {
+    const uint64_t eq1 = ~((*((uint64_t *)*buffer)) ^ wanted1);
+    const uint64_t t0 = (eq1 & 0x7f7f7f7f7f7f7f7fllu) + 0x0101010101010101llu;
+    const uint64_t t1 = (eq1 & 0x8080808080808080llu);
+    if ((t0 & t1)) {
+      break;
+    }
+  }
+#if !defined(__x86_64__)
+finish:
+#endif
+  while (*buffer < limit) {
+    if (**buffer == c) {
+      (*buffer)++;
+      return 1;
+    }
+    (*buffer)++;
+  }
+
+  return 0;
+}
+#else
+
+static inline int swallow_ch(uint8_t **buffer, uint8_t *const limit,
+                             const uint8_t c) {
+  if (limit - *buffer == 0)
+    return 0;
+  void *tmp = memchr(*buffer, c, limit - (*buffer));
+  if (tmp) {
+    *buffer = tmp;
+    (*buffer)++;
+    return 1;
+  }
+  *buffer = (uint8_t *)limit;
+  return 0;
+}
+
+#endif
+
+/* *****************************************************************************
+Creating the IO object
+***************************************************************************** */
+
+/** Creates a new local in-memory IO object */
+FIOBJ fiobj_data_newstr(void) {
+  FIOBJ o = fiobj_data_alloc(malloc(4096), -1);
+  REQUIRE_MEM(obj2io(o)->buffer);
+  obj2io(o)->capa = 4096;
+  obj2io(o)->dealloc = free;
+  return o;
+}
+
+/**
+ * Creates a IO object from an existing buffer. The buffer will be deallocated
+ * using the provided `dealloc` function pointer. Use a NULL `dealloc` function
+ * pointer if the buffer is static and shouldn't be freed.
+ */
+FIOBJ fiobj_data_newstr2(void *buffer, uintptr_t length,
+                         void (*dealloc)(void *)) {
+  FIOBJ o = fiobj_data_alloc(buffer, -1);
+  obj2io(o)->capa = length;
+  obj2io(o)->len = length;
+  obj2io(o)->dealloc = dealloc;
+  return o;
+}
+
+/** Creates a new local file IO object */
+FIOBJ fiobj_data_newfd(int fd) {
+  FIOBJ o = fiobj_data_alloc(malloc(4096), fd);
+  REQUIRE_MEM(obj2io(o)->buffer);
+  obj2io(o)->fpos = 0;
+  return o;
+}
+
+/** Creates a new local tempfile IO object */
+FIOBJ fiobj_data_newtmpfile(void) {
+  // create a temporary file to contain the data.
+  int fd = fio_tmpfile();
+  if (fd == -1)
+    return 0;
+  return fiobj_data_newfd(fd);
+}
+
+/** Creates a slice from an existing Data object. */
+FIOBJ fiobj_data_slice(FIOBJ parent, intptr_t offset, uintptr_t length) {
+  /* cut from the end */
+  if (offset < 0) {
+    size_t parent_len = fiobj_data_len(parent);
+    offset = parent_len + 1 + offset;
+  }
+  if (offset < 0)
+    offset = 0;
+  while (obj2io(parent)->fd == -2) {
+    /* don't slice a slice... climb the parent chain. */
+    offset += obj2io(parent)->capa;
+    parent = obj2io(parent)->parent;
+  }
+  size_t parent_len = fiobj_data_len(parent);
+  if (parent_len <= (size_t)offset) {
+    length = 0;
+    offset = parent_len;
+  } else if (parent_len < offset + length) {
+    length = parent_len - offset;
+  }
+  /* make the object */
+  FIOBJ o = fiobj_data_alloc(NULL, -2);
+  obj2io(o)->capa = offset;
+  obj2io(o)->len = length;
+  obj2io(o)->parent = fiobj_dup(parent);
+  return o;
+}
+
+/* *****************************************************************************
+Saving the IO object
+***************************************************************************** */
+
+static int fiobj_data_save_str(FIOBJ o, const char *filename) {
+  int target = open(filename, O_RDWR | O_CREAT | O_TRUNC, 0777);
+  if (target == -1)
+    return -1;
+  errno = 0;
+  size_t total = 0;
+  do {
+    ssize_t act =
+        write(target, obj2io(o)->buffer + total, obj2io(o)->len - total);
+    if (act < 0)
+      goto error;
+    total += act;
+  } while (total < obj2io(o)->len);
+  close(target);
+  return 0;
+error:
+  close(target);
+  unlink(filename);
+  return -1;
+}
+
+static int fiobj_data_save_file(FIOBJ o, const char *filename) {
+  int target = open(filename, O_RDWR | O_CREAT | O_TRUNC, 0777);
+  if (target == -1)
+    return -1;
+  errno = 0;
+  char buf[1024];
+  size_t total = 0;
+  do {
+    ssize_t act = pread(obj2io(o)->fd, buf, 1024, total);
+    if (act == 0)
+      break;
+    if (act < 0)
+      goto error;
+    ssize_t act2 = write(target, buf, act);
+    if (act2 < act)
+      goto error;
+    total += act2;
+  } while (1);
+  close(target);
+  return 0;
+error:
+  close(target);
+  unlink(filename);
+  return -1;
+}
+
+static int fiobj_data_save_slice(FIOBJ o, const char *filename) {
+  int target = open(filename, O_RDWR | O_CREAT | O_TRUNC, 0777);
+  if (target == -1)
+    return -1;
+  errno = 0;
+  fio_cstr_s tmp;
+  size_t total = 0;
+  do {
+    tmp = fiobj_data_pread(obj2io(o)->parent, obj2io(o)->capa + total, 4096);
+    if (tmp.len == 0)
+      break;
+    if (total + tmp.len > obj2io(o)->len)
+      tmp.len = obj2io(o)->len - total;
+    if (tmp.len) {
+      ssize_t act2 = write(target, tmp.data, tmp.len);
+      if (act2 < 0 || (size_t)act2 < tmp.len)
+        goto error;
+      total += act2;
+    }
+  } while (tmp.len == 4096);
+  close(target);
+  return 0;
+error:
+  close(target);
+  unlink(filename);
+  return -1;
+}
+
+/** Creates a new local file IO object */
+int fiobj_data_save(FIOBJ o, const char *filename) {
+  switch (obj2io(o)->fd) {
+  case -1:
+    return fiobj_data_save_str(o, filename);
+    break;
+  case -2:
+    return fiobj_data_save_slice(o, filename);
+    break;
+  default:
+    return fiobj_data_save_file(o, filename);
+  }
+}
+
+/* *****************************************************************************
+Reading API
+***************************************************************************** */
+
+/** Reads up to `length` bytes */
+static fio_cstr_s fiobj_data_read_str(FIOBJ io, intptr_t length) {
+  if (obj2io(io)->pos == obj2io(io)->len) {
+    /* EOF */
+    return (fio_cstr_s){.buffer = NULL, .len = 0};
+  }
+
+  if (length <= 0) {
+    /* read to EOF - length */
+    length = (obj2io(io)->len - obj2io(io)->pos) + length;
+  }
+
+  if (length <= 0) {
+    /* We are at EOF - length or beyond */
+    return (fio_cstr_s){.buffer = NULL, .len = 0};
+  }
+
+  /* reading length bytes */
+  register size_t pos = obj2io(io)->pos;
+  obj2io(io)->pos = pos + length;
+  if (obj2io(io)->pos > obj2io(io)->len)
+    obj2io(io)->pos = obj2io(io)->len;
+  return (fio_cstr_s){
+      .buffer = (obj2io(io)->buffer + pos), .length = (obj2io(io)->pos - pos),
+  };
+}
+
+/** Reads up to `length` bytes */
+static fio_cstr_s fiobj_data_read_slice(FIOBJ io, intptr_t length) {
+  if (obj2io(io)->pos == obj2io(io)->len) {
+    /* EOF */
+    return (fio_cstr_s){.buffer = NULL, .len = 0};
+  }
+  if (length <= 0) {
+    /* read to EOF - length */
+    length = (obj2io(io)->len - obj2io(io)->pos) + length;
+  }
+
+  if (length <= 0) {
+    /* We are at EOF - length or beyond */
+    return (fio_cstr_s){.buffer = NULL, .len = 0};
+  }
+  register size_t pos = obj2io(io)->pos;
+  obj2io(io)->pos = pos + length;
+  if (obj2io(io)->pos > obj2io(io)->len)
+    obj2io(io)->pos = obj2io(io)->len;
+  return fiobj_data_pread(obj2io(io)->parent, pos + obj2io(io)->capa,
+                          (obj2io(io)->pos - pos));
+}
+
+/** Reads up to `length` bytes */
+static fio_cstr_s fiobj_data_read_file(FIOBJ io, intptr_t length) {
+  uintptr_t fsize = fiobj_data_get_fd_size(io);
+
+  if (length <= 0) {
+    /* read to EOF - length */
+    length = (fsize - obj2io(io)->fpos) + length;
+  }
+
+  if (length <= 0) {
+    /* We are at EOF - length or beyond */
+    errno = 0;
+    return (fio_cstr_s){.buffer = NULL, .len = 0};
+  }
+
+  /* reading length bytes */
+  if (length + obj2io(io)->pos <= obj2io(io)->len) {
+    /* the data already exists in the buffer */
+    // fprintf(stderr, "in_buffer...\n");
+    fio_cstr_s data = {.buffer = (obj2io(io)->buffer + obj2io(io)->pos),
+                       .length = (uintptr_t)length};
+    obj2io(io)->pos += length;
+    obj2io(io)->fpos += length;
+    return data;
+  } else {
+    /* read the data into the buffer - internal counting gets invalidated */
+    // fprintf(stderr, "populate buffer...\n");
+    obj2io(io)->len = 0;
+    obj2io(io)->pos = 0;
+    fiobj_data_pre_write(io, length);
+    ssize_t l;
+  retry_int:
+    l = pread(obj2io(io)->fd, obj2io(io)->buffer, length, obj2io(io)->fpos);
+    if (l == -1 && errno == EINTR)
+      goto retry_int;
+    if (l == -1 || l == 0)
+      return (fio_cstr_s){.buffer = NULL, .len = 0};
+    obj2io(io)->fpos += l;
+    return (fio_cstr_s){.buffer = obj2io(io)->buffer, .len = l};
+  }
+}
+
+/**
+ * Reads up to `length` bytes and returns a temporary(!) C string object.
+ *
+ * The C string object will be invalidate the next time a function call to the
+ * IO object is made.
+ */
+fio_cstr_s fiobj_data_read(FIOBJ io, intptr_t length) {
+  if (!io || !FIOBJ_TYPE_IS(io, FIOBJ_T_DATA)) {
+    errno = EFAULT;
+    return (fio_cstr_s){.buffer = NULL, .len = 0};
+  }
+  errno = 0;
+  switch (obj2io(io)->fd) {
+  case -1:
+    return fiobj_data_read_str(io, length);
+    break;
+  case -2:
+    return fiobj_data_read_slice(io, length);
+    break;
+  default:
+    return fiobj_data_read_file(io, length);
+  }
+}
+
+/* *****************************************************************************
+Tokenize (read2ch)
+***************************************************************************** */
+
+static fio_cstr_s fiobj_data_read2ch_str(FIOBJ io, uint8_t token) {
+  if (obj2io(io)->pos == obj2io(io)->len) /* EOF */
+    return (fio_cstr_s){.buffer = NULL, .len = 0};
+
+  uint8_t *pos = obj2io(io)->buffer + obj2io(io)->pos;
+  uint8_t *lim = obj2io(io)->buffer + obj2io(io)->len;
+  swallow_ch(&pos, lim, token);
+  fio_cstr_s ret = (fio_cstr_s){
+      .buffer = obj2io(io)->buffer + obj2io(io)->pos,
+      .length = (uintptr_t)(pos - obj2io(io)->buffer) - obj2io(io)->pos,
+  };
+  obj2io(io)->pos = (uintptr_t)(pos - obj2io(io)->buffer);
+  return ret;
+}
+
+static fio_cstr_s fiobj_data_read2ch_slice(FIOBJ io, uint8_t token) {
+  if (obj2io(io)->pos == obj2io(io)->len) /* EOF */
+    return (fio_cstr_s){.buffer = NULL, .len = 0};
+  size_t old_pos = obj2io(obj2io(io)->parent)->pos;
+  obj2io(obj2io(io)->parent)->pos = obj2io(io)->capa + obj2io(io)->pos;
+  fio_cstr_s tmp = fiobj_data_read2ch(obj2io(io)->parent, token);
+  obj2io(obj2io(io)->parent)->pos = old_pos;
+  if (tmp.len + obj2io(io)->pos > obj2io(io)->len) {
+    /* EOF */
+    tmp.len = obj2io(io)->len - obj2io(io)->pos;
+    obj2io(io)->pos = obj2io(io)->len;
+    return tmp;
+  }
+  return tmp;
+}
+
+static fio_cstr_s fiobj_data_read2ch_file(FIOBJ io, uint8_t token) {
+  uint8_t *pos = obj2io(io)->buffer + obj2io(io)->pos;
+  uint8_t *lim = obj2io(io)->buffer + obj2io(io)->len;
+  if (pos != lim && swallow_ch(&pos, lim, token)) {
+    /* newline found in existing buffer */
+    const uintptr_t delta =
+        (uintptr_t)(pos - (obj2io(io)->buffer + obj2io(io)->pos));
+    obj2io(io)->pos += delta;
+    obj2io(io)->fpos += delta;
+    return (fio_cstr_s){
+        .buffer =
+            (delta ? ((obj2io(io)->buffer + obj2io(io)->pos) - delta) : NULL),
+        .length = delta,
+    };
+  }
+
+  obj2io(io)->pos = 0;
+  obj2io(io)->len = 0;
+
+  while (1) {
+    ssize_t tmp;
+    fiobj_data_pre_write(io, 4096); /* read a page at a time */
+  retry_int:
+    tmp = pread(obj2io(io)->fd, obj2io(io)->buffer + obj2io(io)->len, 4096,
+                obj2io(io)->fpos + obj2io(io)->len);
+    if (tmp < 0 && errno == EINTR)
+      goto retry_int;
+    if (tmp < 0 || (tmp == 0 && obj2io(io)->len == 0)) {
+      return (fio_cstr_s){.buffer = NULL, .len = 0};
+    }
+    if (tmp == 0) {
+      obj2io(io)->fpos += obj2io(io)->len;
+      return (fio_cstr_s){.buffer = obj2io(io)->buffer, .len = obj2io(io)->len};
+    }
+    obj2io(io)->len += tmp;
+    pos = obj2io(io)->buffer;
+    lim = obj2io(io)->buffer + obj2io(io)->len;
+    if (swallow_ch(&pos, lim, token)) {
+      const uintptr_t delta =
+          (uintptr_t)(pos - (obj2io(io)->buffer + obj2io(io)->pos));
+      obj2io(io)->pos = delta;
+      obj2io(io)->fpos += delta;
+      return (fio_cstr_s){
+          .buffer = obj2io(io)->buffer, .length = delta,
+      };
+    }
+  }
+}
+
+/**
+ * Reads until the `token` byte is encountered or until the end of the stream.
+ *
+ * Returns a temporary(!) C string including the end of line marker.
+ *
+ * Careful when using this call on large file streams, as the whole file
+ * stream might be loaded into the memory.
+ *
+ * The C string object will be invalidate the next time a function call to the
+ * IO object is made.
+ */
+fio_cstr_s fiobj_data_read2ch(FIOBJ io, uint8_t token) {
+  if (!io || !FIOBJ_TYPE_IS(io, FIOBJ_T_DATA)) {
+    errno = EFAULT;
+    return (fio_cstr_s){.buffer = NULL, .len = 0};
+  }
+  switch (obj2io(io)->fd) {
+  case -1:
+    return fiobj_data_read2ch_str(io, token);
+    break;
+  case -2:
+    return fiobj_data_read2ch_slice(io, token);
+    break;
+  default:
+    return fiobj_data_read2ch_file(io, token);
+  }
+}
+
+/* *****************************************************************************
+Position / Seeking
+***************************************************************************** */
+
+/**
+ * Returns the current reading position.
+ */
+intptr_t fiobj_data_pos(FIOBJ io) {
+  if (!io || !FIOBJ_TYPE_IS(io, FIOBJ_T_DATA))
+    return -1;
+  switch (obj2io(io)->fd) {
+  case -1: /* fallthrough */
+  case -2:
+    return obj2io(io)->pos;
+    break;
+  default:
+    return obj2io(io)->fpos;
+  }
+}
+
+/**
+ * Returns the length of the stream.
+ */
+intptr_t fiobj_data_len(FIOBJ io) {
+  if (!io || !FIOBJ_TYPE_IS(io, FIOBJ_T_DATA))
+    return -1;
+  return fiobj_data_i(io);
+}
+
+/**
+ * Moves the reading position to the requested position.
+ */
+void fiobj_data_seek(FIOBJ io, intptr_t position) {
+  if (!io || !FIOBJ_TYPE_IS(io, FIOBJ_T_DATA))
+    return;
+  switch (obj2io(io)->fd) {
+  case -1: /* fallthrough */
+  case -2:
+    /* String / Slice code */
+    if (position == 0) {
+      obj2io(io)->pos = 0;
+      return;
+    }
+    if (position > 0) {
+      if ((uintptr_t)position > obj2io(io)->len)
+        position = obj2io(io)->len;
+      obj2io(io)->pos = position;
+      return;
+    }
+    position = (0 - position);
+    if ((uintptr_t)position > obj2io(io)->len)
+      position = 0;
+    else
+      position = obj2io(io)->len - position;
+    obj2io(io)->pos = position;
+    return;
+    break;
+  default:
+    /* File code */
+    obj2io(io)->pos = 0;
+    obj2io(io)->len = 0;
+
+    if (position == 0) {
+      obj2io(io)->fpos = 0;
+      return;
+    }
+    int64_t len = fiobj_data_get_fd_size(io);
+    if (len < 0)
+      len = 0;
+    if (position > 0) {
+      if (position > len)
+        position = len;
+
+      obj2io(io)->fpos = position;
+      return;
+    }
+    position = (0 - position);
+    if (position > len)
+      position = 0;
+    else
+      position = len - position;
+    obj2io(io)->fpos = position;
+    return;
+  }
+}
+
+/* *****************************************************************************
+`fiobj_data_pread`
+***************************************************************************** */
+// switch(obj2io(o)->fd) {
+//   case -1:
+//   break;
+//   case -2:
+//   break;
+//   default:
+// }
+
+static fio_cstr_s fiobj_data_pread_str(FIOBJ io, intptr_t start_at,
+                                       uintptr_t length) {
+  if (start_at < 0)
+    start_at = obj2io(io)->len + start_at;
+  if (start_at < 0)
+    start_at = 0;
+  if ((size_t)start_at > obj2io(io)->len)
+    start_at = obj2io(io)->len;
+  if (length + start_at > obj2io(io)->len)
+    length = obj2io(io)->len - start_at;
+  if (length == 0)
+    return (fio_cstr_s){
+        .buffer = NULL, .length = 0,
+    };
+  return (fio_cstr_s){
+      .buffer = obj2io(io)->buffer + start_at, .length = length,
+  };
+}
+static fio_cstr_s fiobj_data_pread_slice(FIOBJ io, intptr_t start_at,
+                                         uintptr_t length) {
+  if (start_at < 0)
+    start_at = obj2io(io)->len + start_at;
+  if (start_at < 0)
+    start_at = 0;
+  if ((size_t)start_at > obj2io(io)->len)
+    start_at = obj2io(io)->len;
+  if (length + start_at > obj2io(io)->len)
+    length = obj2io(io)->len - start_at;
+  if (length == 0)
+    return (fio_cstr_s){
+        .buffer = NULL, .length = 0,
+    };
+  return fiobj_data_pread(obj2io(io)->parent, start_at, length);
+}
+
+static fio_cstr_s fiobj_data_pread_file(FIOBJ io, intptr_t start_at,
+                                        uintptr_t length) {
+  const int64_t size = fiobj_data_get_fd_size(io);
+  if (start_at < 0)
+    start_at = size + start_at;
+  if (start_at < 0)
+    start_at = 0;
+  if (length + start_at > (uint64_t)size)
+    length = size - start_at;
+  if (length == 0)
+    return (fio_cstr_s){
+        .buffer = NULL, .length = 0,
+    };
+  obj2io(io)->len = 0;
+  obj2io(io)->pos = 0;
+  fiobj_data_pre_write(io, length + 1);
+  ssize_t tmp = pread(obj2io(io)->fd, obj2io(io)->buffer, length, start_at);
+  if (tmp <= 0) {
+    return (fio_cstr_s){
+        .buffer = NULL, .length = 0,
+    };
+  }
+  obj2io(io)->buffer[tmp] = 0;
+  return (fio_cstr_s){
+      .buffer = obj2io(io)->buffer, .length = tmp,
+  };
+}
+/**
+ * Reads up to `length` bytes starting at `start_at` position and returns a
+ * temporary(!) C string object. The reading position is ignored and
+ * unchanged.
+ *
+ * The C string object will be invalidate the next time a function call to the
+ * IO object is made.
+ */
+fio_cstr_s fiobj_data_pread(FIOBJ io, intptr_t start_at, uintptr_t length) {
+  if (!io || !FIOBJ_TYPE_IS(io, FIOBJ_T_DATA)) {
+    errno = EFAULT;
+    return (fio_cstr_s){
+        .buffer = NULL, .length = 0,
+    };
+  }
+
+  errno = 0;
+  switch (obj2io(io)->fd) {
+  case -1:
+    return fiobj_data_pread_str(io, start_at, length);
+    break;
+  case -2:
+    return fiobj_data_pread_slice(io, start_at, length);
+    break;
+  default:
+    return fiobj_data_pread_file(io, start_at, length);
+  }
+}
+
+/* *****************************************************************************
+Writing API
+***************************************************************************** */
+
+/**
+ * Makes sure the IO object isn't attached to a static or external string.
+ *
+ * If the IO object is attached to a static or external string, the data will be
+ * copied to a new memory block.
+ */
+void fiobj_data_assert_dynamic(FIOBJ io) {
+  if (!io) {
+    errno = ENFILE;
+    return;
+  }
+  assert(FIOBJ_TYPE(io) == FIOBJ_T_DATA);
+  fiobj_data_pre_write(io, 0);
+  return;
+}
+
+/**
+ * Writes `length` bytes at the end of the IO stream, ignoring the reading
+ * position.
+ *
+ * Behaves and returns the same value as the system call `write`.
+ */
+intptr_t fiobj_data_write(FIOBJ io, void *buffer, uintptr_t length) {
+  if (!io || !FIOBJ_TYPE_IS(io, FIOBJ_T_DATA) || (!buffer && length)) {
+    errno = EFAULT;
+    return -1;
+  }
+  errno = 0;
+  /* Unslice slices */
+  if (obj2io(io)->fd == -2)
+    fiobj_data_assert_dynamic(io);
+
+  if (obj2io(io)->fd == -1) {
+    /* String Code */
+    fiobj_data_pre_write(io, length + 1);
+    memcpy(obj2io(io)->buffer + obj2io(io)->len, buffer, length);
+    obj2io(io)->len = obj2io(io)->len + length;
+    obj2io(io)->buffer[obj2io(io)->len] = 0;
+    return length;
+  }
+
+  /* File Code */
+  return pwrite(obj2io(io)->fd, buffer, length, fiobj_data_get_fd_size(io));
+}
+
+/**
+ * Writes `length` bytes at the end of the IO stream, ignoring the reading
+ * position, adding an EOL marker ("\r\n") to the end of the stream.
+ *
+ * Behaves and returns the same value as the system call `write`.
+ */
+intptr_t fiobj_data_puts(FIOBJ io, void *buffer, uintptr_t length) {
+  if (!io || !FIOBJ_TYPE_IS(io, FIOBJ_T_DATA) || (!buffer && length)) {
+    errno = EFAULT;
+    return -1;
+  }
+  /* Unslice slices */
+  if (obj2io(io)->fd == -2)
+    fiobj_data_assert_dynamic(io);
+
+  if (obj2io(io)->fd == -1) {
+    /* String Code */
+    fiobj_data_pre_write(io, length + 2);
+    if (length) {
+      memcpy(obj2io(io)->buffer + obj2io(io)->len, buffer, length);
+    }
+    obj2io(io)->len = obj2io(io)->len + length + 2;
+    obj2io(io)->buffer[obj2io(io)->len - 2] = '\r';
+    obj2io(io)->buffer[obj2io(io)->len - 1] = '\n';
+    return length + 2;
+  }
+  /* File Code */
+  uintptr_t end = fiobj_data_get_fd_size(io);
+  ssize_t t1 = 0, t2 = 0;
+
+  if (length) {
+    t1 = pwrite(obj2io(io)->fd, buffer, length, end);
+    if (t1 < 0)
+      return t1;
+    end += t1;
+  }
+  t2 = pwrite(obj2io(io)->fd, buffer, length, end);
+  if (t2 < 0)
+    return t1;
+  return t1 + t2;
+}
+
+#if DEBUG
+
+void fiobj_data_test(void) {
+  char *filename = NULL;
+  FIOBJ text;
+  fio_cstr_s s1, s2;
+  fprintf(stderr, "=== testing fiobj_data\n");
+  if (filename)
+    text = fiobj_str_readfile(filename, 0, 0);
+  else
+    text = fiobj_str_static("Line 1\r\nLine 2\nLine 3 unended", 29);
+  FIOBJ strio = fiobj_data_newstr();
+  fprintf(stderr, "* `newstr` passed.\n");
+  FIOBJ fdio = fiobj_data_newtmpfile();
+  fprintf(stderr, "* `newtmpfile` passed.\n");
+  fiobj_data_write(fdio, fiobj_obj2cstr(text).buffer,
+                   fiobj_obj2cstr(text).length);
+  fiobj_data_write(strio, fiobj_obj2cstr(text).buffer,
+                   fiobj_obj2cstr(text).length);
+  FIOBJ sliceio = fiobj_data_slice(fdio, 8, 7);
+
+  s1 = fiobj_data_read(sliceio, 4096);
+  if (s1.len != 7 || memcmp(s1.data, fiobj_data_pread(strio, 8, 7).data, 7)) {
+    fprintf(stderr, "* `fiobj_data_slice` operation FAILED!\n");
+    fprintf(stderr, "* `fiobj_data_slice` s1.len = %zu s1.data = %s!\n", s1.len,
+            s1.data);
+    exit(-1);
+  }
+  s1 = fiobj_data_read(sliceio, 4096);
+  if (s1.len || s1.data) {
+    fprintf(stderr, "* `fiobj_data_read` operation overflow - FAILED!\n");
+    exit(-1);
+  }
+
+  if (fiobj_obj2cstr(strio).length != fiobj_obj2cstr(text).length ||
+      fiobj_obj2cstr(fdio).length != fiobj_obj2cstr(text).length) {
+    fprintf(stderr, "* `write` operation FAILED!\n");
+    exit(-1);
+  }
+  s1 = fiobj_data_gets(strio);
+  s2 = fiobj_data_gets(fdio);
+  fprintf(stderr, "str(%d): %.*s", (int)s1.len, (int)s1.len, s1.data);
+  fprintf(stderr, "fd(%d): %.*s", (int)s2.len, (int)s2.len, s2.data);
+  if (s1.length != s2.length || memcmp(s1.data, s2.data, s1.length)) {
+    fprintf(stderr,
+            "* `gets` operation FAILED! (non equal data):\n"
+            "%d bytes vs. %d bytes\n"
+            "%.*s vs %.*s\n",
+            (int)s1.len, (int)s2.len, (int)s1.len, s1.data, (int)s2.len,
+            s2.data);
+    exit(-1);
+  } else
+    fprintf(stderr, "* `gets` operation passed (equal data).\n");
+
+  if (!filename) {
+    intptr_t last_pos = fiobj_data_pos(fdio);
+    fiobj_data_seek(sliceio, 0);
+    s1 = fiobj_data_gets(sliceio);
+    s2 = fiobj_data_gets(fdio);
+    fiobj_data_seek(fdio, last_pos);
+    if (s1.length != s2.length || memcmp(s1.data, s2.data, s1.length)) {
+      fprintf(stderr,
+              "* slice `gets` operation FAILED! (non equal data):\n"
+              "%d bytes vs. %d bytes\n"
+              "%.*s vs %.*s\n",
+              (int)s1.len, (int)s2.len, (int)s1.len, s1.data, (int)s2.len,
+              s2.data);
+      exit(-1);
+    }
+  }
+
+  s1 = fiobj_data_read(strio, 3);
+  s2 = fiobj_data_read(fdio, 3);
+  if (s1.length != s2.length || memcmp(s1.data, s2.data, s1.length)) {
+    fprintf(stderr,
+            "* `read` operation FAILED! (non equal data):\n"
+            "%d bytes vs. %d bytes\n"
+            "%.*s vs %.*s\n",
+            (int)s1.len, (int)s2.len, (int)s1.len, s1.data, (int)s2.len,
+            s2.data);
+    exit(-1);
+  } else
+    fprintf(stderr, "* `read` operation passed (equal data).\n");
+  if (!filename) {
+    s1 = fiobj_data_gets(strio);
+    s2 = fiobj_data_gets(fdio);
+    s1 = fiobj_data_gets(strio);
+    s2 = fiobj_data_gets(fdio);
+    if (s1.length != s2.length || memcmp(s1.data, s2.data, s1.length)) {
+      fprintf(stderr,
+              "* EOF `gets` operation FAILED! (non equal data):\n"
+              "%d bytes vs. %d bytes\n"
+              "%.*s vs %.*s\n",
+              (int)s1.len, (int)s2.len, (int)s1.len, s1.data, (int)s2.len,
+              s2.data);
+      exit(-1);
+    } else
+      fprintf(stderr, "* EOF `gets` operation passed (equal data).\n");
+    s1 = fiobj_data_gets(strio);
+    s2 = fiobj_data_gets(fdio);
+    if (s1.data || s2.data) {
+      fprintf(stderr,
+              "* EOF `gets` was not EOF?!\n"
+              "str(%d): %.*s\n"
+              "fd(%d): %.*s\n",
+              (int)s1.len, (int)s1.len, s1.data, (int)s2.len, (int)s2.len,
+              s2.data);
+      exit(-1);
+    }
+  }
+  fiobj_free(text);
+  fiobj_free(strio);
+  fiobj_free(fdio);
+
+  {
+    fiobj_data_seek(sliceio, 0);
+    s1 = fiobj_data_read(sliceio, 4096);
+    if (s1.len != (size_t)fiobj_data_len(sliceio) || !s1.data) {
+      fprintf(stderr, "* `fiobj_data_slice` data lost? FAILED!\n");
+      fprintf(stderr,
+              "* `fiobj_data_slice` s1.len = %zu (out of %zu) s1.data = %s!\n",
+              s1.len, (size_t)fiobj_data_len(sliceio), s1.data);
+      exit(-1);
+    }
+    size_t old_len = fiobj_data_len(sliceio);
+    fiobj_data_write(sliceio, "hi", 2);
+    fiobj_data_seek(sliceio, 0);
+    s1 = fiobj_data_read(sliceio, 4096);
+    if (s1.len != old_len + 2 || !s1.data || s1.data[s1.len - 1] != 'i') {
+      fprintf(stderr, "* `fiobj_data_write` for Slice data lost? FAILED!\n");
+      fprintf(stderr,
+              "* `fiobj_data_slice` s1.len = %zu (out of %zu) s1.data = %s!\n",
+              s1.len, (size_t)fiobj_data_len(sliceio), s1.data);
+      exit(-1);
+    }
+  }
+  fiobj_free(sliceio);
+
+  fprintf(stderr, "* passed.\n");
+}
+
+#endif
+
+#else /* require POSIX */
+#include "fiobj_data.h"
+
+/** Creates a new local in-memory IO object */
+FIOBJ fiobj_data_newstr(void) { return FIOBJ_INVALID; }
+
+/**
+ * Creates a IO object from an existing buffer. The buffer will be deallocated
+ * using the provided `dealloc` function pointer. Use a NULL `dealloc` function
+ * pointer if the buffer is static and shouldn't be freed.
+ */
+FIOBJ fiobj_data_newstr2(void *buffer, uintptr_t length,
+                         void (*dealloc)(void *)) {
+  return FIOBJ_INVALID;
+}
+
+/** Creates a new local tempfile IO object */
+FIOBJ fiobj_data_newtmpfile(void) { return FIOBJ_INVALID; }
+
+/** Creates a new local file IO object */
+FIOBJ fiobj_data_newfd(int fd) { return FIOBJ_INVALID; }
+
+int fiobj_data_save(FIOBJ io, const char *filename) { return -1; }
+
+#endif /* require POSIX */