Improvements to the ruminate-jansson code

CMakeLists.txt

@@ -10,15 +10,18 @@ set(CMAKE_MODULE_PATH
 #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COMMON_FLAGS} -Wno-vla -Wno-vla-extension -Wno-variadic-macros")
 
 #set(COMMON_FLAGS "-Wall -Wextra -Wnonnull -Werror -pedantic")
+#set(COMMON_FLAGS "-Wall -Wextra -Wnonnull -pedantic -fsanitize=address -fsanitize=undefined")
 set(COMMON_FLAGS "-Wall -Wextra -Wnonnull -pedantic")
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${COMMON_FLAGS}")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COMMON_FLAGS} -Wno-vla -Wno-vla-extension -Wno-variadic-macros")
+#set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--no-undefined -fsanitize=address -fsanitize=undefined")
 set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--no-undefined")
 set(DEBUGGER_CONTROLLER_PATH "${CMAKE_INSTALL_PREFIX}/bin/ruminate-dbgsvr")
 option(BUILD_SHARED_LIBS "Build Shared Libraries" ON)
 
 find_package(GLIB2 REQUIRED)
 find_package(Ice REQUIRED)
+find_package(Jansson)
 
 add_subdirectory(ice)
 add_subdirectory(include)

test/CMakeLists.txt

@@ -1,4 +1,6 @@
 add_subdirectory(backtrace)
 add_subdirectory(json)
 add_subdirectory(ruminate-jansson-test)
+add_subdirectory(stdout)
 add_subdirectory(memory)
+add_subdirectory(main)

test/ruminate-jansson-test/CMakeLists.txt

@@ -1,22 +1,17 @@
-find_package(Jansson)
-find_package(Talloc)
-
-if(JANSSON_FOUND AND TALLOC_FOUND)
+if(JANSSON_FOUND)
 	add_executable(ruminate-jansson-test
 		ruminate-jansson-test.c
 	)
-	set_target_properties(ruminate-jansson-test PROPERTIES COMPILE_FLAGS "-std=c99 -g")
+	set_target_properties(ruminate-jansson-test PROPERTIES COMPILE_FLAGS "-std=c11 -g")
 	target_link_libraries(ruminate-jansson-test
 		ruminate
 		ruminate-jansson
 		jansson
 		${GLIB2_LIBRARIES}
 		${JANSSON_LIBRARIES}
-		${TALLOC_LIBRARIES}
 	)
 	include_directories(
 		${JANSSON_INCLUDE_DIRS}
 		${GLIB2_INCLUDE_DIRS}
-		${TALLOC_INCLUDE_DIRS}
 	)
-endif(JANSSON_FOUND AND TALLOC_FOUND)
+endif(JANSSON_FOUND)

test/ruminate-jansson-test/ruminate-jansson-test.c

