import binn serialization format

1 files changed, 3372 insertions, 0 deletions

diff --git a/src/lib/binn.cc b/src/lib/binn.cc
new file mode 100644
index 0000000..b7e4839
--- /dev/null
+++ b/src/lib/binn.cc
@@ -0,0 +1,3372 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <memory.h>
+#include "lib/binn.h"
+
+#ifdef MULTIPASS_TRACE_MALLOC
+#include "lib/mpmalloc.h"
+#else
+#define mpmalloc malloc
+#define mprealloc realloc
+#define mpfree free
+#endif
+
+#define UNUSED(x) (void)(x)
+#define round(dbl) dbl >= 0.0 ? (int)(dbl + 0.5) : ((dbl - (double)(int)dbl) <= -0.5 ? (int)dbl : (int)(dbl - 0.5))
+
+// magic number:  0x1F 0xb1 0x22 0x1F  =>  0x1FB1221F or 0x1F22B11F
+// because the BINN_STORAGE_NOBYTES (binary 000) may not have so many sub-types (BINN_STORAGE_HAS_MORE = 0x10)
+#define BINN_MAGIC            0x1F22B11F
+
+#define MAX_BINN_HEADER       9  // [1:type][4:size][4:count]
+#define MIN_BINN_SIZE         3  // [1:type][1:size][1:count]
+#define CHUNK_SIZE            256  // 1024
+
+#define BINN_STRUCT        1
+#define BINN_BUFFER        2
+
+void* (*malloc_fn)(size_t len) = 0;
+void* (*realloc_fn)(void *ptr, size_t len) = 0;
+void  (*free_fn)(void *ptr) = 0;
+
+/***************************************************************************/
+
+#if defined(__alpha__) || defined(__hppa__) || defined(__mips__) || defined(__powerpc__) || defined(__sparc__)
+#define BINN_ONLY_ALIGNED_ACCESS
+#elif ( defined(__arm__) || defined(__aarch64__) ) && !defined(__ARM_FEATURE_UNALIGNED)
+#define BINN_ONLY_ALIGNED_ACCESS
+#endif
+
+#if defined(_WIN32)
+#define BIG_ENDIAN      0x1000
+#define LITTLE_ENDIAN   0x0001
+#define BYTE_ORDER      LITTLE_ENDIAN
+#elif defined(__APPLE__)
+/* macros already defined */
+#elif defined(__OpenBSD__) || defined(__NetBSD__) || defined(__FreeBSD__) || defined(__DragonFly__)
+#include <sys/endian.h>
+#elif defined(_AIX)
+#include <sys/machine.h>
+#else
+#include <endian.h>
+#endif
+
+#ifndef BYTE_ORDER
+#error "BYTE_ORDER not defined"
+#endif
+#ifndef BIG_ENDIAN
+#error "BIG_ENDIAN not defined"
+#endif
+#ifndef LITTLE_ENDIAN
+#error "LITTLE_ENDIAN not defined"
+#endif
+#if BIG_ENDIAN == LITTLE_ENDIAN
+#error "BIG_ENDIAN == LITTLE_ENDIAN"
+#endif
+#if BYTE_ORDER!=BIG_ENDIAN && BYTE_ORDER!=LITTLE_ENDIAN
+#error "BYTE_ORDER not supported"
+#endif
+
+typedef unsigned short int     u16;
+typedef unsigned int           u32;
+typedef unsigned long long int u64;
+
+BINN_PRIVATE void copy_be16(u16 *pdest, u16 *psource) {
+#if BYTE_ORDER == LITTLE_ENDIAN
+  unsigned char *source = (unsigned char *) psource;
+  unsigned char *dest = (unsigned char *) pdest;
+  dest[0] = source[1];
+  dest[1] = source[0];
+#else // if BYTE_ORDER == BIG_ENDIAN
+#ifdef BINN_ONLY_ALIGNED_ACCESS
+  if (psource % 2 == 0){  // address aligned to 16 bit
+    *pdest = *psource;
+  } else {
+    unsigned char *source = (unsigned char *) psource;
+    unsigned char *dest = (unsigned char *) pdest;
+    dest[0] = source[0];  // indexes are the same
+    dest[1] = source[1];
+  }
+#else
+  *pdest = *psource;
+#endif
+#endif
+}
+
+BINN_PRIVATE void copy_be32(u32 *pdest, u32 *psource) {
+#if BYTE_ORDER == LITTLE_ENDIAN
+  unsigned char *source = (unsigned char *) psource;
+  unsigned char *dest = (unsigned char *) pdest;
+  dest[0] = source[3];
+  dest[1] = source[2];
+  dest[2] = source[1];
+  dest[3] = source[0];
+#else // if BYTE_ORDER == BIG_ENDIAN
+#ifdef BINN_ONLY_ALIGNED_ACCESS
+  if (psource % 4 == 0){  // address aligned to 32 bit
+    *pdest = *psource;
+  } else {
+    unsigned char *source = (unsigned char *) psource;
+    unsigned char *dest = (unsigned char *) pdest;
+    dest[0] = source[0];  // indexes are the same
+    dest[1] = source[1];
+    dest[2] = source[2];
+    dest[3] = source[3];
+  }
+#else
+  *pdest = *psource;
+#endif
+#endif
+}
+
+BINN_PRIVATE void copy_be64(u64 *pdest, u64 *psource) {
+#if BYTE_ORDER == LITTLE_ENDIAN
+  unsigned char *source = (unsigned char *) psource;
+  unsigned char *dest = (unsigned char *) pdest;
+  int i;
+  for (i=0; i < 8; i++) {
+    dest[i] = source[7-i];
+  }
+#else // if BYTE_ORDER == BIG_ENDIAN
+#ifdef BINN_ONLY_ALIGNED_ACCESS
+  if (psource % 8 == 0){  // address aligned to 64 bit
+    *pdest = *psource;
+  } else {
+    unsigned char *source = (unsigned char *) psource;
+    unsigned char *dest = (unsigned char *) pdest;
+    int i;
+    for (i=0; i < 8; i++) {
+      dest[i] = source[i];  // indexes are the same
+    }
+  }
+#else
+  *pdest = *psource;
+#endif
+#endif
+}
+
+/***************************************************************************/
+
+#ifndef WIN32
+#define stricmp strcasecmp
+#define strnicmp strncasecmp
+#endif
+
+/***************************************************************************/
+
+void APIENTRY binn_set_alloc_functions(void* (*new_malloc)(size_t), void* (*new_realloc)(void*,size_t), void (*new_free)(void*)) {
+
+  malloc_fn = new_malloc;
+  realloc_fn = new_realloc;
+  free_fn = new_free;
+
+}
+
+/***************************************************************************/
+
+BINN_PRIVATE void check_alloc_functions() {
+
+  if (malloc_fn == 0) malloc_fn = &mpmalloc;
+  if (realloc_fn == 0) realloc_fn = &mprealloc;
+  if (free_fn == 0) free_fn = &mpfree;
+
+}
+
+/***************************************************************************/
+
+BINN_PRIVATE void * binn_malloc(int size) {
+  check_alloc_functions();
+  return malloc_fn(size);
+}
+
+/***************************************************************************/
+
+BINN_PRIVATE void * binn_memdup(void *src, int size) {
+  void *dest;
+
+  if (src == NULL || size <= 0) return NULL;
+  dest = binn_malloc(size);
+  if (dest == NULL) return NULL;
+  memcpy(dest, src, size);
+  return dest;
+
+}
+
+/***************************************************************************/
+
+BINN_PRIVATE size_t strlen2(char *str) {
+
+  if (str == NULL) return 0;
+  return strlen(str);
+
+}
+
+/***************************************************************************/
+
+int APIENTRY binn_create_type(int storage_type, int data_type_index) {
+  if (data_type_index < 0) return -1;
+  if ((storage_type < BINN_STORAGE_MIN) || (storage_type > BINN_STORAGE_MAX)) return -1;
+  if (data_type_index < 16)
+    return storage_type | data_type_index;
+  else if (data_type_index < 4096) {
+    storage_type |= BINN_STORAGE_HAS_MORE;
+    storage_type <<= 8;
+    data_type_index >>= 4;
+    return storage_type | data_type_index;
+  } else
+    return -1;
+}
+
+/***************************************************************************/
+
+BOOL APIENTRY binn_get_type_info(int long_type, int *pstorage_type, int *pextra_type) {
+  int storage_type, extra_type;
+  BOOL retval=TRUE;
+
+again:
+
+  if (long_type < 0) {
+    goto loc_invalid;
+  } else if (long_type <= 0xff) {
+    storage_type = long_type & BINN_STORAGE_MASK;
+    extra_type = long_type & BINN_TYPE_MASK;
+  } else if (long_type <= 0xffff) {
+    storage_type = long_type & BINN_STORAGE_MASK16;
+    storage_type >>= 8;
+    extra_type = long_type & BINN_TYPE_MASK16;
+    extra_type >>= 4;
+  } else if (long_type & BINN_STORAGE_VIRTUAL) {
+    //storage_type = BINN_STORAGE_VIRTUAL;
+    //extra_type = xxx;
+    long_type &= 0xffff;
+    goto again;
+  } else {
+loc_invalid:
+    storage_type = -1;
+    extra_type = -1;
+    retval = FALSE;
+  }
+
+  if (pstorage_type) *pstorage_type = storage_type;
+  if (pextra_type) *pextra_type = extra_type;
+
+  return retval;
+
+}
+
+/***************************************************************************/
+
+BOOL APIENTRY binn_create(binn *item, int type, int size, void *pointer) {
+  BOOL retval=FALSE;
+
+  switch (type) {
+    case BINN_LIST:
+    case BINN_MAP:
+    case BINN_OBJECT:
+      break;
+    default:
+      goto loc_exit;
+  }
+
+  if ((item == NULL) || (size < 0)) goto loc_exit;
+  if (size < MIN_BINN_SIZE) {
+    if (pointer) goto loc_exit;
+    else size = 0;
+  }
+
+  memset(item, 0, sizeof(binn));
+
+  if (pointer) {
+    item->pre_allocated = TRUE;
+    item->pbuf = pointer;
+    item->alloc_size = size;
+  } else {
+    item->pre_allocated = FALSE;
+    if (size == 0) size = CHUNK_SIZE;
+    pointer = binn_malloc(size);
+    if (pointer == 0) return INVALID_BINN;
+    item->pbuf = pointer;
+    item->alloc_size = size;
+  }
+
+  item->header = BINN_MAGIC;
+  //item->allocated = FALSE;   -- already zeroed
+  item->writable = TRUE;
+  item->used_size = MAX_BINN_HEADER;  // save space for the header
+  item->type = type;
+  //item->count = 0;           -- already zeroed
+  item->dirty = TRUE;          // the header is not written to the buffer
+
+  retval = TRUE;
+
+loc_exit:
+  return retval;
+
+}
+
+/***************************************************************************/
+
+binn * APIENTRY binn_new(int type, int size, void *pointer) {
+  binn *item;
+
+  item = (binn*) binn_malloc(sizeof(binn));
+
+  if (binn_create(item, type, size, pointer) == FALSE) {
+    free_fn(item);
+    return NULL;
+  }
+
+  item->allocated = TRUE;
+  return item;
+
+}
+
+/*************************************************************************************/
+
+BOOL APIENTRY binn_create_list(binn *list) {
+
+  return binn_create(list, BINN_LIST, 0, NULL);
+
+}
+
+/*************************************************************************************/
+
+BOOL APIENTRY binn_create_map(binn *map) {
+
+  return binn_create(map, BINN_MAP, 0, NULL);
+
+}
+
+/*************************************************************************************/
+
+BOOL APIENTRY binn_create_object(binn *object) {
+
+  return binn_create(object, BINN_OBJECT, 0, NULL);
+
+}
+
+/***************************************************************************/
+
+binn * APIENTRY binn_list() {
+  return binn_new(BINN_LIST, 0, 0);
+}
+
+/***************************************************************************/
+
+binn * APIENTRY binn_map() {
+  return binn_new(BINN_MAP, 0, 0);
+}
+
+/***************************************************************************/
+
+binn * APIENTRY binn_object() {
+  return binn_new(BINN_OBJECT, 0, 0);
+}
+
+/*************************************************************************************/
+
+BOOL APIENTRY binn_load(void *data, binn *value) {
+
+  if ((data == NULL) || (value == NULL)) return FALSE;
+  memset(value, 0, sizeof(binn));
+  value->header = BINN_MAGIC;
+  //value->allocated = FALSE;  --  already zeroed
+  //value->writable = FALSE;
+
+  if (binn_is_valid(data, &value->type, &value->count, &value->size) == FALSE) return FALSE;
+  value->ptr = data;
+  return TRUE;
+
+}
+
+/*************************************************************************************/
+
+binn * APIENTRY binn_open(void *data) {
+  binn *item;
+
+  item = (binn*) binn_malloc(sizeof(binn));
+
+  if (binn_load(data, item) == FALSE) {
+    free_fn(item);
+    return NULL;
+  }
+
+  item->allocated = TRUE;
+  return item;
+
+}
+
+/***************************************************************************/
+
+BINN_PRIVATE int binn_get_ptr_type(void *ptr) {
+
+  if (ptr == NULL) return 0;
+
+  switch (*(unsigned int *)ptr) {
+  case BINN_MAGIC:
+    return BINN_STRUCT;
+  default:
+    return BINN_BUFFER;
+  }
+
+}
+
+/***************************************************************************/
+
+BOOL APIENTRY binn_is_struct(void *ptr) {
+
+  if (ptr == NULL) return FALSE;
+
+  if ((*(unsigned int *)ptr) == BINN_MAGIC) {
+    return TRUE;
+  } else {
+    return FALSE;
+  }
+
+}
+
+/***************************************************************************/
+
+BINN_PRIVATE int CalcAllocation(int needed_size, int alloc_size) {
+  int calc_size;
+
+  calc_size = alloc_size;
+  while (calc_size < needed_size) {
+    calc_size <<= 1;  // same as *= 2
+    //calc_size += CHUNK_SIZE;  -- this is slower than the above line, because there are more reallocations
+  }
+  return calc_size;
+
+}
+
+/***************************************************************************/
+
+BINN_PRIVATE BOOL CheckAllocation(binn *item, int add_size) {
+  int  alloc_size;
+  void *ptr;
+
+  if (item->used_size + add_size > item->alloc_size) {
+    if (item->pre_allocated) return FALSE;
+    alloc_size = CalcAllocation(item->used_size + add_size, item->alloc_size);
+    ptr = realloc_fn(item->pbuf, alloc_size);
+    if (ptr == NULL) return FALSE;
+    item->pbuf = ptr;
+    item->alloc_size = alloc_size;
+  }
+
+  return TRUE;
+
+}
+
+/***************************************************************************/
+
+#if BYTE_ORDER == BIG_ENDIAN
+
+BINN_PRIVATE int get_storage_size(int storage_type) {
+
+  switch (storage_type) {
+  case BINN_STORAGE_NOBYTES:
+    return 0;
+  case BINN_STORAGE_BYTE:
+    return 1;
+  case BINN_STORAGE_WORD:
+    return 2;
+  case BINN_STORAGE_DWORD:
+    return 4;
+  case BINN_STORAGE_QWORD:
+    return 8;
+  default:
+    return 0;
+  }
+
+}
+
+#endif
+
+/***************************************************************************/
+
+BINN_PRIVATE unsigned char * AdvanceDataPos(unsigned char *p, unsigned char *plimit) {
+  unsigned char byte;
+  int  storage_type, DataSize;
+
+  if (p > plimit) return 0;
+
+  byte = *p; p++;
+  storage_type = byte & BINN_STORAGE_MASK;
+  if (byte & BINN_STORAGE_HAS_MORE) p++;
+
+  switch (storage_type) {
+  case BINN_STORAGE_NOBYTES:
+    //p += 0;
+    break;
+  case BINN_STORAGE_BYTE:
+    p ++;
+    break;
+  case BINN_STORAGE_WORD:
+    p += 2;
+    break;
+  case BINN_STORAGE_DWORD:
+    p += 4;
+    break;
+  case BINN_STORAGE_QWORD:
+    p += 8;
+    break;
+  case BINN_STORAGE_BLOB:
+    if (p + sizeof(int) - 1 > plimit) return 0;
+    copy_be32((u32*)&DataSize, (u32*)p);
+    p += 4 + DataSize;
+    break;
+  case BINN_STORAGE_CONTAINER:
+    if (p > plimit) return 0;
+    DataSize = *((unsigned char*)p);
+    if (DataSize & 0x80) {
+      if (p + sizeof(int) - 1 > plimit) return 0;
+      copy_be32((u32*)&DataSize, (u32*)p);
+      DataSize &= 0x7FFFFFFF;
+    }
+    DataSize--;  // remove the type byte already added before
+    p += DataSize;
+    break;
+  case BINN_STORAGE_STRING:
+    if (p > plimit) return 0;
+    DataSize = *((unsigned char*)p);
+    if (DataSize & 0x80) {
+      if (p + sizeof(int) - 1 > plimit) return 0;
+      copy_be32((u32*)&DataSize, (u32*)p);
+      DataSize &= 0x7FFFFFFF;
+      p+=4;
+    } else {
+      p++;
+    }
+    p += DataSize;
+    p++;  // null terminator.
+    break;
+  default:
+    return 0;
+  }
+
+  if (p > plimit) return 0;
+
+  return p;
+
+}
+
+/***************************************************************************/
+
+BINN_PRIVATE unsigned char * SearchForID(unsigned char *p, int header_size, int size, int numitems, int id) {
+  unsigned char *plimit, *base;
+  int  i, int32;
+
+  base = p;
+  plimit = p + size - 1;
+  p += header_size;
+
+  // search for the ID in all the arguments.
+  for (i = 0; i < numitems; i++) {
+    copy_be32((u32*)&int32, (u32*)p);
+    p += 4;
+    if (p > plimit) break;
+    // Compare if the IDs are equal.
+    if (int32 == id) return p;
+    // xxx
+    p = AdvanceDataPos(p, plimit);
+    if ((p == 0) || (p < base)) break;
+  }
+
+  return NULL;
+
+}
+
+/***************************************************************************/
+
+BINN_PRIVATE unsigned char * SearchForKey(unsigned char *p, int header_size, int size, int numitems, char *key) {
+  unsigned char len, *plimit, *base;
+  int  i, keylen;
+
+  base = p;
+  plimit = p + size - 1;
+  p += header_size;
+
+  keylen = strlen(key);
+
+  // search for the key in all the arguments.
+  for (i = 0; i < numitems; i++) {
+    len = *((unsigned char *)p);
+    p++;
+    if (p > plimit) break;
+    // Compare if the strings are equal.
+    if (len > 0) {
+      if (strnicmp((char*)p, key, len) == 0) {   // note that there is no null terminator here
+        if (keylen == len) {
+          p += len;
+          return p;
+        }
+      }
+      p += len;
+      if (p > plimit) break;
+    } else if (len == keylen) {   // in the case of empty string: ""
+      return p;
+    }
+    // xxx
+    p = AdvanceDataPos(p, plimit);
+    if ((p == 0) || (p < base)) break;
+  }
+
+  return NULL;
+
+}
+
+/***************************************************************************/
+
+BINN_PRIVATE BOOL AddValue(binn *item, int type, void *pvalue, int size);
+
+/***************************************************************************/
+
+BINN_PRIVATE BOOL binn_list_add_raw(binn *item, int type, void *pvalue, int size) {
+
+  if ((item == NULL) || (item->type != BINN_LIST) || (item->writable == FALSE)) return FALSE;
+
+  //if (CheckAllocation(item, 4) == FALSE) return FALSE;  // 4 bytes used for data_store and data_format.
+
+  if (AddValue(item, type, pvalue, size) == FALSE) return FALSE;
+
+  item->count++;
+
+  return TRUE;
+
+}
+
+/***************************************************************************/
+
+BINN_PRIVATE BOOL binn_object_set_raw(binn *item, char *key, int type, void *pvalue, int size) {
+  unsigned char *p, len;
+  int int32;
+
+  if ((item == NULL) || (item->type != BINN_OBJECT) || (item->writable == FALSE)) return FALSE;
+
+  if (key == NULL) return FALSE;
+  int32 = strlen(key);
+  if (int32 > 255) return FALSE;
+
+  // is the key already in it?
+  p = SearchForKey((unsigned char*)item->pbuf, MAX_BINN_HEADER, item->used_size, item->count, key);
+  if (p) return FALSE;
+
+  // start adding it
+
+  if (CheckAllocation(item, 1 + int32) == FALSE) return FALSE;  // bytes used for the key size and the key itself.
+
+  p = ((unsigned char *) item->pbuf) + item->used_size;
+  len = int32;
+  *p = len;
+  p++;
+  memcpy(p, key, int32);
+  int32++;  // now contains the strlen + 1 byte for the len
+  item->used_size += int32;
+
+  if (AddValue(item, type, pvalue, size) == FALSE) {
+    item->used_size -= int32;
+    return FALSE;
+  }
+
+  item->count++;
+
+  return TRUE;
+
+}
+
+/***************************************************************************/
+
+BINN_PRIVATE BOOL binn_map_set_raw(binn *item, int id, int type, void *pvalue, int size) {
+  unsigned char *p;
+
+  if ((item == NULL) || (item->type != BINN_MAP) || (item->writable == FALSE)) return FALSE;
+
+  // is the ID already in it?
+  p = SearchForID((unsigned char*)item->pbuf, MAX_BINN_HEADER, item->used_size, item->count, id);
+  if (p) return FALSE;
+
+  // start adding it
+
+  if (CheckAllocation(item, 4) == FALSE) return FALSE;  // 4 bytes used for the id.
+
+  p = ((unsigned char *) item->pbuf) + item->used_size;
+  copy_be32((u32*)p, (u32*)&id);
+  item->used_size += 4;
+
+  if (AddValue(item, type, pvalue, size) == FALSE) {
+    item->used_size -= 4;
+    return FALSE;
+  }
+
+  item->count++;
+
+  return TRUE;
+
+}
+
+/***************************************************************************/
+
+BINN_PRIVATE void * compress_int(int *pstorage_type, int *ptype, void *psource) {
+  int storage_type, storage_type2, type, type2=0;
+  int64  vint;
+  uint64 vuint;
+  char *pvalue;
+#if BYTE_ORDER == BIG_ENDIAN
+  int size1, size2;
+#endif
+
+  storage_type = *pstorage_type;
+  if (storage_type == BINN_STORAGE_BYTE) return psource;
+
+  type = *ptype;
+
+  switch (type) {
+  case BINN_INT64:
+    vint = *(int64*)psource;
+    goto loc_signed;
+  case BINN_INT32:
+    vint = *(int*)psource;
+    goto loc_signed;
+  case BINN_INT16:
+    vint = *(short*)psource;
+    goto loc_signed;
+  case BINN_UINT64:
+    vuint = *(uint64*)psource;
+    goto loc_positive;
+  case BINN_UINT32:
+    vuint = *(unsigned int*)psource;
+    goto loc_positive;
+  case BINN_UINT16:
+    vuint = *(unsigned short*)psource;
+    goto loc_positive;
+  }
+
+loc_signed:
+
+  if (vint >= 0) {
+    vuint = vint;
+    goto loc_positive;
+  }
+
+//loc_negative:
+
+  if (vint >= INT8_MIN) {
+    type2 = BINN_INT8;
+  } else
+  if (vint >= INT16_MIN) {
+    type2 = BINN_INT16;
+  } else
+  if (vint >= INT32_MIN) {
+    type2 = BINN_INT32;
+  }
+  goto loc_exit;
+
+loc_positive:
+
+  if (vuint <= UINT8_MAX) {
+    type2 = BINN_UINT8;
+  } else
+  if (vuint <= UINT16_MAX) {
+    type2 = BINN_UINT16;
+  } else
+  if (vuint <= UINT32_MAX) {
+    type2 = BINN_UINT32;
+  }
+
+loc_exit:
+
+  pvalue = (char *) psource;
+
+  if ((type2) && (type2 != type)) {
+    *ptype = type2;
+    storage_type2 = binn_get_write_storage(type2);
+    *pstorage_type = storage_type2;
+#if BYTE_ORDER == BIG_ENDIAN
+    size1 = get_storage_size(storage_type);
+    size2 = get_storage_size(storage_type2);
+    pvalue += (size1 - size2);
+#endif
+  }
+
+  return pvalue;
+
+}
+
+/***************************************************************************/
+
+BINN_PRIVATE int type_family(int type);
+
+BINN_PRIVATE BOOL AddValue(binn *item, int type, void *pvalue, int size) {
+  int int32, ArgSize, storage_type, extra_type;
+  unsigned char *p;
+
+  binn_get_type_info(type, &storage_type, &extra_type);
+
+  if (pvalue == NULL) {
+    switch (storage_type) {
+      case BINN_STORAGE_NOBYTES:
+        break;
+      case BINN_STORAGE_BLOB:
+      case BINN_STORAGE_STRING:
+        if (size == 0) break; // the 2 above are allowed to have 0 length
+      default:
+        return FALSE;
+    }
+  }
+
+  if ((type_family(type) == BINN_FAMILY_INT) && (item->disable_int_compression == FALSE))
+    pvalue = compress_int(&storage_type, &type, pvalue);
+
+  switch (storage_type) {
+    case BINN_STORAGE_NOBYTES:
+      size = 0;
+      ArgSize = size;
+      break;
+    case BINN_STORAGE_BYTE:
+      size = 1;
+      ArgSize = size;
+      break;
+    case BINN_STORAGE_WORD:
+      size = 2;
+      ArgSize = size;
+      break;
+    case BINN_STORAGE_DWORD:
+      size = 4;
+      ArgSize = size;
+      break;
+    case BINN_STORAGE_QWORD:
+      size = 8;
+      ArgSize = size;
+      break;
+    case BINN_STORAGE_BLOB:
+      if (size < 0) return FALSE;
+      //if (size == 0) ...
+      ArgSize = size + 4;
+      break;
+    case BINN_STORAGE_STRING:
+      if (size < 0) return FALSE;
+      if (size == 0) size = strlen2( (char *) pvalue);
+      ArgSize = size + 5; // at least this size
+      break;
+    case BINN_STORAGE_CONTAINER:
+      if (size <= 0) return FALSE;
+      ArgSize = size;
+      break;
+    default:
+      return FALSE;
+  }
+
+  ArgSize += 2;  // at least 2 bytes used for data_type.
+  if (CheckAllocation(item, ArgSize) == FALSE) return FALSE;
+
+  // Gets the pointer to the next place in buffer
+  p = ((unsigned char *) item->pbuf) + item->used_size;
+
+  // If the data is not a container, store the data type
+  if (storage_type != BINN_STORAGE_CONTAINER) {
+    if (type > 255) {
+      u16 type16 = type;
+      copy_be16((u16*)p, (u16*)&type16);
+      p += 2;
+      item->used_size += 2;
+    } else {
+      *p = type;
+      p++;
+      item->used_size++;
+    }
+  }
+
+  switch (storage_type) {
+    case BINN_STORAGE_NOBYTES:
+      // Nothing to do.
+      break;
+    case BINN_STORAGE_BYTE:
+      *((char *) p) = *((char *) pvalue);
+      item->used_size += 1;
+      break;
+    case BINN_STORAGE_WORD:
+      copy_be16((u16*)p, (u16*)pvalue);
+      item->used_size += 2;
+      break;
+    case BINN_STORAGE_DWORD:
+      copy_be32((u32*)p, (u32*)pvalue);
+      item->used_size += 4;
+      break;
+    case BINN_STORAGE_QWORD:
+      copy_be64((u64*)p, (u64*)pvalue);
+      item->used_size += 8;
+      break;
+    case BINN_STORAGE_BLOB:
+      copy_be32((u32*)p, (u32*)&size);
+      p += 4;
+      memcpy(p, pvalue, size);
+      item->used_size += 4 + size;
+      break;
+    case BINN_STORAGE_STRING:
+      if (size > 127) {
+        int32 = size | 0x80000000;
+        copy_be32((u32*)p, (u32*)&int32);
+        p += 4;
+        item->used_size += 4;
+      } else {
+        *((unsigned char *) p) = size;
+        p++;
+        item->used_size++;
+      }
+      memcpy(p, pvalue, size);
+      p += size;
+      *((char *) p) = (char) 0;
+      size++;  // null terminator
+      item->used_size += size;
+      break;
+    case BINN_STORAGE_CONTAINER:
+      memcpy(p, pvalue, size);
+      item->used_size += size;
+      break;
+  }
+
+  item->dirty = TRUE;
+
+  return TRUE;
+}
+
+/***************************************************************************/
+
+BINN_PRIVATE BOOL binn_save_header(binn *item) {
+  unsigned char byte, *p;
+  int int32, size;
+
+  if (item == NULL) return FALSE;
+
+#ifndef BINN_DISABLE_SMALL_HEADER
+
+  p = ((unsigned char *) item->pbuf) + MAX_BINN_HEADER;
+  size = item->used_size - MAX_BINN_HEADER + 3;  // at least 3 bytes for the header
+
+  // write the count
+  if (item->count > 127) {
+    p -= 4;
+    size += 3;
+    int32 = item->count | 0x80000000;
+    copy_be32((u32*)p, (u32*)&int32);
+  } else {
+    p--;
+    *p = (unsigned char) item->count;
+  }
+
+  // write the size
+  if (size > 127) {
+    p -= 4;
+    size += 3;
+    int32 = size | 0x80000000;
+    copy_be32((u32*)p, (u32*)&int32);
+  } else {
+    p--;
+    *p = (unsigned char) size;
+  }
+
+  // write the type.
+  p--;
+  *p = (unsigned char) item->type;
+
+  // set the values
+  item->ptr = p;
+  item->size = size;
+
+  UNUSED(byte);
+
+#else
+
+  p = (unsigned char *) item->pbuf;
+
+  // write the type.
+  byte = item->type;
+  *p = byte; p++;
+  // write the size
+  int32 = item->used_size | 0x80000000;
+  copy_be32((u32*)p, (u32*)&int32);
+  p+=4;
+  // write the count
+  int32 = item->count | 0x80000000;
+  copy_be32((u32*)p, (u32*)&int32);
+
+  item->ptr = item->pbuf;
+  item->size = item->used_size;
+
+#endif
+
+  item->dirty = FALSE;
+
+  return TRUE;
+
+}
+
+/***************************************************************************/
+
+void APIENTRY binn_free(binn *item) {
+
+  if (item == NULL) return;
+
+  if ((item->writable) && (item->pre_allocated == FALSE)) {
+    free_fn(item->pbuf);
+  }
+
+  if (item->freefn) item->freefn(item->ptr);
+
+  if (item->allocated) {
+    free_fn(item);
+  } else {
+    memset(item, 0, sizeof(binn));
+    item->header = BINN_MAGIC;
+  }
+
+}
+
+/***************************************************************************/
+// free the binn structure but keeps the binn buffer allocated, returning a pointer to it. use the free function to release the buffer later
+void * APIENTRY binn_release(binn *item) {
+  void *data;
+
+  if (item == NULL) return NULL;
+
+  data = binn_ptr(item);
+
+  if (data > item->pbuf) {
+    memmove(item->pbuf, data, item->size);
+    data = item->pbuf;
+  }
+
+  if (item->allocated) {
+    free_fn(item);
+  } else {
+    memset(item, 0, sizeof(binn));
+    item->header = BINN_MAGIC;
+  }
+
+  return data;
+
+}
+
+/***************************************************************************/
+
+BINN_PRIVATE BOOL IsValidBinnHeader(void *pbuf, int *ptype, int *pcount, int *psize, int *pheadersize) {
+  unsigned char byte, *p, *plimit=0;
+  int int32, type, size, count;
+
+  if (pbuf == NULL) return FALSE;
+
+  p = (unsigned char *) pbuf;
+
+  if (psize && *psize > 0) {
+    plimit = p + *psize - 1;
+  }
+
+  // get the type
+  byte = *p; p++;
+  if ((byte & BINN_STORAGE_MASK) != BINN_STORAGE_CONTAINER) return FALSE;
+  if (byte & BINN_STORAGE_HAS_MORE) return FALSE;
+  type = byte;
+
+  switch (type) {
+    case BINN_LIST:
+    case BINN_MAP:
+    case BINN_OBJECT:
+      break;
+    default:
+      return FALSE;
+  }
+
+  // get the size
+  if (plimit && p > plimit) return FALSE;
+  int32 = *((unsigned char*)p);
+  if (int32 & 0x80) {
+    if (plimit && p + sizeof(int) - 1 > plimit) return FALSE;
+    copy_be32((u32*)&int32, (u32*)p);
+    int32 &= 0x7FFFFFFF;
+    p+=4;
+  } else {
+    p++;
+  }
+  size = int32;
+
+  // get the count
+  if (plimit && p > plimit) return FALSE;
+  int32 = *((unsigned char*)p);
+  if (int32 & 0x80) {
+    if (plimit && p + sizeof(int) - 1 > plimit) return FALSE;
+    copy_be32((u32*)&int32, (u32*)p);
+    int32 &= 0x7FFFFFFF;
+    p+=4;
+  } else {
+    p++;
+  }
+  count = int32;
+
+#if 0
+  // get the size
+  copy_be32((u32*)&size, (u32*)p);
+  size &= 0x7FFFFFFF;
+  p+=4;
+
+  // get the count
+  copy_be32((u32*)&count, (u32*)p);
+  count &= 0x7FFFFFFF;
+  p+=4;
+#endif
+
+  if ((size < MIN_BINN_SIZE) || (count < 0)) return FALSE;
+
+  // return the values
+  if (ptype)  *ptype  = type;
+  if (pcount) *pcount = count;
+  if (psize && *psize==0) *psize = size;
+  if (pheadersize) *pheadersize = (int) (p - (unsigned char*)pbuf);
+  return TRUE;
+}
+
+/***************************************************************************/
+
+BINN_PRIVATE int binn_buf_type(void *pbuf) {
+  int  type;
+
+  if (!IsValidBinnHeader(pbuf, &type, NULL, NULL, NULL)) return INVALID_BINN;
+
+  return type;
+
+}
+
+/***************************************************************************/
+
+BINN_PRIVATE int binn_buf_count(void *pbuf) {
+  int  nitems;
+
+  if (!IsValidBinnHeader(pbuf, NULL, &nitems, NULL, NULL)) return 0;
+
+  return nitems;
+
+}
+
+/***************************************************************************/
+
+BINN_PRIVATE int binn_buf_size(void *pbuf) {
+  int  size=0;
+
+  if (!IsValidBinnHeader(pbuf, NULL, NULL, &size, NULL)) return 0;
+
+  return size;
+
+}
+
+/***************************************************************************/
+
+void * APIENTRY binn_ptr(void *ptr) {
+  binn *item;
+
+  switch (binn_get_ptr_type(ptr)) {
+  case BINN_STRUCT:
+    item = (binn*) ptr;
+    if (item->writable && item->dirty) {
+      binn_save_header(item);
+    }
+    return item->ptr;
+  case BINN_BUFFER:
+    return ptr;
+  default:
+    return NULL;
+  }
+
+}
+
+/***************************************************************************/
+
+int APIENTRY binn_size(void *ptr) {
+  binn *item;
+
+  switch (binn_get_ptr_type(ptr)) {
+  case BINN_STRUCT:
+    item = (binn*) ptr;
+    if (item->writable && item->dirty) {
+      binn_save_header(item);
+    }
+    return item->size;
+  case BINN_BUFFER:
+    return binn_buf_size(ptr);
+  default:
+    return 0;
+  }
+
+}
+
+/***************************************************************************/
+
+int APIENTRY binn_type(void *ptr) {
+  binn *item;
+
+  switch (binn_get_ptr_type(ptr)) {
+  case BINN_STRUCT:
+    item = (binn*) ptr;
+    return item->type;
+  case BINN_BUFFER:
+    return binn_buf_type(ptr);
+  default:
+    return -1;
+  }
+
+}
+
+/***************************************************************************/
+
+int APIENTRY binn_count(void *ptr) {
+  binn *item;
+
+  switch (binn_get_ptr_type(ptr)) {
+  case BINN_STRUCT:
+    item = (binn*) ptr;
+    return item->count;
+  case BINN_BUFFER:
+    return binn_buf_count(ptr);
+  default:
+    return -1;
+  }
+
+}
+
+/***************************************************************************/
+
+BOOL APIENTRY binn_is_valid_ex(void *ptr, int *ptype, int *pcount, int *psize) {
+  int  i, type, count, size, header_size;
+  unsigned char *p, *plimit, *base, len;
+  void *pbuf;
+
+  pbuf = binn_ptr(ptr);
+  if (pbuf == NULL) return FALSE;
+
+  // is there an informed size?
+  if (psize && *psize > 0) {
+    size = *psize;
+  } else {
+    size = 0;
+  }
+
+  if (!IsValidBinnHeader(pbuf, &type, &count, &size, &header_size)) return FALSE;
+
+  // is there an informed size?
+  if (psize && *psize > 0) {
+    // is it the same as the one in the buffer?
+    if (size != *psize) return FALSE;
+  }
+  // is there an informed count?
+  if (pcount && *pcount > 0) {
+    // is it the same as the one in the buffer?
+    if (count != *pcount) return FALSE;
+  }
+  // is there an informed type?
+  if (ptype && *ptype != 0) {
+    // is it the same as the one in the buffer?
+    if (type != *ptype) return FALSE;
+  }
+
+  // it could compare the content size with the size informed on the header
+
+  p = (unsigned char *)pbuf;
+  base = p;
+  plimit = p + size;
+
+  p += header_size;
+
+  // process all the arguments.
+  for (i = 0; i < count; i++) {
+    switch (type) {
+      case BINN_OBJECT:
+        // gets the string size (argument name)
+        len = *p;
+        p++;
+        //if (len == 0) goto Invalid;
+        // increment the used space
+        p += len;
+        break;
+      case BINN_MAP:
+        // increment the used space
+        p += 4;
+        break;
+      //case BINN_LIST:
+      //  break;
+    }
+    // xxx
+    p = AdvanceDataPos(p, plimit);
+    if ((p == 0) || (p < base)) goto Invalid;
+  }
+
+  if (ptype  && *ptype==0)  *ptype  = type;
+  if (pcount && *pcount==0) *pcount = count;
+  if (psize  && *psize==0)  *psize  = size;
+  return TRUE;
+
+Invalid:
+  return FALSE;
+
+}
+
+/***************************************************************************/
+
+BOOL APIENTRY binn_is_valid(void *ptr, int *ptype, int *pcount, int *psize) {
+
+  if (ptype)  *ptype  = 0;
+  if (pcount) *pcount = 0;
+  if (psize)  *psize  = 0;
+
+  return binn_is_valid_ex(ptr, ptype, pcount, psize);
+
+}
+
+/***************************************************************************/
+/*** INTERNAL FUNCTIONS ****************************************************/
+/***************************************************************************/
+
+BINN_PRIVATE BOOL GetValue(unsigned char *p, binn *value) {
+  unsigned char byte;
+  int   data_type, storage_type;  //, extra_type;
+  int   DataSize;
+  void *p2;
+
+  if (value == NULL) return FALSE;
+  memset(value, 0, sizeof(binn));
+  value->header = BINN_MAGIC;
+  //value->allocated = FALSE;  --  already zeroed
+  //value->writable = FALSE;
+
+  // saves for use with BINN_STORAGE_CONTAINER
+  p2 = p;
+
+  // read the data type
+  byte = *p; p++;
+  storage_type = byte & BINN_STORAGE_MASK;
+  if (byte & BINN_STORAGE_HAS_MORE) {
+    data_type = byte << 8;
+    byte = *p; p++;
+    data_type |= byte;
+    //extra_type = data_type & BINN_TYPE_MASK16;
+  } else {
+    data_type = byte;
+    //extra_type = byte & BINN_TYPE_MASK;
+  }
+
+  //value->storage_type = storage_type;
+  value->type = data_type;
+
+  switch (storage_type) {
+  case BINN_STORAGE_NOBYTES:
+    break;
+  case BINN_STORAGE_BYTE:
+    value->vuint8 = *((unsigned char *) p);
+    value->ptr = p;   //value->ptr = &value->vuint8;
+    break;
+  case BINN_STORAGE_WORD:
+    copy_be16((u16*)&value->vint16, (u16*)p);
+    value->ptr = &value->vint16;
+    break;
+  case BINN_STORAGE_DWORD:
+    copy_be32((u32*)&value->vint32, (u32*)p);
+    value->ptr = &value->vint32;
+    break;
+  case BINN_STORAGE_QWORD:
+    copy_be64((u64*)&value->vint64, (u64*)p);
+    value->ptr = &value->vint64;
+    break;
+  case BINN_STORAGE_BLOB:
+    copy_be32((u32*)&value->size, (u32*)p);
+    p+=4;
+    value->ptr = p;
+    break;
+  case BINN_STORAGE_CONTAINER:
+    value->ptr = p2;  // <-- it returns the pointer to the container, not the data
+    if (IsValidBinnHeader(p2, NULL, &value->count, &value->size, NULL) == FALSE) return FALSE;
+    break;
+  case BINN_STORAGE_STRING:
+    DataSize = *((unsigned char*)p);
+    if (DataSize & 0x80) {
+      copy_be32((u32*)&DataSize, (u32*)p);
+      DataSize &= 0x7FFFFFFF;
+      p+=4;
+    } else {
+      p++;
+    }
+    value->size = DataSize;
+    value->ptr = p;
+    break;
+  default:
+    return FALSE;
+  }
+
+  // convert the returned value, if needed
+
+  switch (value->type) {
+    case BINN_TRUE:
+      value->type = BINN_BOOL;
+      value->vbool = TRUE;
+      value->ptr = &value->vbool;
+      break;
+    case BINN_FALSE:
+      value->type = BINN_BOOL;
+      value->vbool = FALSE;
+      value->ptr = &value->vbool;
+      break;
+#ifdef BINN_EXTENDED
+    case BINN_SINGLE_STR:
+      value->type = BINN_SINGLE;
+      value->vfloat = (float) atof((const char*)value->ptr);  // converts from string to double, and then to float
+      value->ptr = &value->vfloat;
+      break;
+    case BINN_DOUBLE_STR:
+      value->type = BINN_DOUBLE;
+      value->vdouble = atof((const char*)value->ptr);  // converts from string to double
+      value->ptr = &value->vdouble;
+      break;
+#endif
+    /*
+    case BINN_DECIMAL:
+    case BINN_CURRENCYSTR:
+    case BINN_DATE:
+    case BINN_DATETIME:
+    case BINN_TIME:
+    */
+  }
+
+  return TRUE;
+
+}
+
+/***************************************************************************/
+
+#if BYTE_ORDER == LITTLE_ENDIAN
+
+// on little-endian devices we store the value so we can return a pointer to integers.
+// it's valid only for single-threaded apps. multi-threaded apps must use the _get_ functions instead.
+
+binn local_value;
+
+BINN_PRIVATE void * store_value(binn *value) {
+
+  memcpy(&local_value, value, sizeof(binn));
+
+  switch (binn_get_read_storage(value->type)) {
+  case BINN_STORAGE_NOBYTES:
+    // return a valid pointer
+  case BINN_STORAGE_WORD:
+  case BINN_STORAGE_DWORD:
+  case BINN_STORAGE_QWORD:
+    return &local_value.vint32;  // returns the pointer to the converted value, from big-endian to little-endian
+  }
+
+  return value->ptr;   // returns from the on stack value to be thread-safe (for list, map, object, string and blob)
+
+}
+
+#endif
+
+/***************************************************************************/
+/*** READ FUNCTIONS ********************************************************/
+/***************************************************************************/
+
+BOOL APIENTRY binn_object_get_value(void *ptr, char *key, binn *value) {
+  int type, count, size=0, header_size;
+  unsigned char *p;
+
+  ptr = binn_ptr(ptr);
+  if ((ptr == 0) || (key == 0) || (value == 0)) return FALSE;
+
+  // check the header
+  if (IsValidBinnHeader(ptr, &type, &count, &size, &header_size) == FALSE) return FALSE;
+
+  if (type != BINN_OBJECT) return FALSE;
+  if (count == 0) return FALSE;
+
+  p = (unsigned char *) ptr;
+  p = SearchForKey(p, header_size, size, count, key);
+  if (p == FALSE) return FALSE;
+
+  return GetValue(p, value);
+
+}
+
+/***************************************************************************/
+
+BOOL APIENTRY binn_map_get_value(void* ptr, int id, binn *value) {
+  int type, count, size=0, header_size;
+  unsigned char *p;
+
+  ptr = binn_ptr(ptr);
+  if ((ptr == 0) || (value == 0)) return FALSE;
+
+  // check the header
+  if (IsValidBinnHeader(ptr, &type, &count, &size, &header_size) == FALSE) return FALSE;
+
+  if (type != BINN_MAP) return FALSE;
+  if (count == 0) return FALSE;
+
+  p = (unsigned char *) ptr;
+  p = SearchForID(p, header_size, size, count, id);
+  if (p == FALSE) return FALSE;
+
+  return GetValue(p, value);
+
+}
+
+/***************************************************************************/
+
+BOOL APIENTRY binn_list_get_value(void* ptr, int pos, binn *value) {
+  int  i, type, count, size=0, header_size;
+  unsigned char *p, *plimit, *base;
+
+  ptr = binn_ptr(ptr);
+  if ((ptr == 0) || (value == 0)) return FALSE;
+
+  // check the header
+  if (IsValidBinnHeader(ptr, &type, &count, &size, &header_size) == FALSE) return FALSE;
+
+  if (type != BINN_LIST) return FALSE;
+  if (count == 0) return FALSE;
+  if ((pos <= 0) | (pos > count)) return FALSE;
+  pos--;  // convert from base 1 to base 0
+
+  p = (unsigned char *) ptr;
+  base = p;
+  plimit = p + size;
+  p += header_size;
+
+  for (i = 0; i < pos; i++) {
+    p = AdvanceDataPos(p, plimit);
+    if ((p == 0) || (p < base)) return FALSE;
+  }
+
+  return GetValue(p, value);
+
+}
+
+/***************************************************************************/
+/*** READ PAIR BY POSITION *************************************************/
+/***************************************************************************/
+
+BINN_PRIVATE BOOL binn_read_pair(int expected_type, void *ptr, int pos, int *pid, char *pkey, binn *value) {
+  int  type, count, size=0, header_size;
+  int  i, int32, id, counter=0;
+  unsigned char *p, *plimit, *base, *key, len;
+
+  ptr = binn_ptr(ptr);
+
+  // check the header
+  if (IsValidBinnHeader(ptr, &type, &count, &size, &header_size) == FALSE) return FALSE;
+
+  if ((type != expected_type) || (count == 0) || (pos < 1) || (pos > count)) return FALSE;
+
+  p = (unsigned char *) ptr;
+  base = p;
+  plimit = p + size - 1;
+  p += header_size;
+
+  for (i = 0; i < count; i++) {
+    switch (type) {
+      case BINN_MAP:
+        copy_be32((u32*)&int32, (u32*)p);
+        p += 4;
+        if (p > plimit) return FALSE;
+        id = int32;
+        break;
+      case BINN_OBJECT:
+        len = *((unsigned char *)p); p++;
+        if (p > plimit) return FALSE;
+        key = p;
+        p += len;
+        if (p > plimit) return FALSE;
+        break;
+    }
+    counter++;
+    if (counter == pos) goto found;
+    //
+    p = AdvanceDataPos(p, plimit);
+    if ((p == 0) || (p < base)) return FALSE;
+  }
+
+  return FALSE;
+
+found:
+
+  switch (type) {
+    case BINN_MAP:
+      if (pid) *pid = id;
+      break;
+    case BINN_OBJECT:
+      if (pkey) {
+        memcpy(pkey, key, len);
+        pkey[len] = 0;
+      }
+      break;
+  }
+
+  return GetValue(p, value);
+
+}
+
+/***************************************************************************/
+
+BOOL APIENTRY binn_map_get_pair(void *ptr, int pos, int *pid, binn *value) {
+
+  return binn_read_pair(BINN_MAP, ptr, pos, pid, NULL, value);
+
+}
+
+/***************************************************************************/
+
+BOOL APIENTRY binn_object_get_pair(void *ptr, int pos, char *pkey, binn *value) {
+
+  return binn_read_pair(BINN_OBJECT, ptr, pos, NULL, pkey, value);
+
+}
+
+/***************************************************************************/
+
+binn * APIENTRY binn_map_pair(void *map, int pos, int *pid) {
+  binn *value;
+
+  value = (binn *) binn_malloc(sizeof(binn));
+
+  if (binn_read_pair(BINN_MAP, map, pos, pid, NULL, value) == FALSE) {
+    free_fn(value);
+    return NULL;
+  }
+
+  value->allocated = TRUE;
+  return value;
+
+}
+
+/***************************************************************************/
+
+binn * APIENTRY binn_object_pair(void *obj, int pos, char *pkey) {
+  binn *value;
+
+  value = (binn *) binn_malloc(sizeof(binn));
+
+  if (binn_read_pair(BINN_OBJECT, obj, pos, NULL, pkey, value) == FALSE) {
+    free_fn(value);
+    return NULL;
+  }
+
+  value->allocated = TRUE;
+  return value;
+
+}
+
+/***************************************************************************/
+/***************************************************************************/
+
+void * APIENTRY binn_map_read_pair(void *ptr, int pos, int *pid, int *ptype, int *psize) {
+  binn value;
+
+  if (binn_map_get_pair(ptr, pos, pid, &value) == FALSE) return NULL;
+  if (ptype) *ptype = value.type;
+  if (psize) *psize = value.size;
+#if BYTE_ORDER == LITTLE_ENDIAN
+  return store_value(&value);
+#else
+  return value.ptr;
+#endif
+
+}
+
+/***************************************************************************/
+
+void * APIENTRY binn_object_read_pair(void *ptr, int pos, char *pkey, int *ptype, int *psize) {
+  binn value;
+
+  if (binn_object_get_pair(ptr, pos, pkey, &value) == FALSE) return NULL;
+  if (ptype) *ptype = value.type;
+  if (psize) *psize = value.size;
+#if BYTE_ORDER == LITTLE_ENDIAN
+  return store_value(&value);
+#else
+  return value.ptr;
+#endif
+
+}
+
+/***************************************************************************/
+/*** SEQUENTIAL READ FUNCTIONS *********************************************/
+/***************************************************************************/
+
+BOOL APIENTRY binn_iter_init(binn_iter *iter, void *ptr, int expected_type) {
+  int  type, count, size=0, header_size;
+
+  ptr = binn_ptr(ptr);
+  if ((ptr == 0) || (iter == 0)) return FALSE;
+  memset(iter, 0, sizeof(binn_iter));
+
+  // check the header
+  if (IsValidBinnHeader(ptr, &type, &count, &size, &header_size) == FALSE) return FALSE;
+
+  if (type != expected_type) return FALSE;
+  //if (count == 0) return FALSE;  -- should not be used
+
+  iter->plimit = (unsigned char *)ptr + size - 1;
+  iter->pnext = (unsigned char *)ptr + header_size;
+  iter->count = count;
+  iter->current = 0;
+  iter->type = type;
+
+  return TRUE;
+}
+
+/***************************************************************************/
+
+BOOL APIENTRY binn_list_next(binn_iter *iter, binn *value) {
+  unsigned char *pnow;
+
+  if ((iter == 0) || (iter->pnext == 0) || (iter->pnext > iter->plimit) || (iter->current > iter->count) || (iter->type != BINN_LIST)) return FALSE;
+
+  iter->current++;
+  if (iter->current > iter->count) return FALSE;
+
+  pnow = iter->pnext;
+  iter->pnext = AdvanceDataPos(pnow, iter->plimit);
+  if (iter->pnext != 0 && iter->pnext < pnow) return FALSE;
+
+  return GetValue(pnow, value);
+
+}
+
+/***************************************************************************/
+
+BINN_PRIVATE BOOL binn_read_next_pair(int expected_type, binn_iter *iter, int *pid, char *pkey, binn *value) {
+  int  int32, id;
+  unsigned char *p, *key;
+  unsigned short len;
+
+  if ((iter == 0) || (iter->pnext == 0) || (iter->pnext > iter->plimit) || (iter->current > iter->count) || (iter->type != expected_type)) return FALSE;
+
+  iter->current++;
+  if (iter->current > iter->count) return FALSE;
+
+  p = iter->pnext;
+
+  switch (expected_type) {
+    case BINN_MAP:
+      copy_be32((u32*)&int32, (u32*)p);
+      p += 4;
+      if (p > iter->plimit) return FALSE;
+      id = int32;
+      if (pid) *pid = id;
+      break;
+    case BINN_OBJECT:
+      len = *((unsigned char *)p); p++;
+      key = p;
+      p += len;
+      if (p > iter->plimit) return FALSE;
+      if (pkey) {
+        memcpy(pkey, key, len);
+        pkey[len] = 0;
+      }
+      break;
+  }
+
+  iter->pnext = AdvanceDataPos(p, iter->plimit);
+  if (iter->pnext != 0 && iter->pnext < p) return FALSE;
+
+  return GetValue(p, value);
+
+}
+
+/***************************************************************************/
+
+BOOL APIENTRY binn_map_next(binn_iter *iter, int *pid, binn *value) {
+
+  return binn_read_next_pair(BINN_MAP, iter, pid, NULL, value);
+
+}
+
+/***************************************************************************/
+
+BOOL APIENTRY binn_object_next(binn_iter *iter, char *pkey, binn *value) {
+
+  return binn_read_next_pair(BINN_OBJECT, iter, NULL, pkey, value);
+
+}
+
+/***************************************************************************/
+/***************************************************************************/
+
+binn * APIENTRY binn_list_next_value(binn_iter *iter) {
+  binn *value;
+
+  value = (binn *) binn_malloc(sizeof(binn));
+
+  if (binn_list_next(iter, value) == FALSE) {
+    free_fn(value);
+    return NULL;
+  }
+
+  value->allocated = TRUE;
+  return value;
+
+}
+
+/***************************************************************************/
+
+binn * APIENTRY binn_map_next_value(binn_iter *iter, int *pid) {
+  binn *value;
+
+  value = (binn *) binn_malloc(sizeof(binn));
+
+  if (binn_map_next(iter, pid, value) == FALSE) {
+    free_fn(value);
+    return NULL;
+  }
+
+  value->allocated = TRUE;
+  return value;
+
+}
+
+/***************************************************************************/
+
+binn * APIENTRY binn_object_next_value(binn_iter *iter, char *pkey) {
+  binn *value;
+
+  value = (binn *) binn_malloc(sizeof(binn));
+
+  if (binn_object_next(iter, pkey, value) == FALSE) {
+    free_fn(value);
+    return NULL;
+  }
+
+  value->allocated = TRUE;
+  return value;
+
+}
+
+/***************************************************************************/
+/***************************************************************************/
+
+void * APIENTRY binn_list_read_next(binn_iter *iter, int *ptype, int *psize) {
+  binn value;
+
+  if (binn_list_next(iter, &value) == FALSE) return NULL;
+  if (ptype) *ptype = value.type;
+  if (psize) *psize = value.size;
+#if BYTE_ORDER == LITTLE_ENDIAN
+  return store_value(&value);
+#else
+  return value.ptr;
+#endif
+
+}
+
+/***************************************************************************/
+
+void * APIENTRY binn_map_read_next(binn_iter *iter, int *pid, int *ptype, int *psize) {
+  binn value;
+
+  if (binn_map_next(iter, pid, &value) == FALSE) return NULL;
+  if (ptype) *ptype = value.type;
+  if (psize) *psize = value.size;
+#if BYTE_ORDER == LITTLE_ENDIAN
+  return store_value(&value);
+#else
+  return value.ptr;
+#endif
+
+}
+
+/***************************************************************************/
+
+void * APIENTRY binn_object_read_next(binn_iter *iter, char *pkey, int *ptype, int *psize) {
+  binn value;
+
+  if (binn_object_next(iter, pkey, &value) == FALSE) return NULL;
+  if (ptype) *ptype = value.type;
+  if (psize) *psize = value.size;
+#if BYTE_ORDER == LITTLE_ENDIAN
+  return store_value(&value);
+#else
+  return value.ptr;
+#endif
+
+}
+
+/*************************************************************************************/
+/****** EXTENDED INTERFACE ***********************************************************/
+/****** none of the functions above call the functions below *************************/
+/*************************************************************************************/
+
+int APIENTRY binn_get_write_storage(int type) {
+  int storage_type;
+
+  switch (type) {
+    case BINN_SINGLE_STR:
+    case BINN_DOUBLE_STR:
+      return BINN_STORAGE_STRING;
+
+    case BINN_BOOL:
+      return BINN_STORAGE_NOBYTES;
+
+    default:
+      binn_get_type_info(type, &storage_type, NULL);
+      return storage_type;
+  }
+
+}
+
+/*************************************************************************************/
+
+int APIENTRY binn_get_read_storage(int type) {
+  int storage_type;
+
+  switch (type) {
+#ifdef BINN_EXTENDED
+    case BINN_SINGLE_STR:
+      return BINN_STORAGE_DWORD;
+    case BINN_DOUBLE_STR:
+      return BINN_STORAGE_QWORD;
+#endif
+    case BINN_BOOL:
+    case BINN_TRUE:
+    case BINN_FALSE:
+      return BINN_STORAGE_DWORD;
+    default:
+      binn_get_type_info(type, &storage_type, NULL);
+      return storage_type;
+  }
+
+}
+
+/*************************************************************************************/
+
+BINN_PRIVATE BOOL GetWriteConvertedData(int *ptype, void **ppvalue, int *psize) {
+  int  type;
+  float  f1;
+  double d1;
+  char pstr[128];
+
+  UNUSED(pstr);
+  UNUSED(d1);
+  UNUSED(f1);
+
+  type = *ptype;
+
+  if (*ppvalue == NULL) {
+    switch (type) {
+      case BINN_NULL:
+      case BINN_TRUE:
+      case BINN_FALSE:
+        break;
+      case BINN_STRING:
+      case BINN_BLOB:
+        if (*psize == 0) break;
+      default:
+        return FALSE;
+    }
+  }
+
+  switch (type) {
+#ifdef BINN_EXTENDED
+    case BINN_SINGLE:
+      f1 = **(float**)ppvalue;
+      d1 = f1;  // convert from float (32bits) to double (64bits)
+      type = BINN_SINGLE_STR;
+      goto conv_double;
+    case BINN_DOUBLE:
+      d1 = **(double**)ppvalue;
+      type = BINN_DOUBLE_STR;
+conv_double:
+      // the '%.17e' is more precise than the '%g'
+      snprintf(pstr, 127, "%.17e", d1);
+      *ppvalue = pstr;
+      *ptype = type;
+      break;
+#endif
+    case BINN_DECIMAL:
+    case BINN_CURRENCYSTR:
+      /*
+      if (binn_malloc_extptr(128) == NULL) return FALSE;
+      snprintf(sptr, 127, "%E", **ppvalue);
+      *ppvalue = sptr;
+      */
+      return TRUE;  //! temporary
+      break;
+
+    case BINN_DATE:
+    case BINN_DATETIME:
+    case BINN_TIME:
+      return TRUE;  //! temporary
+      break;
+
+    case BINN_BOOL:
+      if (**((BOOL**)ppvalue) == FALSE) {
+        type = BINN_FALSE;
+      } else {
+        type = BINN_TRUE;
+      }
+      *ptype = type;
+      break;
+
+  }
+
+  return TRUE;
+
+}
+
+/*************************************************************************************/
+
+BINN_PRIVATE int type_family(int type)  {
+
+  switch (type) {
+    case BINN_LIST:
+    case BINN_MAP:
+    case BINN_OBJECT:
+      return BINN_FAMILY_BINN;
+
+    case BINN_INT8:
+    case BINN_INT16:
+    case BINN_INT32:
+    case BINN_INT64:
+    case BINN_UINT8:
+    case BINN_UINT16:
+    case BINN_UINT32:
+    case BINN_UINT64:
+      return BINN_FAMILY_INT;
+
+    case BINN_FLOAT32:
+    case BINN_FLOAT64:
+    //case BINN_SINGLE:
+    case BINN_SINGLE_STR:
+    //case BINN_DOUBLE:
+    case BINN_DOUBLE_STR:
+      return BINN_FAMILY_FLOAT;
+
+    case BINN_STRING:
+    case BINN_HTML:
+    case BINN_CSS:
+    case BINN_XML:
+    case BINN_JSON:
+    case BINN_JAVASCRIPT:
+      return BINN_FAMILY_STRING;
+
+    case BINN_BLOB:
+    case BINN_JPEG:
+    case BINN_GIF:
+    case BINN_PNG:
+    case BINN_BMP:
+      return BINN_FAMILY_BLOB;
+
+    case BINN_DECIMAL:
+    case BINN_CURRENCY:
+    case BINN_DATE:
+    case BINN_TIME:
+    case BINN_DATETIME:
+      return BINN_FAMILY_STRING;
+
+    case BINN_BOOL:
+      return BINN_FAMILY_BOOL;
+
+    case BINN_NULL:
+      return BINN_FAMILY_NULL;
+
+    default:
+      // if it wasn't found
+      return BINN_FAMILY_NONE;
+  }
+
+}
+
+/*************************************************************************************/
+
+BINN_PRIVATE int int_type(int type)  {
+
+  switch (type) {
+  case BINN_INT8:
+  case BINN_INT16:
+  case BINN_INT32:
+  case BINN_INT64:
+    return BINN_SIGNED_INT;
+
+  case BINN_UINT8:
+  case BINN_UINT16:
+  case BINN_UINT32:
+  case BINN_UINT64:
+    return BINN_UNSIGNED_INT;
+
+  default:
+    return 0;
+  }
+
+}
+
+/*************************************************************************************/
+
+BINN_PRIVATE BOOL copy_raw_value(void *psource, void *pdest, int data_store) {
+
+  switch (data_store) {
+  case BINN_STORAGE_NOBYTES:
+    break;
+  case BINN_STORAGE_BYTE:
+    *((char *) pdest) = *(char *)psource;
+    break;
+  case BINN_STORAGE_WORD:
+    *((short *) pdest) = *(short *)psource;
+    break;
+  case BINN_STORAGE_DWORD:
+    *((int *) pdest) = *(int *)psource;
+    break;
+  case BINN_STORAGE_QWORD:
+    *((uint64 *) pdest) = *(uint64 *)psource;
+    break;
+  case BINN_STORAGE_BLOB:
+  case BINN_STORAGE_STRING:
+  case BINN_STORAGE_CONTAINER:
+    *((char **) pdest) = (char *)psource;
+    break;
+  default:
+    return FALSE;
+  }
+
+  return TRUE;
+
+}
+
+/*************************************************************************************/
+
+BINN_PRIVATE BOOL copy_int_value(void *psource, void *pdest, int source_type, int dest_type) {
+  uint64 vuint64; int64 vint64;
+
+  switch (source_type) {
+  case BINN_INT8:
+    vint64 = *(signed char *)psource;
+    break;
+  case BINN_INT16:
+    vint64 = *(short *)psource;
+    break;
+  case BINN_INT32:
+    vint64 = *(int *)psource;
+    break;
+  case BINN_INT64:
+    vint64 = *(int64 *)psource;
+    break;
+
+  case BINN_UINT8:
+    vuint64 = *(unsigned char *)psource;
+    break;
+  case BINN_UINT16:
+    vuint64 = *(unsigned short *)psource;
+    break;
+  case BINN_UINT32:
+    vuint64 = *(unsigned int *)psource;
+    break;
+  case BINN_UINT64:
+    vuint64 = *(uint64 *)psource;
+    break;
+
+  default:
+    return FALSE;
+  }
+
+
+  // copy from int64 to uint64, if possible
+
+  if ((int_type(source_type) == BINN_UNSIGNED_INT) && (int_type(dest_type) == BINN_SIGNED_INT)) {
+    if (vuint64 > INT64_MAX) return FALSE;
+    vint64 = vuint64;
+  } else if ((int_type(source_type) == BINN_SIGNED_INT) && (int_type(dest_type) == BINN_UNSIGNED_INT)) {
+    if (vint64 < 0) return FALSE;
+    vuint64 = vint64;
+  }
+
+
+  switch (dest_type) {
+  case BINN_INT8:
+    if ((vint64 < INT8_MIN) || (vint64 > INT8_MAX)) return FALSE;
+    *(signed char *)pdest = (signed char) vint64;
+    break;
+  case BINN_INT16:
+    if ((vint64 < INT16_MIN) || (vint64 > INT16_MAX)) return FALSE;
+    *(short *)pdest = (short) vint64;
+    break;
+  case BINN_INT32:
+    if ((vint64 < INT32_MIN) || (vint64 > INT32_MAX)) return FALSE;
+    *(int *)pdest = (int) vint64;
+    break;
+  case BINN_INT64:
+    *(int64 *)pdest = vint64;
+    break;
+
+  case BINN_UINT8:
+    if (vuint64 > UINT8_MAX) return FALSE;
+    *(unsigned char *)pdest = (unsigned char) vuint64;
+    break;
+  case BINN_UINT16:
+    if (vuint64 > UINT16_MAX) return FALSE;
+    *(unsigned short *)pdest = (unsigned short) vuint64;
+    break;
+  case BINN_UINT32:
+    if (vuint64 > UINT32_MAX) return FALSE;
+    *(unsigned int *)pdest = (unsigned int) vuint64;
+    break;
+  case BINN_UINT64:
+    *(uint64 *)pdest = vuint64;
+    break;
+
+  default:
+    return FALSE;
+  }
+
+  return TRUE;
+
+}
+
+/*************************************************************************************/
+
+BINN_PRIVATE BOOL copy_float_value(void *psource, void *pdest, int source_type, int dest_type) {
+
+  switch (source_type) {
+  case BINN_FLOAT32:
+    *(double *)pdest = *(float *)psource;
+    break;
+  case BINN_FLOAT64:
+    *(float *)pdest = (float) *(double *)psource;
+    break;
+  default:
+    return FALSE;
+  }
+
+  return TRUE;
+
+}
+
+/*************************************************************************************/
+
+BINN_PRIVATE void zero_value(void *pvalue, int type) {
+  //int size=0;
+
+  switch (binn_get_read_storage(type)) {
+  case BINN_STORAGE_NOBYTES:
+    break;
+  case BINN_STORAGE_BYTE:
+    *((char *) pvalue) = 0;
+    //size=1;
+    break;
+  case BINN_STORAGE_WORD:
+    *((short *) pvalue) = 0;
+    //size=2;
+    break;
+  case BINN_STORAGE_DWORD:
+    *((int *) pvalue) = 0;
+    //size=4;
+    break;
+  case BINN_STORAGE_QWORD:
+    *((uint64 *) pvalue) = 0;
+    //size=8;
+    break;
+  case BINN_STORAGE_BLOB:
+  case BINN_STORAGE_STRING:
+  case BINN_STORAGE_CONTAINER:
+    *(char **)pvalue = NULL;
+    break;
+  }
+
+  //if (size>0) memset(pvalue, 0, size);
+
+}
+
+/*************************************************************************************/
+
+BINN_PRIVATE BOOL copy_value(void *psource, void *pdest, int source_type, int dest_type, int data_store) {
+
+  if (type_family(source_type) != type_family(dest_type)) return FALSE;
+
+  if ((type_family(source_type) == BINN_FAMILY_INT) && (source_type != dest_type)) {
+    return copy_int_value(psource, pdest, source_type, dest_type);
+  } else if ((type_family(source_type) == BINN_FAMILY_FLOAT) && (source_type != dest_type)) {
+    return copy_float_value(psource, pdest, source_type, dest_type);
+  } else {
+    return copy_raw_value(psource, pdest, data_store);
+  }
+
+}
+
+/*************************************************************************************/
+/*** WRITE FUNCTIONS *****************************************************************/
+/*************************************************************************************/
+
+BOOL APIENTRY binn_list_add(binn *list, int type, void *pvalue, int size) {
+
+  if (GetWriteConvertedData(&type, &pvalue, &size) == FALSE) return FALSE;
+
+  return binn_list_add_raw(list, type, pvalue, size);
+
+}
+
+/*************************************************************************************/
+
+BOOL APIENTRY binn_map_set(binn *map, int id, int type, void *pvalue, int size) {
+
+  if (GetWriteConvertedData(&type, &pvalue, &size) == FALSE) return FALSE;
+
+  return binn_map_set_raw(map, id, type, pvalue, size);
+
+}
+
+/*************************************************************************************/
+
+BOOL APIENTRY binn_object_set(binn *obj, char *key, int type, void *pvalue, int size) {
+
+  if (GetWriteConvertedData(&type, &pvalue, &size) == FALSE) return FALSE;
+
+  return binn_object_set_raw(obj, key, type, pvalue, size);
+
+}
+
+/*************************************************************************************/
+
+// this function is used by the wrappers
+BOOL APIENTRY binn_add_value(binn *item, int binn_type, int id, char *name, int type, void *pvalue, int size) {
+
+  switch (binn_type) {
+    case BINN_LIST:
+      return binn_list_add(item, type, pvalue, size);
+    case BINN_MAP:
+      return binn_map_set(item, id, type, pvalue, size);
+    case BINN_OBJECT:
+      return binn_object_set(item, name, type, pvalue, size);
+    default:
+      return FALSE;
+  }
+
+}
+
+/*************************************************************************************/
+/*************************************************************************************/
+
+BOOL APIENTRY binn_list_add_new(binn *list, binn *value) {
+  BOOL retval;
+
+  retval = binn_list_add_value(list, value);
+  if (value) free_fn(value);
+  return retval;
+
+}
+
+/*************************************************************************************/
+
+BOOL APIENTRY binn_map_set_new(binn *map, int id, binn *value) {
+  BOOL retval;
+
+  retval = binn_map_set_value(map, id, value);
+  if (value) free_fn(value);
+  return retval;
+
+}
+
+/*************************************************************************************/
+
+BOOL APIENTRY binn_object_set_new(binn *obj, char *key, binn *value) {
+  BOOL retval;
+
+  retval = binn_object_set_value(obj, key, value);
+  if (value) free_fn(value);
+  return retval;
+
+}
+
+/*************************************************************************************/
+/*** READ FUNCTIONS ******************************************************************/
+/*************************************************************************************/
+
+binn * APIENTRY binn_list_value(void *ptr, int pos) {
+  binn *value;
+
+  value = (binn *) binn_malloc(sizeof(binn));
+
+  if (binn_list_get_value(ptr, pos, value) == FALSE) {
+    free_fn(value);
+    return NULL;
+  }
+
+  value->allocated = TRUE;
+  return value;
+
+}
+
+/*************************************************************************************/
+
+binn * APIENTRY binn_map_value(void *ptr, int id) {
+  binn *value;
+
+  value = (binn *) binn_malloc(sizeof(binn));
+
+  if (binn_map_get_value(ptr, id, value) == FALSE) {
+    free_fn(value);
+    return NULL;
+  }
+
+  value->allocated = TRUE;
+  return value;
+
+}
+
+/*************************************************************************************/
+
+binn * APIENTRY binn_object_value(void *ptr, char *key) {
+  binn *value;
+
+  value = (binn *) binn_malloc(sizeof(binn));
+
+  if (binn_object_get_value(ptr, key, value) == FALSE) {
+    free_fn(value);
+    return NULL;
+  }
+
+  value->allocated = TRUE;
+  return value;
+
+}
+
+/***************************************************************************/
+/***************************************************************************/
+
+void * APIENTRY binn_list_read(void *list, int pos, int *ptype, int *psize) {
+  binn value;
+
+  if (binn_list_get_value(list, pos, &value) == FALSE) return NULL;
+  if (ptype) *ptype = value.type;
+  if (psize) *psize = value.size;
+#if BYTE_ORDER == LITTLE_ENDIAN
+  return store_value(&value);
+#else
+  return value.ptr;
+#endif
+
+}
+
+/***************************************************************************/
+
+void * APIENTRY binn_map_read(void *map, int id, int *ptype, int *psize) {
+  binn value;
+
+  if (binn_map_get_value(map, id, &value) == FALSE) return NULL;
+  if (ptype) *ptype = value.type;
+  if (psize) *psize = value.size;
+#if BYTE_ORDER == LITTLE_ENDIAN
+  return store_value(&value);
+#else
+  return value.ptr;
+#endif
+
+}
+
+/***************************************************************************/
+
+void * APIENTRY binn_object_read(void *obj, char *key, int *ptype, int *psize) {
+  binn value;
+
+  if (binn_object_get_value(obj, key, &value) == FALSE) return NULL;
+  if (ptype) *ptype = value.type;
+  if (psize) *psize = value.size;
+#if BYTE_ORDER == LITTLE_ENDIAN
+  return store_value(&value);
+#else
+  return value.ptr;
+#endif
+
+}
+
+/***************************************************************************/
+/***************************************************************************/
+
+BOOL APIENTRY binn_list_get(void *ptr, int pos, int type, void *pvalue, int *psize) {
+  binn value;
+  int storage_type;
+
+  storage_type = binn_get_read_storage(type);
+  if ((storage_type != BINN_STORAGE_NOBYTES) && (pvalue == NULL)) return FALSE;
+
+  zero_value(pvalue, type);
+
+  if (binn_list_get_value(ptr, pos, &value) == FALSE) return FALSE;
+
+  if (copy_value(value.ptr, pvalue, value.type, type, storage_type) == FALSE) return FALSE;
+
+  if (psize) *psize = value.size;
+
+  return TRUE;
+
+}
+
+/***************************************************************************/
+
+BOOL APIENTRY binn_map_get(void *ptr, int id, int type, void *pvalue, int *psize) {
+  binn value;
+  int storage_type;
+
+  storage_type = binn_get_read_storage(type);
+  if ((storage_type != BINN_STORAGE_NOBYTES) && (pvalue == NULL)) return FALSE;
+
+  zero_value(pvalue, type);
+
+  if (binn_map_get_value(ptr, id, &value) == FALSE) return FALSE;
+
+  if (copy_value(value.ptr, pvalue, value.type, type, storage_type) == FALSE) return FALSE;
+
+  if (psize) *psize = value.size;
+
+  return TRUE;
+
+}
+
+/***************************************************************************/
+
+//   if (binn_object_get(obj, "multiplier", BINN_INT32, &multiplier, NULL) == FALSE) xxx;
+
+BOOL APIENTRY binn_object_get(void *ptr, char *key, int type, void *pvalue, int *psize) {
+  binn value;
+  int storage_type;
+
+  storage_type = binn_get_read_storage(type);
+  if ((storage_type != BINN_STORAGE_NOBYTES) && (pvalue == NULL)) return FALSE;
+
+  zero_value(pvalue, type);
+
+  if (binn_object_get_value(ptr, key, &value) == FALSE) return FALSE;
+
+  if (copy_value(value.ptr, pvalue, value.type, type, storage_type) == FALSE) return FALSE;
+
+  if (psize) *psize = value.size;
+
+  return TRUE;
+
+}
+
+/***************************************************************************/
+/***************************************************************************/
+
+// these functions below may not be implemented as inline functions, because
+// they use a lot of space, even for the variable. so they will be exported.
+
+// but what about using as static?
+//    is there any problem with wrappers? can these wrappers implement these functions using the header?
+//    if as static, will they be present even on modules that don't use the functions?
+
+signed char APIENTRY binn_list_int8(void *list, int pos) {
+  signed char value;
+
+  binn_list_get(list, pos, BINN_INT8, &value, NULL);
+
+  return value;
+}
+
+short APIENTRY binn_list_int16(void *list, int pos) {
+  short value;
+
+  binn_list_get(list, pos, BINN_INT16, &value, NULL);
+
+  return value;
+}
+
+int APIENTRY binn_list_int32(void *list, int pos) {
+  int value;
+
+  binn_list_get(list, pos, BINN_INT32, &value, NULL);
+
+  return value;
+}
+
+int64 APIENTRY binn_list_int64(void *list, int pos) {
+  int64 value;
+
+  binn_list_get(list, pos, BINN_INT64, &value, NULL);
+
+  return value;
+}
+
+unsigned char APIENTRY binn_list_uint8(void *list, int pos) {
+  unsigned char value;
+
+  binn_list_get(list, pos, BINN_UINT8, &value, NULL);
+
+  return value;
+}
+
+unsigned short APIENTRY binn_list_uint16(void *list, int pos) {
+  unsigned short value;
+
+  binn_list_get(list, pos, BINN_UINT16, &value, NULL);
+
+  return value;
+}
+
+unsigned int APIENTRY binn_list_uint32(void *list, int pos) {
+  unsigned int value;
+
+  binn_list_get(list, pos, BINN_UINT32, &value, NULL);
+
+  return value;
+}
+
+uint64 APIENTRY binn_list_uint64(void *list, int pos) {
+  uint64 value;
+
+  binn_list_get(list, pos, BINN_UINT64, &value, NULL);
+
+  return value;
+}
+
+float APIENTRY binn_list_float(void *list, int pos) {
+  float value;
+
+  binn_list_get(list, pos, BINN_FLOAT32, &value, NULL);
+
+  return value;
+}
+
+double APIENTRY binn_list_double(void *list, int pos) {
+  double value;
+
+  binn_list_get(list, pos, BINN_FLOAT64, &value, NULL);
+
+  return value;
+}
+
+BOOL APIENTRY binn_list_bool(void *list, int pos) {
+  BOOL value;
+
+  binn_list_get(list, pos, BINN_BOOL, &value, NULL);
+
+  return value;
+}
+
+BOOL APIENTRY binn_list_null(void *list, int pos) {
+
+  return binn_list_get(list, pos, BINN_NULL, NULL, NULL);
+
+}
+
+char * APIENTRY binn_list_str(void *list, int pos) {
+  char *value;
+
+  binn_list_get(list, pos, BINN_STRING, &value, NULL);
+
+  return value;
+}
+
+void * APIENTRY binn_list_blob(void *list, int pos, int *psize) {
+  void *value;
+
+  binn_list_get(list, pos, BINN_BLOB, &value, psize);
+
+  return value;
+}
+
+void * APIENTRY binn_list_list(void *list, int pos) {
+  void *value;
+
+  binn_list_get(list, pos, BINN_LIST, &value, NULL);
+
+  return value;
+}
+
+void * APIENTRY binn_list_map(void *list, int pos) {
+  void *value;
+
+  binn_list_get(list, pos, BINN_MAP, &value, NULL);
+
+  return value;
+}
+
+void * APIENTRY binn_list_object(void *list, int pos) {
+  void *value;
+
+  binn_list_get(list, pos, BINN_OBJECT, &value, NULL);
+
+  return value;
+}
+
+/***************************************************************************/
+
+signed char APIENTRY binn_map_int8(void *map, int id) {
+  signed char value;
+
+  binn_map_get(map, id, BINN_INT8, &value, NULL);
+
+  return value;
+}
+
+short APIENTRY binn_map_int16(void *map, int id) {
+  short value;
+
+  binn_map_get(map, id, BINN_INT16, &value, NULL);
+
+  return value;
+}
+
+int APIENTRY binn_map_int32(void *map, int id) {
+  int value;
+
+  binn_map_get(map, id, BINN_INT32, &value, NULL);
+
+  return value;
+}
+
+int64 APIENTRY binn_map_int64(void *map, int id) {
+  int64 value;
+
+  binn_map_get(map, id, BINN_INT64, &value, NULL);
+
+  return value;
+}
+
+unsigned char APIENTRY binn_map_uint8(void *map, int id) {
+  unsigned char value;
+
+  binn_map_get(map, id, BINN_UINT8, &value, NULL);
+
+  return value;
+}
+
+unsigned short APIENTRY binn_map_uint16(void *map, int id) {
+  unsigned short value;
+
+  binn_map_get(map, id, BINN_UINT16, &value, NULL);
+
+  return value;
+}
+
+unsigned int APIENTRY binn_map_uint32(void *map, int id) {
+  unsigned int value;
+
+  binn_map_get(map, id, BINN_UINT32, &value, NULL);
+
+  return value;
+}
+
+uint64 APIENTRY binn_map_uint64(void *map, int id) {
+  uint64 value;
+
+  binn_map_get(map, id, BINN_UINT64, &value, NULL);
+
+  return value;
+}
+
+float APIENTRY binn_map_float(void *map, int id) {
+  float value;
+
+  binn_map_get(map, id, BINN_FLOAT32, &value, NULL);
+
+  return value;
+}
+
+double APIENTRY binn_map_double(void *map, int id) {
+  double value;
+
+  binn_map_get(map, id, BINN_FLOAT64, &value, NULL);
+
+  return value;
+}
+
+BOOL APIENTRY binn_map_bool(void *map, int id) {
+  BOOL value;
+
+  binn_map_get(map, id, BINN_BOOL, &value, NULL);
+
+  return value;
+}
+
+BOOL APIENTRY binn_map_null(void *map, int id) {
+
+  return binn_map_get(map, id, BINN_NULL, NULL, NULL);
+
+}
+
+char * APIENTRY binn_map_str(void *map, int id) {
+  char *value;
+
+  binn_map_get(map, id, BINN_STRING, &value, NULL);
+
+  return value;
+}
+
+void * APIENTRY binn_map_blob(void *map, int id, int *psize) {
+  void *value;
+
+  binn_map_get(map, id, BINN_BLOB, &value, psize);
+
+  return value;
+}
+
+void * APIENTRY binn_map_list(void *map, int id) {
+  void *value;
+
+  binn_map_get(map, id, BINN_LIST, &value, NULL);
+
+  return value;
+}
+
+void * APIENTRY binn_map_map(void *map, int id) {
+  void *value;
+
+  binn_map_get(map, id, BINN_MAP, &value, NULL);
+
+  return value;
+}
+
+void * APIENTRY binn_map_object(void *map, int id) {
+  void *value;
+
+  binn_map_get(map, id, BINN_OBJECT, &value, NULL);
+
+  return value;
+}
+
+/***************************************************************************/
+
+signed char APIENTRY binn_object_int8(void *obj, char *key) {
+  signed char value;
+
+  binn_object_get(obj, key, BINN_INT8, &value, NULL);
+
+  return value;
+}
+
+short APIENTRY binn_object_int16(void *obj, char *key) {
+  short value;
+
+  binn_object_get(obj, key, BINN_INT16, &value, NULL);
+
+  return value;
+}
+
+int APIENTRY binn_object_int32(void *obj, char *key) {
+  int value;
+
+  binn_object_get(obj, key, BINN_INT32, &value, NULL);
+
+  return value;
+}
+
+int64 APIENTRY binn_object_int64(void *obj, char *key) {
+  int64 value;
+
+  binn_object_get(obj, key, BINN_INT64, &value, NULL);
+
+  return value;
+}
+
+unsigned char APIENTRY binn_object_uint8(void *obj, char *key) {
+  unsigned char value;
+
+  binn_object_get(obj, key, BINN_UINT8, &value, NULL);
+
+  return value;
+}
+
+unsigned short APIENTRY binn_object_uint16(void *obj, char *key) {
+  unsigned short value;
+
+  binn_object_get(obj, key, BINN_UINT16, &value, NULL);
+
+  return value;
+}
+
+unsigned int APIENTRY binn_object_uint32(void *obj, char *key) {
+  unsigned int value;
+
+  binn_object_get(obj, key, BINN_UINT32, &value, NULL);
+
+  return value;
+}
+
+uint64 APIENTRY binn_object_uint64(void *obj, char *key) {
+  uint64 value;
+
+  binn_object_get(obj, key, BINN_UINT64, &value, NULL);
+
+  return value;
+}
+
+float APIENTRY binn_object_float(void *obj, char *key) {
+  float value;
+
+  binn_object_get(obj, key, BINN_FLOAT32, &value, NULL);
+
+  return value;
+}
+
+double APIENTRY binn_object_double(void *obj, char *key) {
+  double value;
+
+  binn_object_get(obj, key, BINN_FLOAT64, &value, NULL);
+
+  return value;
+}
+
+BOOL APIENTRY binn_object_bool(void *obj, char *key) {
+  BOOL value;
+
+  binn_object_get(obj, key, BINN_BOOL, &value, NULL);
+
+  return value;
+}
+
+BOOL APIENTRY binn_object_null(void *obj, char *key) {
+
+  return binn_object_get(obj, key, BINN_NULL, NULL, NULL);
+
+}
+
+char * APIENTRY binn_object_str(void *obj, char *key) {
+  char *value;
+
+  binn_object_get(obj, key, BINN_STRING, &value, NULL);
+
+  return value;
+}
+
+void * APIENTRY binn_object_blob(void *obj, char *key, int *psize) {
+  void *value;
+
+  binn_object_get(obj, key, BINN_BLOB, &value, psize);
+
+  return value;
+}
+
+void * APIENTRY binn_object_list(void *obj, char *key) {
+  void *value;
+
+  binn_object_get(obj, key, BINN_LIST, &value, NULL);
+
+  return value;
+}
+
+void * APIENTRY binn_object_map(void *obj, char *key) {
+  void *value;
+
+  binn_object_get(obj, key, BINN_MAP, &value, NULL);
+
+  return value;
+}
+
+void * APIENTRY binn_object_object(void *obj, char *key) {
+  void *value;
+
+  binn_object_get(obj, key, BINN_OBJECT, &value, NULL);
+
+  return value;
+}
+
+/*************************************************************************************/
+/*************************************************************************************/
+
+BINN_PRIVATE binn * binn_alloc_item() {
+  binn *item;
+  item = (binn *) binn_malloc(sizeof(binn));
+  if (item) {
+    memset(item, 0, sizeof(binn));
+    item->header = BINN_MAGIC;
+    item->allocated = TRUE;
+    //item->writable = FALSE;  -- already zeroed
+  }
+  return item;
+}
+
+/*************************************************************************************/
+
+binn * APIENTRY binn_value(int type, void *pvalue, int size, binn_mem_free freefn) {
+  int storage_type;
+  binn *item = binn_alloc_item();
+  if (item) {
+    item->type = type;
+    binn_get_type_info(type, &storage_type, NULL);
+    switch (storage_type) {
+    case BINN_STORAGE_NOBYTES:
+      break;
+    case BINN_STORAGE_STRING:
+      if (size == 0) size = strlen((char*)pvalue) + 1;
+    case BINN_STORAGE_BLOB:
+    case BINN_STORAGE_CONTAINER:
+      if (freefn == BINN_TRANSIENT) {
+        item->ptr = binn_memdup(pvalue, size);
+        if (item->ptr == NULL) {
+          free_fn(item);
+          return NULL;
+        }
+        item->freefn = free_fn;
+        if (storage_type == BINN_STORAGE_STRING) size--;
+      } else {
+        item->ptr = pvalue;
+        item->freefn = freefn;
+      }
+      item->size = size;
+      break;
+    default:
+      item->ptr = &item->vint32;
+      copy_raw_value(pvalue, item->ptr, storage_type);
+    }
+  }
+  return item;
+}
+
+/*************************************************************************************/
+
+BOOL APIENTRY binn_set_string(binn *item, char *str, binn_mem_free pfree) {
+
+  if (item == NULL || str == NULL) return FALSE;
+
+  if (pfree == BINN_TRANSIENT) {
+    item->ptr = binn_memdup(str, strlen(str) + 1);
+    if (item->ptr == NULL) return FALSE;
+    item->freefn = free_fn;
+  } else {
+    item->ptr = str;
+    item->freefn = pfree;
+  }
+
+  item->type = BINN_STRING;
+  return TRUE;
+
+}
+
+/*************************************************************************************/
+
+BOOL APIENTRY binn_set_blob(binn *item, void *ptr, int size, binn_mem_free pfree) {
+
+  if (item == NULL || ptr == NULL) return FALSE;
+
+  if (pfree == BINN_TRANSIENT) {
+    item->ptr = binn_memdup(ptr, size);
+    if (item->ptr == NULL) return FALSE;
+    item->freefn = free_fn;
+  } else {
+    item->ptr = ptr;
+    item->freefn = pfree;
+  }
+
+  item->type = BINN_BLOB;
+  item->size = size;
+  return TRUE;
+
+}
+
+/*************************************************************************************/
+/*** READ CONVERTED VALUE ************************************************************/
+/*************************************************************************************/
+
+#ifdef _MSC_VER
+#define atoi64 _atoi64
+#else
+int64 atoi64(char *str) {
+  int64 retval;
+  int is_negative=0;
+
+  if (*str == '-') {
+    is_negative = 1;
+    str++;
+  }
+  retval = 0;
+  for (; *str; str++) {
+    retval = 10 * retval + (*str - '0');
+  }
+  if (is_negative) retval *= -1;
+  return retval;
+}
+#endif
+
+/*****************************************************************************/
+
+BINN_PRIVATE BOOL is_integer(char *p) {
+  BOOL retval;
+
+  if (p == NULL) return FALSE;
+  if (*p == '-') p++;
+  if (*p == 0) return FALSE;
+
+  retval = TRUE;
+
+  for (; *p; p++) {
+    if ( (*p < '0') || (*p > '9') ) {
+      retval = FALSE;
+    }
+  }
+
+  return retval;
+}
+
+/*****************************************************************************/
+
+BINN_PRIVATE BOOL is_float(char *p) {
+  BOOL retval, number_found=FALSE;
+
+  if (p == NULL) return FALSE;
+  if (*p == '-') p++;
+  if (*p == 0) return FALSE;
+
+  retval = TRUE;
+
+  for (; *p; p++) {
+    if ((*p == '.') || (*p == ',')) {
+      if (!number_found) retval = FALSE;
+    } else if ( (*p >= '0') && (*p <= '9') ) {
+      number_found = TRUE;
+    } else {
+      return FALSE;
+    }
+  }
+
+  return retval;
+}
+
+/*************************************************************************************/
+
+BINN_PRIVATE BOOL is_bool_str(char *str, BOOL *pbool) {
+  int64  vint;
+  double vdouble;
+
+  if (str == NULL || pbool == NULL) return FALSE;
+
+  if (stricmp(str, "true") == 0) goto loc_true;
+  if (stricmp(str, "yes") == 0) goto loc_true;
+  if (stricmp(str, "on") == 0) goto loc_true;
+  //if (stricmp(str, "1") == 0) goto loc_true;
+
+  if (stricmp(str, "false") == 0) goto loc_false;
+  if (stricmp(str, "no") == 0) goto loc_false;
+  if (stricmp(str, "off") == 0) goto loc_false;
+  //if (stricmp(str, "0") == 0) goto loc_false;
+
+  if (is_integer(str)) {
+    vint = atoi64(str);
+    *pbool = (vint != 0) ? TRUE : FALSE;
+    return TRUE;
+  } else if (is_float(str)) {
+    vdouble = atof(str);
+    *pbool = (vdouble != 0) ? TRUE : FALSE;
+    return TRUE;
+  }
+
+  return FALSE;
+
+loc_true:
+  *pbool = TRUE;
+  return TRUE;
+
+loc_false:
+  *pbool = FALSE;
+  return TRUE;
+
+}
+
+/*************************************************************************************/
+
+BOOL APIENTRY binn_get_int32(binn *value, int *pint) {
+
+  if (value == NULL || pint == NULL) return FALSE;
+
+  if (type_family(value->type) == BINN_FAMILY_INT) {
+    return copy_int_value(value->ptr, pint, value->type, BINN_INT32);
+  }
+
+  switch (value->type) {
+  case BINN_FLOAT:
+    if ((value->vfloat < INT32_MIN) || (value->vfloat > INT32_MAX)) return FALSE;
+    *pint = round(value->vfloat);
+    break;
+  case BINN_DOUBLE:
+    if ((value->vdouble < INT32_MIN) || (value->vdouble > INT32_MAX)) return FALSE;
+    *pint = round(value->vdouble);
+    break;
+  case BINN_STRING:
+    if (is_integer((char*)value->ptr))
+      *pint = atoi((char*)value->ptr);
+    else if (is_float((char*)value->ptr))
+      *pint = round(atof((char*)value->ptr));
+    else
+      return FALSE;
+    break;
+  case BINN_BOOL:
+    *pint = value->vbool;
+    break;
+  default:
+    return FALSE;
+  }
+
+  return TRUE;
+}
+
+/*************************************************************************************/
+
+BOOL APIENTRY binn_get_int64(binn *value, int64 *pint) {
+
+  if (value == NULL || pint == NULL) return FALSE;
+
+  if (type_family(value->type) == BINN_FAMILY_INT) {
+    return copy_int_value(value->ptr, pint, value->type, BINN_INT64);
+  }
+
+  switch (value->type) {
+  case BINN_FLOAT:
+    if ((value->vfloat < INT64_MIN) || (value->vfloat > INT64_MAX)) return FALSE;
+    *pint = round(value->vfloat);
+    break;
+  case BINN_DOUBLE:
+    if ((value->vdouble < INT64_MIN) || (value->vdouble > INT64_MAX)) return FALSE;
+    *pint = round(value->vdouble);
+    break;
+  case BINN_STRING:
+    if (is_integer((char*)value->ptr))
+      *pint = atoi64((char*)value->ptr);
+    else if (is_float((char*)value->ptr))
+      *pint = round(atof((char*)value->ptr));
+    else
+      return FALSE;
+    break;
+  case BINN_BOOL:
+    *pint = value->vbool;
+    break;
+  default:
+    return FALSE;
+  }
+
+  return TRUE;
+}
+
+/*************************************************************************************/
+
+BOOL APIENTRY binn_get_double(binn *value, double *pfloat) {
+  int64 vint;
+
+  if (value == NULL || pfloat == NULL) return FALSE;
+
+  if (type_family(value->type) == BINN_FAMILY_INT) {
+    if (copy_int_value(value->ptr, &vint, value->type, BINN_INT64) == FALSE) return FALSE;
+    *pfloat = (double) vint;
+    return TRUE;
+  }
+
+  switch (value->type) {
+  case BINN_FLOAT:
+    *pfloat = value->vfloat;
+    break;
+  case BINN_DOUBLE:
+    *pfloat = value->vdouble;
+    break;
+  case BINN_STRING:
+    if (is_integer((char*)value->ptr))
+      *pfloat = (double) atoi64((char*)value->ptr);
+    else if (is_float((char*)value->ptr))
+      *pfloat = atof((char*)value->ptr);
+    else
+      return FALSE;
+    break;
+  case BINN_BOOL:
+    *pfloat = value->vbool;
+    break;
+  default:
+    return FALSE;
+  }
+
+  return TRUE;
+}
+
+/*************************************************************************************/
+
+BOOL APIENTRY binn_get_bool(binn *value, BOOL *pbool) {
+  int64 vint;
+
+  if (value == NULL || pbool == NULL) return FALSE;
+
+  if (type_family(value->type) == BINN_FAMILY_INT) {
+    if (copy_int_value(value->ptr, &vint, value->type, BINN_INT64) == FALSE) return FALSE;
+    *pbool = (vint != 0) ? TRUE : FALSE;
+    return TRUE;
+  }
+
+  switch (value->type) {
+  case BINN_BOOL:
+    *pbool = value->vbool;
+    break;
+  case BINN_FLOAT:
+    *pbool = (value->vfloat != 0) ? TRUE : FALSE;
+    break;
+  case BINN_DOUBLE:
+    *pbool = (value->vdouble != 0) ? TRUE : FALSE;
+    break;
+  case BINN_STRING:
+    return is_bool_str((char*)value->ptr, pbool);
+  default:
+    return FALSE;
+  }
+
+  return TRUE;
+}
+
+/*************************************************************************************/
+
+char * APIENTRY binn_get_str(binn *value) {
+  int64 vint;
+  char buf[128];
+
+  if (value == NULL) return NULL;
+
+  if (type_family(value->type) == BINN_FAMILY_INT) {
+    if (copy_int_value(value->ptr, &vint, value->type, BINN_INT64) == FALSE) return NULL;
+    sprintf(buf, "%" INT64_FORMAT, vint);
+    goto loc_convert_value;
+  }
+
+  switch (value->type) {
+  case BINN_FLOAT:
+    value->vdouble = value->vfloat;
+  case BINN_DOUBLE:
+    sprintf(buf, "%g", value->vdouble);
+    goto loc_convert_value;
+  case BINN_STRING:
+    return (char*) value->ptr;
+  case BINN_BOOL:
+    if (value->vbool)
+      strcpy(buf, "true");
+    else
+      strcpy(buf, "false");
+    goto loc_convert_value;
+  }
+
+  return NULL;
+
+loc_convert_value:
+
+  //value->vint64 = 0;
+  value->ptr = strdup(buf);
+  if (value->ptr == NULL) return NULL;
+  value->freefn = free;
+  value->type = BINN_STRING;
+  return (char*) value->ptr;
+
+}
+
+/*************************************************************************************/
+/*** GENERAL FUNCTIONS ***************************************************************/
+/*************************************************************************************/
+
+BOOL APIENTRY binn_is_container(binn *item) {
+
+  if (item == NULL) return FALSE;
+
+  switch (item->type) {
+  case BINN_LIST:
+  case BINN_MAP:
+  case BINN_OBJECT:
+    return TRUE;
+  default:
+    return FALSE;
+  }
+
+}
+
+/*************************************************************************************/