celix-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From pnol...@apache.org
Subject celix git commit: CELIX-237: Added dyn_function.c for dynamically calling function and dynamically creating closure using a schema
Date Wed, 17 Jun 2015 11:47:50 GMT
Repository: celix
Updated Branches:
  refs/heads/feature/CELIX-237_rsa-ffi 387f7792d -> 7f3383247


CELIX-237: Added dyn_function.c for dynamically calling function and dynamically creating
closure using a schema


Project: http://git-wip-us.apache.org/repos/asf/celix/repo
Commit: http://git-wip-us.apache.org/repos/asf/celix/commit/7f338324
Tree: http://git-wip-us.apache.org/repos/asf/celix/tree/7f338324
Diff: http://git-wip-us.apache.org/repos/asf/celix/diff/7f338324

Branch: refs/heads/feature/CELIX-237_rsa-ffi
Commit: 7f338324707f1100f25f7b1f3ca82f01e56663fc
Parents: 387f779
Author: Pepijn Noltes <pepijnnoltes@gmail.com>
Authored: Wed Jun 17 13:46:18 2015 +0200
Committer: Pepijn Noltes <pepijnnoltes@gmail.com>
Committed: Wed Jun 17 13:46:18 2015 +0200

----------------------------------------------------------------------
 remote_services/dyn_type/CMakeLists.txt  |  14 ++
 remote_services/dyn_type/closure_tests.c |  98 ++++++++++++
 remote_services/dyn_type/dyn_function.c  | 209 ++++++++++++++++++++++++++
 remote_services/dyn_type/dyn_function.h  |  24 +++
 remote_services/dyn_type/dyn_type.c      |  26 +---
 remote_services/dyn_type/dyn_type.h      |  28 +++-
 remote_services/dyn_type/func_tests.c    |  66 ++++++++
 7 files changed, 443 insertions(+), 22 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/celix/blob/7f338324/remote_services/dyn_type/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/remote_services/dyn_type/CMakeLists.txt b/remote_services/dyn_type/CMakeLists.txt
index 8b5b78f..351bb7c 100644
--- a/remote_services/dyn_type/CMakeLists.txt
+++ b/remote_services/dyn_type/CMakeLists.txt
@@ -6,4 +6,18 @@ add_executable(struct_tests
     json_serializer.c
 )
 
+add_executable(func_tests
+    func_tests.c
+    dyn_type.c
+    dyn_function.c
+)
+
+add_executable(closure_tests
+    closure_tests.c
+    dyn_type.c
+    dyn_function.c
+)
+
 target_link_libraries(struct_tests ${JANSSON_LIBRARIES} /lib64/libffi.so ) 
+target_link_libraries(func_tests ${JANSSON_LIBRARIES} /lib64/libffi.so ) 
+target_link_libraries(closure_tests ${JANSSON_LIBRARIES} /lib64/libffi.so ) 

