iodine 0.7.3 → 0.7.4

data/ext/iodine/fio_cli.c

@@ -28,11 +28,11 @@ typedef struct {
 #define FIO_SET_KEY_COMPARE(o1, o2)                                            \
   (o1.len == o2.len &&                                                         \
    (o1.data == o2.data || !memcmp(o1.data, o2.data, o1.len)))
-#define FIO_SET_NAME fio_hash
+#define FIO_SET_NAME fio_cli_hash
 #include <fio.h>
 
-static fio_hash_s fio_aliases = FIO_SET_INIT;
-static fio_hash_s fio_values = FIO_SET_INIT;
+static fio_cli_hash_s fio_aliases = FIO_SET_INIT;
+static fio_cli_hash_s fio_values = FIO_SET_INIT;
 static size_t fio_unknown_count = 0;
 
 typedef struct {
@@ -63,7 +63,8 @@ static void fio_cli_map_line2alias(char const *line) {
       ++n.len;
     }
     const char *old = NULL;
-    fio_hash_insert(&fio_aliases, FIO_CLI_HASH_VAL(n), n, (void *)line, &old);
+    fio_cli_hash_insert(&fio_aliases, FIO_CLI_HASH_VAL(n), n, (void *)line,
+                        &old);
     if (old) {
       FIO_LOG_WARNING("CLI argument name conflict detected\n"
                       "         The following two directives conflict:\n"
@@ -122,7 +123,7 @@ static void fio_cli_set_arg(cstr_s arg, char const *value, char const *line,
       goto print_help;
     }
     cstr_s n = {.len = ++parser->unknown_count};
-    fio_hash_insert(&fio_values, n.len, n, value, NULL);
+    fio_cli_hash_insert(&fio_values, n.len, n, value, NULL);
     if (!parser->allow_unknown) {
       arg.len = 0;
       goto error;
@@ -170,7 +171,7 @@ static void fio_cli_set_arg(cstr_s arg, char const *value, char const *line,
       while (n.data[n.len] && n.data[n.len] != ' ' && n.data[n.len] != ',') {
         ++n.len;
       }
-      fio_hash_insert(&fio_values, FIO_CLI_HASH_VAL(n), n, value, NULL);
+      fio_cli_hash_insert(&fio_values, FIO_CLI_HASH_VAL(n), n, value, NULL);
       while (n.data[n.len] && (n.data[n.len] == ' ' || n.data[n.len] == ',')) {
         ++n.len;
       }
@@ -295,7 +296,7 @@ void fio_cli_start AVOID_MACRO(int argc, char const *argv[], int allow_unknown,
       .pos = 0,
   };
 
-  if (fio_hash_count(&fio_values)) {
+  if (fio_cli_hash_count(&fio_values)) {
     fio_cli_end();
   }
 
@@ -324,7 +325,7 @@ void fio_cli_start AVOID_MACRO(int argc, char const *argv[], int allow_unknown,
     }
     const char *l = NULL;
     while (n.len &&
-           !(l = fio_hash_find(&fio_aliases, FIO_CLI_HASH_VAL(n), n))) {
+           !(l = fio_cli_hash_find(&fio_aliases, FIO_CLI_HASH_VAL(n), n))) {
       --n.len;
       value = n.data + n.len;
     }
@@ -336,13 +337,13 @@ void fio_cli_start AVOID_MACRO(int argc, char const *argv[], int allow_unknown,
   }
 
   /* Cleanup and save state for API */
-  fio_hash_free(&fio_aliases);
+  fio_cli_hash_free(&fio_aliases);
   fio_unknown_count = parser.unknown_count;
 }
 
 void fio_cli_end(void) {
-  fio_hash_free(&fio_values);
-  fio_hash_free(&fio_aliases);
+  fio_cli_hash_free(&fio_values);
+  fio_cli_hash_free(&fio_aliases);
   fio_unknown_count = 0;
 }
 /* *****************************************************************************
@@ -352,10 +353,10 @@ CLI Data Access
 /** Returns the argument's value as a NUL terminated C String. */
 char const *fio_cli_get(char const *name) {
   cstr_s n = {.data = name, .len = strlen(name)};
-  if (!fio_hash_count(&fio_values)) {
+  if (!fio_cli_hash_count(&fio_values)) {
     return NULL;
   }
-  return fio_hash_find(&fio_values, FIO_CLI_HASH_VAL(n), n);
+  return fio_cli_hash_find(&fio_values, FIO_CLI_HASH_VAL(n), n);
 }
 
 /** Returns the argument's value as an integer. */
@@ -388,11 +389,11 @@ unsigned int fio_cli_unknown_count(void) {
 
 /** Returns the unrecognized argument using a 0 based `index`. */
 char const *fio_cli_unknown(unsigned int index) {
-  if (!fio_hash_count(&fio_values) || !fio_unknown_count) {
+  if (!fio_cli_hash_count(&fio_values) || !fio_unknown_count) {
     return NULL;
   }
   cstr_s n = {.data = NULL, .len = index + 1};
-  return fio_hash_find(&fio_values, index + 1, n);
+  return fio_cli_hash_find(&fio_values, index + 1, n);
 }
 
 /**
@@ -403,5 +404,5 @@ char const *fio_cli_unknown(unsigned int index) {
  */
 void fio_cli_set(char const *name, char const *value) {
   cstr_s n = (cstr_s){.data = name, .len = strlen(name)};
-  fio_hash_insert(&fio_values, FIO_CLI_HASH_VAL(n), n, value, NULL);
+  fio_cli_hash_insert(&fio_values, FIO_CLI_HASH_VAL(n), n, value, NULL);
 }

data/ext/iodine/fio_json_parser.h

@@ -275,6 +275,30 @@ static inline int seek2eos(uint8_t **buffer,
   return 0;
 }
 
+/* *****************************************************************************
+JSON String to Numeral Helpers - allowing for stand-alone mode
+***************************************************************************** */
+
+#ifndef H_FACIL_IO_H /* defined in fio.h */
+
+/**
+ * We include this in case the parser is used outside of facil.io.
+ */
+int64_t __attribute__((weak)) fio_atol(char **pstr) {
+  return strtoll((char *)*pstr, (char **)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((char *)*pstr, (char **)pstr);
+}
+#pragma weak fio_atof
+
+#endif
+
 /* *****************************************************************************
 JSON Consumption (astract parsing)
 ***************************************************************************** */
@@ -425,12 +449,13 @@ fio_json_parse(json_parser_s *parser, const char *buffer, size_t length) {
     case 'i': /* overflow */
     case 'I': /* overflow */
     numeral : {
-      uint8_t *tmp = NULL;
-      long long i = strtoll((char *)pos, (char **)&tmp, 0);
+      uint8_t *tmp = pos;
+      long long i = fio_atol((char **)&tmp);
       if (tmp > limit)
         goto stop;
       if (!tmp || JSON_NUMERAL[*tmp]) {
-        double f = strtod((char *)pos, (char **)&tmp);
+        tmp = pos;
+        double f = fio_atof((char **)&tmp);
         if (tmp > limit)
           goto stop;
         if (!tmp || JSON_NUMERAL[*tmp])

data/ext/iodine/fiobj_ary.c

@@ -2,32 +2,25 @@
 Copyright: Boaz Segev, 2017-2018
 License: MIT
 */
-
-#define FIO_OVERRIDE_MALLOC 1
 #include <fio.h>
 #include <fiobject.h>
 
+#define FIO_ARY_NAME fio_ary__
 #define FIO_ARY_TYPE FIOBJ
 #define FIO_ARY_TYPE_INVALID FIOBJ_INVALID
 #define FIO_ARY_TYPE_COMPARE(a, b) (fiobj_iseq((a), (b)))
-#include <fio_ary.h>
+#define FIO_ARY_INVALID FIOBJ_INVALID
+#include <fio.h>
 
 #include <assert.h>
 
-#ifndef FIOBJ_ARRAY_DEFAULT_CAPA
-#define FIOBJ_ARRAY_DEFAULT_CAPA 8
-#endif
-#ifndef FIOBJ_ARRAY_DEFAULT_OFFSET
-#define FIOBJ_ARRAY_DEFAULT_OFFSET (FIOBJ_ARRAY_DEFAULT_CAPA >> 2)
-#endif
-
 /* *****************************************************************************
 Array Type
 ***************************************************************************** */
 
 typedef struct {
   fiobj_object_header_s head;
-  fio_ary_s ary;
+  fio_ary___s ary;
 } fiobj_ary_s;
 
 #define obj2ary(o) ((fiobj_ary_s *)(o))
@@ -37,20 +30,20 @@ VTable
 ***************************************************************************** */
 
 static void fiobj_ary_dealloc(FIOBJ o, void (*task)(FIOBJ, void *), void *arg) {
-  FIO_ARY_FOR(&obj2ary(o)->ary, i) { task(i.obj, arg); }
-  fio_ary_free(&obj2ary(o)->ary);
-  free(FIOBJ2PTR(o));
+  FIO_ARY_FOR((&obj2ary(o)->ary), i) { task(*i, arg); }
+  fio_ary___free(&obj2ary(o)->ary);
+  fio_free(FIOBJ2PTR(o));
 }
 
 static size_t fiobj_ary_each1(FIOBJ o, size_t start_at,
                               int (*task)(FIOBJ obj, void *arg), void *arg) {
-  return fio_ary_each(&obj2ary(o)->ary, start_at, task, arg);
+  return fio_ary___each(&obj2ary(o)->ary, start_at, task, arg);
 }
 
 static size_t fiobj_ary_is_eq(const FIOBJ self, const FIOBJ other) {
-  fio_ary_s *a = &obj2ary(self)->ary;
-  fio_ary_s *b = &obj2ary(other)->ary;
-  if (fio_ary_count(a) != fio_ary_count(b))
+  fio_ary___s *a = &obj2ary(self)->ary;
+  fio_ary___s *b = &obj2ary(other)->ary;
+  if (fio_ary___count(a) != fio_ary___count(b))
     return 0;
   return 1;
 }
@@ -58,7 +51,7 @@ static size_t fiobj_ary_is_eq(const FIOBJ self, const FIOBJ other) {
 /** Returns the number of elements in the Array. */
 size_t fiobj_ary_count(const FIOBJ ary) {
   assert(FIOBJ_TYPE_IS(ary, FIOBJ_T_ARRAY));
-  return fio_ary_count(&obj2ary(ary)->ary);
+  return fio_ary___count(&obj2ary(ary)->ary);
 }
 
 static size_t fiobj_ary_is_true(const FIOBJ ary) {
@@ -85,8 +78,8 @@ const fiobj_object_vtable_s FIOBJECT_VTABLE_ARRAY = {
 Allocation
 ***************************************************************************** */
 
-static FIOBJ fiobj_ary_alloc(size_t capa, size_t start_at) {
-  fiobj_ary_s *ary = malloc(sizeof(*ary));
+static inline FIOBJ fiobj_ary_alloc(size_t capa) {
+  fiobj_ary_s *ary = fio_malloc(sizeof(*ary));
   if (!ary) {
     perror("ERROR: fiobj array couldn't allocate memory");
     exit(errno);
@@ -98,17 +91,15 @@ static FIOBJ fiobj_ary_alloc(size_t capa, size_t start_at) {
               .type = FIOBJ_T_ARRAY,
           },
   };
-  fio_ary_new(&ary->ary, capa);
-  ary->ary.start = ary->ary.end = start_at;
+  if (capa)
+    fio_ary_____require_on_top(&ary->ary, capa);
   return (FIOBJ)ary;
 }
 
 /** Creates a mutable empty Array object. Use `fiobj_free` when done. */
-FIOBJ fiobj_ary_new(void) {
-  return fiobj_ary_alloc(FIOBJ_ARRAY_DEFAULT_CAPA, FIOBJ_ARRAY_DEFAULT_OFFSET);
-}
+FIOBJ fiobj_ary_new(void) { return fiobj_ary_alloc(0); }
 /** Creates a mutable empty Array object with the requested capacity. */
-FIOBJ fiobj_ary_new2(size_t capa) { return fiobj_ary_alloc(capa, 0); }
+FIOBJ fiobj_ary_new2(size_t capa) { return fiobj_ary_alloc(capa); }
 
 /* *****************************************************************************
 Array direct entry access API
@@ -117,7 +108,7 @@ Array direct entry access API
 /** Returns the current, temporary, array capacity (it's dynamic). */
 size_t fiobj_ary_capa(FIOBJ ary) {
   assert(ary && FIOBJ_TYPE_IS(ary, FIOBJ_T_ARRAY));
-  return fio_ary_capa(&obj2ary(ary)->ary);
+  return fio_ary___capa(&obj2ary(ary)->ary);
 }
 
 /**
@@ -139,7 +130,7 @@ FIOBJ *fiobj_ary2ptr(FIOBJ ary) {
  */
 FIOBJ fiobj_ary_index(FIOBJ ary, int64_t pos) {
   assert(ary && FIOBJ_TYPE_IS(ary, FIOBJ_T_ARRAY));
-  return fio_ary_index(&obj2ary(ary)->ary, pos);
+  return fio_ary___get(&obj2ary(ary)->ary, pos);
 }
 
 /**
@@ -147,7 +138,8 @@ FIOBJ fiobj_ary_index(FIOBJ ary, int64_t pos) {
  */
 void fiobj_ary_set(FIOBJ ary, FIOBJ obj, int64_t pos) {
   assert(ary && FIOBJ_TYPE_IS(ary, FIOBJ_T_ARRAY));
-  FIOBJ old = fio_ary_set(&obj2ary(ary)->ary, obj, pos);
+  FIOBJ old = FIOBJ_INVALID;
+  fio_ary___set(&obj2ary(ary)->ary, pos, obj, &old);
   fiobj_free(old);
 }
 
@@ -160,13 +152,15 @@ Array push / shift API
  */
 void fiobj_ary_push(FIOBJ ary, FIOBJ obj) {
   assert(ary && FIOBJ_TYPE_IS(ary, FIOBJ_T_ARRAY));
-  fio_ary_push(&obj2ary(ary)->ary, obj);
+  fio_ary___push(&obj2ary(ary)->ary, obj);
 }
 
 /** Pops an object from the end of the Array. */
 FIOBJ fiobj_ary_pop(FIOBJ ary) {
   assert(ary && FIOBJ_TYPE_IS(ary, FIOBJ_T_ARRAY));
-  return fio_ary_pop(&obj2ary(ary)->ary);
+  FIOBJ ret = FIOBJ_INVALID;
+  fio_ary___pop(&obj2ary(ary)->ary, &ret);
+  return ret;
 }
 
 /**
@@ -175,13 +169,15 @@ FIOBJ fiobj_ary_pop(FIOBJ ary) {
  */
 void fiobj_ary_unshift(FIOBJ ary, FIOBJ obj) {
   assert(ary && FIOBJ_TYPE_IS(ary, FIOBJ_T_ARRAY));
-  fio_ary_unshift(&obj2ary(ary)->ary, obj);
+  fio_ary___unshift(&obj2ary(ary)->ary, obj);
 }
 
 /** Shifts an object from the beginning of the Array. */
 FIOBJ fiobj_ary_shift(FIOBJ ary) {
   assert(ary && FIOBJ_TYPE_IS(ary, FIOBJ_T_ARRAY));
-  return fio_ary_shift(&obj2ary(ary)->ary);
+  FIOBJ ret = FIOBJ_INVALID;
+  fio_ary___shift(&obj2ary(ary)->ary, &ret);
+  return ret;
 }
 
 /* *****************************************************************************
@@ -205,7 +201,7 @@ FIOBJ fiobj_ary_replace(FIOBJ ary, FIOBJ obj, int64_t pos) {
  */
 int64_t fiobj_ary_find(FIOBJ ary, FIOBJ data) {
   assert(ary && FIOBJ_TYPE_IS(ary, FIOBJ_T_ARRAY));
-  return (int64_t)fio_ary_find(&obj2ary(ary)->ary, data);
+  return (int64_t)fio_ary___find(&obj2ary(ary)->ary, data);
 }
 
 /**
@@ -216,8 +212,8 @@ int64_t fiobj_ary_find(FIOBJ ary, FIOBJ data) {
  */
 int fiobj_ary_remove(FIOBJ ary, int64_t pos) {
   assert(ary && FIOBJ_TYPE_IS(ary, FIOBJ_T_ARRAY));
-  FIOBJ old = fio_ary_remove(&obj2ary(ary)->ary, (intptr_t)pos);
-  if (!old) {
+  FIOBJ old = FIOBJ_INVALID;
+  if (fio_ary___remove(&obj2ary(ary)->ary, (intptr_t)pos, &old)) {
     return -1;
   }
   fiobj_free(old);
@@ -232,8 +228,7 @@ int fiobj_ary_remove(FIOBJ ary, int64_t pos) {
  */
 int fiobj_ary_remove2(FIOBJ ary, FIOBJ data) {
   assert(ary && FIOBJ_TYPE_IS(ary, FIOBJ_T_ARRAY));
-  int found = fio_ary_remove2(&obj2ary(ary)->ary, data);
-  if (found == -1) {
+  if (-1 == fio_ary___remove2(&obj2ary(ary)->ary, data, &data)) {
     return -1;
   }
   fiobj_free(data);
@@ -253,7 +248,7 @@ Array compacting (untested)
  */
 void fiobj_ary_compact(FIOBJ ary) {
   assert(ary && FIOBJ_TYPE_IS(ary, FIOBJ_T_ARRAY));
-  fio_ary_compact(&obj2ary(ary)->ary);
+  fio_ary___compact(&obj2ary(ary)->ary);
 }
 
 /* *****************************************************************************
@@ -271,7 +266,7 @@ void fiobj_test_array(void) {
   }
   FIOBJ a = fiobj_ary_new2(4);
   TEST_ASSERT(FIOBJ_TYPE_IS(a, FIOBJ_T_ARRAY), "Array type isn't an array!\n");
-  TEST_ASSERT(fiobj_ary_capa(a) == 4, "Array capacity ignored!\n");
+  TEST_ASSERT(fiobj_ary_capa(a) > 4, "Array capacity ignored!\n");
   fiobj_ary_push(a, fiobj_null());
   TEST_ASSERT(fiobj_ary2ptr(a)[0] == fiobj_null(),
               "Array direct access failed!\n");
@@ -279,7 +274,8 @@ void fiobj_test_array(void) {
   fiobj_ary_push(a, fiobj_false());
   TEST_ASSERT(fiobj_ary_count(a) == 3, "Array count isn't 3\n");
   fiobj_ary_set(a, fiobj_true(), 63);
-  TEST_ASSERT(fiobj_ary_count(a) == 64, "Array count isn't 64\n");
+  TEST_ASSERT(fiobj_ary_count(a) == 64, "Array count isn't 64 (%zu)\n",
+              fiobj_ary_count(a));
   TEST_ASSERT(fiobj_ary_index(a, 0) == fiobj_null(),
               "Array index retrival error for fiobj_null\n");
   TEST_ASSERT(fiobj_ary_index(a, 1) == fiobj_true(),
@@ -303,8 +299,9 @@ void fiobj_test_array(void) {
               "Array replace didn't return correct value\n");
 
   FIO_ARY_FOR(&obj2ary(a)->ary, pos) {
-    if (pos.obj) {
-      fprintf(stderr, "%lu) %s\n", pos.i, fiobj_obj2cstr(pos.obj).data);
+    if (*pos) {
+      fprintf(stderr, "%lu) %s\n", pos - obj2ary(a)->ary.arry,
+              fiobj_obj2cstr(*pos).data);
     }
   }
 
@@ -315,8 +312,9 @@ void fiobj_test_array(void) {
   TEST_ASSERT(fiobj_ary_count(a) == 3, "Array remove error\n");
 
   FIO_ARY_FOR(&obj2ary(a)->ary, pos) {
-    if (pos.obj) {
-      fprintf(stderr, "%lu) %s\n", pos.i, fiobj_obj2cstr(pos.obj).data);
+    if (*pos) {
+      fprintf(stderr, "%lu) %s\n", pos - obj2ary(a)->ary.arry,
+              fiobj_obj2cstr(*pos).data);
     }
   }
 

data/ext/iodine/fiobj_data.c

@@ -29,7 +29,6 @@ License: MIT
 #include <sys/types.h>
 #include <unistd.h>
 
-#define FIO_OVERRIDE_MALLOC 1
 #include <fio.h>
 
 /* *****************************************************************************
@@ -66,19 +65,19 @@ Object required VTable and functions
 
 static void fiobj_data_copy_buffer(FIOBJ o) {
   obj2io(o)->capa = (((obj2io(o)->len) >> 12) + 1) << 12;
-  void *tmp = malloc(obj2io(o)->capa);
+  void *tmp = fio_malloc(obj2io(o)->capa);
   REQUIRE_MEM(tmp);
   memcpy(tmp, obj2io(o)->buffer, obj2io(o)->len);
   if (obj2io(o)->source.dealloc)
     obj2io(o)->source.dealloc(obj2io(o)->buffer);
-  obj2io(o)->source.dealloc = free;
+  obj2io(o)->source.dealloc = fio_free;
   obj2io(o)->buffer = tmp;
 }
 
 static void fiobj_data_copy_parent(FIOBJ o) {
   switch (obj2io(obj2io(o)->source.parent)->fd) {
   case -1:
-    obj2io(o)->buffer = malloc(obj2io(o)->len + 1);
+    obj2io(o)->buffer = fio_malloc(obj2io(o)->len + 1);
     memcpy(obj2io(o)->buffer,
            obj2io(obj2io(o)->source.parent)->buffer + obj2io(o)->capa,
            obj2io(o)->len);
@@ -86,7 +85,7 @@ static void fiobj_data_copy_parent(FIOBJ o) {
     obj2io(o)->capa = obj2io(o)->len;
     obj2io(o)->fd = -1;
     fiobj_free(obj2io(o)->source.parent);
-    obj2io(o)->source.dealloc = free;
+    obj2io(o)->source.dealloc = fio_free;
     return;
   default:
     obj2io(o)->fd = fio_tmpfile();
@@ -125,7 +124,7 @@ static void fiobj_data_copy_parent(FIOBJ o) {
 static inline void fiobj_data_pre_write(FIOBJ o, uintptr_t length) {
   switch (obj2io(o)->fd) {
   case -1:
-    if (obj2io(o)->source.dealloc != free) {
+    if (obj2io(o)->source.dealloc != fio_free) {
       fiobj_data_copy_buffer(o);
     }
     break;
@@ -137,7 +136,7 @@ static inline void fiobj_data_pre_write(FIOBJ o, uintptr_t 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);
+  obj2io(o)->buffer = fio_realloc(obj2io(o)->buffer, obj2io(o)->capa);
   REQUIRE_MEM(obj2io(o)->buffer);
 }
 
@@ -153,7 +152,7 @@ retry:
 }
 
 static FIOBJ fiobj_data_alloc(void *buffer, int fd) {
-  fiobj_data_s *io = malloc(sizeof(*io));
+  fiobj_data_s *io = fio_malloc(sizeof(*io));
   REQUIRE_MEM(io);
   *io = (fiobj_data_s){
       .head = {.ref = 1, .type = FIOBJ_T_DATA},
@@ -175,10 +174,10 @@ static void fiobj_data_dealloc(FIOBJ o, void (*task)(FIOBJ, void *),
     break;
   default:
     close(obj2io(o)->fd);
-    free(obj2io(o)->buffer);
+    fio_free(obj2io(o)->buffer);
     break;
   }
-  free((void *)o);
+  fio_free((void *)o);
   (void)task;
   (void)arg;
 }
@@ -325,10 +324,10 @@ 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);
+  FIOBJ o = fiobj_data_alloc(fio_malloc(4096), -1);
   REQUIRE_MEM(obj2io(o)->buffer);
   obj2io(o)->capa = 4096;
-  obj2io(o)->source.dealloc = free;
+  obj2io(o)->source.dealloc = fio_free;
   return o;
 }
 
@@ -348,7 +347,7 @@ FIOBJ fiobj_data_newstr2(void *buffer, uintptr_t length,
 
 /** Creates a new local file IO object */
 FIOBJ fiobj_data_newfd(int fd) {
-  FIOBJ o = fiobj_data_alloc(malloc(4096), fd);
+  FIOBJ o = fiobj_data_alloc(fio_malloc(4096), fd);
   REQUIRE_MEM(obj2io(o)->buffer);
   obj2io(o)->source.fpos = 0;
   return o;