celix-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From pnol...@apache.org
Subject [1/2] celix git commit: CELIX-237: refactoring to dynamic_function_interface. dyn_type now uses mem stream and avro descriptor translator added
Date Thu, 02 Jul 2015 08:02:10 GMT
Repository: celix
Updated Branches:
  refs/heads/feature/CELIX-237_rsa-ffi 7f3383247 -> bdeba2bcb


http://git-wip-us.apache.org/repos/asf/celix/blob/bdeba2bc/remote_services/dynamic_function_interface/dyn_type.c
----------------------------------------------------------------------
diff --git a/remote_services/dynamic_function_interface/dyn_type.c b/remote_services/dynamic_function_interface/dyn_type.c
new file mode 100644
index 0000000..5ad18f4
--- /dev/null
+++ b/remote_services/dynamic_function_interface/dyn_type.c
@@ -0,0 +1,822 @@
+/**
+ * Licensed under Apache License v2. See LICENSE for more information.
+ */
+#include "dyn_type.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+#include <ctype.h>
+#include <assert.h>
+#include <errno.h>
+
+static int dynType_createWithStream(FILE *stream, dyn_type *parent, dyn_type **type);
+static void dynType_clear(dyn_type *type);
+static void dynType_clearComplex(dyn_type *type);
+static void dynType_clearSequence(dyn_type *type);
+static void dynType_clearTypedPointer(dyn_type *type);
+
+static ffi_type * dynType_ffiTypeFor(int c);
+static dyn_type * dynType_findType(dyn_type *type, char *name);
+static int dynType_parse(FILE *stream, dyn_type *type);
+static int dynType_parseComplex(FILE *stream, dyn_type *type);
+static int dynType_parseName(FILE *stream, char **name);
+static int dynType_parseNestedType(FILE *stream, dyn_type *type);
+static int dynType_parseReference(FILE *stream, dyn_type *type);
+static int dynType_parseRefByValue(FILE *stream, dyn_type *type);
+static int dynType_parseSequence(FILE *stream, dyn_type *type);
+static int dynType_parseSimple(int c, dyn_type *type);
+static int dynType_parseTypedPointer(FILE *stream, dyn_type *type);
+static void dynType_prepCif(ffi_type *type);
+static unsigned short dynType_getOffset(dyn_type *type, int index);
+
+static void dynType_printAny(char *name, dyn_type *type, int depth);
+static void dynType_printComplex(char *name, dyn_type *type, int depth);
+static void dynType_printSequence(char *name, dyn_type *type, int depth);
+static void dynType_printSimple(char *name, dyn_type *type, int depth);
+static void dynType_printTypedPointer(char *name, dyn_type *type, int depth);
+static void printDepth(int depth);
+
+static void dynType_printTypes(dyn_type *type);
+static void dynType_printComplexType(dyn_type *type);
+static void dynType_printSimpleType(dyn_type *type);
+
+struct generic_sequence {
+    uint32_t cap;
+    uint32_t len;
+    void *buf;
+};
+
+static const int DT_OK = 0;
+static const int DT_ERROR = 1;
+static const int DT_MEM_ERROR = 2;
+static const int DT_PARSE_ERROR = 3;
+
+#define DT_LOG_ERROR    1
+#define DT_LOG_WARNING  2
+#define DT_LOG_INFO     3
+#define DT_LOG_DEBUG    4
+#define DT_LOG(lvl, msg, ...) if(g_logf != NULL) { \
+    g_logf(g_logHandle, (lvl), __FILE__, __LINE__, (msg),  ##__VA_ARGS__);  \
+}
+
+static void (*g_logf)(void *handle, int level, const char *file, int line, const char *msgFormat, ...) = NULL;
+static void *g_logHandle = NULL;
+
+void dynType_setupLogger(void (*logf)(void *handle, int level, const char *file, int line, const char *msgFormat, ...), void *handle) {
+    g_logHandle = handle;
+    g_logf = logf;
+}
+
+int dynType_create(const char *descriptor, dyn_type **type) {
+    int status = DT_OK;
+    FILE *stream = fmemopen((char *)descriptor, strlen(descriptor), "r");
+    if (stream != NULL) {
+        status = dynType_createWithStream(stream, NULL, type);
+        if (status == DT_OK) {
+            int c = fgetc(stream);
+            if (c != '\0' && c != EOF) {
+                status = DT_PARSE_ERROR;
+                DT_LOG(DT_LOG_ERROR, "Expected EOF got %c", c);
+            }
+        } 
+        fclose(stream);
+    } else {
+        status = DT_ERROR;
+        DT_LOG(DT_LOG_ERROR, "Error creating mem stream for descriptor string. %s", strerror(errno)); 
+    }
+    return status;
+}
+
+static int dynType_createWithStream(FILE *stream, dyn_type *parent, dyn_type **result) {
+    int status = DT_OK;
+    dyn_type *type = calloc(1, sizeof(*type));
+    if (type != NULL) {
+        type->parent = parent;
+        type->type = DYN_TYPE_INVALID;
+        TAILQ_INIT(&type->nestedTypesHead);
+        status = dynType_parse(stream, type);        
+        if (status == DT_OK) {
+            *result = type;
+        } else {
+            dynType_destroy(type);
+        }
+    } else {
+        status = DT_MEM_ERROR;
+        DT_LOG(DT_LOG_ERROR, "Error allocating memory for type");
+    }
+    return status;
+}
+
+static int dynType_parse(FILE *stream, dyn_type *type) {
+    int status = DT_OK;
+
+    int c = fgetc(stream);
+    switch(c) {
+        case 'T' :
+            status = dynType_parseNestedType(stream, type);
+            if (status == DT_OK) {
+                status = dynType_parse(stream, type);
+            } 
+            break;
+        case 'L' :
+            status = dynType_parseReference(stream, type);
+            break;
+        case 'l' :
+            status = dynType_parseRefByValue(stream, type);
+            break;
+        case '{' :
+            status = dynType_parseComplex(stream, type);
+            break;
+        case '[' :
+            status = dynType_parseSequence(stream, type);
+            break;
+        case '*' :
+            status = dynType_parseTypedPointer(stream, type);
+            break;
+        default :
+            status = dynType_parseSimple(c, type);
+            break;
+    }
+
+    return status;
+}
+
+static int dynType_parseComplex(FILE *stream, dyn_type *type) {
+    int status = DT_OK;
+    type->type = DYN_TYPE_COMPLEX;
+    type->descriptor = '{';
+    type->ffiType = &type->complex.structType;
+    TAILQ_INIT(&type->complex.entriesHead);
+
+    int c = fgetc(stream);
+    struct complex_type_entry *entry = NULL;
+    while (c != ' ' && c != '}') {
+        ungetc(c,stream);
+        entry = calloc(1, sizeof(*entry));
+        if (entry != NULL) {
+            entry->type.parent = type;
+            entry->type.type = DYN_TYPE_INVALID;
+            TAILQ_INIT(&entry->type.nestedTypesHead);
+            TAILQ_INSERT_TAIL(&type->complex.entriesHead, entry, entries);
+            status = dynType_parse(stream, &entry->type);
+        } else {
+            status = DT_MEM_ERROR;
+            DT_LOG(DT_LOG_ERROR, "Error allocating memory for type");
+        }
+        c = fgetc(stream);
+    }
+
+    entry = TAILQ_FIRST(&type->complex.entriesHead);
+    char *name = NULL;
+    while (c == ' ' && entry != NULL) {
+        status = dynType_parseName(stream, &name);
+        if (status == DT_OK) {
+            entry->name = name;
+            entry = TAILQ_NEXT(entry, entries);
+        } else {
+            break;
+        }
+        c = getc(stream); 
+    }
+
+    int count = 0;
+    TAILQ_FOREACH(entry, &type->complex.entriesHead, entries) {
+        count +=1;
+    }
+
+    if (status == DT_OK) {
+        type->complex.structType.type =  FFI_TYPE_STRUCT;
+        type->complex.structType.elements = calloc(count + 1, sizeof(ffi_type));
+        type->complex.structType.elements[count] = NULL;
+        if (type->complex.structType.elements != NULL) {
+            int index = 0;
+            TAILQ_FOREACH(entry, &type->complex.entriesHead, entries) {
+                type->complex.structType.elements[index++] = entry->type.ffiType;
+            }
+        } else {
+            status = DT_MEM_ERROR;
+            //T\nODO log: error allocating memory
+        }
+    }
+
+    if (status == DT_OK) {
+        type->complex.types = calloc(count, sizeof(dyn_type *));
+        if (type != NULL) {
+            int index = 0;
+            TAILQ_FOREACH(entry, &type->complex.entriesHead, entries) {
+                type->complex.types[index++] = &entry->type;
+            }
+        } else {
+            status = DT_MEM_ERROR;
+            DT_LOG(DT_LOG_ERROR, "Error allocating memory for type")
+        }
+    }
+
+    if (status == DT_OK) {
+        dynType_prepCif(type->ffiType);
+    }
+
+
+    return status;
+}
+
+static int dynType_parseName(FILE *stream, char **result) {
+    int status = DT_OK;
+
+    char *buf = NULL;
+    size_t size = 0;
+    FILE *name = open_memstream(&buf, &size);
+
+    if (name != NULL) { 
+        int c = getc(stream);
+        while (isalnum(c) || c == '_') {
+            fputc(c, name); 
+            c = getc(stream);
+        }
+        fflush(name);
+        fclose(name);
+        *result = buf;
+        ungetc(c, stream);
+    } else {
+        status = DT_ERROR;
+        DT_LOG(DT_LOG_ERROR, "Error creating mem stream for name. %s", strerror(errno));
+    }
+
+    return status;
+}
+
+static int dynType_parseNestedType(FILE *stream, dyn_type *type) {
+    int status = DT_OK;
+    char *name = NULL;
+    struct nested_entry *entry = NULL; 
+
+    entry = calloc(1, sizeof(*entry));
+    if (entry != NULL) {
+        entry->type.parent = type;
+        entry->type.type = DYN_TYPE_INVALID;
+        TAILQ_INIT(&entry->type.nestedTypesHead);
+        TAILQ_INSERT_TAIL(&type->nestedTypesHead, entry, entries);
+        status = dynType_parseName(stream, &name);
+        entry->type.name = name;
+    } else {
+        status = DT_MEM_ERROR;  
+    }     
+
+    if (status == DT_OK) {
+        int c = fgetc(stream);
+        if (c != '=') {
+            status = DT_PARSE_ERROR;
+            DT_LOG(DT_LOG_ERROR, "Error parsing nested type expected '=' got '%c'", c);
+        }
+    }
+
+    if (status == DT_OK) {
+        status = dynType_parse(stream, &entry->type);
+        int c = fgetc(stream);
+        if (c != ';') {
+            status = DT_PARSE_ERROR;
+            DT_LOG(DT_LOG_ERROR, "Expected ';' got '%c'\n", c);
+        }
+    }
+
+    return status;
+}
+
+static int dynType_parseReference(FILE *stream, dyn_type *type) {
+    int status = DT_OK;
+    type->type = DYN_TYPE_TYPED_POINTER;
+    type->descriptor = '*';
+
+    type->ffiType = &ffi_type_pointer;
+    type->typedPointer.typedType =  NULL;
+
+    dyn_type *subType = calloc(1, sizeof(*subType));
+
+    if (subType != NULL) {
+        type->typedPointer.typedType = subType;
+        subType->parent = type;
+        subType->type = DYN_TYPE_INVALID;
+        TAILQ_INIT(&subType->nestedTypesHead);
+        status = dynType_parseRefByValue(stream, subType);
+    } else {
+        status = DT_MEM_ERROR;
+        DT_LOG(DT_LOG_ERROR, "Error allocating memory for subtype\n");
+    }
+
+    return status;
+}
+
+static int dynType_parseRefByValue(FILE *stream, dyn_type *type) {
+    int status = DT_OK;
+    type->type = DYN_TYPE_REF;
+    type->descriptor = 'l';
+
+    char *name = NULL;
+    status = dynType_parseName(stream, &name);
+    if (status == DT_OK) {
+        dyn_type *ref = dynType_findType(type, name);
+        free(name);
+        if (ref != NULL) {
+            type->ref.ref = ref;
+        } else {
+            status = DT_PARSE_ERROR;
+            DT_LOG(DT_LOG_ERROR, "Error cannot find type '%s'", name);
+        }
+    } 
+
+    if (status == DT_OK) {
+        int c = fgetc(stream);
+        if (c != ';') {
+            status = DT_PARSE_ERROR;
+            DT_LOG(DT_LOG_ERROR, "Error expected ';' got '%c'", c);
+        } 
+    }
+
+    return status;
+}
+
+static ffi_type *seq_types[] = {&ffi_type_uint32, &ffi_type_uint32, &ffi_type_pointer, NULL};
+
+static int dynType_parseSequence(FILE *stream, dyn_type *type) {
+    int status = DT_OK;
+    type->type = DYN_TYPE_SEQUENCE;
+    type->descriptor = '[';
+
+    type->sequence.seqType.elements = seq_types;
+    status = dynType_createWithStream(stream, type, &type->sequence.itemType);
+
+    if (status == DT_OK) {
+        type->ffiType = &type->sequence.seqType;
+        dynType_prepCif(&type->sequence.seqType);
+    }
+
+    return status;
+}
+
+static int dynType_parseSimple(int c, dyn_type *type) {
+    int status = DT_OK;
+    ffi_type *ffiType = dynType_ffiTypeFor(c);
+    if (ffiType != NULL) {
+        type->type = DYN_TYPE_SIMPLE;
+        type->descriptor = c;
+        type->ffiType = ffiType;
+    } else {
+        status = DT_PARSE_ERROR;
+        DT_LOG(DT_LOG_ERROR, "Error unsupported type '%c'", c);
+    }
+
+    return status;
+}
+
+static int dynType_parseTypedPointer(FILE *stream, dyn_type *type) {
+    int status = DT_OK;
+    type->type = DYN_TYPE_TYPED_POINTER;
+    type->descriptor = '*';
+    type->ffiType = &ffi_type_pointer;
+
+    status = dynType_createWithStream(stream, type, &type->typedPointer.typedType);
+
+    return status;
+}
+
+static void dynType_prepCif(ffi_type *type) {
+    ffi_cif cif;
+    ffi_type *args[1];
+    args[0] = type;
+    ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 1, &ffi_type_uint, args);
+}
+
+void dynType_destroy(dyn_type *type) {
+    if (type != NULL) {          
+        dynType_clear(type);
+        free(type);
+    }
+}
+
+static void dynType_clear(dyn_type *type) {
+    struct nested_entry *entry = TAILQ_FIRST(&type->nestedTypesHead);
+    struct nested_entry *tmp = NULL;
+    while (entry != NULL) {
+        tmp = entry;
+        entry = TAILQ_NEXT(entry, entries);
+        dynType_clear(&tmp->type);
+        free(tmp);
+    }
+
+    switch (type->type) {
+        case DYN_TYPE_COMPLEX :
+            dynType_clearComplex(type);
+            break;
+        case DYN_TYPE_SEQUENCE :
+            dynType_clearSequence(type);
+            break;
+        case DYN_TYPE_TYPED_POINTER :
+            dynType_clearTypedPointer(type);
+            break;
+    } 
+
+    if (type->name != NULL) {
+        free(type->name);
+    }
+}
+
+static void dynType_clearComplex(dyn_type *type) {
+    assert(type->type == DYN_TYPE_COMPLEX);
+    struct complex_type_entry *entry = TAILQ_FIRST(&type->complex.entriesHead);
+    struct complex_type_entry *tmp = NULL;
+    while (entry != NULL) {
+        dynType_clear(&entry->type);
+        if (entry->name != NULL) {
+            free(entry->name);
+        }
+        tmp = entry;
+        entry = TAILQ_NEXT(entry, entries);
+        free(tmp);
+    }
+    if (type->complex.types != NULL) {
+        free(type->complex.types);
+    }
+    if (type->complex.structType.elements != NULL) {
+        free(type->complex.structType.elements);
+    }
+}
+
+static void dynType_clearSequence(dyn_type *type) {
+    assert(type->type == DYN_TYPE_SEQUENCE);
+    if (type->sequence.itemType != NULL) {
+        dynType_destroy(type->sequence.itemType);
+    }
+}
+
+static void dynType_clearTypedPointer(dyn_type *type) {
+    assert(type->type == DYN_TYPE_TYPED_POINTER);
+    if (type->typedPointer.typedType != NULL) {
+        dynType_destroy(type->typedPointer.typedType);
+    }
+}
+
+int dynType_alloc(dyn_type *type, void **bufLoc) {
+    int status = DT_OK;
+    void *inst = calloc(1, type->ffiType->size);
+    if (inst != NULL) {
+        *bufLoc = inst;
+    } else {
+        status = DT_MEM_ERROR;
+        //TODO log
+    }
+    return status;
+}
+
+
+int dynType_complex_indexForName(dyn_type *type, const char *name) {
+    printf("descriptor is %c\n", type->descriptor);
+    assert(type->type == DYN_TYPE_COMPLEX);
+    int i = 0;
+    int index = -1;
+    struct complex_type_entry *entry = NULL;
+    TAILQ_FOREACH(entry, &type->complex.entriesHead, entries) {
+        if (strcmp(name, entry->name) == 0) {
+            index = i;
+        }
+        i +=1;
+    }
+    return index;
+}
+
+char dynType_complex_descriptorTypeAt(dyn_type *type, int index) {
+    assert(type->type == DYN_TYPE_COMPLEX);
+
+    dyn_type *item = type->complex.types[index];
+    return item->descriptor;
+}
+
+int dynType_complex_dynTypeAt(dyn_type *type, int index, dyn_type **result) {
+    assert(type->type == DYN_TYPE_COMPLEX);
+    *result = type->complex.types[index];
+    return 0;
+}
+
+int dynType_complex_setValueAt(dyn_type *type, int index, void *start, void *in) {
+    assert(type->type == DYN_TYPE_COMPLEX);
+    char *loc = ((char *)start) + dynType_getOffset(type, index);
+    size_t size = type->complex.structType.elements[index]->size;
+    memcpy(loc, in, size);
+    return 0;
+}
+
+int dynType_complex_valLocAt(dyn_type *type, int index, void *inst, void **result) {
+    assert(type->type == DYN_TYPE_COMPLEX);
+    char *l = (char *)inst;
+    void *loc = (void *)(l + dynType_getOffset(type, index));
+    *result = loc;
+    return 0;
+}
+
+//sequence
+int dynType_sequence_alloc(dyn_type *type, void *inst, int cap, void **out) {
+    assert(type->type == DYN_TYPE_SEQUENCE);
+    int status = DT_OK;
+    struct generic_sequence *seq = inst;
+    if (seq != NULL) {
+        size_t size = dynType_size(type->sequence.itemType);
+        seq->buf = calloc(cap, size);
+        if (seq->buf != NULL) {
+            seq->cap = cap;
+            seq->len = 0;
+            *out = seq->buf;
+        } else {
+            seq->cap = 0;
+            status = DT_MEM_ERROR;
+            DT_LOG(DT_LOG_ERROR, "Error allocating memory for buf")
+        }
+    } else {
+            status = DT_MEM_ERROR;
+            DT_LOG(DT_LOG_ERROR, "Error allocating memory for seq")
+    }
+    return status;
+}
+
+int dynType_sequence_append(dyn_type *type, void *inst, void *in) {
+    assert(type->type == DYN_TYPE_SEQUENCE);
+    int status = DT_OK;
+    int index = -1;
+    struct generic_sequence *seq = inst;
+    if (seq->len + 1 <= seq->cap) {
+        index = seq->len;
+        seq->len += 1;
+        char *buf = seq->buf;
+        size_t elSize = dynType_size(type->sequence.itemType);
+        size_t offset = (elSize * index);
+        memcpy(buf + offset, in, elSize);
+    } else {
+        status = DT_ERROR;
+        DT_LOG(DT_LOG_ERROR, "Sequence out of capacity")
+    }
+    return status;
+}
+
+dyn_type * dynType_sequence_itemType(dyn_type *type) {
+    assert(type->type == DYN_TYPE_SEQUENCE);
+    return type->sequence.itemType;
+}
+
+void dynType_simple_setValue(dyn_type *type, void *inst, void *in) {
+    size_t size = dynType_size(type);
+    memcpy(inst, in, size);
+}
+
+
+int dynType_descriptorType(dyn_type *type) {
+    return type->descriptor;
+}
+
+static ffi_type * dynType_ffiTypeFor(int c) {
+    ffi_type *type = NULL;
+    switch (c) {
+        case 'F' :
+            type = &ffi_type_float;
+            break;
+        case 'D' :
+            type = &ffi_type_double;
+            break;
+        case 'B' :
+            type = &ffi_type_sint8;
+            break;
+        case 'b' :
+            type = &ffi_type_uint8;
+            break;
+        case 'S' :
+            type = &ffi_type_sint16;
+            break;
+        case 's' :
+            type = &ffi_type_uint16;
+            break;
+        case 'I' :
+            type = &ffi_type_sint32;
+            break;
+        case 'i' :
+            type = &ffi_type_uint32;
+            break;
+        case 'J' :
+            type = &ffi_type_sint64;
+            break;
+        case 'j' :
+            type = &ffi_type_sint64;
+            break;
+        case 'N' :
+            type = &ffi_type_sint;
+            break;
+        case 'P' :
+            type = &ffi_type_pointer;
+            break;
+    }
+    return type;
+}
+
+static dyn_type * dynType_findType(dyn_type *type, char *name) {
+    dyn_type *result = NULL;
+
+    struct nested_entry *entry = NULL;
+    TAILQ_FOREACH(entry, &type->nestedTypesHead, entries) {
+        if (strcmp(name, entry->type.name) == 0) {
+            result = &entry->type;
+            break;
+        }
+    }
+
+    if (result == NULL && type->parent != NULL) {
+        result = dynType_findType(type->parent, name);
+    }
+
+    return result;
+}
+
+static unsigned short dynType_getOffset(dyn_type *type, int index) {
+    assert(type->type == DYN_TYPE_COMPLEX);
+    unsigned short offset = 0;
+
+    ffi_type *ffiType = &type->complex.structType;
+    int i;
+    for (i = 0;  i <= index && ffiType->elements[i] != NULL; i += 1) {
+        size_t size = ffiType->elements[i]->size;
+        unsigned short alignment = ffiType->elements[i]->alignment;
+        int alignment_diff = offset % alignment;
+        if (alignment_diff > 0) {
+            offset += (alignment - alignment_diff);
+        }
+        if (i < index) {
+            offset += size;
+        }
+    }
+
+    return offset;
+}
+
+size_t dynType_size(dyn_type *type) {
+    return type->ffiType->size;
+}
+
+int dynType_type(dyn_type *type) {
+    return type->type;
+}
+
+void dynType_print(dyn_type *type) {
+    if (type != NULL) {
+        dynType_printTypes(type);
+
+        printf("main type:\n");
+        dynType_printAny("root", type, 0);
+    } else {
+        printf("invalid type\n");
+    }
+}
+
+static void printDepth(int depth) {
+    int i;
+    for (i = 0; i < depth; i +=1 ) {
+        printf("\t");
+    }
+}
+
+static void dynType_printAny(char *name, dyn_type *type, int depth) {
+    dyn_type *toPrint = type;
+    if (toPrint->type == DYN_TYPE_REF) {
+        toPrint = toPrint->ref.ref;
+    }
+    switch(toPrint->type) {
+        case DYN_TYPE_COMPLEX :
+            dynType_printComplex(name, toPrint, depth);
+            break;
+        case DYN_TYPE_SIMPLE :
+            dynType_printSimple(name, toPrint, depth);
+            break;
+        case DYN_TYPE_SEQUENCE :
+            dynType_printSequence(name, toPrint, depth);
+            break;
+        case DYN_TYPE_TYPED_POINTER :
+            dynType_printTypedPointer(name, toPrint, depth);
+            break;
+        default :
+            printf("TODO Unsupported type %i\n", toPrint->type);
+            break;
+    }
+}
+
+static void dynType_printComplex(char *name, dyn_type *type, int depth) {
+    if (type->name == NULL) {
+        printDepth(depth);
+        printf("%s: complex type (anon), size is %zu, alignment is %i, descriptor is '%c'. fields:\n", name,  type->ffiType->size, type->ffiType->alignment, type->descriptor); 
+
+        struct complex_type_entry *entry = NULL;
+        TAILQ_FOREACH(entry, &type->complex.entriesHead, entries) {
+            dynType_printAny(entry->name, &entry->type, depth + 1);
+        }
+
+        printDepth(depth);
+        printf("}\n");
+    } else {
+        printDepth(depth);
+        printf("%s: complex type ('%s'), size is %zu, alignment is %i, descriptor is '%c'.\n", name, type->name, type->ffiType->size, type->ffiType->alignment, type->descriptor); 
+    }
+}
+
+static void dynType_printSequence(char *name, dyn_type *type, int depth) {
+        printDepth(depth);
+        printf("sequence, size is %zu, alignment is %i, descriptor is '%c'. fields:\n", type->ffiType->size, type->ffiType->alignment, type->descriptor); 
+
+        printDepth(depth + 1);
+        printf("cap: simple type, size is %zu, alignment is %i.\n", type->sequence.seqType.elements[0]->size, type->sequence.seqType.elements[0]->alignment);
+
+        printDepth(depth + 1);
+        printf("len: simple type, size is %zu, alignment is %i.\n", type->sequence.seqType.elements[1]->size, type->sequence.seqType.elements[1]->alignment);
+
+        printDepth(depth + 1);
+        printf("buf: array, size is %zu, alignment is %i. points to ->\n", type->sequence.seqType.elements[2]->size, type->sequence.seqType.elements[2]->alignment);
+        dynType_printAny("element", type->sequence.itemType, depth + 1);
+}
+
+static void dynType_printSimple(char *name, dyn_type *type, int depth) {
+    printDepth(depth);
+    printf("%s: simple type, size is %zu, alignment is %i, descriptor is '%c'.\n", name, type->ffiType->size, type->ffiType->alignment, type->descriptor);
+}
+
+static void dynType_printTypedPointer(char *name, dyn_type *type, int depth) {
+    printDepth(depth);
+    printf("%s: typed pointer, size is %zu, alignment is %i, points to ->\n", name, type->ffiType->size, type->ffiType->alignment);
+    char *subName = NULL;
+    if (name != NULL) {
+        char buf[128];
+        snprintf(buf, 128, "*%s", name);
+        subName = buf;
+    }
+    dynType_printAny(subName, type->typedPointer.typedType, depth + 1);
+}
+
+static void dynType_printTypes(dyn_type *type) {
+
+    dyn_type *parent = type->parent;
+    struct nested_entry *pentry = NULL;
+    while (parent != NULL) {
+        TAILQ_FOREACH(pentry, &parent->nestedTypesHead, entries) {
+            if (&pentry->type == type) {
+                return;
+            }
+        }
+        parent = parent->parent;
+    }
+
+    struct nested_entry *entry = NULL;
+    TAILQ_FOREACH(entry, &type->nestedTypesHead, entries) {
+        dyn_type *toPrint = &entry->type;
+        if (toPrint->type == DYN_TYPE_REF) {
+            toPrint = toPrint->ref.ref;
+        }
+
+        switch(toPrint->type) {
+            case DYN_TYPE_COMPLEX :
+                dynType_printComplexType(toPrint);
+                break;
+            case DYN_TYPE_SIMPLE :
+                dynType_printSimpleType(toPrint);
+                break;
+            default :
+                printf("TODO Print Type\n");
+                break;
+        }
+    }
+
+
+    struct complex_type_entry *centry = NULL;
+    switch(type->type) {
+        case DYN_TYPE_COMPLEX :
+            TAILQ_FOREACH(centry, &type->complex.entriesHead, entries) {
+                dynType_printTypes(&centry->type);
+            }
+            break;
+        case DYN_TYPE_SEQUENCE :
+            dynType_printTypes(type->sequence.itemType);
+            break;
+        case DYN_TYPE_TYPED_POINTER :
+            dynType_printTypes(type->typedPointer.typedType);
+            break;
+    }
+}
+
+static void dynType_printComplexType(dyn_type *type) {
+    printf("type '%s': complex type, size is %zu, alignment is %i, descriptor is '%c'. fields:\n", type->name,  type->ffiType->size, type->ffiType->alignment, type->descriptor); 
+
+    struct complex_type_entry *entry = NULL;
+    TAILQ_FOREACH(entry, &type->complex.entriesHead, entries) {
+        dynType_printAny(entry->name, &entry->type, 2);
+    }
+
+    printf("}\n");
+}
+
+static void dynType_printSimpleType(dyn_type *type) {
+    printf("\ttype '%s': simple type, size is %zu, alignment is %i, descriptor is '%c'\n", type->name, type->ffiType->size, type->ffiType->alignment, type->descriptor);
+}