http://git-wip-us.apache.org/repos/asf/celix/blob/7f338324/remote_services/dyn_type/closure_tests.c
----------------------------------------------------------------------
diff --git a/remote_services/dyn_type/closure_tests.c b/remote_services/dyn_type/closure_tests.c
new file mode 100644
index 0000000..39e4ca5
--- /dev/null
+++ b/remote_services/dyn_type/closure_tests.c
@@ -0,0 +1,98 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "dyn_function.h"
+
+#define EXAMPLE1_SCHEMA "example(III)I"
+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 = out;
+    *ret = a + b + c;
+}
+
+#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 = out;
+    *ret = a + b->val1 + b->val2 + b->val3 + c;
+}
+
+
+#define EXAMPLE3_SCHEMA "example(III){III sum max min}"
+struct example3_ret {
+    int32_t sum;
+    int32_t max;
+    int32_t min;
+};
+
+void example3_binding(void *userData, void* args[], void *out) {
+    printf("exampleelosure 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 = calloc(1,sizeof(*result));
+    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 = out;
+    (*ret) = result;
+}
+
+int main() {
+    dyn_closure_type *dynClosure = NULL;
+    int rc;
+
+    rc = dynClosure_create(EXAMPLE1_SCHEMA, example1_binding, NULL, &dynClosure);
+    if (rc == 0) {
+        int32_t (*func)(int32_t a, int32_t b, int32_t c) = NULL;
+        dynClosure_getFnPointer(dynClosure, (void *)&func);
+        int32_t ret = func(2,3,4);
+        printf("Return value for example1 is %i\n", ret);
+        dynClosure_destroy(dynClosure);
+    } else {
+        printf("example1 failed\n");
+    }
+
+    dynClosure = NULL;
+    rc = dynClosure_create(EXAMPLE2_SCHEMA, example2_binding, NULL, &dynClosure);
+    if (rc == 0) {
+        double (*func)(int32_t a, struct example2_arg2 *b, int32_t c) = NULL;
+        dynClosure_getFnPointer(dynClosure, (void *)&func);
+        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);
+        dynClosure_destroy(dynClosure);
+    } else {
+        printf("example2 failed\n");
+    }
+
+    dynClosure = NULL;
+    rc = dynClosure_create(EXAMPLE3_SCHEMA, example3_binding, NULL, &dynClosure);
+    if (rc == 0) {
+        struct example3_ret * (*func)(int32_t a, int32_t b, int32_t c) = NULL;
+        dynClosure_getFnPointer(dynClosure, (void *)&func);
+        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);
+        dynClosure_destroy(dynClosure);
+        free(ret);
+    } else {
+        printf("example2 failed\n");
+    }
+}

