summaryrefslogtreecommitdiff
path: root/src/lib/binn.cc
diff options
context:
space:
mode:
authorDaniel Friesel <derf@finalrewind.org>2019-01-09 10:39:27 +0100
committerDaniel Friesel <derf@finalrewind.org>2019-01-09 10:39:27 +0100
commit27e97cca23e8222b147e2070282bcdb14e3bddfc (patch)
tree409b40d40377cf36eca926228732c34f8600593c /src/lib/binn.cc
parent2d4375cab1f2a216d060db3197f62379cd9f09a9 (diff)
import binn serialization format
Diffstat (limited to 'src/lib/binn.cc')
-rw-r--r--src/lib/binn.cc3372
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;
+ }
+
+}
+
+/*************************************************************************************/