http://git-wip-us.apache.org/repos/asf/celix/blob/bdeba2bc/remote_services/dynamic_function_interface/dyn_type.h
----------------------------------------------------------------------
diff --git a/remote_services/dynamic_function_interface/dyn_type.h b/remote_services/dynamic_function_interface/dyn_type.h
new file mode 100644
index 0000000..2a3b445
--- /dev/null
+++ b/remote_services/dynamic_function_interface/dyn_type.h
@@ -0,0 +1,137 @@
+/**
+ * Licensed under Apache License v2. See LICENSE for more information.
+ */
+
+#ifndef _DYN_TYPE_H_
+#define _DYN_TYPE_H_
+
+#include <stdio.h>
+#include <sys/queue.h>
+#include <stdbool.h>
+
+#include <ffi.h>
+
+/* Description string
+ *
+ * Type = [TypeDef]* (SimpleType | ComplexType | SequenceType | TypedPointer | PointerReference ) [TypeDef]*
+ * Name = alpha[(alpha|numeric)*]
+ * SPACE = ' ' 
+ *
+ * SimplesTypes (based on java bytecode method signatures)
+ * //Java based:
+ * B char
+ * C (not supported)
+ * D double
+ * F float
+ * I int //TODO use int32_t instead?
+ * J long //TODO use int64_t intead?
+ * S short //TODO use int16_t instead?
+ * V void
+ * Z boolean
+ * //Extended
+ * b unsigned char
+ * i unsigned int (see I)
+ * j unsigned long (see J)
+ * s unsigned short (see S)
+ * P pointer
+ * t char* string
+ * N native int
+ *
+ *
+ * ComplexTypes (Struct)
+ * {[Type]+ [(Name)(SPACE)]+}
+ *
+ * PointerReference
+ * L(Name);
+ *
+ * ReferenceByValue
+ * l(name);
+ *
+ * TypeDef 
+ * T(Name)=Type;
+ *
+ * SequenceType
+ * [(Type)
+ *
+ * examples
+ * "{DDII a b c d}" -> struct { double a; double b; int c; int d; }; 
+ * "{DD{FF c1 c2} a b c" -> struct { double a; double b; struct c { float c1; float c2; }; }; 
+ *
+ *
+ */
+
+#define DYN_TYPE_INVALID 0
+#define DYN_TYPE_SIMPLE 1
+#define DYN_TYPE_COMPLEX 2
+#define DYN_TYPE_SEQUENCE 3
+#define DYN_TYPE_TYPED_POINTER 4
+#define DYN_TYPE_REF 5
+
+typedef struct _dyn_type dyn_type;
+
+struct _dyn_type {
+    char *name;
+    char descriptor;
+    int type;
+    ffi_type *ffiType;
+    dyn_type *parent;
+    TAILQ_HEAD(, nested_entry) nestedTypesHead;
+    union {
+        struct {
+            TAILQ_HEAD(, complex_type_entry) entriesHead;
+            ffi_type structType; //dyn_type.ffiType points to this
+            dyn_type **types; //based on entriesHead for fast access
+        } complex;
+        struct {
+            ffi_type seqType; //dyn_type.ffiType points to this
+            dyn_type *itemType; 
+        } sequence;
+        struct {
+            dyn_type *typedType;
+        } typedPointer;
+        struct {
+            dyn_type *ref;
+        } ref;
+    };
+};
+
+struct complex_type_entry {
+    dyn_type type;
+    char *name;
+    TAILQ_ENTRY(complex_type_entry) entries;
+};
+
+struct nested_entry {
+    dyn_type type;
+    TAILQ_ENTRY(nested_entry) entries;
+};
+
+
+//logging
+void dynType_setupLogger(void (*logf)(void *handle, int level, const char *file, int line, const char *msgFormat, ...), void *handle);
+
+//generic
+int dynType_create(const char *descriptor, dyn_type **type);
+void dynType_destroy(dyn_type *type);
+int dynType_alloc(dyn_type *type, void **bufLoc);
+void dynType_print(dyn_type *type);
+size_t dynType_size(dyn_type *type);
+int dynType_type(dyn_type *type);
+int dynType_descriptorType(dyn_type *type);
+
+//complexType
+int dynType_complex_indexForName(dyn_type *type, const char *name);
+char dynType_complex_descriptorTypeAt(dyn_type *type, int index);
+int dynType_complex_dynTypeAt(dyn_type *type, int index, dyn_type **subType);
+int dynType_complex_setValueAt(dyn_type *type, int index, void *inst, void *in);
+int dynType_complex_valLocAt(dyn_type *type, int index, void *inst, void **valLoc);
+
+//sequence
+int dynType_sequence_alloc(dyn_type *type, void *inst, int cap, void **buf);
+int dynType_sequence_append(dyn_type *type, void *seq, void *in);
+dyn_type * dynType_sequence_itemType(dyn_type *type);
+
+//simple
+void dynType_simple_setValue(dyn_type *type, void *inst, void *in);
+
+#endif