http://git-wip-us.apache.org/repos/asf/celix/blob/7f338324/remote_services/dyn_type/dyn_function.c
----------------------------------------------------------------------
diff --git a/remote_services/dyn_type/dyn_function.c b/remote_services/dyn_type/dyn_function.c
new file mode 100644
index 0000000..a90bc64
--- /dev/null
+++ b/remote_services/dyn_type/dyn_function.c
@@ -0,0 +1,209 @@
+#include "dyn_function.h"
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <strings.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <ffi.h>
+
+#include "dyn_type.h"
+
+struct _dyn_function_type {
+    dyn_type *arguments;
+    dyn_type *funcReturn;
+    void (*fn)(void);
+    ffi_cif cif;
+};
+
+struct _dyn_closure_type {
+    dyn_type *arguments;
+    dyn_type *funcReturn;
+    ffi_cif cif;
+    ffi_closure *ffiClosure;
+    void (*fn)(void);
+    void (*bind)(void *userData, void *args[], void *ret);
+    void *userData;
+};
+
+
+static int dynFunction_initCif(ffi_cif *cif, dyn_type *arguments, dyn_type  *funcReturn);
+static int dynFunction_parseSchema(const char *schema, dyn_type **arguments, dyn_type **funcReturn);
+static void dynClosure_ffiBind(ffi_cif *cif, void *ret, void *args[], void *userData); 
+
+int dynFunction_create(const char *schema, void (*fn)(void), dyn_function_type **out)  {
+    int status = 0;
+    dyn_function_type *dynFunc = NULL;
+    
+    dynFunc = calloc(1, sizeof(*dynFunc));
+
+    if (dynFunc != NULL) {
+        dynFunc->fn = fn;
+        status = dynFunction_parseSchema(schema, &dynFunc->arguments, &dynFunc->funcReturn);
+            if (status == 0) {
+                status = dynFunction_initCif(&dynFunc->cif, dynFunc->arguments,
dynFunc->funcReturn);
+            }
+    } else {
+        status = 2;
+    }
+    
+    if (status == 0) {
+        *out = dynFunc;
+    } else {
+        if (status == 1) {
+            printf("Cannot parse func schema '%s'\n", schema);
+        } else {
+            printf("Cannot allocate memory for dyn function\n");
+        }
+    }
+    return status;
+}
+
+static int dynFunction_parseSchema(const char *schema, dyn_type **arguments, dyn_type **funcReturn)
{
+    int status = 0;
+    //FIXME white space parsing is missing. Note move parsing to lex/bison?
+    //TODO move to parse schema function
+    char *startPos = index(schema, '(');
+    char *endPos = index(schema, ')');
+
+    if (startPos != NULL && endPos != NULL) {
+        int nrOfArgs = 0;
+        int len = endPos - startPos - 1;
+
+        char *pos = startPos + 1;
+        while (*pos != ')') {
+            nrOfArgs += 1;
+            if (*pos == '{') { //embedded struct
+                while (*pos != '}' && *pos != '\0') {
+                    pos += 1;
+                }
+            }
+            pos += 1;
+        }
+
+        printf("nrOfAgrs is %i\n", nrOfArgs);
+
+        //length needed is len args +2 -> {DD}
+        //+ 7 per arg e.g. {DD arg001 arg002}
+        //+ 1 x \0
+        //--> len args + 3 + 7 * nrArgs
+        int argLength = 3 + len + 7 * nrOfArgs;
+
+        char argSchema[argLength];
+        argSchema[0] = '{';
+        memcpy(argSchema + 1, startPos + 1, len);
+        pos += len + 1;
+        int i;
+        for (i = 0 ; i < nrOfArgs; i += 1) {
+            sprintf(argSchema + 1 + len + 7 * i, " arg%03d", i);
+            pos += 7;
+        }
+        argSchema[argLength -2] = '}';
+        argSchema[argLength -1] = '\0';
+        printf("arg schema is '%s'\n", argSchema);
+
+        size_t returnLen = strlen(endPos + 1);
+        char returnSchema[returnLen + 1];
+        memcpy(returnSchema, endPos +1, returnLen);
+        returnSchema[returnLen] = '\0';
+        printf("return schema is '%s'\n", returnSchema);
+
+        status = dynType_create(argSchema, arguments);
+        if (status == 0) {
+            status = dynType_create(returnSchema, funcReturn);
+        } 
+    } else {
+        status = 1;
+    }
+    
+    return status;
+}
+
+static int dynFunction_initCif(ffi_cif *cif, dyn_type *arguments, dyn_type *returnValue)
{
+    int result = 0;
+
+    int count = 0;
+    int i;
+    for (i = 0; arguments->complex.ffiType.elements[i] != NULL; i += 1) {
+        count += 1;
+    }
+
+    ffi_type **args = arguments->complex.ffiType.elements;
+    ffi_type *returnType = &ffi_type_pointer;
+    if (returnType->type == DYN_TYPE_SIMPLE) {
+        returnType = returnValue->simple.ffiType;
+    }
+
+
+    int ffiResult = ffi_prep_cif(cif, FFI_DEFAULT_ABI, count, returnType, args);
+    if (ffiResult != FFI_OK) {
+        result = 1;
+    }
+
+    return result;
+}
+
+int dynFunction_destroy(dyn_function_type *dynFunc) {
+    int result = 0;
+    printf("TODO destroy dyn dync\n");
+    return result;
+}
+
+int dynFunction_call(dyn_function_type *dynFunc, void *returnValue, void **argValues) {
+    ffi_call(&dynFunc->cif, dynFunc->fn, returnValue, argValues);    
+    return 0;
+}
+
+static void dynClosure_ffiBind(ffi_cif *cif, void *ret, void *args[], void *userData) {
+    dyn_closure_type *dynClosure = userData;
+    dynClosure->bind(dynClosure->userData, args, ret);
+}
+
+int dynClosure_create(const char *schema, void (*bind)(void *, void **, void*), void *userData,
dyn_closure_type **out) {
+    int status = 0;
+    dyn_closure_type *dynClosure = calloc(1, sizeof(*dynClosure));
+    if (dynClosure != NULL) {
+        dynClosure->bind = bind;
+        dynClosure->userData = userData;
+        status = dynFunction_parseSchema(schema, &dynClosure->arguments, &dynClosure->funcReturn);
+        if (status == 0) {
+            status = dynFunction_initCif(&dynClosure->cif, dynClosure->arguments,
dynClosure->funcReturn);
+            if (status == 0) {
+                dynClosure->ffiClosure = ffi_closure_alloc(sizeof(ffi_closure), (void
**)&dynClosure->fn);
+                if (dynClosure->ffiClosure != NULL) {
+                    int rc = ffi_prep_closure_loc(dynClosure->ffiClosure, &dynClosure->cif,
dynClosure_ffiBind, dynClosure, dynClosure->fn);
+                    if (rc != FFI_OK) {
+                        status = 1;
+                    }
+                } else {
+                    status = 2;
+                }
+            }
+        }
+    } else {
+        status = 2;
+    }
+
+    if (status == 0) {
+        *out = dynClosure;
+    }
+    return status;
+}
+
+int dynClosure_getFnPointer(dyn_closure_type *dynClosure, void (**fn)(void)) {
+    int status = 0;
+    if (dynClosure != NULL) {
+        (*fn) = dynClosure->fn;
+    } else {
+        status = 1;
+    }
+    return status;
+}
+
+
+int dynClosure_destroy(dyn_closure_type *dynClosure) {
+    int result = 0;
+    printf("TODO destroy closure\n");
+    return result;
+}