@@ -11,10 +11,14 @@ typedef char *string;
 
 struct MyStruct {
 	int i;
+	union {
+		char b;
+		void *v;
+	} *u1;
 	union MyUnion {
 		char b;
 		void *v;
-	} u;
+	} u2;
 	string s;
 	enum MyEnum {
 		MY_ENUM_VALUE_1,
@@ -24,19 +28,19 @@ struct MyStruct {
 	char a[3];
 };
 
-static void *deserialize_my_union( JsonState *js, RType *rt, json_t *value, void *data, GError **error ) {
-	(void) js, (void) data, (void) error;
-	char *ret = r_mem_malloc_fn(rt, error);
+static void *deserialize_my_union( JsonDeserializerArgs args, void *data, GError **error ) {
+	(void) data, (void) error;
+	char *ret = r_mem_malloc_fn(args.type, error);
 	if( ret == NULL ) return NULL;
 
-	const char *c = json_string_value(value);
+	const char *c = json_string_value(args.value);
 	*ret = *c;
 	return ret;
 }
 
-static json_t *serialize_my_union( JsonState *js, RType *rt, void *value, void *data, GError **error ) {
-	(void) js, (void) rt, (void) data, (void) error;
-	char v[] = { *((char *) value), '\0' };
+static json_t *serialize_my_union( JsonSerializerArgs args, void *data, GError **error ) {
+	(void) data, (void) error;
+	char v[] = { *((char *) args.value), '\0' };
 	return json_string(v);
 }
 
@@ -45,12 +49,12 @@ static JsonHook my_union_hook = {
 	.deserializer = deserialize_my_union
 };
 
-static void *deserialize_string( JsonState *js, RType *rt, json_t *value, void *data, GError **error ) {
-	(void) js, (void) data, (void) error;
-	const char *str = json_string_value(value);
+static void *deserialize_string( JsonDeserializerArgs args, void *data, GError **error ) {
+	(void) data, (void) error;
+	const char *str = json_string_value(args.value);
 	size_t str_len = strlen(str) + 1;
 
-	char **ret = r_mem_malloc_fn(rt, error);
+	char **ret = r_mem_malloc_fn(args.type, error);
 	if( ret == NULL ) return NULL;
 	*ret = r_mem_malloc_sized(char *, str_len, error);
 	if( *ret == NULL ) {
@@ -62,9 +66,9 @@ static void *deserialize_string( JsonState *js, RType *rt, json_t *value, void *
 	return ret;
 }
 
-static json_t *serialize_string( JsonState *js, RType *rt, void *value, void *data, GError **error ) {
-	(void) js, (void) rt, (void) data, (void) error;
-	return json_string(*((char **) value));
+static json_t *serialize_string( JsonSerializerArgs args, void *data, GError **error ) {
+	(void) data, (void) error;
+	return json_string(*((char **) args.value));
 }
 
 static JsonHook string_hook = {
@@ -78,7 +82,8 @@ int main( int argc, char *argv[] ) {
 	int ipt = 2;
 	struct MyStruct foo = {
 		.i = 1,
-		.u = {
+		.u1 = NULL,
+		.u2 = {
 			.b = 'c'
 		},
 		.s = "hello world!",
@@ -89,25 +94,20 @@ int main( int argc, char *argv[] ) {
 	JsonState *st = json_state_new();
 	json_state_add_hook(st, g_quark_from_static_string("string"), &string_hook);
 	json_state_add_hook(st, g_quark_from_static_string("MyUnion"), &my_union_hook);
-	json_state_set_flags(st, JSON_FLAG_BIJECTIVE);
-	//json_dumpf(json_serialize(st, ruminate_get_type(foo, NULL), &foo, NULL), stdout, 0);
+	json_state_set_flags(st, JSON_FLAG_INVERTABLE);
 	json_t *serialized = json_serialize(st, ruminate_get_type(foo, NULL), &foo, NULL);
 	json_dumpf(serialized, stdout, 0);
 	printf("\n");
-	GError *err = NULL;
-	struct MyStruct *_foo = json_deserialize(st, serialized, &err);
-	if( _foo == NULL ) {
-		fprintf(stderr, "%s\n", err->message);
-		exit(EXIT_FAILURE);
-	}
-	printf("struct MyStruct {\n");
-	printf("\t.i = %d,\n", _foo->i);
-	printf("\t.u = { .b = '%c' },\n", _foo->u.b);
-	printf("\t.s = \"%s\",\n", _foo->s);
-	printf("\t.e = %d,\n", _foo->e);
-	printf("\t.p = %p (%d),\n", _foo->p, *_foo->p);
-	printf("\t.a = [%d, %d, %d]\n", _foo->a[0], _foo->a[1], _foo->a[2]);
-	printf("};\n");
+	struct MyStruct *_foo = json_deserialize(st, serialized, NULL);
+	printf("struct MyStruct {");
+	printf(" .i = %d,", _foo->i);
+	printf(" .u1 = %p,", _foo->u1);
+	printf(" .u2 = { .b = '%c' },", _foo->u2.b);
+	printf(" .s = \"%s\",", _foo->s);
+	printf(" .e = %d,", _foo->e);
+	printf(" .p = %p (%d),", _foo->p, *_foo->p);
+	printf(" .a = [%d, %d, %d]", _foo->a[0], _foo->a[1], _foo->a[2]);
+	printf(" };\n");
 	r_mem_unref(_foo->s);
 	r_mem_unref(_foo->p);
 	r_mem_unref(_foo);

test/stdout/CMakeLists.txt

@@ -0,0 +1,17 @@
+if(JANSSON_FOUND)
+	add_executable(stdout
+		stdout.c
+	)
+	set_target_properties(stdout PROPERTIES COMPILE_FLAGS "-std=c99 -g")
+	target_link_libraries(stdout
+		ruminate
+		ruminate-jansson
+		jansson
+		${GLIB2_LIBRARIES}
+		${JANSSON_LIBRARIES}
+	)
+	include_directories(
+		${JANSSON_INCLUDE_DIRS}
+		${GLIB2_INCLUDE_DIRS}
+	)
+endif(JANSSON_FOUND)

test/stdout/stdout.c

@@ -0,0 +1,75 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <ctype.h>
+
+#include <ruminate.h>
+#include <jansson.h>
+#include <glib.h>
+#include <ruminate-jansson.h>
+
+static void die_if_error( GError *err ) {
+	if( err == NULL ) return;
+	fprintf(stderr, "%s\n", err->message);
+	exit(EXIT_FAILURE);
+}
+
+static json_t *serialize_void( JsonSerializerArgs args, void *data, GError **error ) {
+	(void) args, (void) data, (void) error;
+	return NULL;
+}
+
+static JsonHook void_hook = {
+	.serializer = serialize_void
+};
+
+static json_t *serialize_char_ptr( JsonSerializerArgs args, void *data, GError **error ) {
+	(void) data;
+	g_assert(args.value != NULL);
+	char *str = *((char **) args.value);
+	if( str == NULL ) return json_null();
+
+	bool is_string = false;
+	while( true ) {
+		if( *str == '\0' ) {
+			is_string = true;
+			break;
+		}
+		if( !isalnum(*str) ) break;
+		str++;
+	}
+
+	if( is_string ) return json_string(str);
+	return args.cont(args.state, args.type, args.value, error);
+}
+
+static JsonHook char_ptr_hook = {
+	.serializer = serialize_char_ptr
+};
+
+int main( int argc, char *argv[] ) {
+	(void) argc;
+	GError *err = NULL;
+
+	ruminate_init(argv[0], &err);
+	die_if_error(err);
+
+	RType *rt = ruminate_get_type(stdout, &err);
+	die_if_error(err);
+
+	JsonState *st = json_state_new();
+	json_state_add_hook(st, g_quark_from_static_string("void"), &void_hook);
+	json_state_add_hook(st, g_quark_from_static_string("char *"), &char_ptr_hook);
+	json_state_set_flags(st, JSON_FLAG_SKIP_UNKNOWN);
+
+	printf("Hello World!");
+	json_t *serialized = json_serialize(st, rt, &stdout, &err);
+	die_if_error(err);
+
+	printf("\n");
+	json_dumpf(serialized, stdout, 0);
+	printf("\n");
+
+	json_decref(serialized);
+	r_type_unref(rt);
+	return EXIT_SUCCESS;
+}

util/ruminate-jansson/CMakeLists.txt

@@ -1,18 +1,14 @@
-find_package(Jansson)
-find_package(Talloc)
-
-if(JANSSON_FOUND AND TALLOC_FOUND)
+if(JANSSON_FOUND)
 	add_library(ruminate-jansson
 		serialize.c
 		deserialize.c
 		json_state.c
 	)
-	set_target_properties(ruminate-jansson PROPERTIES COMPILE_FLAGS "-std=c99 -g")
+	set_target_properties(ruminate-jansson PROPERTIES COMPILE_FLAGS "-std=c11 -g")
 	target_link_libraries(ruminate-jansson
-		LINK_PRIVATE ruminate jansson ${GLIB2_LIBRARIES} ${TALLOC_LIBRARIES}
+		LINK_PRIVATE ruminate jansson ${GLIB2_LIBRARIES}
 	)
 	target_include_directories(ruminate-jansson
 		PUBLIC ${JANSSON_INCLUDE_DIRS} ${GLIB2_INCLUDE_DIRS} ${CMAKE_CURRENT_SOURCE_DIR}
-		PRIVATE ${TALLOC_INCLUDE_DIRS}
 	)
-endif(JANSSON_FOUND AND TALLOC_FOUND)
+endif(JANSSON_FOUND)