http://git-wip-us.apache.org/repos/asf/celix/blob/bdeba2bc/remote_services/dynamic_function_interface/json_serializer.c
----------------------------------------------------------------------
diff --git a/remote_services/dynamic_function_interface/json_serializer.c b/remote_services/dynamic_function_interface/json_serializer.c
new file mode 100644
index 0000000..628bec9
--- /dev/null
+++ b/remote_services/dynamic_function_interface/json_serializer.c
@@ -0,0 +1,151 @@
+/**
+ * Licensed under Apache License v2. See LICENSE for more information.
+ */
+#include "json_serializer.h"
+
+#include <jansson.h>
+#include <assert.h>
+
+static int json_serializer_createObject(dyn_type *type, json_t *object, void **result);
+static int json_serializer_writeObject(dyn_type *type, json_t *object, void *inst);
+static void json_serializer_writeObjectMember(dyn_type *type, const char *name, json_t *val, void *inst); 
+static void json_serializer_writeSequence(json_t *array, dyn_type *seq, void *seqLoc); 
+
+int json_deserialize(dyn_type *type, const char *input, void **result) {
+    assert(type->type == DYN_TYPE_COMPLEX);
+    int status = 0;
+
+    json_error_t error;
+    json_t *root = json_loads(input, JSON_DECODE_ANY, &error);
+
+    if (root != NULL) {
+        status = json_serializer_createObject(type, root, result);
+        json_decref(root);
+    } else {
+        status = 1;
+        printf("JSON_SERIALIZER: error parsing json input '%s'. Error is %s\n", input, error.text);
+    }
+
+    return status;
+}
+
+static int json_serializer_createObject(dyn_type *type, json_t *object, void **result) {
+    assert(object != NULL);
+    int status = 0;
+
+    void *inst = NULL;
+    status = dynType_alloc(type, &inst);
+
+    if (status == 0) {
+        assert(inst != NULL);
+        status = json_serializer_writeObject(type, object, inst);
+    } else {
+        //TODO destroy
+    }
+
+    if (status == 0) {
+        *result = inst;
+    } 
+
+    return status;
+}
+                
+static int json_serializer_writeObject(dyn_type *type, json_t *object, void *inst) {
+    assert(object != NULL);
+    int status = 0;
+    json_t *value;
+    const char *key;
+
+    if (status == 0)  {
+        json_object_foreach(object, key, value) {
+            json_serializer_writeObjectMember(type, key, value, inst);
+        }
+    } else {
+        status = 1;
+        printf("JSON_SERIALIZER: Error allocating memory\n");
+    }
+
+    return status;
+}
+
+static void json_serializer_writeObjectMember(dyn_type *type, const char *name, json_t *val, void *inst) {
+    //TODO rename to complex. write generic write
+    int status = 0;
+    int index = dynType_complex_indexForName(type, name);
+    char charType = dynType_complex_descriptorTypeAt(type, index); 
+    void *valp = NULL;
+    status = dynType_complex_valLocAt(type, index, inst, &valp);
+
+    //TODO check status
+
+    float *f;
+    double *d;
+    char *c;
+    short *s;
+    int *i;
+    long *l;
+    dyn_type *nested;
+
+    switch (charType) {
+        case 'F' :
+            f = valp;
+            *f = json_real_value(val);
+            break;
+        case 'D' :
+            d = valp;
+            *d = json_real_value(val);
+            break;
+        case 'B' :
+            c = valp;
+            *c = json_integer_value(val);
+            break;
+        case 'S' :
+            s = valp;
+            *s = json_integer_value(val);
+            break;
+        case 'I' :
+            i = valp;
+            *i = json_integer_value(val);
+            break;
+        case 'J' :
+            l = valp;
+            *l = json_integer_value(val);
+            break;
+        case '[' :
+            status = dynType_complex_dynTypeAt(type, index, &nested); 
+            //TODO check status
+            //TODO json_serializer_writeSequence(val, val, valp); 
+            break;
+        case '{' :
+            status = dynType_complex_dynTypeAt(type, index, &nested); 
+            //TODO check status
+            status = json_serializer_writeObject(nested, val, valp); 
+            //TODO check status
+            break;
+        default :
+            printf("JSON_SERIALIZER: error provided type '%c' not supported\n", charType);
+            printf("Skipping\n");
+    }
+} 
+
+static void json_serializer_writeSequence(json_t *array, dyn_type *seq, void *seqLoc) {
+    assert(dynType_type(seq) == DYN_TYPE_SEQUENCE);
+    size_t size = json_array_size(array);
+    //char seqType = dynType_sequence_elementSchemaType(seq);
+
+    void *buf = NULL;
+    dynType_sequence_alloc(seq, seqLoc, size, &buf); //seq is already allocated. only need to allocate the buf
+
+    //assuming int
+    int32_t i;
+    int index;
+    json_t *val;
+    json_array_foreach(array, index, val) {
+        i = json_number_value(val);
+        dynType_sequence_append(seq, seqLoc, &i);
+    }
+}
+
+int json_serialize(dyn_type *type, void *input, char **output, size_t *size) {
+    return 0;
+}