http://git-wip-us.apache.org/repos/asf/celix/blob/7f338324/remote_services/dyn_type/dyn_function.h
----------------------------------------------------------------------
diff --git a/remote_services/dyn_type/dyn_function.h b/remote_services/dyn_type/dyn_function.h
new file mode 100644
index 0000000..21a5e0d
--- /dev/null
+++ b/remote_services/dyn_type/dyn_function.h
@@ -0,0 +1,24 @@
+#ifndef __DYN_FUNCTION_H_
+#define __DYN_FUNCTION_H_
+
+#include <ffi.h>
+#include "dyn_type.h"
+
+/**
+ * Uses the following schema
+ * (Name)([Type]*)Type
+ * e.g add(DD)D or sum({[D[D setA setB})D
+ */
+
+typedef struct _dyn_function_type dyn_function_type;
+typedef struct _dyn_closure_type dyn_closure_type;
+
+int dynFunction_create(const char *schema, void (*fn)(void), dyn_function_type **dynFunc);
+int dynFunction_destroy(dyn_function_type *dynFunc);
+int dynFunction_call(dyn_function_type *dynFunc, void *returnValue, void **argValues);
+
+int dynClosure_create(const char *schema, void (*bind)(void *, void **, void*), void *userData,
dyn_closure_type **out);
+int dynClosure_getFnPointer(dyn_closure_type *dynClosure, void(**fn)(void));
+int dynClosure_destroy(dyn_closure_type *dynClosure);
+
+#endif

http://git-wip-us.apache.org/repos/asf/celix/blob/7f338324/remote_services/dyn_type/dyn_type.c
----------------------------------------------------------------------
diff --git a/remote_services/dyn_type/dyn_type.c b/remote_services/dyn_type/dyn_type.c
index fe4c9bc..e7a2645 100644
--- a/remote_services/dyn_type/dyn_type.c
+++ b/remote_services/dyn_type/dyn_type.c
@@ -16,26 +16,6 @@ struct generic_sequence {
     void *buf;
 };
 
-struct _dyn_type {
-    int type;
-    union {
-        struct {
-            ffi_type *ffiType;
-        } simple;
-
-        struct {
-            ffi_type ffiType;
-            char **names; 
-            dyn_type **nested_types; 
-        } complex;
-
-        struct {
-            ffi_type seqStruct;
-            dyn_type *dynType; //set if sequence is of a complex type
-            ffi_type *simpleType; //set if sequence is of a simple type
-        } sequence;
-    };
-};
 
 static char dynType_schemaType(dyn_type *dynType, ffi_type *ffiType);
 
@@ -105,12 +85,15 @@ static int dynType_simple_create(char t, dyn_type **result) {
     ffi_type *ffiType = dynType_ffiType_for(t); 
     dyn_type *simple = NULL;
     if (ffiType != NULL) {
-        dyn_type *simple = calloc(1,sizeof(*simple));
+        simple = calloc(1,sizeof(*simple));
         simple->type = DYN_TYPE_SIMPLE;
         simple->simple.ffiType = ffiType;
     }
     if (ffiType != NULL && simple != NULL) {
         *result = simple;
+    } else {
+        printf("Error creating simple dyn type for '%c'\n", t);
+        status = 1;
     }
     return status;
 }
