You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@celix.apache.org by pn...@apache.org on 2015/07/12 20:08:33 UTC
[1/2] celix git commit: CELIX-237: some refactoring in function names
Repository: celix
Updated Branches:
refs/heads/feature/CELIX-237_rsa-ffi 8b1b23cc1 -> 08b5bc0ca
CELIX-237: some refactoring in function names
Project: http://git-wip-us.apache.org/repos/asf/celix/repo
Commit: http://git-wip-us.apache.org/repos/asf/celix/commit/5c52b219
Tree: http://git-wip-us.apache.org/repos/asf/celix/tree/5c52b219
Diff: http://git-wip-us.apache.org/repos/asf/celix/diff/5c52b219
Branch: refs/heads/feature/CELIX-237_rsa-ffi
Commit: 5c52b2192130075ed31030c6057dbd8882088003
Parents: 8b1b23c
Author: Pepijn Noltes <pe...@gmail.com>
Authored: Sat Jul 11 21:29:13 2015 +0200
Committer: Pepijn Noltes <pe...@gmail.com>
Committed: Sat Jul 11 21:29:13 2015 +0200
----------------------------------------------------------------------
.../dynamic_function_interface/dyn_function.c | 18 ++++++++++---
.../dynamic_function_interface/dyn_function.h | 6 +++--
.../dynamic_function_interface/dyn_type.c | 27 +++++++++++++++-----
.../dynamic_function_interface/dyn_type.h | 23 ++++++++++-------
.../tst/dyn_closure_tests.cpp | 6 ++---
.../tst/dyn_function_tests.cpp | 4 +--
.../tst/dyn_type_tests.cpp | 10 ++++----
.../tst/json_serializer_tests.cpp | 12 ++++-----
8 files changed, 68 insertions(+), 38 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/celix/blob/5c52b219/remote_services/dynamic_function_interface/dyn_function.c
----------------------------------------------------------------------
diff --git a/remote_services/dynamic_function_interface/dyn_function.c b/remote_services/dynamic_function_interface/dyn_function.c
index 96804e7..8814d3c 100644
--- a/remote_services/dynamic_function_interface/dyn_function.c
+++ b/remote_services/dynamic_function_interface/dyn_function.c
@@ -38,7 +38,12 @@ static int dynFunction_initCif(ffi_cif *cif, dyn_type *arguments, dyn_type *fun
static int dynFunction_parseDescriptor(const char *functionDescriptor, dyn_type_list_type *typeReferences, dyn_type **arguments, dyn_type **funcReturn);
static void dynClosure_ffiBind(ffi_cif *cif, void *ret, void *args[], void *userData);
-int dynFunction_create(const char *descriptor, dyn_type_list_type *typeReferences, void (*fn)(void), dyn_function_type **out) {
+int dynFunction_create(FILE *descriptorStream, dyn_type_list_type *typeReferences, void (*fn)(void), dyn_function_type **dynFunc) {
+ //TODO
+ return 0;
+}
+
+int dynFunction_createWithStr(const char *descriptor, dyn_type_list_type *typeReferences, void (*fn)(void), dyn_function_type **out) {
int status = 0;
dyn_function_type *dynFunc = NULL;
LOG_DEBUG("Creating dyn function for descriptor '%s'\n", descriptor);
@@ -89,9 +94,9 @@ static int dynFunction_parseDescriptor(const char *descriptor, dyn_type_list_typ
returnDesc[len] = '\0';
LOG_DEBUG("returnDesc is '%s'\n", returnDesc);
- status = dynType_create(argDesc, typeReferences, arguments);
+ status = dynType_createWithStr(argDesc, NULL, typeReferences, arguments);
if (status == 0) {
- status = dynType_create(returnDesc, typeReferences, funcReturn);
+ status = dynType_createWithStr(returnDesc, NULL, typeReferences, funcReturn);
}
} else {
status = 1;
@@ -142,7 +147,12 @@ static void dynClosure_ffiBind(ffi_cif *cif, void *ret, void *args[], void *user
dynClosure->bind(dynClosure->userData, args, ret);
}
-int dynClosure_create(const char *descriptor, dyn_type_list_type *typeReferences, void (*bind)(void *, void **, void*), void *userData, dyn_closure_type **out) {
+int dynClosure_create(FILE *descriptorStream, dyn_type_list_type *typeReferences, void (*bind)(void *, void **, void*), void *userData, dyn_closure_type **out) {
+ //TODO
+ return 0;
+}
+
+int dynClosure_createWithStr(const char *descriptor, dyn_type_list_type *typeReferences, 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) {
http://git-wip-us.apache.org/repos/asf/celix/blob/5c52b219/remote_services/dynamic_function_interface/dyn_function.h
----------------------------------------------------------------------
diff --git a/remote_services/dynamic_function_interface/dyn_function.h b/remote_services/dynamic_function_interface/dyn_function.h
index 4d3536e..11994fe 100644
--- a/remote_services/dynamic_function_interface/dyn_function.h
+++ b/remote_services/dynamic_function_interface/dyn_function.h
@@ -19,11 +19,13 @@ typedef struct _dyn_closure_type dyn_closure_type;
DFI_SETUP_LOG_HEADER(dynFunction);
-int dynFunction_create(const char *descriptor, dyn_type_list_type *typeReferences, void (*fn)(void), dyn_function_type **dynFunc);
+int dynFunction_create(FILE *descriptorStream, dyn_type_list_type *typeReferences, void (*fn)(void), dyn_function_type **dynFunc);
+int dynFunction_createWithStr(const char *descriptor, dyn_type_list_type *typeReferences, void (*fn)(void), dyn_function_type **dynFunc);
void dynFunction_destroy(dyn_function_type *dynFunc);
int dynFunction_call(dyn_function_type *dynFunc, void *returnValue, void **argValues);
-int dynClosure_create(const char *descriptor, dyn_type_list_type *typeReferences, void (*bind)(void *, void **, void*), void *userData, dyn_closure_type **out);
+int dynClosure_create(FILE *descriptorStream, dyn_type_list_type *typeReferences, void (*bind)(void *, void **, void*), void *userData, dyn_closure_type **out);
+int dynClosure_createWithStr(const char *descriptor, dyn_type_list_type *typeReferences, void (*bind)(void *, void **, void*), void *userData, dyn_closure_type **out);
int dynClosure_getFnPointer(dyn_closure_type *dynClosure, void(**fn)(void));
void dynClosure_destroy(dyn_closure_type *dynClosure);
http://git-wip-us.apache.org/repos/asf/celix/blob/5c52b219/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
index cfb2c3f..2dbb645 100644
--- a/remote_services/dynamic_function_interface/dyn_type.c
+++ b/remote_services/dynamic_function_interface/dyn_type.c
@@ -15,7 +15,7 @@
DFI_SETUP_LOG(dynType)
-static int dynType_createWithStream(FILE *stream, dyn_type *parent, dyn_type_list_type *typeReferences, dyn_type **result);
+static int dynType_createWithStream(FILE *stream, const char *name, dyn_type *parent, dyn_type_list_type *typeReferences, dyn_type **result);
static void dynType_clear(dyn_type *type);
static void dynType_clearComplex(dyn_type *type);
static void dynType_clearSequence(dyn_type *type);
@@ -57,11 +57,15 @@ static const int DT_ERROR = 1;
static const int DT_MEM_ERROR = 2;
static const int DT_PARSE_ERROR = 3;
-int dynType_create(const char *descriptor, dyn_type_list_type *typeReferences, dyn_type **type) {
+int dynType_create(FILE *descriptorStream, const char *name, dyn_type_list_type *typeReferences, dyn_type **type) {
+ return dynType_createWithStream(descriptorStream, name, NULL, typeReferences, type);
+}
+
+int dynType_createWithStr(const char *descriptor, const char *name, dyn_type_list_type *typeReferences, dyn_type **type) {
int status = DT_OK;
FILE *stream = fmemopen((char *)descriptor, strlen(descriptor), "r");
if (stream != NULL) {
- status = dynType_createWithStream(stream, NULL, typeReferences, type);
+ status = dynType_createWithStream(stream, name, NULL, typeReferences, type);
if (status == DT_OK) {
int c = fgetc(stream);
if (c != '\0' && c != EOF) {
@@ -77,7 +81,7 @@ int dynType_create(const char *descriptor, dyn_type_list_type *typeReferences, d
return status;
}
-static int dynType_createWithStream(FILE *stream, dyn_type *parent, dyn_type_list_type *typeReferences, dyn_type **result) {
+static int dynType_createWithStream(FILE *stream, const char *name, dyn_type *parent, dyn_type_list_type *typeReferences, dyn_type **result) {
int status = DT_OK;
dyn_type *type = calloc(1, sizeof(*type));
if (type != NULL) {
@@ -85,7 +89,16 @@ static int dynType_createWithStream(FILE *stream, dyn_type *parent, dyn_type_lis
type->type = DYN_TYPE_INVALID;
type->typeReferences = typeReferences;
TAILQ_INIT(&type->nestedTypesHead);
- status = dynType_parse(stream, type);
+ if (name != NULL) {
+ type->name = strdup(name);
+ if (type->name == NULL) {
+ status = DT_MEM_ERROR;
+ LOG_ERROR("Error strdup'ing name '%s'\n", name);
+ }
+ }
+ if (status == DT_OK) {
+ status = dynType_parse(stream, type);
+ }
if (status == DT_OK) {
*result = type;
} else {
@@ -334,7 +347,7 @@ static int dynType_parseSequence(FILE *stream, dyn_type *type) {
type->descriptor = '[';
type->sequence.seqType.elements = seq_types;
- status = dynType_createWithStream(stream, type, NULL, &type->sequence.itemType);
+ status = dynType_createWithStream(stream, NULL, type, NULL, &type->sequence.itemType);
if (status == DT_OK) {
type->ffiType = &type->sequence.seqType;
@@ -365,7 +378,7 @@ static int dynType_parseTypedPointer(FILE *stream, dyn_type *type) {
type->descriptor = '*';
type->ffiType = &ffi_type_pointer;
- status = dynType_createWithStream(stream, type, NULL, &type->typedPointer.typedType);
+ status = dynType_createWithStream(stream, NULL, type, NULL, &type->typedPointer.typedType);
return status;
}
http://git-wip-us.apache.org/repos/asf/celix/blob/5c52b219/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
index 2495811..a02b347 100644
--- a/remote_services/dynamic_function_interface/dyn_type.h
+++ b/remote_services/dynamic_function_interface/dyn_type.h
@@ -20,7 +20,7 @@
/* Description string
*
- * Type = [TypeDef]* (SimpleType | ComplexType | SequenceType | TypedPointer | PointerReference ) [TypeDef]*
+ * Type = [TypeDef]* (SimpleType | ComplexType | SequenceType | TypedPointer | PointerReference ) [TypeDef]* [Annotation]*
* Name = alpha[(alpha|numeric)*]
* SPACE = ' '
*
@@ -30,16 +30,16 @@
* 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?
+ * I int32_t
+ * J int64_t
+ * S int16_t
* V void
* Z boolean
* //Extended
* b unsigned char
- * i unsigned int (see I)
- * j unsigned long (see J)
- * s unsigned short (see S)
+ * i uint32_t
+ * j uint62_t
+ * s uint64_t
* P pointer
* t char* string
* N native int
@@ -60,9 +60,12 @@
* SequenceType
* [(Type)
*
+ * Annotation TODO
+ * <(Name)=(Value)>
+ *
* 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; }; };
+ * "{DD{FF c1 c2} a b c}" -> struct { double a; double b; struct c { float c1; float c2; }; };
*
*
*/
@@ -122,8 +125,10 @@ struct nested_entry {
DFI_SETUP_LOG_HEADER(dynType);
//generic
-int dynType_create(const char *descriptor, dyn_type_list_type *typeReferences, dyn_type **type);
+int dynType_create(FILE *descriptorStream, const char *name, dyn_type_list_type *typeReferences, dyn_type **type);
+int dynType_createWithStr(const char *descriptor, const char *name, dyn_type_list_type *typeReferences, 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);
http://git-wip-us.apache.org/repos/asf/celix/blob/5c52b219/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
index ac0566b..072c0f3 100644
--- a/remote_services/dynamic_function_interface/tst/dyn_closure_tests.cpp
+++ b/remote_services/dynamic_function_interface/tst/dyn_closure_tests.cpp
@@ -79,7 +79,7 @@ static void tests() {
int rc = 0;
{
- rc = dynClosure_create(EXAMPLE1_DESCRIPTOR, NULL, example1_binding, NULL, &dynClosure);
+ rc = dynClosure_createWithStr(EXAMPLE1_DESCRIPTOR, NULL, 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);
@@ -92,7 +92,7 @@ static void tests() {
{
dynClosure = NULL;
- rc = dynClosure_create(EXAMPLE2_DESCRIPTOR, NULL, example2_binding, NULL, &dynClosure);
+ rc = dynClosure_createWithStr(EXAMPLE2_DESCRIPTOR, NULL, 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);
@@ -109,7 +109,7 @@ static void tests() {
{
dynClosure = NULL;
- rc = dynClosure_create(EXAMPLE3_DESCRIPTOR, NULL, example3_binding, NULL, &dynClosure);
+ rc = dynClosure_createWithStr(EXAMPLE3_DESCRIPTOR, NULL, 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);
http://git-wip-us.apache.org/repos/asf/celix/blob/5c52b219/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
index c7b5679..478a70c 100644
--- a/remote_services/dynamic_function_interface/tst/dyn_function_tests.cpp
+++ b/remote_services/dynamic_function_interface/tst/dyn_function_tests.cpp
@@ -35,7 +35,7 @@ extern "C" {
int rc;
void (*fp)(void) = (void (*)(void)) example1;
- rc = dynFunction_create(EXAMPLE1_DESCRIPTOR, NULL, fp, &dynFunc);
+ rc = dynFunction_createWithStr(EXAMPLE1_DESCRIPTOR, NULL, fp, &dynFunc);
CHECK_EQUAL(0, rc);
int32_t a = 2;
@@ -74,7 +74,7 @@ extern "C" {
int rc;
void (*fp)(void) = (void (*)(void)) example2;
- rc = dynFunction_create(EXAMPLE2_DESCRIPTOR, NULL, fp, &dynFunc);
+ rc = dynFunction_createWithStr(EXAMPLE2_DESCRIPTOR, NULL, fp, &dynFunc);
CHECK_EQUAL(0, rc);
int32_t arg1 = 2;
http://git-wip-us.apache.org/repos/asf/celix/blob/5c52b219/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
index 046c757..bd3c333 100644
--- a/remote_services/dynamic_function_interface/tst/dyn_type_tests.cpp
+++ b/remote_services/dynamic_function_interface/tst/dyn_type_tests.cpp
@@ -24,7 +24,7 @@ extern "C" {
int i;
type = NULL;
printf("\n-- example %s with descriptor string '%s' --\n", exName, descriptorStr);
- int status = dynType_create(descriptorStr, NULL, &type);
+ int status = dynType_createWithStr(descriptorStr, exName, NULL, &type);
CHECK_EQUAL(0, status);
if (status == 0) {
dynType_print(type);
@@ -105,8 +105,8 @@ TEST(DynTypeTests, ParseRandomGarbageTest) {
}
//printf("ParseRandomGarbageTest iteration %i with descriptor string '%s'\n", k, descriptorStr);
- dyn_type *type = NULL;
- int status = dynType_create(descriptorStr, NULL, &type);
+ dyn_type *type = NULL;
+ int status = dynType_createWithStr(descriptorStr, NULL, NULL, &type);
if (status == 0) {
dynType_destroy(type);
}
@@ -122,7 +122,7 @@ TEST(DynTypeTests, AssignTest1) {
struct ex1 inst;
const char *desc = "{III a b c}";
dyn_type *type = NULL;
- int status = dynType_create(desc, NULL, &type);
+ int status = dynType_createWithStr(desc, NULL, NULL, &type);
CHECK_EQUAL(0, status);
int32_t val1 = 2;
int32_t val2 = 4;
@@ -146,7 +146,7 @@ TEST(DynTypeTests, AssignTest2) {
struct ex inst;
const char *desc = "{I{DD a b} a b}";
dyn_type *type = NULL;
- int status = dynType_create(desc, NULL, &type);
+ int status = dynType_createWithStr(desc, NULL, NULL, &type);
CHECK_EQUAL(0, status);
int32_t a = 2;
double b_a = 1.1;
http://git-wip-us.apache.org/repos/asf/celix/blob/5c52b219/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
index ee6d4d9..1ec4655 100644
--- a/remote_services/dynamic_function_interface/tst/json_serializer_tests.cpp
+++ b/remote_services/dynamic_function_interface/tst/json_serializer_tests.cpp
@@ -47,7 +47,7 @@ struct example1 {
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);
+ printf("example1: a:%f, b:%li, c:%i, d:%i, e:%f\n", ex->a, (long)ex->b, ex->c, ex->d, ex->e);
}
/*********** example 2 ************************/
@@ -73,7 +73,7 @@ struct example2 {
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);
+ printf("example2: byte:%i, long1:%li, long2:%li, double1:%f, float1:%f, double2:%f\n", ex->byte, (long)ex->long1, (long)ex->long2, ex->double1, ex->float1, ex->double2);
}
@@ -136,7 +136,7 @@ static void tests() {
type = NULL;
inst = NULL;
- rc = dynType_create(example1_descriptor, NULL, &type);
+ rc = dynType_createWithStr(example1_descriptor, NULL, NULL, &type);
CHECK_EQUAL(0, rc);
rc = json_deserialize(type, example1_input, &inst);
CHECK_EQUAL(0, rc);
@@ -146,7 +146,7 @@ static void tests() {
type = NULL;
inst = NULL;
- rc = dynType_create(example2_descriptor, NULL, &type);
+ rc = dynType_createWithStr(example2_descriptor, NULL, NULL, &type);
CHECK_EQUAL(0, rc);
rc = json_deserialize(type, example2_input, &inst);
CHECK_EQUAL(0, rc);
@@ -155,7 +155,7 @@ static void tests() {
type = NULL;
inst = NULL;
- rc = dynType_create(example3_descriptor, NULL, &type);
+ rc = dynType_createWithStr(example3_descriptor, NULL, NULL, &type);
CHECK_EQUAL(0, rc);
rc = json_deserialize(type, example3_input, &inst);
CHECK_EQUAL(0, rc);
@@ -163,7 +163,7 @@ static void tests() {
type = NULL;
inst = NULL;
- rc = dynType_create(example4_descriptor, NULL, &type);
+ rc = dynType_createWithStr(example4_descriptor, NULL, NULL, &type);
CHECK_EQUAL(0, rc);
rc = json_deserialize(type, example4_input, &inst);
CHECK_EQUAL(0, rc);
[2/2] celix git commit: CELIX-237: refactoring of parsing. mostly
using streams (FILE *) now
Posted by pn...@apache.org.
CELIX-237: refactoring of parsing. mostly using streams (FILE *) now
Project: http://git-wip-us.apache.org/repos/asf/celix/repo
Commit: http://git-wip-us.apache.org/repos/asf/celix/commit/08b5bc0c
Tree: http://git-wip-us.apache.org/repos/asf/celix/tree/08b5bc0c
Diff: http://git-wip-us.apache.org/repos/asf/celix/diff/08b5bc0c
Branch: refs/heads/feature/CELIX-237_rsa-ffi
Commit: 08b5bc0ca3ba5e6524922957ce832ba4bdbc683f
Parents: 5c52b21
Author: Pepijn Noltes <pe...@gmail.com>
Authored: Sun Jul 12 20:14:08 2015 +0200
Committer: Pepijn Noltes <pe...@gmail.com>
Committed: Sun Jul 12 20:14:08 2015 +0200
----------------------------------------------------------------------
.../dynamic_function_interface/CMakeLists.txt | 5 +-
.../dynamic_function_interface/dyn_common.c | 41 +++
.../dynamic_function_interface/dyn_common.h | 31 +++
.../dynamic_function_interface/dyn_function.c | 256 +++++++++++--------
.../dynamic_function_interface/dyn_function.h | 13 +-
.../dynamic_function_interface/dyn_interface.c | 22 +-
.../dynamic_function_interface/dyn_interface.h | 33 ++-
.../dynamic_function_interface/dyn_type.c | 62 ++---
.../dynamic_function_interface/dyn_type.h | 4 +-
.../tst/avro_descriptor_translator_tests.cpp | 2 +
.../tst/dyn_closure_tests.cpp | 38 +--
.../tst/dyn_function_tests.cpp | 11 +-
.../tst/dyn_type_tests.cpp | 13 +-
.../tst/json_serializer_tests.cpp | 10 +-
14 files changed, 317 insertions(+), 224 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/celix/blob/08b5bc0c/remote_services/dynamic_function_interface/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/remote_services/dynamic_function_interface/CMakeLists.txt b/remote_services/dynamic_function_interface/CMakeLists.txt
index 0c8cccb..0c69d92 100644
--- a/remote_services/dynamic_function_interface/CMakeLists.txt
+++ b/remote_services/dynamic_function_interface/CMakeLists.txt
@@ -19,11 +19,12 @@ if (${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
endif()
add_library(dfi
+ dyn_common.c
dyn_type.c
dyn_function.c
dyn_interface.c
json_serializer.c
- avro_descriptor_translator.c
+# avro_descriptor_translator.c
${MEMSTREAM_SOURCES}
)
target_link_libraries(dfi ${FFI_LIBRARIES} ${JANSSON_LIBRARY})
@@ -35,7 +36,7 @@ target_link_libraries(dfi ${FFI_LIBRARIES} ${JANSSON_LIBRARY})
tst/dyn_function_tests.cpp
tst/dyn_closure_tests.cpp
tst/json_serializer_tests.cpp
- tst/avro_descriptor_translator_tests.cpp
+# tst/avro_descriptor_translator_tests.cpp
tst/run_tests.cpp
)
target_link_libraries(dfi_tests dfi ${FFI_LIBRARIES} ${CPPUTEST_LIBRARY} ${JANSSON_LIBRARY})
http://git-wip-us.apache.org/repos/asf/celix/blob/08b5bc0c/remote_services/dynamic_function_interface/dyn_common.c
----------------------------------------------------------------------
diff --git a/remote_services/dynamic_function_interface/dyn_common.c b/remote_services/dynamic_function_interface/dyn_common.c
new file mode 100644
index 0000000..c0d5ca0
--- /dev/null
+++ b/remote_services/dynamic_function_interface/dyn_common.c
@@ -0,0 +1,41 @@
+/**
+ * Licensed under Apache License v2. See LICENSE for more information.
+ */
+#include "dyn_common.h"
+
+#include <stdio.h>
+#include <ctype.h>
+
+#if defined(BSD) || defined(__APPLE__)
+#include "open_memstream.h"
+#include "fmemopen.h"
+#endif
+
+static const int OK = 0;
+static const int ERROR = 1;
+
+DFI_SETUP_LOG(dynCommon)
+
+int dynCommon_parseName(FILE *stream, char **result) {
+ int status = 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 = ERROR;
+ LOG_ERROR("Error creating mem stream for name. %s", strerror(errno));
+ }
+ return status;
+}
http://git-wip-us.apache.org/repos/asf/celix/blob/08b5bc0c/remote_services/dynamic_function_interface/dyn_common.h
----------------------------------------------------------------------
diff --git a/remote_services/dynamic_function_interface/dyn_common.h b/remote_services/dynamic_function_interface/dyn_common.h
new file mode 100644
index 0000000..8a9491a
--- /dev/null
+++ b/remote_services/dynamic_function_interface/dyn_common.h
@@ -0,0 +1,31 @@
+/**
+ * Licensed under Apache License v2. See LICENSE for more information.
+ */
+#ifndef _DYN_COMMON_H_
+#define _DYN_COMMON_H_
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/queue.h>
+
+#include "dfi_log_util.h"
+
+//logging
+DFI_SETUP_LOG_HEADER(dynCommon);
+
+typedef struct _dyn_annotation_list_type annotation_list_type;
+TAILQ_HEAD(_dyn_annotation_list_type, _dyn_annotation_type);
+
+typedef struct _dyn_annotation_type dyn_annotation_type;
+struct _dyn_annotation_type {
+ char *name;
+ char *value;
+};
+
+int dynCommon_parseName(FILE *stream, char **result);
+//TODO int dynCommon_parseNameValue(FILE *stream, char **name, char **value);
+//TODO int dynCommon_parseAnnotation(FILE *stream,
+
+
+#endif
http://git-wip-us.apache.org/repos/asf/celix/blob/08b5bc0c/remote_services/dynamic_function_interface/dyn_function.c
----------------------------------------------------------------------
diff --git a/remote_services/dynamic_function_interface/dyn_function.c b/remote_services/dynamic_function_interface/dyn_function.c
index 8814d3c..75aa1ae 100644
--- a/remote_services/dynamic_function_interface/dyn_function.c
+++ b/remote_services/dynamic_function_interface/dyn_function.c
@@ -11,53 +11,61 @@
#include <ffi.h>
+#include "dyn_common.h"
#include "dyn_type.h"
#include "dfi_log_util.h"
DFI_SETUP_LOG(dynFunction)
struct _dyn_function_type {
- dyn_type *arguments;
+ char *name;
+ dyn_type_list_type *refTypes; //NOTE not owned
+ TAILQ_HEAD(,_dyn_function_argument_type) arguments;
+ ffi_type **ffiArguments;
dyn_type *funcReturn;
- void (*fn)(void);
ffi_cif cif;
-};
-struct _dyn_closure_type {
- dyn_type *arguments;
- dyn_type *funcReturn;
- ffi_cif cif;
+ //closure part
ffi_closure *ffiClosure;
void (*fn)(void);
+ void *userData;
void (*bind)(void *userData, void *args[], void *ret);
- void *userData; //for bind
};
+typedef struct _dyn_function_argument_type dyn_function_argument_type;
+struct _dyn_function_argument_type {
+ int index;
+ char *name;
+ dyn_type *type;
+ TAILQ_ENTRY(_dyn_function_argument_type) entries;
+};
-static int dynFunction_initCif(ffi_cif *cif, dyn_type *arguments, dyn_type *funcReturn);
-static int dynFunction_parseDescriptor(const char *functionDescriptor, dyn_type_list_type *typeReferences, dyn_type **arguments, dyn_type **funcReturn);
-static void dynClosure_ffiBind(ffi_cif *cif, void *ret, void *args[], void *userData);
+static const int OK = 0;
+static const int MEM_ERROR = 1;
+static const int PARSE_ERROR = 2;
-int dynFunction_create(FILE *descriptorStream, dyn_type_list_type *typeReferences, void (*fn)(void), dyn_function_type **dynFunc) {
- //TODO
- return 0;
-}
+static int dynFunction_initCif(dyn_function_type *dynFunc);
+static int dynFunction_parseDescriptor(dyn_function_type *dynFunc, FILE *descriptor);
+static void dynFunction_ffiBind(ffi_cif *cif, void *ret, void *args[], void *userData);
-int dynFunction_createWithStr(const char *descriptor, dyn_type_list_type *typeReferences, void (*fn)(void), dyn_function_type **out) {
- int status = 0;
+int dynFunction_parse(FILE *descriptor, dyn_type_list_type *typeReferences, dyn_function_type **out) {
+ int status = OK;
dyn_function_type *dynFunc = NULL;
- LOG_DEBUG("Creating dyn function for descriptor '%s'\n", descriptor);
+ LOG_DEBUG("Creating dyn function", descriptor);
dynFunc = calloc(1, sizeof(*dynFunc));
if (dynFunc != NULL) {
- dynFunc->fn = fn;
- status = dynFunction_parseDescriptor(descriptor, typeReferences, &dynFunc->arguments, &dynFunc->funcReturn);
+ TAILQ_INIT(&dynFunc->arguments);
+ dynFunc->refTypes = typeReferences;
+ status = dynFunction_parseDescriptor(dynFunc, descriptor);
if (status == 0) {
- status = dynFunction_initCif(&dynFunc->cif, dynFunc->arguments, dynFunc->funcReturn);
+ int rc = dynFunction_initCif(dynFunc);
+ status = rc != 0 ? rc : 0;
}
} else {
- status = 2;
+ LOG_ERROR("Error allocationg memory for dyn functipn\n");
+ status = MEM_ERROR;
}
if (status == 0) {
@@ -72,121 +80,161 @@ int dynFunction_createWithStr(const char *descriptor, dyn_type_list_type *typeRe
return status;
}
-static int dynFunction_parseDescriptor(const char *descriptor, dyn_type_list_type *typeReferences, dyn_type **arguments, dyn_type **funcReturn) {
- int status = 0;
- char *startPos = index(descriptor, '(');
- char *endPos = index(descriptor, ')');
-
- if (startPos != NULL && endPos != NULL) {
- int len = endPos - startPos - 1;
-
- //TODO add names (arg001, arg002, etc)
- char argDesc[len+3];
- argDesc[0] = '{';
- argDesc[len+1] = '}';
- memcpy(argDesc+1, startPos +1, len);
- argDesc[len+2] = '\0';
- LOG_DEBUG("argDesc is '%s'\n", argDesc);
-
- len = strlen(endPos);
- char returnDesc[len+1];
- memcpy(returnDesc, endPos + 1, len);
- returnDesc[len] = '\0';
- LOG_DEBUG("returnDesc is '%s'\n", returnDesc);
-
- status = dynType_createWithStr(argDesc, NULL, typeReferences, arguments);
+int dynFunction_parseWithStr(const char *descriptor, dyn_type_list_type *typeReferences, dyn_function_type **out) {
+ int status = OK;
+ FILE *stream = fmemopen((char *)descriptor, strlen(descriptor), "r");
+ if (stream != NULL) {
+ status = dynFunction_parse(stream, typeReferences, out);
+ fclose(stream);
+ } else {
+ status = MEM_ERROR;
+ LOG_ERROR("Error creating mem stream for descriptor string. %s", strerror(errno));
+ }
+ return status;
+}
+
+static int dynFunction_parseDescriptor(dyn_function_type *dynFunc, FILE *descriptor) {
+ int status = OK;
+ char *name = NULL;
+
+ status = dynCommon_parseName(descriptor, &name);
+
+ if (status == OK) {
+ dynFunc->name = name;
+ }
+
+ if (status == OK) {
+ int c = fgetc(descriptor);
+ if ( c != '(') {
+ status = PARSE_ERROR;
+ LOG_ERROR("Expected '(' token got '%c'", c);
+ }
+ }
+
+ int nextChar = fgetc(descriptor);
+ int index = 0;
+ dyn_type *type = NULL;
+ while (nextChar != ')' && status == 0) {
+ type = NULL;
+ ungetc(nextChar, descriptor);
+ status = dynType_parse(descriptor, NULL, dynFunc->refTypes, &type);
if (status == 0) {
- status = dynType_createWithStr(returnDesc, NULL, typeReferences, funcReturn);
+ dyn_function_argument_type *arg = calloc(1, sizeof(*arg));
+ arg->index = index++;
+ arg->type = type;
+ arg->name = NULL; //TODO
+ if (arg != NULL) {
+ TAILQ_INSERT_TAIL(&dynFunc->arguments, arg, entries);
+ } else {
+ LOG_ERROR("Error allocating memory");
+ status = MEM_ERROR;
+ }
}
- } else {
- status = 1;
+ nextChar = fgetc(descriptor);
+ }
+
+ if (status == 0) {
+ status = dynType_parse(descriptor, NULL, dynFunc->refTypes, &dynFunc->funcReturn);
}
return status;
}
-static int dynFunction_initCif(ffi_cif *cif, dyn_type *arguments, dyn_type *returnValue) {
- int result = 0;
+static int dynFunction_initCif(dyn_function_type *dynFunc) {
+ int status = 0;
int count = 0;
- int i;
- for (i = 0; arguments->ffiType->elements[i] != NULL; i += 1) {
- count += 1;
+ dyn_function_argument_type *entry = NULL;
+ TAILQ_FOREACH(entry, &dynFunc->arguments, entries) {
+ count +=1;
}
- ffi_type **args = arguments->ffiType->elements;
- ffi_type *returnType = returnValue->ffiType;
+ dynFunc->ffiArguments = calloc(count, sizeof(ffi_type));
+
+ TAILQ_FOREACH(entry, &dynFunc->arguments, entries) {
+ dynFunc->ffiArguments[entry->index] = entry->type->ffiType;
+ }
+
+ ffi_type **args = dynFunc->ffiArguments;
+ ffi_type *returnType = dynFunc->funcReturn->ffiType;
- int ffiResult = ffi_prep_cif(cif, FFI_DEFAULT_ABI, count, returnType, args);
+ int ffiResult = ffi_prep_cif(&dynFunc->cif, FFI_DEFAULT_ABI, count, returnType, args);
if (ffiResult != FFI_OK) {
- result = 1;
+ status = 1;
}
- return result;
+ return status;
}
void dynFunction_destroy(dyn_function_type *dynFunc) {
if (dynFunc != NULL) {
- if (dynFunc->arguments != NULL) {
- dynType_destroy(dynFunc->arguments);
- }
if (dynFunc->funcReturn != NULL) {
- dynType_destroy(dynFunc->funcReturn);
- }
- free(dynFunc);
+ dynType_destroy(dynFunc->funcReturn);
+ }
+ if (dynFunc->ffiClosure != NULL) {
+ ffi_closure_free(dynFunc->ffiClosure);
+ }
+ if (dynFunc->name != NULL) {
+ free(dynFunc->name);
+ }
+ if (dynFunc->ffiArguments != NULL) {
+ free(dynFunc->ffiArguments);
+ }
+
+ dyn_function_argument_type *entry = NULL;
+ dyn_function_argument_type *tmp = NULL;
+ entry = TAILQ_FIRST(&dynFunc->arguments);
+ while (entry != NULL) {
+ if (entry->name != NULL) {
+ free(entry->name);
+ }
+ dynType_destroy(entry->type);
+ tmp = entry;
+ entry = TAILQ_NEXT(entry, entries);
+ free(tmp);
+ }
+
+ free(dynFunc);
}
}
-int dynFunction_call(dyn_function_type *dynFunc, void *returnValue, void **argValues) {
- ffi_call(&dynFunc->cif, dynFunc->fn, returnValue, argValues);
+int dynFunction_call(dyn_function_type *dynFunc, void(*fn)(void), void *returnValue, void **argValues) {
+ //TODO check dynFunc arg
+ ffi_call(&dynFunc->cif, 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);
+static void dynFunction_ffiBind(ffi_cif *cif, void *ret, void *args[], void *userData) {
+ dyn_function_type *dynFunc = userData;
+ dynFunc->bind(dynFunc->userData, args, ret);
}
-int dynClosure_create(FILE *descriptorStream, dyn_type_list_type *typeReferences, void (*bind)(void *, void **, void*), void *userData, dyn_closure_type **out) {
- //TODO
- return 0;
-}
-
-int dynClosure_createWithStr(const char *descriptor, dyn_type_list_type *typeReferences, void (*bind)(void *, void **, void*), void *userData, dyn_closure_type **out) {
+int dynFunction_createClosure(dyn_function_type *dynFunc, void (*bind)(void *, void **, void*), void *userData, void(**out)(void)) {
int status = 0;
- dyn_closure_type *dynClosure = calloc(1, sizeof(*dynClosure));
- if (dynClosure != NULL) {
- dynClosure->bind = bind;
- dynClosure->userData = userData;
- status = dynFunction_parseDescriptor(descriptor, typeReferences, &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;
- }
- }
+ void (*fn)(void);
+ dynFunc->ffiClosure = ffi_closure_alloc(sizeof(ffi_closure), (void **)&fn);
+ if (dynFunc->ffiClosure != NULL) {
+ int rc = ffi_prep_closure_loc(dynFunc->ffiClosure, &dynFunc->cif, dynFunction_ffiBind, dynFunc, fn);
+ if (rc != FFI_OK) {
+ status = 1;
}
} else {
status = 2;
}
if (status == 0) {
- *out = dynClosure;
+ dynFunc->bind = bind;
+ dynFunc->fn = fn;
+ *out =fn;
}
+
return status;
}
-int dynClosure_getFnPointer(dyn_closure_type *dynClosure, void (**fn)(void)) {
+int dynClosure_getFnPointer(dyn_function_type *dynFunc, void (**fn)(void)) {
int status = 0;
- if (dynClosure != NULL) {
- (*fn) = dynClosure->fn;
+ if (dynFunc != NULL && dynFunc->fn != NULL) {
+ (*fn) = dynFunc->fn;
} else {
status = 1;
}
@@ -194,17 +242,3 @@ int dynClosure_getFnPointer(dyn_closure_type *dynClosure, void (**fn)(void)) {
}
-void dynClosure_destroy(dyn_closure_type *dynClosure) {
- if (dynClosure != NULL) {
- if (dynClosure->arguments != NULL) {
- dynType_destroy(dynClosure->arguments);
- }
- if (dynClosure->funcReturn != NULL) {
- dynType_destroy(dynClosure->funcReturn);
- }
- if (dynClosure->ffiClosure != NULL) {
- ffi_closure_free(dynClosure->ffiClosure);
- }
- free(dynClosure);
- }
-}
http://git-wip-us.apache.org/repos/asf/celix/blob/08b5bc0c/remote_services/dynamic_function_interface/dyn_function.h
----------------------------------------------------------------------
diff --git a/remote_services/dynamic_function_interface/dyn_function.h b/remote_services/dynamic_function_interface/dyn_function.h
index 11994fe..3747656 100644
--- a/remote_services/dynamic_function_interface/dyn_function.h
+++ b/remote_services/dynamic_function_interface/dyn_function.h
@@ -19,14 +19,13 @@ typedef struct _dyn_closure_type dyn_closure_type;
DFI_SETUP_LOG_HEADER(dynFunction);
-int dynFunction_create(FILE *descriptorStream, dyn_type_list_type *typeReferences, void (*fn)(void), dyn_function_type **dynFunc);
-int dynFunction_createWithStr(const char *descriptor, dyn_type_list_type *typeReferences, void (*fn)(void), dyn_function_type **dynFunc);
+int dynFunction_parse(FILE *descriptorStream, dyn_type_list_type *typeReferences, dyn_function_type **dynFunc);
+int dynFunction_parseWithStr(const char *descriptor, dyn_type_list_type *typeReferences, dyn_function_type **dynFunc);
+
void dynFunction_destroy(dyn_function_type *dynFunc);
-int dynFunction_call(dyn_function_type *dynFunc, void *returnValue, void **argValues);
+int dynFunction_call(dyn_function_type *dynFunc, void(*fn)(void), void *returnValue, void **argValues);
-int dynClosure_create(FILE *descriptorStream, dyn_type_list_type *typeReferences, void (*bind)(void *, void **, void*), void *userData, dyn_closure_type **out);
-int dynClosure_createWithStr(const char *descriptor, dyn_type_list_type *typeReferences, void (*bind)(void *, void **, void*), void *userData, dyn_closure_type **out);
-int dynClosure_getFnPointer(dyn_closure_type *dynClosure, void(**fn)(void));
-void dynClosure_destroy(dyn_closure_type *dynClosure);
+int dynFunction_createClosure(dyn_function_type *func, void (*bind)(void *, void **, void*), void *userData, void(**fn)(void));
+int dynFunction_getFnPointer(dyn_function_type *func, void (**fn)(void));
#endif
http://git-wip-us.apache.org/repos/asf/celix/blob/08b5bc0c/remote_services/dynamic_function_interface/dyn_interface.c
----------------------------------------------------------------------
diff --git a/remote_services/dynamic_function_interface/dyn_interface.c b/remote_services/dynamic_function_interface/dyn_interface.c
index 601669c..1fbb831 100644
--- a/remote_services/dynamic_function_interface/dyn_interface.c
+++ b/remote_services/dynamic_function_interface/dyn_interface.c
@@ -20,8 +20,8 @@ int dynInterface_create(const char *name, dyn_interface_type **out) {
}
if (status == 0) {
- TAILQ_INIT(&inft->typeInfos);
- TAILQ_INIT(&inft->methodInfos);
+ TAILQ_INIT(&inft->types);
+ TAILQ_INIT(&inft->methods);
}
*out = inft;
return status;
@@ -33,8 +33,8 @@ void dynInterface_destroy(dyn_interface_type *intf) {
free(intf->name);
}
- type_info_type *tmp = NULL;
- type_info_type *tInfo = TAILQ_FIRST(&intf->typeInfos);
+ interface_type_type *tmp = NULL;
+ interface_type_type *tInfo = TAILQ_FIRST(&intf->types);
while (tInfo != NULL) {
tmp = tInfo;
tInfo = TAILQ_NEXT(tInfo, entries);
@@ -42,15 +42,12 @@ void dynInterface_destroy(dyn_interface_type *intf) {
if (tmp->name != NULL) {
free(tmp->name);
}
- if (tmp->descriptor != NULL) {
- free(tmp->descriptor);
- }
free(tmp);
}
- method_info_type *mTmp = NULL;
- method_info_type *mInfo = TAILQ_FIRST(&intf->methodInfos);
+ interface_method_type *mTmp = NULL;
+ interface_method_type *mInfo = TAILQ_FIRST(&intf->methods);
while (mInfo != NULL) {
mTmp = mInfo;
mInfo = TAILQ_NEXT(mInfo, entries);
@@ -58,19 +55,12 @@ void dynInterface_destroy(dyn_interface_type *intf) {
if (mTmp->strIdentifier != NULL) {
free(mTmp->strIdentifier);
}
- if (mTmp->descriptor != NULL) {
- free(mTmp->descriptor);
- }
if (mTmp->name != NULL) {
free(mTmp->name);
}
if (mTmp->dynFunc != NULL) {
dynFunction_destroy(mTmp->dynFunc);
}
- if (mTmp->dynClosure != NULL) {
- dynClosure_destroy(mTmp->dynClosure);
- }
-
free(mTmp);
}
http://git-wip-us.apache.org/repos/asf/celix/blob/08b5bc0c/remote_services/dynamic_function_interface/dyn_interface.h
----------------------------------------------------------------------
diff --git a/remote_services/dynamic_function_interface/dyn_interface.h b/remote_services/dynamic_function_interface/dyn_interface.h
index 5d0b427..77eefb8 100644
--- a/remote_services/dynamic_function_interface/dyn_interface.h
+++ b/remote_services/dynamic_function_interface/dyn_interface.h
@@ -14,32 +14,39 @@ typedef struct _dyn_interface_type dyn_interface_type;
struct _dyn_interface_type {
char *name;
- TAILQ_HEAD(, _type_info_type) typeInfos;
- TAILQ_HEAD(, _method_info_type) methodInfos;
+ int versionMajor;
+ int versionMinor;
+ int versionMicro;
+ TAILQ_HEAD(, _interface_annotation_type) annotations;
+ TAILQ_HEAD(, _interface_type_type) types;
+ TAILQ_HEAD(, _interface_method_type) methods;
};
-typedef struct _method_info_type method_info_type;
-struct _method_info_type {
+typedef struct _interface_annotation_type interface_annotation_type;
+struct _interface_annotation_type {
+ char *name;
+ char *value;
+ TAILQ_ENTRY(_interface_annotation_type) entries;
+};
+
+typedef struct _interface_method_type interface_method_type;
+struct _interface_method_type {
int identifier;
char *strIdentifier;
- char *descriptor;
char *name;
dyn_function_type *dynFunc;
- dyn_closure_type *dynClosure;
- TAILQ_ENTRY(_method_info_type) entries;
+ TAILQ_ENTRY(_interface_method_type) entries;
};
-typedef struct _type_info_type type_info_type;
-struct _type_info_type {
+typedef struct _interface_type_type interface_type_type;
+struct _interface_type_type {
char *name;
- char *descriptor;
- TAILQ_ENTRY(_type_info_type) entries;
+ TAILQ_ENTRY(_interface_type_type) entries;
};
-
-int dynInterface_create(const char *name, dyn_interface_type **out);
+int dynInterface_parse(const FILE *descriptor, dyn_interface_type **out);
void dynInterface_destroy(dyn_interface_type *intf);
http://git-wip-us.apache.org/repos/asf/celix/blob/08b5bc0c/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
index 2dbb645..2915093 100644
--- a/remote_services/dynamic_function_interface/dyn_type.c
+++ b/remote_services/dynamic_function_interface/dyn_type.c
@@ -13,9 +13,11 @@
#include <assert.h>
#include <errno.h>
+#include "dyn_common.h"
+
DFI_SETUP_LOG(dynType)
-static int dynType_createWithStream(FILE *stream, const char *name, dyn_type *parent, dyn_type_list_type *typeReferences, dyn_type **result);
+static int dynType_parseWithStream(FILE *stream, const char *name, dyn_type *parent, dyn_type_list_type *typeReferences, dyn_type **result);
static void dynType_clear(dyn_type *type);
static void dynType_clearComplex(dyn_type *type);
static void dynType_clearSequence(dyn_type *type);
@@ -23,9 +25,8 @@ 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_parseAny(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);
@@ -57,15 +58,15 @@ static const int DT_ERROR = 1;
static const int DT_MEM_ERROR = 2;
static const int DT_PARSE_ERROR = 3;
-int dynType_create(FILE *descriptorStream, const char *name, dyn_type_list_type *typeReferences, dyn_type **type) {
- return dynType_createWithStream(descriptorStream, name, NULL, typeReferences, type);
+int dynType_parse(FILE *descriptorStream, const char *name, dyn_type_list_type *typeReferences, dyn_type **type) {
+ return dynType_parseWithStream(descriptorStream, name, NULL, typeReferences, type);
}
-int dynType_createWithStr(const char *descriptor, const char *name, dyn_type_list_type *typeReferences, dyn_type **type) {
+int dynType_parseWithStr(const char *descriptor, const char *name, dyn_type_list_type *typeReferences, dyn_type **type) {
int status = DT_OK;
FILE *stream = fmemopen((char *)descriptor, strlen(descriptor), "r");
if (stream != NULL) {
- status = dynType_createWithStream(stream, name, NULL, typeReferences, type);
+ status = dynType_parseWithStream(stream, name, NULL, typeReferences, type);
if (status == DT_OK) {
int c = fgetc(stream);
if (c != '\0' && c != EOF) {
@@ -81,7 +82,7 @@ int dynType_createWithStr(const char *descriptor, const char *name, dyn_type_lis
return status;
}
-static int dynType_createWithStream(FILE *stream, const char *name, dyn_type *parent, dyn_type_list_type *typeReferences, dyn_type **result) {
+static int dynType_parseWithStream(FILE *stream, const char *name, dyn_type *parent, dyn_type_list_type *typeReferences, dyn_type **result) {
int status = DT_OK;
dyn_type *type = calloc(1, sizeof(*type));
if (type != NULL) {
@@ -97,7 +98,7 @@ static int dynType_createWithStream(FILE *stream, const char *name, dyn_type *pa
}
}
if (status == DT_OK) {
- status = dynType_parse(stream, type);
+ status = dynType_parseAny(stream, type);
}
if (status == DT_OK) {
*result = type;
@@ -111,7 +112,7 @@ static int dynType_createWithStream(FILE *stream, const char *name, dyn_type *pa
return status;
}
-static int dynType_parse(FILE *stream, dyn_type *type) {
+static int dynType_parseAny(FILE *stream, dyn_type *type) {
int status = DT_OK;
int c = fgetc(stream);
@@ -119,7 +120,7 @@ static int dynType_parse(FILE *stream, dyn_type *type) {
case 'T' :
status = dynType_parseNestedType(stream, type);
if (status == DT_OK) {
- status = dynType_parse(stream, type);
+ status = dynType_parseAny(stream, type);
}
break;
case 'L' :
@@ -162,7 +163,7 @@ static int dynType_parseComplex(FILE *stream, dyn_type *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);
+ status = dynType_parseAny(stream, &entry->type);
} else {
status = DT_MEM_ERROR;
LOG_ERROR("Error allocating memory for type");
@@ -173,7 +174,7 @@ static int dynType_parseComplex(FILE *stream, dyn_type *type) {
entry = TAILQ_FIRST(&type->complex.entriesHead);
char *name = NULL;
while (c == ' ' && entry != NULL) {
- status = dynType_parseName(stream, &name);
+ status = dynCommon_parseName(stream, &name);
if (status == DT_OK) {
entry->name = name;
entry = TAILQ_NEXT(entry, entries);
@@ -224,31 +225,6 @@ static int dynType_parseComplex(FILE *stream, dyn_type *type) {
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;
- 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;
@@ -260,7 +236,7 @@ static int dynType_parseNestedType(FILE *stream, dyn_type *type) {
entry->type.type = DYN_TYPE_INVALID;
TAILQ_INIT(&entry->type.nestedTypesHead);
TAILQ_INSERT_TAIL(&type->nestedTypesHead, entry, entries);
- status = dynType_parseName(stream, &name);
+ status = dynCommon_parseName(stream, &name);
entry->type.name = name;
} else {
status = DT_MEM_ERROR;
@@ -275,7 +251,7 @@ static int dynType_parseNestedType(FILE *stream, dyn_type *type) {
}
if (status == DT_OK) {
- status = dynType_parse(stream, &entry->type);
+ status = dynType_parseAny(stream, &entry->type);
int c = fgetc(stream);
if (c != ';') {
status = DT_PARSE_ERROR;
@@ -316,7 +292,7 @@ static int dynType_parseRefByValue(FILE *stream, dyn_type *type) {
type->descriptor = 'l';
char *name = NULL;
- status = dynType_parseName(stream, &name);
+ status = dynCommon_parseName(stream, &name);
if (status == DT_OK) {
dyn_type *ref = dynType_findType(type, name);
free(name);
@@ -347,7 +323,7 @@ static int dynType_parseSequence(FILE *stream, dyn_type *type) {
type->descriptor = '[';
type->sequence.seqType.elements = seq_types;
- status = dynType_createWithStream(stream, NULL, type, NULL, &type->sequence.itemType);
+ status = dynType_parseWithStream(stream, NULL, type, NULL, &type->sequence.itemType);
if (status == DT_OK) {
type->ffiType = &type->sequence.seqType;
@@ -378,7 +354,7 @@ static int dynType_parseTypedPointer(FILE *stream, dyn_type *type) {
type->descriptor = '*';
type->ffiType = &ffi_type_pointer;
- status = dynType_createWithStream(stream, NULL, type, NULL, &type->typedPointer.typedType);
+ status = dynType_parseWithStream(stream, NULL, type, NULL, &type->typedPointer.typedType);
return status;
}
http://git-wip-us.apache.org/repos/asf/celix/blob/08b5bc0c/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
index a02b347..bc19836 100644
--- a/remote_services/dynamic_function_interface/dyn_type.h
+++ b/remote_services/dynamic_function_interface/dyn_type.h
@@ -125,8 +125,8 @@ struct nested_entry {
DFI_SETUP_LOG_HEADER(dynType);
//generic
-int dynType_create(FILE *descriptorStream, const char *name, dyn_type_list_type *typeReferences, dyn_type **type);
-int dynType_createWithStr(const char *descriptor, const char *name, dyn_type_list_type *typeReferences, dyn_type **type);
+int dynType_parse(FILE *descriptorStream, const char *name, dyn_type_list_type *typeReferences, dyn_type **type);
+int dynType_parseWithStr(const char *descriptor, const char *name, dyn_type_list_type *typeReferences, dyn_type **type);
void dynType_destroy(dyn_type *type);
int dynType_alloc(dyn_type *type, void **bufLoc);
http://git-wip-us.apache.org/repos/asf/celix/blob/08b5bc0c/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
index 8f8dbc8..63401e5 100644
--- a/remote_services/dynamic_function_interface/tst/avro_descriptor_translator_tests.cpp
+++ b/remote_services/dynamic_function_interface/tst/avro_descriptor_translator_tests.cpp
@@ -10,6 +10,7 @@ extern "C" {
#include <assert.h>
#include <string.h>
+#include "dyn_common.h"
#include "descriptor_translator.h"
#if defined(BSD) || defined(__APPLE__)
@@ -142,6 +143,7 @@ TEST_GROUP(AvroDescTranslatorTest) {
descriptorTranslator_logSetup(stdLog, NULL, 3);
dynInterface_logSetup(stdLog, NULL, 3);
dynType_logSetup(stdLog, NULL, 3);
+ dynCommon_logSetup(stdLog, NULL, 3);
}
};
http://git-wip-us.apache.org/repos/asf/celix/blob/08b5bc0c/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
index 072c0f3..d01b22e 100644
--- a/remote_services/dynamic_function_interface/tst/dyn_closure_tests.cpp
+++ b/remote_services/dynamic_function_interface/tst/dyn_closure_tests.cpp
@@ -12,6 +12,7 @@ extern "C" {
#include <string.h>
#include <ctype.h>
+#include "dyn_common.h"
#include "dyn_function.h"
static int g_count;
@@ -75,27 +76,27 @@ static void example3_binding(void *userData, void* args[], void *out) {
}
static void tests() {
- dyn_closure_type *dynClosure = NULL;
+ dyn_function_type *dynFunction = NULL;
int rc = 0;
{
- rc = dynClosure_createWithStr(EXAMPLE1_DESCRIPTOR, NULL, 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);
+ rc = dynFunction_parseWithStr(EXAMPLE1_DESCRIPTOR, NULL, &dynFunction);
+ CHECK_EQUAL(0, rc);
+ rc = dynFunction_createClosure(dynFunction, example1_binding, NULL, (void(**)(void))&func);
CHECK_EQUAL(0, rc);
int32_t ret = func(2,3,4);
CHECK_EQUAL(1, g_count);
- CHECK_EQUAL(9, ret);
- dynClosure_destroy(dynClosure);
+ CHECK_EQUAL(9, ret);
+ dynFunction_destroy(dynFunction);
}
{
- dynClosure = NULL;
- rc = dynClosure_createWithStr(EXAMPLE2_DESCRIPTOR, NULL, 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);
+ dynFunction = NULL;
+ rc = dynFunction_parseWithStr(EXAMPLE2_DESCRIPTOR, NULL, &dynFunction);
+ CHECK_EQUAL(0, rc);
+ rc = dynFunction_createClosure(dynFunction, example2_binding, NULL, (void(**)(void))&func);
CHECK_EQUAL(0, rc);
struct example2_arg2 b;
b.val1 = 1.0;
@@ -103,21 +104,21 @@ static void tests() {
b.val3 = 2.0;
double ret = func(2,b,4);
CHECK_EQUAL(2, g_count);
- CHECK_EQUAL(10.5, ret);
- dynClosure_destroy(dynClosure);
+ CHECK_EQUAL(10.5, ret);
+ dynFunction_destroy(dynFunction);
}
{
- dynClosure = NULL;
- rc = dynClosure_createWithStr(EXAMPLE3_DESCRIPTOR, NULL, 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);
+ dynFunction = NULL;
+ rc = dynFunction_parseWithStr(EXAMPLE3_DESCRIPTOR, NULL, &dynFunction);
+ CHECK_EQUAL(0, rc);
+ rc = dynFunction_createClosure(dynFunction, example3_binding, NULL, (void(**)(void))&func);
CHECK_EQUAL(0, rc);
struct example3_ret *ret = func(2,8,4);
CHECK_EQUAL(3, g_count);
- CHECK_EQUAL(14, ret->sum);
- dynClosure_destroy(dynClosure);
+ CHECK_EQUAL(14, ret->sum);
+ dynFunction_destroy(dynFunction);
free(ret);
}
}
@@ -130,6 +131,7 @@ TEST_GROUP(DynClosureTests) {
dynFunction_logSetup(stdLog, NULL, 3);
dynType_logSetup(stdLog, NULL, 3);
//TODO dynType_logSetup(stdLog, NULL, 4);
+ dynCommon_logSetup(stdLog, NULL, 3);
g_count = 0;
}
};
http://git-wip-us.apache.org/repos/asf/celix/blob/08b5bc0c/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
index 478a70c..410b3ec 100644
--- a/remote_services/dynamic_function_interface/tst/dyn_function_tests.cpp
+++ b/remote_services/dynamic_function_interface/tst/dyn_function_tests.cpp
@@ -11,6 +11,8 @@ extern "C" {
#include <string.h>
#include <ctype.h>
+
+ #include "dyn_common.h"
#include "dyn_function.h"
static void stdLog(void *handle, int level, const char *file, int line, const char *msg, ...) {
@@ -35,7 +37,7 @@ extern "C" {
int rc;
void (*fp)(void) = (void (*)(void)) example1;
- rc = dynFunction_createWithStr(EXAMPLE1_DESCRIPTOR, NULL, fp, &dynFunc);
+ rc = dynFunction_parseWithStr(EXAMPLE1_DESCRIPTOR, NULL, &dynFunc);
CHECK_EQUAL(0, rc);
int32_t a = 2;
@@ -47,7 +49,7 @@ extern "C" {
values[1] = &b;
values[2] = &c;
- rc = dynFunction_call(dynFunc, &rVal, values);
+ rc = dynFunction_call(dynFunc, fp, &rVal, values);
CHECK_EQUAL(0, rc);
CHECK_EQUAL(1, rVal);
dynFunction_destroy(dynFunc);
@@ -74,7 +76,7 @@ extern "C" {
int rc;
void (*fp)(void) = (void (*)(void)) example2;
- rc = dynFunction_createWithStr(EXAMPLE2_DESCRIPTOR, NULL, fp, &dynFunc);
+ rc = dynFunction_parseWithStr(EXAMPLE2_DESCRIPTOR, NULL, &dynFunc);
CHECK_EQUAL(0, rc);
int32_t arg1 = 2;
@@ -89,7 +91,7 @@ extern "C" {
values[1] = &arg2;
values[2] = &arg3;
- rc = dynFunction_call(dynFunc, &returnVal, values);
+ rc = dynFunction_call(dynFunc, fp, &returnVal, values);
CHECK_EQUAL(0, rc);
CHECK_EQUAL(2.2, returnVal);
dynFunction_destroy(dynFunc);
@@ -100,6 +102,7 @@ TEST_GROUP(DynFunctionTests) {
void setup() {
dynFunction_logSetup(stdLog, NULL, 3);
dynType_logSetup(stdLog, NULL, 3);
+ dynCommon_logSetup(stdLog, NULL, 3);
}
};
http://git-wip-us.apache.org/repos/asf/celix/blob/08b5bc0c/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
index bd3c333..96bebdc 100644
--- a/remote_services/dynamic_function_interface/tst/dyn_type_tests.cpp
+++ b/remote_services/dynamic_function_interface/tst/dyn_type_tests.cpp
@@ -8,6 +8,7 @@ extern "C" {
#include <string.h>
#include <stdarg.h>
+ #include "dyn_common.h"
#include "dyn_type.h"
static void stdLog(void *handle, int level, const char *file, int line, const char *msg, ...) {
@@ -24,7 +25,7 @@ extern "C" {
int i;
type = NULL;
printf("\n-- example %s with descriptor string '%s' --\n", exName, descriptorStr);
- int status = dynType_createWithStr(descriptorStr, exName, NULL, &type);
+ int status = dynType_parseWithStr(descriptorStr, exName, NULL, &type);
CHECK_EQUAL(0, status);
if (status == 0) {
dynType_print(type);
@@ -106,7 +107,7 @@ TEST(DynTypeTests, ParseRandomGarbageTest) {
//printf("ParseRandomGarbageTest iteration %i with descriptor string '%s'\n", k, descriptorStr);
dyn_type *type = NULL;
- int status = dynType_createWithStr(descriptorStr, NULL, NULL, &type);
+ int status = dynType_parseWithStr(descriptorStr, NULL, NULL, &type);
if (status == 0) {
dynType_destroy(type);
}
@@ -122,7 +123,7 @@ TEST(DynTypeTests, AssignTest1) {
struct ex1 inst;
const char *desc = "{III a b c}";
dyn_type *type = NULL;
- int status = dynType_createWithStr(desc, NULL, NULL, &type);
+ int status = dynType_parseWithStr(desc, NULL, NULL, &type);
CHECK_EQUAL(0, status);
int32_t val1 = 2;
int32_t val2 = 4;
@@ -133,6 +134,8 @@ TEST(DynTypeTests, AssignTest1) {
CHECK_EQUAL(4, inst.b);
dynType_complex_setValueAt(type, 2, &inst, &val3);
CHECK_EQUAL(8, inst.c);
+
+ dynType_destroy(type);
}
TEST(DynTypeTests, AssignTest2) {
@@ -146,7 +149,7 @@ TEST(DynTypeTests, AssignTest2) {
struct ex inst;
const char *desc = "{I{DD a b} a b}";
dyn_type *type = NULL;
- int status = dynType_createWithStr(desc, NULL, NULL, &type);
+ int status = dynType_parseWithStr(desc, NULL, NULL, &type);
CHECK_EQUAL(0, status);
int32_t a = 2;
double b_a = 1.1;
@@ -165,6 +168,8 @@ TEST(DynTypeTests, AssignTest2) {
dynType_complex_setValueAt(subType, 1, &inst.b, &b_b);
CHECK_EQUAL(1.2, inst.b.b);
+
+ dynType_destroy(type);
}
http://git-wip-us.apache.org/repos/asf/celix/blob/08b5bc0c/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
index 1ec4655..cd61e6e 100644
--- a/remote_services/dynamic_function_interface/tst/json_serializer_tests.cpp
+++ b/remote_services/dynamic_function_interface/tst/json_serializer_tests.cpp
@@ -13,6 +13,7 @@ extern "C" {
#include <ffi.h>
+#include "dyn_common.h"
#include "dyn_type.h"
#include "json_serializer.h"
@@ -136,7 +137,7 @@ static void tests() {
type = NULL;
inst = NULL;
- rc = dynType_createWithStr(example1_descriptor, NULL, NULL, &type);
+ rc = dynType_parseWithStr(example1_descriptor, NULL, NULL, &type);
CHECK_EQUAL(0, rc);
rc = json_deserialize(type, example1_input, &inst);
CHECK_EQUAL(0, rc);
@@ -146,7 +147,7 @@ static void tests() {
type = NULL;
inst = NULL;
- rc = dynType_createWithStr(example2_descriptor, NULL, NULL, &type);
+ rc = dynType_parseWithStr(example2_descriptor, NULL, NULL, &type);
CHECK_EQUAL(0, rc);
rc = json_deserialize(type, example2_input, &inst);
CHECK_EQUAL(0, rc);
@@ -155,7 +156,7 @@ static void tests() {
type = NULL;
inst = NULL;
- rc = dynType_createWithStr(example3_descriptor, NULL, NULL, &type);
+ rc = dynType_parseWithStr(example3_descriptor, NULL, NULL, &type);
CHECK_EQUAL(0, rc);
rc = json_deserialize(type, example3_input, &inst);
CHECK_EQUAL(0, rc);
@@ -163,7 +164,7 @@ static void tests() {
type = NULL;
inst = NULL;
- rc = dynType_createWithStr(example4_descriptor, NULL, NULL, &type);
+ rc = dynType_parseWithStr(example4_descriptor, NULL, NULL, &type);
CHECK_EQUAL(0, rc);
rc = json_deserialize(type, example4_input, &inst);
CHECK_EQUAL(0, rc);
@@ -174,6 +175,7 @@ static void tests() {
TEST_GROUP(JsonSerializerTests) {
void setup() {
dynType_logSetup(stdLog, NULL, 3);
+ dynCommon_logSetup(stdLog, NULL, 3);
}
};