http://git-wip-us.apache.org/repos/asf/celix/blob/bdeba2bc/remote_services/dynamic_function_interface/json_serializer.h
----------------------------------------------------------------------
diff --git a/remote_services/dynamic_function_interface/json_serializer.h b/remote_services/dynamic_function_interface/json_serializer.h
new file mode 100644
index 0000000..6b42244
--- /dev/null
+++ b/remote_services/dynamic_function_interface/json_serializer.h
@@ -0,0 +1,12 @@
+/**
+ * Licensed under Apache License v2. See LICENSE for more information.
+ */
+#ifndef __JSON_SERIALIZER_H_
+#define __JSON_SERIALIZER_H_
+
+#include "dyn_type.h"
+
+int json_deserialize(dyn_type *type, const char *input, void **result);
+int json_serialize(dyn_type *type, void *input, char **output, size_t *size);
+
+#endif

http://git-wip-us.apache.org/repos/asf/celix/blob/bdeba2bc/remote_services/dynamic_function_interface/schemas/complex.avdl
----------------------------------------------------------------------
diff --git a/remote_services/dynamic_function_interface/schemas/complex.avdl b/remote_services/dynamic_function_interface/schemas/complex.avdl
new file mode 100644
index 0000000..0490dcd
--- /dev/null
+++ b/remote_services/dynamic_function_interface/schemas/complex.avdl
@@ -0,0 +1,11 @@
+protocol Complex {
+
+  record StatResult {
+    double sum;
+    double min;
+    double max;
+    array<double> input;
+  }
+
+  StatResult stats(array<double> input);
+}