@@ -203,6 +186,7 @@ static int dynType_complex_create(char *schema, dyn_type **result) {
                 memcpy(nested, schema + start + 1, len);
                 nested[len] = '\0';
                 dyn_type *nestedType = NULL;
+                //TODO catch nested problem
                 dynType_complex_create(nested, &nestedType); //TODO use status result
                 type->complex.nested_types[index] = nestedType;
                 type->complex.ffiType.elements[index] = &ffi_type_pointer;

http://git-wip-us.apache.org/repos/asf/celix/blob/7f338324/remote_services/dyn_type/dyn_type.h
----------------------------------------------------------------------
diff --git a/remote_services/dyn_type/dyn_type.h b/remote_services/dyn_type/dyn_type.h
index 5877fdf..c7fabc5 100644
--- a/remote_services/dyn_type/dyn_type.h
+++ b/remote_services/dyn_type/dyn_type.h
@@ -31,7 +31,10 @@
  *
  *
  * ComplexTypes
- * {[Type]+} [(Name)(SPACE)]+
+ * {[Type]+ [(Name)(SPACE)]+}
+ *
+ * NOTE MAYBE SUPPORT STRUCT BY VALUE ->
+ * <[Type]+ [(Name)(SPACE)]+>
  *
  * SequenceType
  * [(Type)
@@ -49,6 +52,29 @@
 
 typedef struct _dyn_type dyn_type;
 
+/* TODO MOVE TO PRIVATE HEADER */
+struct _dyn_type {
+    int type;
+    union {
+        struct {
+            ffi_type *ffiType;
+        } simple;
+
+        struct {
+            ffi_type ffiType;
+            char **names; 
+            dyn_type **nested_types; 
+        } complex;
+
+        struct {
+            ffi_type seqStruct;
+            dyn_type *dynType; //set if sequence is of a complex type
+            ffi_type *simpleType; //set if sequence is of a simple type
+        } sequence;
+    };
+};
+
+
 int dynType_create(const char *schema, dyn_type **type);
 int dynType_destroy(dyn_type *type);
 

http://git-wip-us.apache.org/repos/asf/celix/blob/7f338324/remote_services/dyn_type/func_tests.c
----------------------------------------------------------------------
diff --git a/remote_services/dyn_type/func_tests.c b/remote_services/dyn_type/func_tests.c
new file mode 100644
index 0000000..95811d7
--- /dev/null
+++ b/remote_services/dyn_type/func_tests.c
@@ -0,0 +1,66 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "dyn_function.h"
+
+#define EXAMPLE1_SCHEMA "example(III)I"
+int32_t example1(int32_t a, int32_t b, int32_t c) {
+    printf("example1 called with a:%i, b:%i, c:%i\n", a, b, c);
+    return 1;
+}
+
+#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) {
+    printf("example2 called with arg1:%i, arg2:{val1:%i, val2:%i, val3:%f}, arg3:%f\n", arg1,
arg2->val1, arg2->val2, arg2->val3, arg3);
+    return 2.2;
+}
+
+
+int main() {
+    dyn_function_type *dynFunc = NULL;
+    int rc;
+
+    rc = dynFunction_create(EXAMPLE1_SCHEMA, (void *)example1, &dynFunc);
+    if (rc == 0 ) {
+        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;
+        dynFunction_call(dynFunc, &rVal, values);
+        dynFunction_destroy(dynFunc);
+        dynFunc = NULL;
+    } else {
+        printf("Example 1 failed\n");
+    }
+
+    rc = dynFunction_create(EXAMPLE2_SCHEMA, (void *)example2, &dynFunc);
+    if (rc == 0 ) {
+        int32_t arg1 = 2;
+        struct example2_arg complexVal = { .val1 = 2, .val2 = 3, .val3 = 4.1 };
+        struct example2_arg *arg2 = &complexVal;
+        double arg3 = 8.1;
+        double returnVal = 0;
+        void *values[3];
+        values[0] = &arg1;
+        values[1] = &arg2;
+        values[2] = &arg3;
+        dynFunction_call(dynFunc, &returnVal, values);
+        dynFunction_destroy(dynFunc);
+        dynFunc = NULL;
+    } else {
+        printf("Example 3 failed\n");
+    }
+}


Mime
View raw message