Implement dynamic type attributes

Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>

diff --git a/include/side/trace.h b/include/side/trace.h
index 104872d7a822bcd4726616aeaa43d39298f45ca9..ed039fa77c8b15d5483978dadc5a26449f7a6764 100644 (file)
--- a/include/side/trace.h
+++ b/include/side/trace.h
@@ -172,6 +172,8 @@ struct side_arg_dynamic_vec_vla {
 
 struct side_arg_dynamic_vec {
        uint32_t dynamic_type;  /* enum side_dynamic_type */
+       uint32_t nr_attr;
+       const struct side_attr *attr;
        union {
                uint8_t side_bool;
 
@@ -203,7 +205,6 @@ struct side_arg_dynamic_vec {
 struct side_arg_dynamic_event_field {
        const char *field_name;
        const struct side_arg_dynamic_vec elem;
-       //TODO: we should add something like a list of user attributes (namespaced strings)
 };
 
 struct side_arg_dynamic_event_struct {
@@ -411,23 +412,122 @@ struct side_tracer_dynamic_vla_visitor_ctx {
                }, \
        }
 
-#define side_arg_dynamic_null(val)     { .dynamic_type = SIDE_DYNAMIC_TYPE_NULL }
+#define side_arg_dynamic_null(_attr) \
+       { \
+               .dynamic_type = SIDE_DYNAMIC_TYPE_NULL, \
+               .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+               .attr = _attr, \
+       }
+
+#define side_arg_dynamic_bool(_val, _attr) \
+       { \
+               .dynamic_type = SIDE_DYNAMIC_TYPE_BOOL, \
+               .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+               .attr = _attr, \
+               .u = { \
+                       .side_bool = !!(_val), \
+               }, \
+       }
 
-#define side_arg_dynamic_bool(val)     { .dynamic_type = SIDE_DYNAMIC_TYPE_BOOL, .u = { .side_bool = !!(val) } }
-#define side_arg_dynamic_u8(val)       { .dynamic_type = SIDE_DYNAMIC_TYPE_U8, .u = { .side_u8 = (val) } }
-#define side_arg_dynamic_u16(val)      { .dynamic_type = SIDE_DYNAMIC_TYPE_U16, .u = { .side_u16 = (val) } }
-#define side_arg_dynamic_u32(val)      { .dynamic_type = SIDE_DYNAMIC_TYPE_U32, .u = { .side_u32 = (val) } }
-#define side_arg_dynamic_u64(val)      { .dynamic_type = SIDE_DYNAMIC_TYPE_U64, .u = { .side_u64 = (val) } }
-#define side_arg_dynamic_s8(val)       { .dynamic_type = SIDE_DYNAMIC_TYPE_S8, .u = { .side_s8 = (val) } }
-#define side_arg_dynamic_s16(val)      { .dynamic_type = SIDE_DYNAMIC_TYPE_S16, .u = { .side_s16 = (val) } }
-#define side_arg_dynamic_s32(val)      { .dynamic_type = SIDE_DYNAMIC_TYPE_S32, .u = { .side_s32 = (val) } }
-#define side_arg_dynamic_s64(val)      { .dynamic_type = SIDE_DYNAMIC_TYPE_S64, .u = { .side_s64 = (val) } }
-#define side_arg_dynamic_string(val)   { .dynamic_type = SIDE_DYNAMIC_TYPE_STRING, .u = { .string = (val) } }
+#define side_arg_dynamic_u8(_val, _attr) \
+       { \
+               .dynamic_type = SIDE_DYNAMIC_TYPE_U8, \
+               .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+               .attr = _attr, \
+               .u = { \
+                       .side_u8 = (_val), \
+               }, \
+       }
+#define side_arg_dynamic_u16(_val, _attr) \
+       { \
+               .dynamic_type = SIDE_DYNAMIC_TYPE_U16, \
+               .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+               .attr = _attr, \
+               .u = { \
+                       .side_u16 = (_val), \
+               }, \
+       }
+#define side_arg_dynamic_u32(_val, _attr) \
+       { \
+               .dynamic_type = SIDE_DYNAMIC_TYPE_U32, \
+               .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+               .attr = _attr, \
+               .u = { \
+                       .side_u32 = (_val), \
+               }, \
+       }
+#define side_arg_dynamic_u64(_val, _attr) \
+       { \
+               .dynamic_type = SIDE_DYNAMIC_TYPE_U64, \
+               .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+               .attr = _attr, \
+               .u = { \
+                       .side_u64 = (_val), \
+               }, \
+       }
 
-#define side_arg_dynamic_vla(_vla)     { .dynamic_type = SIDE_DYNAMIC_TYPE_VLA, .u = { .side_dynamic_vla = (_vla) } }
-#define side_arg_dynamic_vla_visitor(_dynamic_vla_visitor, _ctx) \
+#define side_arg_dynamic_s8(_val, _attr) \
+       { \
+               .dynamic_type = SIDE_DYNAMIC_TYPE_S8, \
+               .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+               .attr = _attr, \
+               .u = { \
+                       .side_s8 = (_val), \
+               }, \
+       }
+#define side_arg_dynamic_s16(_val, _attr) \
+       { \
+               .dynamic_type = SIDE_DYNAMIC_TYPE_S16, \
+               .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+               .attr = _attr, \
+               .u = { \
+                       .side_s16 = (_val), \
+               }, \
+       }
+#define side_arg_dynamic_s32(_val, _attr) \
+       { \
+               .dynamic_type = SIDE_DYNAMIC_TYPE_S32, \
+               .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+               .attr = _attr, \
+               .u = { \
+                       .side_s32 = (_val), \
+               }, \
+       }
+#define side_arg_dynamic_s64(_val, _attr) \
+       { \
+               .dynamic_type = SIDE_DYNAMIC_TYPE_S64, \
+               .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+               .attr = _attr, \
+               .u = { \
+                       .side_s64 = (_val), \
+               }, \
+       }
+
+#define side_arg_dynamic_string(_val, _attr) \
+       { \
+               .dynamic_type = SIDE_DYNAMIC_TYPE_STRING, \
+               .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+               .attr = _attr, \
+               .u = { \
+                       .string = (_val), \
+               }, \
+       }
+
+#define side_arg_dynamic_vla(_vla, _attr) \
+       { \
+               .dynamic_type = SIDE_DYNAMIC_TYPE_VLA, \
+               .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+               .attr = _attr, \
+               .u = { \
+                       .side_dynamic_vla = (_vla), \
+               }, \
+       }
+
+#define side_arg_dynamic_vla_visitor(_dynamic_vla_visitor, _ctx, _attr) \
        { \
                .dynamic_type = SIDE_DYNAMIC_TYPE_VLA_VISITOR, \
+               .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+               .attr = _attr, \
                .u = { \
                        .side_dynamic_vla_visitor = { \
                                .app_ctx = _ctx, \
@@ -436,10 +536,21 @@ struct side_tracer_dynamic_vla_visitor_ctx {
                }, \
        }
 
-#define side_arg_dynamic_struct(_struct)       { .dynamic_type = SIDE_DYNAMIC_TYPE_STRUCT, .u = { .side_dynamic_struct = (_struct) } }
-#define side_arg_dynamic_struct_visitor(_dynamic_struct_visitor, _ctx) \
+#define side_arg_dynamic_struct(_struct, _attr) \
+       { \
+               .dynamic_type = SIDE_DYNAMIC_TYPE_STRUCT, \
+               .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+               .attr = _attr, \
+               .u = { \
+                       .side_dynamic_struct = (_struct), \
+               }, \
+       }
+
+#define side_arg_dynamic_struct_visitor(_dynamic_struct_visitor, _ctx, _attr) \
        { \
                .dynamic_type = SIDE_DYNAMIC_TYPE_STRUCT_VISITOR, \
+               .nr_attr = SIDE_ARRAY_SIZE(SIDE_PARAM(_attr)), \
+               .attr = _attr, \
                .u = { \
                        .side_dynamic_struct_visitor = { \
                                .app_ctx = _ctx, \

diff --git a/src/test.c b/src/test.c
index 63305bafe6b2fda9a11f9fae6813489af70cd269..4ff2c8d846110e846d52c3a3d9d5940357853162 100644 (file)
--- a/src/test.c
+++ b/src/test.c
@@ -31,7 +31,7 @@ void test_fields(void)
 
        my_provider_event.enabled = 1;
        side_event(&my_provider_event, side_arg_list(side_arg_u32(uw), side_arg_s64(sdw),
-               side_arg_dynamic(side_arg_dynamic_string("zzz"))));
+               side_arg_dynamic(side_arg_dynamic_string("zzz", side_attr_list()))));
 }
 
 static side_define_event(my_provider_event2, "myprovider", "myevent2", SIDE_LOGLEVEL_DEBUG,
@@ -274,7 +274,7 @@ void test_dynamic_basic_type(void)
 {
        my_provider_event_dynamic_basic.enabled = 1;
        side_event(&my_provider_event_dynamic_basic,
-               side_arg_list(side_arg_dynamic(side_arg_dynamic_s16(-33))));
+               side_arg_list(side_arg_dynamic(side_arg_dynamic_s16(-33, side_attr_list()))));
 }
 
 static side_define_event(my_provider_event_dynamic_vla,
@@ -290,12 +290,14 @@ void test_dynamic_vla(void)
 {
        side_arg_dynamic_define_vec(myvla,
                side_arg_list(
-                       side_arg_dynamic_u32(1), side_arg_dynamic_u32(2), side_arg_dynamic_u32(3),
+                       side_arg_dynamic_u32(1, side_attr_list()),
+                       side_arg_dynamic_u32(2, side_attr_list()),
+                       side_arg_dynamic_u32(3, side_attr_list()),
                )
        );
        my_provider_event_dynamic_vla.enabled = 1;
        side_event(&my_provider_event_dynamic_vla,
-               side_arg_list(side_arg_dynamic(side_arg_dynamic_vla(&myvla))));
+               side_arg_list(side_arg_dynamic(side_arg_dynamic_vla(&myvla, side_attr_list()))));
 }
 
 static side_define_event(my_provider_event_dynamic_null,
@@ -311,7 +313,7 @@ void test_dynamic_null(void)
 {
        my_provider_event_dynamic_null.enabled = 1;
        side_event(&my_provider_event_dynamic_null,
-               side_arg_list(side_arg_dynamic(side_arg_dynamic_null())));
+               side_arg_list(side_arg_dynamic(side_arg_dynamic_null(side_attr_list()))));
 }
 
 static side_define_event(my_provider_event_dynamic_struct,
@@ -327,15 +329,15 @@ void test_dynamic_struct(void)
 {
        side_arg_dynamic_define_struct(mystruct,
                side_arg_list(
-                       side_arg_dynamic_field("a", side_arg_dynamic_u32(43)),
-                       side_arg_dynamic_field("b", side_arg_dynamic_string("zzz")),
-                       side_arg_dynamic_field("c", side_arg_dynamic_null()),
+                       side_arg_dynamic_field("a", side_arg_dynamic_u32(43, side_attr_list())),
+                       side_arg_dynamic_field("b", side_arg_dynamic_string("zzz", side_attr_list())),
+                       side_arg_dynamic_field("c", side_arg_dynamic_null(side_attr_list())),
                )
        );
 
        my_provider_event_dynamic_struct.enabled = 1;
        side_event(&my_provider_event_dynamic_struct,
-               side_arg_list(side_arg_dynamic(side_arg_dynamic_struct(&mystruct))));
+               side_arg_list(side_arg_dynamic(side_arg_dynamic_struct(&mystruct, side_attr_list()))));
 }
 
 static side_define_event(my_provider_event_dynamic_nested_struct,
@@ -351,25 +353,25 @@ void test_dynamic_nested_struct(void)
 {
        side_arg_dynamic_define_struct(nested,
                side_arg_list(
-                       side_arg_dynamic_field("a", side_arg_dynamic_u32(43)),
-                       side_arg_dynamic_field("b", side_arg_dynamic_u8(55)),
+                       side_arg_dynamic_field("a", side_arg_dynamic_u32(43, side_attr_list())),
+                       side_arg_dynamic_field("b", side_arg_dynamic_u8(55, side_attr_list())),
                )
        );
        side_arg_dynamic_define_struct(nested2,
                side_arg_list(
-                       side_arg_dynamic_field("aa", side_arg_dynamic_u64(128)),
-                       side_arg_dynamic_field("bb", side_arg_dynamic_u16(1)),
+                       side_arg_dynamic_field("aa", side_arg_dynamic_u64(128, side_attr_list())),
+                       side_arg_dynamic_field("bb", side_arg_dynamic_u16(1, side_attr_list())),
                )
        );
        side_arg_dynamic_define_struct(mystruct,
                side_arg_list(
-                       side_arg_dynamic_field("nested", side_arg_dynamic_struct(&nested)),
-                       side_arg_dynamic_field("nested2", side_arg_dynamic_struct(&nested2)),
+                       side_arg_dynamic_field("nested", side_arg_dynamic_struct(&nested, side_attr_list())),
+                       side_arg_dynamic_field("nested2", side_arg_dynamic_struct(&nested2, side_attr_list())),
                )
        );
        my_provider_event_dynamic_nested_struct.enabled = 1;
        side_event(&my_provider_event_dynamic_nested_struct,
-               side_arg_list(side_arg_dynamic(side_arg_dynamic_struct(&mystruct))));
+               side_arg_list(side_arg_dynamic(side_arg_dynamic_struct(&mystruct, side_attr_list()))));
 }
 
 static side_define_event(my_provider_event_dynamic_vla_struct,
@@ -385,21 +387,21 @@ void test_dynamic_vla_struct(void)
 {
        side_arg_dynamic_define_struct(nested,
                side_arg_list(
-                       side_arg_dynamic_field("a", side_arg_dynamic_u32(43)),
-                       side_arg_dynamic_field("b", side_arg_dynamic_u8(55)),
+                       side_arg_dynamic_field("a", side_arg_dynamic_u32(43, side_attr_list())),
+                       side_arg_dynamic_field("b", side_arg_dynamic_u8(55, side_attr_list())),
                )
        );
        side_arg_dynamic_define_vec(myvla,
                side_arg_list(
-                       side_arg_dynamic_struct(&nested),
-                       side_arg_dynamic_struct(&nested),
-                       side_arg_dynamic_struct(&nested),
-                       side_arg_dynamic_struct(&nested),
+                       side_arg_dynamic_struct(&nested, side_attr_list()),
+                       side_arg_dynamic_struct(&nested, side_attr_list()),
+                       side_arg_dynamic_struct(&nested, side_attr_list()),
+                       side_arg_dynamic_struct(&nested, side_attr_list()),
                )
        );
        my_provider_event_dynamic_vla_struct.enabled = 1;
        side_event(&my_provider_event_dynamic_vla_struct,
-               side_arg_list(side_arg_dynamic(side_arg_dynamic_vla(&myvla))));
+               side_arg_list(side_arg_dynamic(side_arg_dynamic_vla(&myvla, side_attr_list()))));
 }
 
 static side_define_event(my_provider_event_dynamic_struct_vla,
@@ -415,23 +417,27 @@ void test_dynamic_struct_vla(void)
 {
        side_arg_dynamic_define_vec(myvla,
                side_arg_list(
-                       side_arg_dynamic_u32(1), side_arg_dynamic_u32(2), side_arg_dynamic_u32(3),
+                       side_arg_dynamic_u32(1, side_attr_list()),
+                       side_arg_dynamic_u32(2, side_attr_list()),
+                       side_arg_dynamic_u32(3, side_attr_list()),
                )
        );
        side_arg_dynamic_define_vec(myvla2,
                side_arg_list(
-                       side_arg_dynamic_u32(4), side_arg_dynamic_u64(5), side_arg_dynamic_u32(6),
+                       side_arg_dynamic_u32(4, side_attr_list()),
+                       side_arg_dynamic_u64(5, side_attr_list()),
+                       side_arg_dynamic_u32(6, side_attr_list()),
                )
        );
        side_arg_dynamic_define_struct(mystruct,
                side_arg_list(
-                       side_arg_dynamic_field("a", side_arg_dynamic_vla(&myvla)),
-                       side_arg_dynamic_field("b", side_arg_dynamic_vla(&myvla2)),
+                       side_arg_dynamic_field("a", side_arg_dynamic_vla(&myvla, side_attr_list())),
+                       side_arg_dynamic_field("b", side_arg_dynamic_vla(&myvla2, side_attr_list())),
                )
        );
        my_provider_event_dynamic_struct_vla.enabled = 1;
        side_event(&my_provider_event_dynamic_struct_vla,
-               side_arg_list(side_arg_dynamic(side_arg_dynamic_struct(&mystruct))));
+               side_arg_list(side_arg_dynamic(side_arg_dynamic_struct(&mystruct, side_attr_list()))));
 }
 
 static side_define_event(my_provider_event_dynamic_nested_vla,
@@ -447,23 +453,27 @@ void test_dynamic_nested_vla(void)
 {
        side_arg_dynamic_define_vec(nestedvla,
                side_arg_list(
-                       side_arg_dynamic_u32(1), side_arg_dynamic_u16(2), side_arg_dynamic_u32(3),
+                       side_arg_dynamic_u32(1, side_attr_list()),
+                       side_arg_dynamic_u16(2, side_attr_list()),
+                       side_arg_dynamic_u32(3, side_attr_list()),
                )
        );
        side_arg_dynamic_define_vec(nestedvla2,
                side_arg_list(
-                       side_arg_dynamic_u8(4), side_arg_dynamic_u32(5), side_arg_dynamic_u32(6),
+                       side_arg_dynamic_u8(4, side_attr_list()),
+                       side_arg_dynamic_u32(5, side_attr_list()),
+                       side_arg_dynamic_u32(6, side_attr_list()),
                )
        );
        side_arg_dynamic_define_vec(myvla,
                side_arg_list(
-                       side_arg_dynamic_vla(&nestedvla),
-                       side_arg_dynamic_vla(&nestedvla2),
+                       side_arg_dynamic_vla(&nestedvla, side_attr_list()),
+                       side_arg_dynamic_vla(&nestedvla2, side_attr_list()),
                )
        );
        my_provider_event_dynamic_nested_vla.enabled = 1;
        side_event(&my_provider_event_dynamic_nested_vla,
-               side_arg_list(side_arg_dynamic(side_arg_dynamic_vla(&myvla))));
+               side_arg_list(side_arg_dynamic(side_arg_dynamic_vla(&myvla, side_attr_list()))));
 }
 
 static side_define_event_variadic(my_provider_event_variadic,
@@ -479,8 +489,8 @@ void test_variadic(void)
        side_event_variadic(&my_provider_event_variadic,
                side_arg_list(),
                side_arg_list(
-                       side_arg_dynamic_field("a", side_arg_dynamic_u32(55)),
-                       side_arg_dynamic_field("b", side_arg_dynamic_s8(-4)),
+                       side_arg_dynamic_field("a", side_arg_dynamic_u32(55, side_attr_list())),
+                       side_arg_dynamic_field("b", side_arg_dynamic_s8(-4, side_attr_list())),
                )
        );
 }
@@ -504,8 +514,8 @@ void test_static_variadic(void)
                        side_arg_u16(2),
                ),
                side_arg_list(
-                       side_arg_dynamic_field("a", side_arg_dynamic_u32(55)),
-                       side_arg_dynamic_field("b", side_arg_dynamic_s8(-4)),
+                       side_arg_dynamic_field("a", side_arg_dynamic_u32(55, side_attr_list())),
+                       side_arg_dynamic_field("b", side_arg_dynamic_s8(-4, side_attr_list())),
                )
        );
 }
@@ -561,10 +571,10 @@ void test_dynamic_bool(void)
        side_event_variadic(&my_provider_event_dynamic_bool,
                side_arg_list(),
                side_arg_list(
-                       side_arg_dynamic_field("a_true", side_arg_dynamic_bool(55)),
-                       side_arg_dynamic_field("b_true", side_arg_dynamic_bool(-4)),
-                       side_arg_dynamic_field("c_false", side_arg_dynamic_bool(0)),
-                       side_arg_dynamic_field("d_true", side_arg_dynamic_bool(256)),
+                       side_arg_dynamic_field("a_true", side_arg_dynamic_bool(55, side_attr_list())),
+                       side_arg_dynamic_field("b_true", side_arg_dynamic_bool(-4, side_attr_list())),
+                       side_arg_dynamic_field("c_false", side_arg_dynamic_bool(0, side_attr_list())),
+                       side_arg_dynamic_field("d_true", side_arg_dynamic_bool(256, side_attr_list())),
                )
        );
 }
@@ -591,6 +601,8 @@ enum side_visitor_status test_dynamic_vla_visitor(const struct side_tracer_dynam
        for (i = 0; i < length; i++) {
                const struct side_arg_dynamic_vec elem = {
                        .dynamic_type = SIDE_DYNAMIC_TYPE_U32,
+                       .nr_attr = 0,
+                       .attr = NULL,
                        .u = {
                                .side_u32 = ctx->ptr[i],
                        },
@@ -615,7 +627,7 @@ void test_dynamic_vla_with_visitor(void)
                side_event_call(&my_provider_event_dynamic_vla_visitor,
                        side_arg_list(
                                side_arg_dynamic(
-                                       side_arg_dynamic_vla_visitor(test_dynamic_vla_visitor, &ctx)
+                                       side_arg_dynamic_vla_visitor(test_dynamic_vla_visitor, &ctx, side_attr_list())
                                )
                        )
                );
@@ -651,6 +663,8 @@ enum side_visitor_status test_dynamic_struct_visitor(const struct side_tracer_dy
                        .field_name = ctx->ptr[i].name,
                        .elem = {
                                .dynamic_type = SIDE_DYNAMIC_TYPE_U32,
+                               .nr_attr = 0,
+                               .attr = NULL,
                                .u = {
                                        .side_u32 = ctx->ptr[i].value,
                                },
@@ -681,7 +695,7 @@ void test_dynamic_struct_with_visitor(void)
                side_event_call(&my_provider_event_dynamic_struct_visitor,
                        side_arg_list(
                                side_arg_dynamic(
-                                       side_arg_dynamic_struct_visitor(test_dynamic_struct_visitor, &ctx)
+                                       side_arg_dynamic_struct_visitor(test_dynamic_struct_visitor, &ctx, side_attr_list())
                                )
                        )
                );
@@ -731,6 +745,115 @@ void test_field_user_attribute(void)
        side_event(&my_provider_field_user_attribute, side_arg_list(side_arg_u32(1), side_arg_s64(2)));
 }
 
+static side_define_event_variadic(my_provider_event_variadic_attr,
+       "myprovider", "myvariadiceventattr", SIDE_LOGLEVEL_DEBUG,
+       side_field_list(),
+       side_attr_list()
+);
+
+static
+void test_variadic_attr(void)
+{
+       my_provider_event_variadic_attr.enabled = 1;
+       side_event_variadic(&my_provider_event_variadic_attr,
+               side_arg_list(),
+               side_arg_list(
+                       side_arg_dynamic_field("a",
+                               side_arg_dynamic_u32(55,
+                                       side_attr_list(
+                                               side_attr("user_attribute_c", "valX"),
+                                               side_attr("user_attribute_d", "valY"),
+                                       )
+                               )
+                       ),
+                       side_arg_dynamic_field("b",
+                               side_arg_dynamic_s8(-4,
+                                       side_attr_list(
+                                               side_attr("X", "1"),
+                                               side_attr("Y", "2"),
+                                       )
+                               )
+                       ),
+               )
+       );
+}
+
+static side_define_event_variadic(my_provider_event_variadic_vla_attr,
+       "myprovider", "myvariadiceventvlaattr", SIDE_LOGLEVEL_DEBUG,
+       side_field_list(),
+       side_attr_list()
+);
+
+static
+void test_variadic_vla_attr(void)
+{
+       side_arg_dynamic_define_vec(myvla,
+               side_arg_list(
+                       side_arg_dynamic_u32(1,
+                               side_attr_list(
+                                       side_attr("Z", "0"),
+                                       side_attr("A", "123"),
+                               )
+                       ),
+                       side_arg_dynamic_u32(2, side_attr_list()),
+                       side_arg_dynamic_u32(3, side_attr_list()),
+               )
+       );
+       my_provider_event_variadic_vla_attr.enabled = 1;
+       side_event_variadic(&my_provider_event_variadic_vla_attr,
+               side_arg_list(),
+               side_arg_list(
+                       side_arg_dynamic_field("a",
+                               side_arg_dynamic_vla(&myvla,
+                                       side_attr_list(
+                                               side_attr("X", "1"),
+                                               side_attr("Y", "2"),
+                                       )
+                               )
+                       ),
+               )
+       );
+}
+
+static side_define_event_variadic(my_provider_event_variadic_struct_attr,
+       "myprovider", "myvariadiceventstructattr", SIDE_LOGLEVEL_DEBUG,
+       side_field_list(),
+       side_attr_list()
+);
+
+static
+void test_variadic_struct_attr(void)
+{
+       my_provider_event_variadic_struct_attr.enabled = 1;
+       side_event_cond(&my_provider_event_variadic_struct_attr) {
+               side_arg_dynamic_define_struct(mystruct,
+                       side_arg_list(
+                               side_arg_dynamic_field("a",
+                                       side_arg_dynamic_u32(43,
+                                               side_attr_list(
+                                                       side_attr("A", "1"),
+                                               )
+                                       )
+                               ),
+                               side_arg_dynamic_field("b", side_arg_dynamic_u8(55, side_attr_list())),
+                       )
+               );
+               side_event_call_variadic(&my_provider_event_variadic_struct_attr,
+                       side_arg_list(),
+                       side_arg_list(
+                               side_arg_dynamic_field("a",
+                                       side_arg_dynamic_struct(&mystruct,
+                                               side_attr_list(
+                                                       side_attr("X", "1"),
+                                                       side_attr("Y", "2"),
+                                               )
+                                       )
+                               ),
+                       )
+               );
+       }
+}
+
 int main()
 {
        test_fields();
@@ -757,5 +880,8 @@ int main()
        test_dynamic_struct_with_visitor();
        test_event_user_attribute();
        test_field_user_attribute();
+       test_variadic_attr();
+       test_variadic_vla_attr();
+       test_variadic_struct_attr();
        return 0;
 }

diff --git a/src/tracer.c b/src/tracer.c
index 3b13f4cc40176cd5bd36285bb31fb0aabc612f3c..fd8ed5eb7314e0bf04b5e085e7e3d65bfcc5b483 100644 (file)
--- a/src/tracer.c
+++ b/src/tracer.c
@@ -562,6 +562,10 @@ void tracer_print_dynamic_vla_visitor(const struct side_arg_dynamic_vec *item)
 static
 void tracer_print_dynamic(const struct side_arg_dynamic_vec *item)
 {
+       printf("{ ");
+       print_attributes("attr: ", item->attr, item->nr_attr);
+       printf("%s", item->nr_attr ? ", " : "");
+       printf("value: ");
        switch (item->dynamic_type) {
        case SIDE_DYNAMIC_TYPE_NULL:
                printf("<NULL TYPE>");
@@ -612,6 +616,7 @@ void tracer_print_dynamic(const struct side_arg_dynamic_vec *item)
                printf("<UNKNOWN TYPE>");
                abort();
        }
+       printf(" }");
 }
 
 static