http://git-wip-us.apache.org/repos/asf/celix/blob/bdeba2bc/remote_services/dynamic_function_interface/schemas/complex.avpr
----------------------------------------------------------------------
diff --git a/remote_services/dynamic_function_interface/schemas/complex.avpr b/remote_services/dynamic_function_interface/schemas/complex.avpr
new file mode 100644
index 0000000..0577397
--- /dev/null
+++ b/remote_services/dynamic_function_interface/schemas/complex.avpr
@@ -0,0 +1,36 @@
+{
+  "protocol" : "Complex",
+  "namespace" : null,
+  "types" : [ {
+    "type" : "record",
+    "name" : "StatResult",
+    "fields" : [ {
+      "name" : "sum",
+      "type" : "double"
+    }, {
+      "name" : "min",
+      "type" : "double"
+    }, {
+      "name" : "max",
+      "type" : "double"
+    }, {
+      "name" : "input",
+      "type" : {
+        "type" : "array",
+        "items" : "double"
+      }
+    } ]
+  } ],
+  "messages" : {
+    "stats" : {
+      "request" : [ {
+        "name" : "input",
+        "type" : {
+          "type" : "array",
+          "items" : "double"
+        }
+      } ],
+      "response" : "StatResult"
+    }
+  }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/celix/blob/bdeba2bc/remote_services/dynamic_function_interface/schemas/simple.avdl
----------------------------------------------------------------------
diff --git a/remote_services/dynamic_function_interface/schemas/simple.avdl b/remote_services/dynamic_function_interface/schemas/simple.avdl
new file mode 100644
index 0000000..cd5cafe
--- /dev/null
+++ b/remote_services/dynamic_function_interface/schemas/simple.avdl
@@ -0,0 +1,6 @@
+@namespace("org.apache.avro.test")
+protocol Simple {
+  double sum(double a, double b);
+  double sub(double a, double b);
+  double sqrt(double a);
+}

http://git-wip-us.apache.org/repos/asf/celix/blob/bdeba2bc/remote_services/dynamic_function_interface/schemas/simple.avpr
----------------------------------------------------------------------
diff --git a/remote_services/dynamic_function_interface/schemas/simple.avpr b/remote_services/dynamic_function_interface/schemas/simple.avpr
new file mode 100644
index 0000000..8a90bb2
--- /dev/null
+++ b/remote_services/dynamic_function_interface/schemas/simple.avpr
@@ -0,0 +1,33 @@
+{
+  "protocol" : "Simple",
+  "types" : [ ],
+  "messages" : {
+    "sum" : {
+      "request" : [ {
+        "name" : "a",
+        "type" : "double"
+      }, {
+        "name" : "b",
+        "type" : "double"
+      } ],
+      "response" : "double"
+    },
+    "sub" : {
+      "request" : [ {
+        "name" : "a",
+        "type" : "double"
+      }, {
+        "name" : "b",
+        "type" : "double"
+      } ],
+      "response" : "double"
+    },
+    "sqrt" : {
+      "request" : [ {
+        "name" : "a",
+        "type" : "double"
+      } ],
+      "response" : "double"
+    }
+  }
+}

http://git-wip-us.apache.org/repos/asf/celix/blob/bdeba2bc/remote_services/dynamic_function_interface/schemas/simple_min.avpr
----------------------------------------------------------------------
diff --git a/remote_services/dynamic_function_interface/schemas/simple_min.avpr b/remote_services/dynamic_function_interface/schemas/simple_min.avpr
new file mode 100644
index 0000000..c2bce19
--- /dev/null
+++ b/remote_services/dynamic_function_interface/schemas/simple_min.avpr
@@ -0,0 +1 @@
+{"protocol":"Simple","types":[],"messages":{"sum":{"request":[{"name":"a","type":"double"},{"name":"b","type":"double"}],"response":"double"},"sub":{"request":[{"name":"a","type":"double"},{"name":"b","type":"double"}],"response":"double"},"sqrt":{"request":[{"name":"a","type":"double"}],"response":"double"}}}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/celix/blob/bdeba2bc/remote_services/dynamic_function_interface/tst/avro_descriptor_translator_tests.cpp
----------------------------------------------------------------------
diff --git a/remote_services/dynamic_function_interface/tst/avro_descriptor_translator_tests.cpp b/remote_services/dynamic_function_interface/tst/avro_descriptor_translator_tests.cpp
new file mode 100644
index 0000000..4a63c16
--- /dev/null
+++ b/remote_services/dynamic_function_interface/tst/avro_descriptor_translator_tests.cpp
@@ -0,0 +1,67 @@
+/**
+ * Licensed under Apache License v2. See LICENSE for more information.
+ */
+#include <CppUTest/TestHarness.h>
+#include "CppUTest/CommandLineTestRunner.h"                                                                                                                                                                        
+
+extern "C" {
+
+#include <stdio.h>
+#include <assert.h>
+#include <string.h>
+
+#include "descriptor_translator.h"
+
+void test1(void) {
+    //TODO split up
+    size_t size = 0;
+    char *ptr = NULL;
+
+    //first argument void *handle, last argument output pointer for result and return int with status for exception handling
+    //sum(DD)D -> sum(PDD*D)N 
+    //sub(DD)D -> sub(PDD*D)N
+    //sqrt(D)D -> sqrt(PD*D)N
+    FILE *schema = fopen("schemas/simple.avpr", "r");
+    FILE *stream = open_memstream(&ptr, &size);
+
+    int c = fgetc(schema);
+    while (c != EOF ) {
+        fputc(c, stream);
+        c = fgetc(schema);
+    }
+    fclose(schema);
+    fclose(stream);
+   
+    assert(schema != NULL && stream != NULL); 
+    interface_descriptor_type *ift= NULL;
+    int status = descriptorTranslator_create(ptr, &ift);
+    CHECK_EQUAL(0, status);
+
+    int count = 0;
+    method_descriptor_type *mDesc = NULL;
+    TAILQ_FOREACH(mDesc, &ift->methodDescriptors, entries) {
+        count +=1;
+    }
+    CHECK_EQUAL(3, count);
+
+    TAILQ_FOREACH(mDesc, &ift->methodDescriptors, entries) {
+        if (strcmp("sum", mDesc->name) == 0) {
+            STRCMP_EQUAL("sum(PDD*D)N", mDesc->descriptor);
+        } else if (strcmp("add", mDesc->name) == 0) {
+            STRCMP_EQUAL("add(PDD*D)N", mDesc->descriptor);
+        } else if (strcmp("sqrt", mDesc->name) == 0) {
+            STRCMP_EQUAL("sqrt(PD*D)N", mDesc->descriptor);
+        }
+    }
+}
+
+}
+
+TEST_GROUP(AvroDescTranslatorTest) {
+    void setup() {
+    }
+};
+
+TEST(AvroDescTranslatorTest, Test1) {
+    test1();
+}

http://git-wip-us.apache.org/repos/asf/celix/blob/bdeba2bc/remote_services/dynamic_function_interface/tst/dyn_closure_tests.cpp
----------------------------------------------------------------------
diff --git a/remote_services/dynamic_function_interface/tst/dyn_closure_tests.cpp b/remote_services/dynamic_function_interface/tst/dyn_closure_tests.cpp
new file mode 100644
index 0000000..30b0b65
--- /dev/null
+++ b/remote_services/dynamic_function_interface/tst/dyn_closure_tests.cpp
@@ -0,0 +1,139 @@
+/*
+ * Licensed under Apache License v2. See LICENSE for more information.
+ */
+#include <CppUTest/TestHarness.h>
+#include "CppUTest/CommandLineTestRunner.h"                                                                                                                                                                        
+
+extern "C" {
+    
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "dyn_function.h"
+
+static int g_count;
+
+static void stdLog(void *handle, int level, const char *file, int line, const char *msg, ...) {
+    va_list ap;
+    const char *levels[5] = {"NIL", "ERROR", "WARNING", "INFO", "DEBUG"};
+    fprintf(stderr, "%s: FILE:%s, LINE:%i, MSG:",levels[level], file, line);
+    va_start(ap, msg);
+    vfprintf(stderr, msg, ap);
+    fprintf(stderr, "\n");
+}
+
+#define EXAMPLE1_SCHEMA "example(III)I"
+static void example1_binding(void *userData, void* args[], void *out) {
+    printf("example1 closure called\n");
+    int32_t a = *((int32_t *)args[0]);
+    int32_t b = *((int32_t *)args[1]);
+    int32_t c = *((int32_t *)args[2]);
+    int32_t *ret = (int32_t *)out;
+    *ret = a + b + c;
+    g_count += 1;
+}
+
+#define EXAMPLE2_SCHEMA "example(I{DDD val1 val2 val3}I)D"
+struct example2_arg2 {
+    double val1;
+    double val2;
+    double val3;
+};
+void example2_binding(void *userData, void* args[], void *out) {
+    printf("example2 closure called\n");
+    int32_t a = *((int32_t *)args[0]);
+    struct example2_arg2 b =  *((struct example2_arg2 *)args[1]);
+    int32_t c = *((int32_t *)args[2]);
+    int32_t *ret = (int32_t *)out;
+    *ret = a + b.val1 + b.val2 + b.val3 + c;
+    g_count += 1;
+}
+
+
+#define EXAMPLE3_SCHEMA "example(III){III sum max min}"
+struct example3_ret {
+    int32_t sum;
+    int32_t max;
+    int32_t min;
+};
+
+static void example3_binding(void *userData, void* args[], void *out) {
+    printf("example closure called\n");
+    int32_t a = *((int32_t *)args[0]);
+    int32_t b = *((int32_t *)args[1]);
+    int32_t c = *((int32_t *)args[2]);
+    struct example3_ret *result = (struct example3_ret *)calloc(1,sizeof(struct example3_ret));
+    result->sum = a + b + c;
+    result->min = a <= b ? a : b;
+    result->max = a >= b ? a : b;
+    result->min = result->min <= c ? result->min : c;
+    result->max = result->max >= c ? result->max : c;
+
+    struct example3_ret **ret = (struct example3_ret **)out;
+    (*ret) = result;
+    g_count += 1;
+}
+
+static void tests() {
+    dyn_closure_type *dynClosure = NULL;
+    int rc;
+
+    {
+        rc = dynClosure_create(EXAMPLE1_SCHEMA, example1_binding, NULL, &dynClosure);
+        CHECK_EQUAL(0, rc);
+        int32_t (*func)(int32_t a, int32_t b, int32_t c) = NULL;
+        int rc = dynClosure_getFnPointer(dynClosure, (void(**)(void))&func);
+        CHECK_EQUAL(0, rc);
+        int32_t ret = func(2,3,4);
+        printf("Return value for example1 is %i\n", ret);
+        CHECK_EQUAL(1, g_count);
+        dynClosure_destroy(dynClosure);
+    }
+
+    {
+        dynClosure = NULL;
+        rc = dynClosure_create(EXAMPLE2_SCHEMA, example2_binding, NULL, &dynClosure);
+        CHECK_EQUAL(0, rc);
+        double (*func)(int32_t a, struct example2_arg2 b, int32_t c) = NULL;
+        rc = dynClosure_getFnPointer(dynClosure, (void(**)(void))&func);
+        CHECK_EQUAL(0, rc);
+        struct example2_arg2 b = { .val1 = 1.0, .val2 = 1.5, .val3 = 2.0 };
+        double ret = func(2,b,4);
+        printf("Return value for example2 is %f\n", ret);
+        CHECK_EQUAL(2, g_count);
+        dynClosure_destroy(dynClosure);
+    }
+
+    {
+        dynClosure = NULL;
+        rc = dynClosure_create(EXAMPLE3_SCHEMA, example3_binding, NULL, &dynClosure);
+        CHECK_EQUAL(0, rc);
+        struct example3_ret * (*func)(int32_t a, int32_t b, int32_t c) = NULL;
+        rc = dynClosure_getFnPointer(dynClosure, (void(**)(void))&func);
+        CHECK_EQUAL(0, rc);
+        struct example3_ret *ret = func(2,8,4);
+        printf("Return value for example3 is {sum:%i, max:%i, min:%i}\n", ret->sum, ret->max, ret->min);
+        CHECK_EQUAL(3, g_count);
+        dynClosure_destroy(dynClosure);
+        free(ret);
+    }
+}
+
+}
+
+
+TEST_GROUP(DynClosureTests) {
+    void setup() {
+        dynFunction_logSetup(stdLog, NULL, 4);
+        //TODO dynType_logSetup(stdLog, NULL, 4);
+        g_count = 0;
+    }
+};
+
+TEST(DynClosureTests, DynCLosureTest1) {
+    //TODO split up
+    tests();
+}

http://git-wip-us.apache.org/repos/asf/celix/blob/bdeba2bc/remote_services/dynamic_function_interface/tst/dyn_function_tests.cpp
----------------------------------------------------------------------
diff --git a/remote_services/dynamic_function_interface/tst/dyn_function_tests.cpp b/remote_services/dynamic_function_interface/tst/dyn_function_tests.cpp
new file mode 100644
index 0000000..a2b7f69
--- /dev/null
+++ b/remote_services/dynamic_function_interface/tst/dyn_function_tests.cpp
@@ -0,0 +1,109 @@
+/*
+ * Licensed under Apache License v2. See LICENSE for more information.
+ */
+#include <CppUTest/TestHarness.h>
+#include "CppUTest/CommandLineTestRunner.h"                                                                                                                                                                        
+
+extern "C" {
+    #include <stdio.h>
+    #include <stdint.h>
+    #include <stdlib.h>
+    #include <string.h>
+    #include <ctype.h>
+
+    #include "dyn_function.h"
+
+    static void stdLog(void *handle, int level, const char *file, int line, const char *msg, ...) {
+        va_list ap;
+        const char *levels[5] = {"NIL", "ERROR", "WARNING", "INFO", "DEBUG"};
+        fprintf(stderr, "%s: FILE:%s, LINE:%i, MSG:",levels[level], file, line);
+        va_start(ap, msg);
+        vfprintf(stderr, msg, ap);
+        fprintf(stderr, "\n");
+    }
+
+    #define EXAMPLE1_SCHEMA "example(III)I"
+    int32_t example1(int32_t a, int32_t b, int32_t c) {
+        CHECK_EQUAL(2, a);
+        CHECK_EQUAL(4, b);
+        CHECK_EQUAL(8, c);
+        return 1;
+    }
+
+    void test_example1(void) {
+        dyn_function_type *dynFunc = NULL;
+        int rc;
+        void (*fp)(void) = (void (*)(void)) example1;
+
+        rc = dynFunction_create(EXAMPLE1_SCHEMA, fp, &dynFunc);
+        CHECK_EQUAL(0, rc);
+
+        int32_t a = 2;
+        int32_t b = 4;
+        int32_t c = 8;
+        void *values[3];
+        int32_t rVal = 0;
+        values[0] = &a;
+        values[1] = &b;
+        values[2] = &c;
+
+        rc = dynFunction_call(dynFunc, &rVal, values);
+        CHECK_EQUAL(0, rc);
+        CHECK_EQUAL(1, rVal);
+        dynFunction_destroy(dynFunc);
+    }
+
+    #define EXAMPLE2_SCHEMA "example(I{IID val1 val2 val3}D)D"
+    struct example2_arg {
+        int32_t val1;
+        int32_t val2;
+        double val3;
+    };
+
+    double example2(int32_t arg1, struct example2_arg arg2, double arg3) {
+        CHECK_EQUAL(2, arg1);
+        CHECK_EQUAL(2, arg2.val1);
+        CHECK_EQUAL(3, arg2.val2);
+        CHECK_EQUAL(4.1, arg2.val3);
+        CHECK_EQUAL(8.1, arg3);
+        return 2.2;
+    }
+
+    void test_example2(void) {
+        dyn_function_type *dynFunc = NULL;
+        int rc;
+        void (*fp)(void) = (void (*)(void)) example2;
+
+        rc = dynFunction_create(EXAMPLE2_SCHEMA, fp, &dynFunc);
+        CHECK_EQUAL(0, rc);
+
+        int32_t arg1 = 2;
+        struct example2_arg arg2 = { .val1 = 2, .val2 = 3, .val3 = 4.1 };
+        double arg3 = 8.1;
+        double returnVal = 0;
+        void *values[3];
+        values[0] = &arg1;
+        values[1] = &arg2;
+        values[2] = &arg3;
+
+        rc = dynFunction_call(dynFunc, &returnVal, values);
+        CHECK_EQUAL(0, rc);
+        CHECK_EQUAL(2.2, returnVal);
+        dynFunction_destroy(dynFunc);
+    }
+}
+
+TEST_GROUP(DynFunctionTests) {
+    void setup() {
+        dynFunction_logSetup(stdLog, NULL, 4);
+        //TODO dynType_logSetup(stdLog, NULL, 4);
+    }
+};
+
+TEST(DynFunctionTests, DynFuncTest1) {
+    test_example1();
+}
+
+TEST(DynFunctionTests, DynFuncTest2) {
+    test_example2();
+}

http://git-wip-us.apache.org/repos/asf/celix/blob/bdeba2bc/remote_services/dynamic_function_interface/tst/dyn_type_tests.cpp
----------------------------------------------------------------------
diff --git a/remote_services/dynamic_function_interface/tst/dyn_type_tests.cpp b/remote_services/dynamic_function_interface/tst/dyn_type_tests.cpp
new file mode 100644
index 0000000..07c419b
--- /dev/null
+++ b/remote_services/dynamic_function_interface/tst/dyn_type_tests.cpp
@@ -0,0 +1,183 @@
+/*
+ * Licensed under Apache License v2. See LICENSE for more information.
+ */
+#include <CppUTest/TestHarness.h>
+#include "CppUTest/CommandLineTestRunner.h"                                                                                                                                                                        
+
+extern "C" {
+    #include <string.h>
+    #include <stdarg.h>
+    
+    #include "dyn_type.h"
+
+    void runTest(const char *descriptorStr, const char *exName) {
+        dyn_type *type;
+        int i;
+        type = NULL;
+        printf("\n-- example %s with descriptor string '%s' --\n", exName, descriptorStr);
+        int status = dynType_create(descriptorStr, &type);
+        CHECK_EQUAL(0, status);
+        if (status == 0) {
+            dynType_print(type);
+            dynType_destroy(type);
+        }
+        printf("--\n\n");
+    }
+}
+
+TEST_GROUP(DynTypeTests) {
+};
+
+#define EX1 "{BbJjIiSsDFNN arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10 arg11 arg12}"
+#define EX2 "{D{DD b_1 b_2}I a b c}"
+#define EX3 "Tsub={DD b_1 b_2};{DLsub;I a b c}"
+#define EX4 "{[I numbers}"
+#define EX5 "[[{DD{iii val3_1 val3_2 val3_3} val1 val2 val3}"
+#define EX6 "Tsample={DD vala valb};Lsample;"
+#define EX7 "Tsample={DD vala valb};[Lsample;"
+#define EX8 "[Tsample={DD a b};Lsample;"
+#define EX9 "*D"
+#define EX10 "Tsample={DD a b};******Lsample;"
+#define EX11 "Tsample=D;Lsample;"
+#define EX12 "Tnode={Lnode;Lnode; left right};{Lnode; head}" //note recursive example
+#define EX13 "Ttype={DDDDD a b c d e};{ltype;Ltype;ltype;Ltype; byVal1 byRef1 byVal2 ByRef2}" 
+#define EX14 "{DD{FF{JJ}{II*{ss}}}}"  //unnamed fields
+
+#define CREATE_EXAMPLES_TEST(DESC) \
+    TEST(DynTypeTests, ParseTestExample ## DESC) { \
+        runTest(DESC, #DESC); \
+    }    
+
+CREATE_EXAMPLES_TEST(EX1)
+CREATE_EXAMPLES_TEST(EX2)
+CREATE_EXAMPLES_TEST(EX3)
+CREATE_EXAMPLES_TEST(EX4)
+CREATE_EXAMPLES_TEST(EX5)
+CREATE_EXAMPLES_TEST(EX6)
+CREATE_EXAMPLES_TEST(EX7)
+CREATE_EXAMPLES_TEST(EX8)
+CREATE_EXAMPLES_TEST(EX9)
+CREATE_EXAMPLES_TEST(EX10)
+CREATE_EXAMPLES_TEST(EX11)
+CREATE_EXAMPLES_TEST(EX12)
+CREATE_EXAMPLES_TEST(EX13)
+CREATE_EXAMPLES_TEST(EX14)
+
+TEST(DynTypeTests, ParseRandomGarbageTest) {
+    return; //TODO enable
+    unsigned int seed = 4148;
+    char *testRandom = getenv("DYN_TYPE_TEST_RANDOM");
+    if (testRandom != NULL && strcmp("true", testRandom) == 0) {
+        seed = (unsigned int) time(NULL);
+    } 
+    srandom(seed);
+    size_t nrOfTests = 10000;
+
+    printf("\nStarting test with random seed %i and nrOfTests %zu.\n", seed, nrOfTests);
+
+    int i;
+    int k;
+    int c;
+    int sucesses = 0;
+    char descriptorStr[32];
+    descriptorStr[31] = '\0';
+    for(i = 0; i < nrOfTests; i += 1) {  
+        for(k = 0; k < 31; k += 1) {
+            do {
+                c = (char) (((random() * 128) / RAND_MAX) - 1);
+            } while (!isprint(c));
+            descriptorStr[k] = c;
+            if (c == '\0') { 
+                break;
+            }
+        }
+
+        //printf("ParseRandomGarbageTest iteration %i with descriptor string '%s'\n", k, descriptorStr); 
+        dyn_type *type = NULL;
+        int status = dynType_create(descriptorStr, &type);
+        if (status == 0) {
+            dynType_destroy(type);
+        }
+    }
+}
+
+extern "C" {
+    static int logCount = 0;
+    static void logf_test(void *handle, int level, const char *file, int line, const char *msg, ...) {
+        logCount += 1;
+        
+        /*
+        va_list ap;
+        const char *levels[5] = {"NIL", "ERROR", "WARNING", "INFO", "DEBUG"};
+        printf("%s: FILE:%s, LINE:%i, MSG:",levels[level], file, line);
+        va_start(ap, msg);
+        vprintf(msg, ap);
+        printf("\n");
+        */
+    }
+}
+
+TEST(DynTypeTests, DynTypeLoggerTest) {
+    dyn_type *type = NULL;
+    dynType_setupLogger(logf_test, NULL);
+    dynType_create("*", &type);
+    CHECK_EQUAL(1, logCount);
+}
+
+TEST(DynTypeTests, AssignTest1) {
+    struct ex1 {
+        int32_t a;
+        int32_t b;
+        int32_t c;
+    };
+    struct ex1 inst;
+    const char *desc = "{III a b c}";
+    dyn_type *type = NULL;
+    int status = dynType_create(desc, &type);
+    CHECK_EQUAL(0, status);
+    int32_t val1 = 2;
+    int32_t val2 = 4;
+    int32_t val3 = 8;
+    dynType_complex_setValueAt(type, 0,  &inst, &val1);
+    CHECK_EQUAL(2, inst.a);
+    dynType_complex_setValueAt(type, 1,  &inst, &val2);
+    CHECK_EQUAL(4, inst.b);
+    dynType_complex_setValueAt(type, 2,  &inst, &val3);
+    CHECK_EQUAL(8, inst.c);
+}
+
+TEST(DynTypeTests, AssignTest2) {
+    struct ex {
+        int32_t a;
+        struct {
+            double a;
+            double b;
+        } b;
+    };
+    struct ex inst;
+    const char *desc = "{I{DD a b} a b}";
+    dyn_type *type = NULL;
+    int status = dynType_create(desc, &type);
+    CHECK_EQUAL(0, status);
+    int32_t a = 2;
+    double b_a = 1.1;
+    double b_b = 1.2;
+
+    dynType_complex_setValueAt(type, 0,  &inst, &a);
+    CHECK_EQUAL(2, inst.a);
+
+    void *loc = NULL;
+    dyn_type *subType = NULL;
+    dynType_complex_valLocAt(type, 1, (void *)&inst, &loc);
+    dynType_complex_dynTypeAt(type, 1, &subType);
+
+    dynType_complex_setValueAt(subType, 0, &inst.b, &b_a);
+    CHECK_EQUAL(1.1, inst.b.a);
+
+    dynType_complex_setValueAt(subType, 1, &inst.b, &b_b);
+    CHECK_EQUAL(1.2, inst.b.b);
+}
+
+//TODO allocating / freeing
+
+//TODO sequences 

http://git-wip-us.apache.org/repos/asf/celix/blob/bdeba2bc/remote_services/dynamic_function_interface/tst/json_serializer_tests.cpp
----------------------------------------------------------------------
diff --git a/remote_services/dynamic_function_interface/tst/json_serializer_tests.cpp b/remote_services/dynamic_function_interface/tst/json_serializer_tests.cpp
new file mode 100644
index 0000000..6cabe8a
--- /dev/null
+++ b/remote_services/dynamic_function_interface/tst/json_serializer_tests.cpp
@@ -0,0 +1,182 @@
+/**
+ * Licensed under Apache License v2. See LICENSE for more information.
+ */
+#include <CppUTest/TestHarness.h>
+#include "CppUTest/CommandLineTestRunner.h"                                                                                                                                                                        
+
+extern "C" {
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include <ffi.h>
+
+#include "dyn_type.h"
+#include "json_serializer.h"
+
+static void stdLog(void *handle, int level, const char *file, int line, const char *msg, ...) {
+    va_list ap;
+    const char *levels[5] = {"NIL", "ERROR", "WARNING", "INFO", "DEBUG"};
+    fprintf(stderr, "%s: FILE:%s, LINE:%i, MSG:",levels[level], file, line);
+    va_start(ap, msg);
+    vfprintf(stderr, msg, ap);
+    fprintf(stderr, "\n");
+}
+
+/*********** example 1 ************************/
+/** struct type ******************************/
+const char *example1_descriptor = "{DJISF a b c d e}";
+
+const char *example1_input = "{ \
+    \"a\" : 1.0, \
+    \"b\" : 22, \
+    \"c\" : 32, \
+    \"d\" : 42, \
+    \"e\" : 4.4 \
+}";
+
+struct example1 {
+    double a;   //0
+    int64_t b;  //1
+    int32_t c;  //2
+    int16_t d;  //3
+    float e;    //4
+};
+
+static void print_example1(void *data) {
+    struct example1 *ex = (struct example1 *)data;
+    printf("example1: a:%f, b:%li, c:%i, d:%i, e:%f\n", ex->a, ex->b, ex->c, ex->d, ex->e);
+}
+
+/*********** example 2 ************************/
+const char *example2_descriptor = "{BJJDFD byte long1 long2 double1 float1 double2}";
+
+const char *example2_input = "{ \
+    \"byte\" : 42, \
+    \"long1\" : 232, \
+    \"long2\" : 242, \
+    \"double1\" : 4.2, \
+    \"float1\" : 3.2, \
+    \"double2\" : 4.4 \
+}";
+
+struct example2 {
+    char byte;      //0
+    int64_t long1;     //1
+    int64_t long2;     //2
+    double double1; //3
+    float float1;   //4
+    double double2; //5
+};
+
+static void print_example2(void *data) {
+    struct example2 *ex = (struct example2 *)data;
+    printf("example2: byte:%i, long1:%li, long2:%li, double1:%f, float1:%f, double2:%f\n", ex->byte, ex->long1, ex->long2, ex->double1, ex->float1, ex->double2);
+}
+
+
+/*********** example 3 ************************/
+/** sequence with a simple type **************/
+const char *example3_descriptor = "{[I numbers}";
+
+const char *example3_input = "{ \
+    \"numbers\" : [22,32,42] \
+}";
+
+struct example3 {
+    struct {
+        uint32_t _cap;
+        uint32_t _len;
+        int32_t *buf;
+    } numbers;
+};
+
+static void print_example3(void *data) {
+    struct example3 *ex = (struct example3 *)data;
+    printf("example3: numbers length is %u and cap is %u and pointer buf is %p\n", ex->numbers._len, ex->numbers._cap, ex->numbers.buf);
+    int i;
+    for (i = 0; i < ex->numbers._len; i += 1) {
+        printf("\telement %i : %i\n", i, ex->numbers.buf[i]);
+    }
+}
+
+/*********** example 4 ************************/
+/** structs within a struct (by reference)*******/
+//TODO think about references in descriptor e.g "{Lleaf;Lleaf; left right}\nleaf{IDD index val1 val2}"
+const char *example4_descriptor = "{{IDD index val1 val2}{IDD index val1 val2} left right}";
+
+static const char *example4_input =  "{ \
+    \"left\" : {\"index\":1, \"val1\":1.0, \"val2\":2.0 }, \
+    \"right\" : {\"index\":2, \"val1\":5.0, \"val2\":4.0 } \
+}";
+
+struct leaf {
+    int32_t index;
+    double val1;
+    double val2;
+};
+
+struct example4 {
+    struct leaf left;
+    struct leaf right;
+};
+
+static void print_example4(void *data) {
+    struct example4 *ex = (struct example4 *)data;
+    printf("example4: left { index:%i, val1:%f, val2:%f }, right { index;%i, val1:%f, val2:%f }\n", ex->left.index, ex->left.val1, ex->left.val2, ex->right.index, ex->right.val1, ex->right.val2);
+}
+
+static void tests() {
+    printf("Starting json serializer tests\n");
+    dyn_type *type;
+    void *inst;
+    int rc;
+
+    type = NULL;
+    inst = NULL;
+    rc = dynType_create(example1_descriptor, &type);    
+    CHECK_EQUAL(0, rc);
+    rc = json_deserialize(type, example1_input, &inst); 
+    CHECK_EQUAL(0, rc);
+    print_example1(inst);
+    printf("--\n\n");
+
+
+    type = NULL;
+    inst = NULL;
+    rc = dynType_create(example2_descriptor, &type);
+    CHECK_EQUAL(0, rc);
+    rc = json_deserialize(type, example2_input, &inst); 
+    CHECK_EQUAL(0, rc);
+    print_example2(inst);
+    printf("--\n\n");
+
+    type = NULL;
+    inst = NULL;
+    rc = dynType_create(example3_descriptor, &type);
+    CHECK_EQUAL(0, rc);
+    rc = json_deserialize(type, example3_input, &inst); 
+    CHECK_EQUAL(0, rc);
+    print_example3(inst);
+
+    type = NULL;
+    inst = NULL;
+    rc = dynType_create(example4_descriptor, &type);
+    CHECK_EQUAL(0, rc);
+    rc = json_deserialize(type, example4_input, &inst); 
+    CHECK_EQUAL(0, rc);
+    print_example4(inst);
+}
+}
+
+TEST_GROUP(JsonSerializerTests) {
+    void setup() {
+    }
+};
+
+TEST(JsonSerializerTests, Test1) {
+    //TODO split up
+    tests();
+}

http://git-wip-us.apache.org/repos/asf/celix/blob/bdeba2bc/remote_services/dynamic_function_interface/tst/run_tests.cpp
----------------------------------------------------------------------
diff --git a/remote_services/dynamic_function_interface/tst/run_tests.cpp b/remote_services/dynamic_function_interface/tst/run_tests.cpp
new file mode 100644
index 0000000..f405c9f
--- /dev/null
+++ b/remote_services/dynamic_function_interface/tst/run_tests.cpp
@@ -0,0 +1,9 @@
+/*
+ * Licensed under Apache License v2. See LICENSE for more information.
+ */
+#include <CppUTest/TestHarness.h>
+#include "CppUTest/CommandLineTestRunner.h"                                                                                                                                                                        
+
+int main(int argc, char** argv) {
+        return RUN_ALL_TESTS(argc, argv);
+}


Mime
View raw message